From 66ef31882341852229c74996867916fbd4a2fe2a Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Mon, 9 Sep 2024 13:22:16 +0200
Subject: [PATCH 001/762] project panel: select autofolded entries (#17520)

Closes #17252

Release Notes:

- Intermediate auto-folded project entries can now be selected and acted
upon (removed, renamed, cut, pasted).
---
 crates/project_panel/src/project_panel.rs     | 238 +++++++++++++++---
 .../src/components/label/highlighted_label.rs |   5 +
 crates/ui/src/components/label/label.rs       |   5 +
 crates/ui/src/components/label/label_like.rs  |  22 +-
 4 files changed, 238 insertions(+), 32 deletions(-)

diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 9d73557761343a..be945cde773bbc 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -60,11 +60,15 @@ pub struct ProjectPanel {
     scroll_handle: UniformListScrollHandle,
     focus_handle: FocusHandle,
     visible_entries: Vec<(WorktreeId, Vec<Entry>, OnceCell<HashSet<Arc<Path>>>)>,
+    /// Maps from leaf project entry ID to the currently selected ancestor.
+    /// Relevant only for auto-fold dirs, where a single project panel entry may actually consist of several
+    /// project entries (and all non-leaf nodes are guaranteed to be directories).
+    ancestors: HashMap<ProjectEntryId, FoldedAncestors>,
     last_worktree_root_id: Option<ProjectEntryId>,
     last_external_paths_drag_over_entry: Option<ProjectEntryId>,
     expanded_dir_ids: HashMap<WorktreeId, Vec<ProjectEntryId>>,
     unfolded_dir_ids: HashSet<ProjectEntryId>,
-    // Currently selected entry in a file tree
+    // Currently selected leaf entry (see auto-folding for a definition of that) in a file tree
     selection: Option<SelectedEntry>,
     marked_entries: BTreeSet<SelectedEntry>,
     context_menu: Option<(View<ContextMenu>, Point<Pixels>, Subscription)>,
@@ -96,7 +100,7 @@ enum ClipboardEntry {
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub struct EntryDetails {
+struct EntryDetails {
     filename: String,
     icon: Option<SharedString>,
     path: Arc<Path>,
@@ -111,18 +115,19 @@ pub struct EntryDetails {
     is_cut: bool,
     git_status: Option<GitFileStatus>,
     is_private: bool,
+    is_auto_folded: bool,
     worktree_id: WorktreeId,
     canonical_path: Option<Box<Path>>,
 }
 
 #[derive(PartialEq, Clone, Default, Debug, Deserialize)]
-pub struct Delete {
+struct Delete {
     #[serde(default)]
     pub skip_prompt: bool,
 }
 
 #[derive(PartialEq, Clone, Default, Debug, Deserialize)]
-pub struct Trash {
+struct Trash {
     #[serde(default)]
     pub skip_prompt: bool,
 }
@@ -155,6 +160,18 @@ actions!(
     ]
 );
 
+#[derive(Debug, Default)]
+struct FoldedAncestors {
+    current_ancestor_depth: usize,
+    ancestors: Vec<ProjectEntryId>,
+}
+
+impl FoldedAncestors {
+    fn max_ancestor_depth(&self) -> usize {
+        self.ancestors.len()
+    }
+}
+
 pub fn init_settings(cx: &mut AppContext) {
     ProjectPanelSettings::register(cx);
 }
@@ -277,6 +294,7 @@ impl ProjectPanel {
                 scroll_handle: UniformListScrollHandle::new(),
                 focus_handle,
                 visible_entries: Default::default(),
+                ancestors: Default::default(),
                 last_worktree_root_id: Default::default(),
                 last_external_paths_drag_over_entry: None,
                 expanded_dir_ids: Default::default(),
@@ -457,7 +475,7 @@ impl ProjectPanel {
             entry_id,
         });
 
-        if let Some((worktree, entry)) = self.selected_entry(cx) {
+        if let Some((worktree, entry)) = self.selected_sub_entry(cx) {
             let auto_fold_dirs = ProjectPanelSettings::get_global(cx).auto_fold_dirs;
             let is_root = Some(entry) == worktree.root_entry();
             let is_dir = entry.is_dir();
@@ -583,6 +601,13 @@ impl ProjectPanel {
 
     fn expand_selected_entry(&mut self, _: &ExpandSelectedEntry, cx: &mut ViewContext<Self>) {
         if let Some((worktree, entry)) = self.selected_entry(cx) {
+            if let Some(folded_ancestors) = self.ancestors.get_mut(&entry.id) {
+                if folded_ancestors.current_ancestor_depth > 0 {
+                    folded_ancestors.current_ancestor_depth -= 1;
+                    cx.notify();
+                    return;
+                }
+            }
             if entry.is_dir() {
                 let worktree_id = worktree.id();
                 let entry_id = entry.id;
@@ -611,6 +636,13 @@ impl ProjectPanel {
 
     fn collapse_selected_entry(&mut self, _: &CollapseSelectedEntry, cx: &mut ViewContext<Self>) {
         if let Some((worktree, mut entry)) = self.selected_entry(cx) {
+            if let Some(folded_ancestors) = self.ancestors.get_mut(&entry.id) {
+                if folded_ancestors.current_ancestor_depth < folded_ancestors.max_ancestor_depth() {
+                    folded_ancestors.current_ancestor_depth += 1;
+                    cx.notify();
+                    return;
+                }
+            }
             let worktree_id = worktree.id();
             let expanded_dir_ids =
                 if let Some(expanded_dir_ids) = self.expanded_dir_ids.get_mut(&worktree_id) {
@@ -943,6 +975,17 @@ impl ProjectPanel {
         }
     }
 
+    fn unflatten_entry_id(&self, leaf_entry_id: ProjectEntryId) -> ProjectEntryId {
+        if let Some(ancestors) = self.ancestors.get(&leaf_entry_id) {
+            ancestors
+                .ancestors
+                .get(ancestors.current_ancestor_depth)
+                .copied()
+                .unwrap_or(leaf_entry_id)
+        } else {
+            leaf_entry_id
+        }
+    }
     fn rename(&mut self, _: &Rename, cx: &mut ViewContext<Self>) {
         if let Some(SelectedEntry {
             worktree_id,
@@ -950,6 +993,7 @@ impl ProjectPanel {
         }) = self.selection
         {
             if let Some(worktree) = self.project.read(cx).worktree_for_id(worktree_id, cx) {
+                let entry_id = self.unflatten_entry_id(entry_id);
                 if let Some(entry) = worktree.read(cx).entry_for_id(entry_id) {
                     self.edit_state = Some(EditState {
                         worktree_id,
@@ -1161,7 +1205,7 @@ impl ProjectPanel {
     }
 
     fn select_parent(&mut self, _: &SelectParent, cx: &mut ViewContext<Self>) {
-        if let Some((worktree, entry)) = self.selected_entry(cx) {
+        if let Some((worktree, entry)) = self.selected_sub_entry(cx) {
             if let Some(parent) = entry.path.parent() {
                 if let Some(parent_entry) = worktree.entry_for_path(parent) {
                     self.selection = Some(SelectedEntry {
@@ -1447,13 +1491,13 @@ impl ProjectPanel {
     }
 
     fn reveal_in_finder(&mut self, _: &RevealInFileManager, cx: &mut ViewContext<Self>) {
-        if let Some((worktree, entry)) = self.selected_entry(cx) {
+        if let Some((worktree, entry)) = self.selected_sub_entry(cx) {
             cx.reveal_path(&worktree.abs_path().join(&entry.path));
         }
     }
 
     fn open_in_terminal(&mut self, _: &OpenInTerminal, cx: &mut ViewContext<Self>) {
-        if let Some((worktree, entry)) = self.selected_entry(cx) {
+        if let Some((worktree, entry)) = self.selected_sub_entry(cx) {
             let abs_path = worktree.abs_path().join(&entry.path);
             let working_directory = if entry.is_dir() {
                 Some(abs_path)
@@ -1476,7 +1520,7 @@ impl ProjectPanel {
         _: &NewSearchInDirectory,
         cx: &mut ViewContext<Self>,
     ) {
-        if let Some((worktree, entry)) = self.selected_entry(cx) {
+        if let Some((worktree, entry)) = self.selected_sub_entry(cx) {
             if entry.is_dir() {
                 let include_root = self.project.read(cx).visible_worktrees(cx).count() > 1;
                 let dir_path = if include_root {
@@ -1596,15 +1640,36 @@ impl ProjectPanel {
     // Returns list of entries that should be affected by an operation.
     // When currently selected entry is not marked, it's treated as the only marked entry.
     fn marked_entries(&self) -> BTreeSet<SelectedEntry> {
-        let Some(selection) = self.selection else {
+        let Some(mut selection) = self.selection else {
             return Default::default();
         };
         if self.marked_entries.contains(&selection) {
-            self.marked_entries.clone()
+            self.marked_entries
+                .iter()
+                .copied()
+                .map(|mut entry| {
+                    entry.entry_id = self.resolve_entry(entry.entry_id);
+                    entry
+                })
+                .collect()
         } else {
+            selection.entry_id = self.resolve_entry(selection.entry_id);
             BTreeSet::from_iter([selection])
         }
     }
+
+    fn resolve_entry(&self, id: ProjectEntryId) -> ProjectEntryId {
+        self.ancestors
+            .get(&id)
+            .and_then(|ancestors| {
+                if ancestors.current_ancestor_depth == 0 {
+                    return None;
+                }
+                ancestors.ancestors.get(ancestors.current_ancestor_depth)
+            })
+            .copied()
+            .unwrap_or(id)
+    }
     pub fn selected_entry<'a>(
         &self,
         cx: &'a AppContext,
@@ -1613,6 +1678,21 @@ impl ProjectPanel {
         Some((worktree.read(cx), entry))
     }
 
+    /// Compared to selected_entry, this function resolves to the currently
+    /// selected subentry if dir auto-folding is enabled.
+    fn selected_sub_entry<'a>(
+        &self,
+        cx: &'a AppContext,
+    ) -> Option<(&'a Worktree, &'a project::Entry)> {
+        let (worktree, mut entry) = self.selected_entry_handle(cx)?;
+
+        let worktree = worktree.read(cx);
+        let resolved_id = self.resolve_entry(entry.id);
+        if resolved_id != entry.id {
+            entry = worktree.entry_for_id(resolved_id)?;
+        }
+        Some((worktree, entry))
+    }
     fn selected_entry_handle<'a>(
         &self,
         cx: &'a AppContext,
@@ -1655,6 +1735,7 @@ impl ProjectPanel {
             .and_then(|worktree| worktree.read(cx).root_entry())
             .map(|entry| entry.id);
 
+        let old_ancestors = std::mem::take(&mut self.ancestors);
         self.visible_entries.clear();
         for worktree in project.visible_worktrees(cx) {
             let snapshot = worktree.read(cx).snapshot();
@@ -1688,25 +1769,42 @@ impl ProjectPanel {
 
             let mut visible_worktree_entries = Vec::new();
             let mut entry_iter = snapshot.entries(true, 0);
+            let mut auto_folded_ancestors = vec![];
             while let Some(entry) = entry_iter.entry() {
-                if auto_collapse_dirs
-                    && entry.kind.is_dir()
-                    && !self.unfolded_dir_ids.contains(&entry.id)
-                {
-                    if let Some(root_path) = snapshot.root_entry() {
-                        let mut child_entries = snapshot.child_entries(&entry.path);
-                        if let Some(child) = child_entries.next() {
-                            if entry.path != root_path.path
-                                && child_entries.next().is_none()
-                                && child.kind.is_dir()
-                            {
-                                entry_iter.advance();
-                                continue;
+                if auto_collapse_dirs && entry.kind.is_dir() {
+                    auto_folded_ancestors.push(entry.id);
+                    if !self.unfolded_dir_ids.contains(&entry.id) {
+                        if let Some(root_path) = snapshot.root_entry() {
+                            let mut child_entries = snapshot.child_entries(&entry.path);
+                            if let Some(child) = child_entries.next() {
+                                if entry.path != root_path.path
+                                    && child_entries.next().is_none()
+                                    && child.kind.is_dir()
+                                {
+                                    entry_iter.advance();
+
+                                    continue;
+                                }
                             }
                         }
                     }
+                    let depth = old_ancestors
+                        .get(&entry.id)
+                        .map(|ancestor| ancestor.current_ancestor_depth)
+                        .unwrap_or_default();
+                    let mut ancestors = std::mem::take(&mut auto_folded_ancestors);
+                    if ancestors.len() > 1 {
+                        ancestors.reverse();
+                        self.ancestors.insert(
+                            entry.id,
+                            FoldedAncestors {
+                                current_ancestor_depth: depth,
+                                ancestors,
+                            },
+                        );
+                    }
                 }
-
+                auto_folded_ancestors.clear();
                 visible_worktree_entries.push(entry.clone());
                 if Some(entry.id) == new_entry_parent_id {
                     visible_worktree_entries.push(Entry {
@@ -1999,6 +2097,7 @@ impl ProjectPanel {
                             .map_or(false, |e| e.is_cut() && e.items().contains(&selection)),
                         git_status: status,
                         is_private: entry.is_private,
+                        is_auto_folded: difference > 1,
                         worktree_id: *worktree_id,
                         canonical_path: entry.canonical_path.clone(),
                     };
@@ -2008,6 +2107,15 @@ impl ProjectPanel {
                             entry.id == NEW_ENTRY_ID
                         } else {
                             entry.id == edit_state.entry_id
+                                || self
+                                    .ancestors
+                                    .get(&entry.id)
+                                    .is_some_and(|auto_folded_dirs| {
+                                        auto_folded_dirs
+                                            .ancestors
+                                            .iter()
+                                            .any(|entry_id| *entry_id == edit_state.entry_id)
+                                    })
                         };
 
                         if is_edited_entry {
@@ -2102,6 +2210,7 @@ impl ProjectPanel {
             active_selection: selection,
             marked_selections: selections,
         };
+        let is_auto_folded = details.is_auto_folded;
         div()
             .id(entry_id.to_proto() as usize)
             .on_drag_move::<ExternalPaths>(cx.listener(
@@ -2202,11 +2311,78 @@ impl ProjectPanel {
                         if let (Some(editor), true) = (Some(&self.filename_editor), show_editor) {
                             h_flex().h_6().w_full().child(editor.clone())
                         } else {
-                            h_flex().h_6().child(
-                                Label::new(file_name)
-                                    .single_line()
-                                    .color(filename_text_color),
-                            )
+                            h_flex().h_6().map(|this| {
+                                if is_auto_folded && is_active {
+                                    let folded_ancestors = self.ancestors.get(&entry_id).unwrap();
+                                    let Some(part_to_highlight) = Path::new(&file_name)
+                                        .ancestors()
+                                        .nth(folded_ancestors.current_ancestor_depth)
+                                    else {
+                                        return this;
+                                    };
+
+                                    let suffix = Path::new(&file_name)
+                                        .strip_prefix(part_to_highlight)
+                                        .ok()
+                                        .filter(|suffix| !suffix.as_os_str().is_empty());
+                                    let prefix = part_to_highlight
+                                        .parent()
+                                        .filter(|prefix| !prefix.as_os_str().is_empty());
+                                    let Some(part_to_highlight) = part_to_highlight
+                                        .file_name()
+                                        .and_then(|name| name.to_str().map(String::from))
+                                    else {
+                                        return this;
+                                    };
+
+                                    this.children(prefix.and_then(|prefix| {
+                                        Some(
+                                            h_flex()
+                                                .child(
+                                                    Label::new(prefix.to_str().map(String::from)?)
+                                                        .single_line()
+                                                        .color(filename_text_color),
+                                                )
+                                                .child(
+                                                    Label::new(std::path::MAIN_SEPARATOR_STR)
+                                                        .single_line()
+                                                        .color(filename_text_color),
+                                                ),
+                                        )
+                                    }))
+                                    .child(
+                                        Label::new(part_to_highlight)
+                                            .single_line()
+                                            .color(filename_text_color)
+                                            .underline(true),
+                                    )
+                                    .children(
+                                        suffix.and_then(|suffix| {
+                                            Some(
+                                                h_flex()
+                                                    .child(
+                                                        Label::new(std::path::MAIN_SEPARATOR_STR)
+                                                            .single_line()
+                                                            .color(filename_text_color),
+                                                    )
+                                                    .child(
+                                                        Label::new(
+                                                            suffix.to_str().map(String::from)?,
+                                                        )
+                                                        .single_line()
+                                                        .color(filename_text_color),
+                                                    ),
+                                            )
+                                        }),
+                                    )
+                                } else {
+                                    this.child(
+                                        Label::new(file_name)
+                                            .single_line()
+                                            .color(filename_text_color),
+                                    )
+                                }
+                            })
                         }
                         .ml_1(),
                     )
@@ -2551,7 +2727,7 @@ impl Render for ProjectPanel {
                 .child(
                     uniform_list(cx.view().clone(), "entries", items_count, {
                         |this, range, cx| {
-                            let mut items = Vec::new();
+                            let mut items = Vec::with_capacity(range.end - range.start);
                             this.for_each_visible_entry(range, cx, |id, details, cx| {
                                 items.push(this.render_entry(id, details, cx));
                             });
diff --git a/crates/ui/src/components/label/highlighted_label.rs b/crates/ui/src/components/label/highlighted_label.rs
index ab71ffdc4c7204..6b170bb810f42b 100644
--- a/crates/ui/src/components/label/highlighted_label.rs
+++ b/crates/ui/src/components/label/highlighted_label.rs
@@ -58,6 +58,11 @@ impl LabelCommon for HighlightedLabel {
         self.base = self.base.alpha(alpha);
         self
     }
+
+    fn underline(mut self, underline: bool) -> Self {
+        self.base = self.base.underline(underline);
+        self
+    }
 }
 
 pub fn highlight_ranges(
diff --git a/crates/ui/src/components/label/label.rs b/crates/ui/src/components/label/label.rs
index f29e4656e933ca..898a59de775d9e 100644
--- a/crates/ui/src/components/label/label.rs
+++ b/crates/ui/src/components/label/label.rs
@@ -170,6 +170,11 @@ impl LabelCommon for Label {
         self.base = self.base.alpha(alpha);
         self
     }
+
+    fn underline(mut self, underline: bool) -> Self {
+        self.base = self.base.underline(underline);
+        self
+    }
 }
 
 impl RenderOnce for Label {
diff --git a/crates/ui/src/components/label/label_like.rs b/crates/ui/src/components/label/label_like.rs
index a59c93e31d6c5d..bc2fae15a7fdc4 100644
--- a/crates/ui/src/components/label/label_like.rs
+++ b/crates/ui/src/components/label/label_like.rs
@@ -1,4 +1,4 @@
-use gpui::{relative, AnyElement, FontWeight, StyleRefinement, Styled};
+use gpui::{relative, AnyElement, FontWeight, StyleRefinement, Styled, UnderlineStyle};
 use settings::Settings;
 use smallvec::SmallVec;
 use theme::ThemeSettings;
@@ -42,6 +42,9 @@ pub trait LabelCommon {
     /// Sets the italic property of the label.
     fn italic(self, italic: bool) -> Self;
 
+    /// Sets the underline property of the label
+    fn underline(self, underline: bool) -> Self;
+
     /// Sets the alpha property of the label, overwriting the alpha value of the color.
     fn alpha(self, alpha: f32) -> Self;
 }
@@ -57,6 +60,7 @@ pub struct LabelLike {
     italic: bool,
     children: SmallVec<[AnyElement; 2]>,
     alpha: Option<f32>,
+    underline: bool,
 }
 
 impl Default for LabelLike {
@@ -77,6 +81,7 @@ impl LabelLike {
             italic: false,
             children: SmallVec::new(),
             alpha: None,
+            underline: false,
         }
     }
 }
@@ -123,6 +128,11 @@ impl LabelCommon for LabelLike {
         self
     }
 
+    fn underline(mut self, underline: bool) -> Self {
+        self.underline = underline;
+        self
+    }
+
     fn alpha(mut self, alpha: f32) -> Self {
         self.alpha = Some(alpha);
         self
@@ -165,6 +175,16 @@ impl RenderOnce for LabelLike {
                 this.line_height(relative(1.))
             })
             .when(self.italic, |this| this.italic())
+            .when(self.underline, |mut this| {
+                this.text_style()
+                    .get_or_insert_with(Default::default)
+                    .underline = Some(UnderlineStyle {
+                    thickness: px(1.),
+                    color: None,
+                    wavy: false,
+                });
+                this
+            })
             .text_color(color)
             .font_weight(self.weight.unwrap_or(settings.ui_font.weight))
             .children(self.children)

From fcf79c0f1d6ec5153fef7ee3191450e50749dff9 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Mon, 9 Sep 2024 15:01:26 +0200
Subject: [PATCH 002/762] assistant: Support copy/pasting creases (#17490)

https://github.com/user-attachments/assets/78a2572d-8e8f-4206-9680-dcd884e7bbbd

Release Notes:

- Added support for copying and pasting slash commands in the assistant
panel

---------

Co-authored-by: Thorsten <thorsten@zed.dev>
---
 crates/assistant/src/assistant_panel.rs     | 233 ++++++++++++++++----
 crates/editor/src/display_map/crease_map.rs |  92 +++++++-
 2 files changed, 280 insertions(+), 45 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index fd5f62e1881f99..0828b9b9916725 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -26,8 +26,8 @@ use collections::{BTreeSet, HashMap, HashSet};
 use editor::{
     actions::{FoldAt, MoveToEndOfLine, Newline, ShowCompletions, UnfoldAt},
     display_map::{
-        BlockDisposition, BlockId, BlockProperties, BlockStyle, Crease, CustomBlockId, FoldId,
-        RenderBlock, ToDisplayPoint,
+        BlockDisposition, BlockId, BlockProperties, BlockStyle, Crease, CreaseMetadata,
+        CustomBlockId, FoldId, RenderBlock, ToDisplayPoint,
     },
     scroll::{Autoscroll, AutoscrollStrategy, ScrollAnchor},
     Anchor, Editor, EditorEvent, ExcerptRange, MultiBuffer, RowExt, ToOffset as _, ToPoint,
@@ -54,13 +54,13 @@ use multi_buffer::MultiBufferRow;
 use picker::{Picker, PickerDelegate};
 use project::{Project, ProjectLspAdapterDelegate, Worktree};
 use search::{buffer_search::DivRegistrar, BufferSearchBar};
+use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings};
 use smol::stream::StreamExt;
 use std::{
     borrow::Cow,
     cmp,
     collections::hash_map,
-    fmt::Write,
     ops::{ControlFlow, Range},
     path::PathBuf,
     sync::Arc,
@@ -2491,20 +2491,26 @@ impl ContextEditor {
                     .unwrap();
                 let buffer_row = MultiBufferRow(start.to_point(&buffer).row);
                 buffer_rows_to_fold.insert(buffer_row);
-                creases.push(Crease::new(
-                    start..end,
-                    FoldPlaceholder {
-                        render: render_fold_icon_button(
-                            cx.view().downgrade(),
-                            section.icon,
-                            section.label.clone(),
-                        ),
-                        constrain_width: false,
-                        merge_adjacent: false,
-                    },
-                    render_slash_command_output_toggle,
-                    |_, _, _| Empty.into_any_element(),
-                ));
+                creases.push(
+                    Crease::new(
+                        start..end,
+                        FoldPlaceholder {
+                            render: render_fold_icon_button(
+                                cx.view().downgrade(),
+                                section.icon,
+                                section.label.clone(),
+                            ),
+                            constrain_width: false,
+                            merge_adjacent: false,
+                        },
+                        render_slash_command_output_toggle,
+                        |_, _, _| Empty.into_any_element(),
+                    )
+                    .with_metadata(CreaseMetadata {
+                        icon: section.icon,
+                        label: section.label,
+                    }),
+                );
             }
 
             editor.insert_creases(creases, cx);
@@ -3318,39 +3324,113 @@ impl ContextEditor {
     }
 
     fn copy(&mut self, _: &editor::actions::Copy, cx: &mut ViewContext<Self>) {
-        let editor = self.editor.read(cx);
-        let context = self.context.read(cx);
-        if editor.selections.count() == 1 {
-            let selection = editor.selections.newest::<usize>(cx);
-            let mut copied_text = String::new();
-            let mut spanned_messages = 0;
-            for message in context.messages(cx) {
-                if message.offset_range.start >= selection.range().end {
-                    break;
-                } else if message.offset_range.end >= selection.range().start {
-                    let range = cmp::max(message.offset_range.start, selection.range().start)
-                        ..cmp::min(message.offset_range.end, selection.range().end);
-                    if !range.is_empty() {
-                        spanned_messages += 1;
-                        write!(&mut copied_text, "## {}\n\n", message.role).unwrap();
-                        for chunk in context.buffer().read(cx).text_for_range(range) {
-                            copied_text.push_str(chunk);
+        if self.editor.read(cx).selections.count() == 1 {
+            let (copied_text, metadata) = self.get_clipboard_contents(cx);
+            cx.write_to_clipboard(ClipboardItem::new_string_with_json_metadata(
+                copied_text,
+                metadata,
+            ));
+            cx.stop_propagation();
+            return;
+        }
+
+        cx.propagate();
+    }
+
+    fn cut(&mut self, _: &editor::actions::Cut, cx: &mut ViewContext<Self>) {
+        if self.editor.read(cx).selections.count() == 1 {
+            let (copied_text, metadata) = self.get_clipboard_contents(cx);
+
+            self.editor.update(cx, |editor, cx| {
+                let selections = editor.selections.all::<Point>(cx);
+
+                editor.transact(cx, |this, cx| {
+                    this.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                        s.select(selections);
+                    });
+                    this.insert("", cx);
+                    cx.write_to_clipboard(ClipboardItem::new_string_with_json_metadata(
+                        copied_text,
+                        metadata,
+                    ));
+                });
+            });
+
+            cx.stop_propagation();
+            return;
+        }
+
+        cx.propagate();
+    }
+
+    fn get_clipboard_contents(&mut self, cx: &mut ViewContext<Self>) -> (String, CopyMetadata) {
+        let creases = self.editor.update(cx, |editor, cx| {
+            let selection = editor.selections.newest::<Point>(cx);
+            let selection_start = editor.selections.newest::<usize>(cx).start;
+            let snapshot = editor.buffer().read(cx).snapshot(cx);
+            editor.display_map.update(cx, |display_map, cx| {
+                display_map
+                    .snapshot(cx)
+                    .crease_snapshot
+                    .creases_in_range(
+                        MultiBufferRow(selection.start.row)..MultiBufferRow(selection.end.row + 1),
+                        &snapshot,
+                    )
+                    .filter_map(|crease| {
+                        if let Some(metadata) = &crease.metadata {
+                            let start = crease
+                                .range
+                                .start
+                                .to_offset(&snapshot)
+                                .saturating_sub(selection_start);
+                            let end = crease
+                                .range
+                                .end
+                                .to_offset(&snapshot)
+                                .saturating_sub(selection_start);
+
+                            let range_relative_to_selection = start..end;
+
+                            if range_relative_to_selection.is_empty() {
+                                None
+                            } else {
+                                Some(SelectedCreaseMetadata {
+                                    range_relative_to_selection,
+                                    crease: metadata.clone(),
+                                })
+                            }
+                        } else {
+                            None
                         }
-                        copied_text.push('\n');
+                    })
+                    .collect::<Vec<_>>()
+            })
+        });
+
+        let context = self.context.read(cx);
+        let selection = self.editor.read(cx).selections.newest::<usize>(cx);
+        let mut text = String::new();
+        for message in context.messages(cx) {
+            if message.offset_range.start >= selection.range().end {
+                break;
+            } else if message.offset_range.end >= selection.range().start {
+                let range = cmp::max(message.offset_range.start, selection.range().start)
+                    ..cmp::min(message.offset_range.end, selection.range().end);
+                if !range.is_empty() {
+                    for chunk in context.buffer().read(cx).text_for_range(range) {
+                        text.push_str(chunk);
                     }
+                    text.push('\n');
                 }
             }
-
-            if spanned_messages > 1 {
-                cx.write_to_clipboard(ClipboardItem::new_string(copied_text));
-                return;
-            }
         }
 
-        cx.propagate();
+        (text, CopyMetadata { creases })
     }
 
-    fn paste(&mut self, _: &editor::actions::Paste, cx: &mut ViewContext<Self>) {
+    fn paste(&mut self, action: &editor::actions::Paste, cx: &mut ViewContext<Self>) {
+        cx.stop_propagation();
+
         let images = if let Some(item) = cx.read_from_clipboard() {
             item.into_entries()
                 .filter_map(|entry| {
@@ -3365,9 +3445,62 @@ impl ContextEditor {
             Vec::new()
         };
 
+        let metadata = if let Some(item) = cx.read_from_clipboard() {
+            item.entries().first().and_then(|entry| {
+                if let ClipboardEntry::String(text) = entry {
+                    text.metadata_json::<CopyMetadata>()
+                } else {
+                    None
+                }
+            })
+        } else {
+            None
+        };
+
         if images.is_empty() {
-            // If we didn't find any valid image data to paste, propagate to let normal pasting happen.
-            cx.propagate();
+            self.editor.update(cx, |editor, cx| {
+                let paste_position = editor.selections.newest::<usize>(cx).head();
+                editor.paste(action, cx);
+
+                if let Some(metadata) = metadata {
+                    let buffer = editor.buffer().read(cx).snapshot(cx);
+
+                    let mut buffer_rows_to_fold = BTreeSet::new();
+                    let weak_editor = cx.view().downgrade();
+                    editor.insert_creases(
+                        metadata.creases.into_iter().map(|metadata| {
+                            let start = buffer.anchor_after(
+                                paste_position + metadata.range_relative_to_selection.start,
+                            );
+                            let end = buffer.anchor_before(
+                                paste_position + metadata.range_relative_to_selection.end,
+                            );
+
+                            let buffer_row = MultiBufferRow(start.to_point(&buffer).row);
+                            buffer_rows_to_fold.insert(buffer_row);
+                            Crease::new(
+                                start..end,
+                                FoldPlaceholder {
+                                    constrain_width: false,
+                                    render: render_fold_icon_button(
+                                        weak_editor.clone(),
+                                        metadata.crease.icon,
+                                        metadata.crease.label.clone(),
+                                    ),
+                                    merge_adjacent: false,
+                                },
+                                render_slash_command_output_toggle,
+                                |_, _, _| Empty.into_any(),
+                            )
+                            .with_metadata(metadata.crease.clone())
+                        }),
+                        cx,
+                    );
+                    for buffer_row in buffer_rows_to_fold.into_iter().rev() {
+                        editor.fold_at(&FoldAt { buffer_row }, cx);
+                    }
+                }
+            });
         } else {
             let mut image_positions = Vec::new();
             self.editor.update(cx, |editor, cx| {
@@ -4037,6 +4170,17 @@ fn render_fold_icon_button(
     })
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct CopyMetadata {
+    creases: Vec<SelectedCreaseMetadata>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct SelectedCreaseMetadata {
+    range_relative_to_selection: Range<usize>,
+    crease: CreaseMetadata,
+}
+
 impl EventEmitter<EditorEvent> for ContextEditor {}
 impl EventEmitter<SearchEvent> for ContextEditor {}
 
@@ -4062,6 +4206,7 @@ impl Render for ContextEditor {
             .capture_action(cx.listener(ContextEditor::cancel))
             .capture_action(cx.listener(ContextEditor::save))
             .capture_action(cx.listener(ContextEditor::copy))
+            .capture_action(cx.listener(ContextEditor::cut))
             .capture_action(cx.listener(ContextEditor::paste))
             .capture_action(cx.listener(ContextEditor::cycle_message_role))
             .capture_action(cx.listener(ContextEditor::confirm_command))
diff --git a/crates/editor/src/display_map/crease_map.rs b/crates/editor/src/display_map/crease_map.rs
index 9aa2728dca8c45..10ee125b3237ac 100644
--- a/crates/editor/src/display_map/crease_map.rs
+++ b/crates/editor/src/display_map/crease_map.rs
@@ -1,10 +1,11 @@
 use collections::HashMap;
 use gpui::{AnyElement, IntoElement};
 use multi_buffer::{Anchor, AnchorRangeExt, MultiBufferRow, MultiBufferSnapshot, ToPoint};
+use serde::{Deserialize, Serialize};
 use std::{cmp::Ordering, ops::Range, sync::Arc};
 use sum_tree::{Bias, SeekTarget, SumTree};
 use text::Point;
-use ui::WindowContext;
+use ui::{IconName, SharedString, WindowContext};
 
 use crate::FoldPlaceholder;
 
@@ -49,6 +50,31 @@ impl CreaseSnapshot {
         None
     }
 
+    pub fn creases_in_range<'a>(
+        &'a self,
+        range: Range<MultiBufferRow>,
+        snapshot: &'a MultiBufferSnapshot,
+    ) -> impl '_ + Iterator<Item = &'a Crease> {
+        let start = snapshot.anchor_before(Point::new(range.start.0, 0));
+        let mut cursor = self.creases.cursor::<ItemSummary>();
+        cursor.seek(&start, Bias::Left, snapshot);
+
+        std::iter::from_fn(move || {
+            while let Some(item) = cursor.item() {
+                cursor.next(snapshot);
+                let crease_start = item.crease.range.start.to_point(snapshot);
+                let crease_end = item.crease.range.end.to_point(snapshot);
+                if crease_end.row > range.end.0 {
+                    continue;
+                }
+                if crease_start.row >= range.start.0 && crease_end.row < range.end.0 {
+                    return Some(&item.crease);
+                }
+            }
+            None
+        })
+    }
+
     pub fn crease_items_with_offsets(
         &self,
         snapshot: &MultiBufferSnapshot,
@@ -87,6 +113,14 @@ pub struct Crease {
     pub placeholder: FoldPlaceholder,
     pub render_toggle: RenderToggleFn,
     pub render_trailer: RenderTrailerFn,
+    pub metadata: Option<CreaseMetadata>,
+}
+
+/// Metadata about a [`Crease`], that is used for serialization.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CreaseMetadata {
+    pub icon: IconName,
+    pub label: SharedString,
 }
 
 impl Crease {
@@ -124,8 +158,14 @@ impl Crease {
             render_trailer: Arc::new(move |row, folded, cx| {
                 render_trailer(row, folded, cx).into_any_element()
             }),
+            metadata: None,
         }
     }
+
+    pub fn with_metadata(mut self, metadata: CreaseMetadata) -> Self {
+        self.metadata = Some(metadata);
+        self
+    }
 }
 
 impl std::fmt::Debug for Crease {
@@ -304,4 +344,54 @@ mod test {
             .query_row(MultiBufferRow(3), &snapshot)
             .is_none());
     }
+
+    #[gpui::test]
+    fn test_creases_in_range(cx: &mut AppContext) {
+        let text = "line1\nline2\nline3\nline4\nline5\nline6\nline7";
+        let buffer = MultiBuffer::build_simple(text, cx);
+        let snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
+        let mut crease_map = CreaseMap::default();
+
+        let creases = [
+            Crease::new(
+                snapshot.anchor_before(Point::new(1, 0))..snapshot.anchor_after(Point::new(1, 5)),
+                FoldPlaceholder::test(),
+                |_row, _folded, _toggle, _cx| div(),
+                |_row, _folded, _cx| div(),
+            ),
+            Crease::new(
+                snapshot.anchor_before(Point::new(3, 0))..snapshot.anchor_after(Point::new(3, 5)),
+                FoldPlaceholder::test(),
+                |_row, _folded, _toggle, _cx| div(),
+                |_row, _folded, _cx| div(),
+            ),
+            Crease::new(
+                snapshot.anchor_before(Point::new(5, 0))..snapshot.anchor_after(Point::new(5, 5)),
+                FoldPlaceholder::test(),
+                |_row, _folded, _toggle, _cx| div(),
+                |_row, _folded, _cx| div(),
+            ),
+        ];
+        crease_map.insert(creases, &snapshot);
+
+        let crease_snapshot = crease_map.snapshot();
+
+        let range = MultiBufferRow(0)..MultiBufferRow(7);
+        let creases: Vec<_> = crease_snapshot.creases_in_range(range, &snapshot).collect();
+        assert_eq!(creases.len(), 3);
+
+        let range = MultiBufferRow(2)..MultiBufferRow(5);
+        let creases: Vec<_> = crease_snapshot.creases_in_range(range, &snapshot).collect();
+        assert_eq!(creases.len(), 1);
+        assert_eq!(creases[0].range.start.to_point(&snapshot).row, 3);
+
+        let range = MultiBufferRow(0)..MultiBufferRow(2);
+        let creases: Vec<_> = crease_snapshot.creases_in_range(range, &snapshot).collect();
+        assert_eq!(creases.len(), 1);
+        assert_eq!(creases[0].range.start.to_point(&snapshot).row, 1);
+
+        let range = MultiBufferRow(6)..MultiBufferRow(7);
+        let creases: Vec<_> = crease_snapshot.creases_in_range(range, &snapshot).collect();
+        assert_eq!(creases.len(), 0);
+    }
 }

From dd257b8412c3c8005c710185dc8fc2eed3cc67ba Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Mon, 9 Sep 2024 15:14:07 +0200
Subject: [PATCH 003/762] project panel: Do not allow collapsing auto-folded
 directory past the list of ancestors (#17594)

Closes #ISSUE

Release Notes:

- N/A
---
 crates/project_panel/src/project_panel.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index be945cde773bbc..9add77c864db97 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -637,7 +637,9 @@ impl ProjectPanel {
     fn collapse_selected_entry(&mut self, _: &CollapseSelectedEntry, cx: &mut ViewContext<Self>) {
         if let Some((worktree, mut entry)) = self.selected_entry(cx) {
             if let Some(folded_ancestors) = self.ancestors.get_mut(&entry.id) {
-                if folded_ancestors.current_ancestor_depth < folded_ancestors.max_ancestor_depth() {
+                if folded_ancestors.current_ancestor_depth + 1
+                    < folded_ancestors.max_ancestor_depth()
+                {
                     folded_ancestors.current_ancestor_depth += 1;
                     cx.notify();
                     return;

From 12dde176084c9950b78093c1e7fb13e5988292ba Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Mon, 9 Sep 2024 18:31:55 +0200
Subject: [PATCH 004/762] assistant panel: automatically insert selections
 (#17589)

Addresses parts of feedback from
https://www.jacobcolling.com/friction-log/zed-friction-log

Release Notes:
- "Assistant::NewContext" now automatically does quote selection as well
- "Assistant::QuoteSelection" now handles multicursor selections,
inserting multiple excerpts.
---
 crates/assistant/src/assistant_panel.rs | 226 +++++++++++++-----------
 1 file changed, 120 insertions(+), 106 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 0828b9b9916725..82888b498a3c80 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -939,9 +939,16 @@ impl AssistantPanel {
         cx: &mut ViewContext<Workspace>,
     ) {
         if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
-            panel.update(cx, |panel, cx| {
-                panel.new_context(cx);
-            });
+            let did_create_context = panel
+                .update(cx, |panel, cx| {
+                    panel.new_context(cx)?;
+
+                    Some(())
+                })
+                .is_some();
+            if did_create_context {
+                ContextEditor::quote_selection(workspace, &Default::default(), cx);
+            }
         }
     }
 
@@ -3186,87 +3193,93 @@ impl ContextEditor {
             return;
         };
 
-        let selection = editor.update(cx, |editor, cx| editor.selections.newest_adjusted(cx));
-        let editor = editor.read(cx);
-        let buffer = editor.buffer().read(cx).snapshot(cx);
-        let range = editor::ToOffset::to_offset(&selection.start, &buffer)
-            ..editor::ToOffset::to_offset(&selection.end, &buffer);
-        let selected_text = buffer.text_for_range(range.clone()).collect::<String>();
-        if selected_text.is_empty() {
-            return;
-        }
-
-        let start_language = buffer.language_at(range.start);
-        let end_language = buffer.language_at(range.end);
-        let language_name = if start_language == end_language {
-            start_language.map(|language| language.code_fence_block_name())
-        } else {
-            None
-        };
-        let language_name = language_name.as_deref().unwrap_or("");
-
-        let filename = buffer
-            .file_at(selection.start)
-            .map(|file| file.full_path(cx));
-
-        let text = if language_name == "markdown" {
-            selected_text
-                .lines()
-                .map(|line| format!("> {}", line))
-                .collect::<Vec<_>>()
-                .join("\n")
-        } else {
-            let start_symbols = buffer
-                .symbols_containing(selection.start, None)
-                .map(|(_, symbols)| symbols);
-            let end_symbols = buffer
-                .symbols_containing(selection.end, None)
-                .map(|(_, symbols)| symbols);
-
-            let outline_text =
-                if let Some((start_symbols, end_symbols)) = start_symbols.zip(end_symbols) {
-                    Some(
-                        start_symbols
-                            .into_iter()
-                            .zip(end_symbols)
-                            .take_while(|(a, b)| a == b)
-                            .map(|(a, _)| a.text)
-                            .collect::<Vec<_>>()
-                            .join(" > "),
-                    )
+        let mut creases = vec![];
+        editor.update(cx, |editor, cx| {
+            let selections = editor.selections.all_adjusted(cx);
+            let buffer = editor.buffer().read(cx).snapshot(cx);
+            for selection in selections {
+                let range = editor::ToOffset::to_offset(&selection.start, &buffer)
+                    ..editor::ToOffset::to_offset(&selection.end, &buffer);
+                let selected_text = buffer.text_for_range(range.clone()).collect::<String>();
+                if selected_text.is_empty() {
+                    continue;
+                }
+                let start_language = buffer.language_at(range.start);
+                let end_language = buffer.language_at(range.end);
+                let language_name = if start_language == end_language {
+                    start_language.map(|language| language.code_fence_block_name())
                 } else {
                     None
                 };
+                let language_name = language_name.as_deref().unwrap_or("");
+                let filename = buffer
+                    .file_at(selection.start)
+                    .map(|file| file.full_path(cx));
+                let text = if language_name == "markdown" {
+                    selected_text
+                        .lines()
+                        .map(|line| format!("> {}", line))
+                        .collect::<Vec<_>>()
+                        .join("\n")
+                } else {
+                    let start_symbols = buffer
+                        .symbols_containing(selection.start, None)
+                        .map(|(_, symbols)| symbols);
+                    let end_symbols = buffer
+                        .symbols_containing(selection.end, None)
+                        .map(|(_, symbols)| symbols);
+
+                    let outline_text = if let Some((start_symbols, end_symbols)) =
+                        start_symbols.zip(end_symbols)
+                    {
+                        Some(
+                            start_symbols
+                                .into_iter()
+                                .zip(end_symbols)
+                                .take_while(|(a, b)| a == b)
+                                .map(|(a, _)| a.text)
+                                .collect::<Vec<_>>()
+                                .join(" > "),
+                        )
+                    } else {
+                        None
+                    };
 
-            let line_comment_prefix = start_language
-                .and_then(|l| l.default_scope().line_comment_prefixes().first().cloned());
-
-            let fence = codeblock_fence_for_path(
-                filename.as_deref(),
-                Some(selection.start.row..selection.end.row),
-            );
+                    let line_comment_prefix = start_language
+                        .and_then(|l| l.default_scope().line_comment_prefixes().first().cloned());
 
-            if let Some((line_comment_prefix, outline_text)) = line_comment_prefix.zip(outline_text)
-            {
-                let breadcrumb = format!("{line_comment_prefix}Excerpt from: {outline_text}\n");
-                format!("{fence}{breadcrumb}{selected_text}\n```")
-            } else {
-                format!("{fence}{selected_text}\n```")
-            }
-        };
+                    let fence = codeblock_fence_for_path(
+                        filename.as_deref(),
+                        Some(selection.start.row..selection.end.row),
+                    );
 
-        let crease_title = if let Some(path) = filename {
-            let start_line = selection.start.row + 1;
-            let end_line = selection.end.row + 1;
-            if start_line == end_line {
-                format!("{}, Line {}", path.display(), start_line)
-            } else {
-                format!("{}, Lines {} to {}", path.display(), start_line, end_line)
+                    if let Some((line_comment_prefix, outline_text)) =
+                        line_comment_prefix.zip(outline_text)
+                    {
+                        let breadcrumb =
+                            format!("{line_comment_prefix}Excerpt from: {outline_text}\n");
+                        format!("{fence}{breadcrumb}{selected_text}\n```")
+                    } else {
+                        format!("{fence}{selected_text}\n```")
+                    }
+                };
+                let crease_title = if let Some(path) = filename {
+                    let start_line = selection.start.row + 1;
+                    let end_line = selection.end.row + 1;
+                    if start_line == end_line {
+                        format!("{}, Line {}", path.display(), start_line)
+                    } else {
+                        format!("{}, Lines {} to {}", path.display(), start_line, end_line)
+                    }
+                } else {
+                    "Quoted selection".to_string()
+                };
+                creases.push((text, crease_title));
             }
-        } else {
-            "Quoted selection".to_string()
-        };
-
+        });
+        if creases.is_empty() {
+            return;
+        }
         // Activate the panel
         if !panel.focus_handle(cx).contains_focused(cx) {
             workspace.toggle_panel_focus::<AssistantPanel>(cx);
@@ -3283,39 +3296,40 @@ impl ContextEditor {
                     context.update(cx, |context, cx| {
                         context.editor.update(cx, |editor, cx| {
                             editor.insert("\n", cx);
+                            for (text, crease_title) in creases {
+                                let point = editor.selections.newest::<Point>(cx).head();
+                                let start_row = MultiBufferRow(point.row);
 
-                            let point = editor.selections.newest::<Point>(cx).head();
-                            let start_row = MultiBufferRow(point.row);
+                                editor.insert(&text, cx);
 
-                            editor.insert(&text, cx);
+                                let snapshot = editor.buffer().read(cx).snapshot(cx);
+                                let anchor_before = snapshot.anchor_after(point);
+                                let anchor_after = editor
+                                    .selections
+                                    .newest_anchor()
+                                    .head()
+                                    .bias_left(&snapshot);
 
-                            let snapshot = editor.buffer().read(cx).snapshot(cx);
-                            let anchor_before = snapshot.anchor_after(point);
-                            let anchor_after = editor
-                                .selections
-                                .newest_anchor()
-                                .head()
-                                .bias_left(&snapshot);
+                                editor.insert("\n", cx);
 
-                            editor.insert("\n", cx);
-
-                            let fold_placeholder = quote_selection_fold_placeholder(
-                                crease_title,
-                                cx.view().downgrade(),
-                            );
-                            let crease = Crease::new(
-                                anchor_before..anchor_after,
-                                fold_placeholder,
-                                render_quote_selection_output_toggle,
-                                |_, _, _| Empty.into_any(),
-                            );
-                            editor.insert_creases(vec![crease], cx);
-                            editor.fold_at(
-                                &FoldAt {
-                                    buffer_row: start_row,
-                                },
-                                cx,
-                            );
+                                let fold_placeholder = quote_selection_fold_placeholder(
+                                    crease_title,
+                                    cx.view().downgrade(),
+                                );
+                                let crease = Crease::new(
+                                    anchor_before..anchor_after,
+                                    fold_placeholder,
+                                    render_quote_selection_output_toggle,
+                                    |_, _, _| Empty.into_any(),
+                                );
+                                editor.insert_creases(vec![crease], cx);
+                                editor.fold_at(
+                                    &FoldAt {
+                                        buffer_row: start_row,
+                                    },
+                                    cx,
+                                );
+                            }
                         })
                     });
                 };

From 59be07ad90206fdba94dbdc66154831b24b9478a Mon Sep 17 00:00:00 2001
From: Fernando Tagawa <fernando.tagawa.gamail.com@gmail.com>
Date: Mon, 9 Sep 2024 18:27:45 -0300
Subject: [PATCH 005/762] x11: Implement Drag and Drop (#17491)

Closes #16225

Release Notes:

- x11: Implemented Drag and Drop.
---
 crates/gpui/src/platform/linux/x11/client.rs | 210 ++++++++++++++++++-
 crates/gpui/src/platform/linux/x11/window.rs |  17 ++
 typos.toml                                   |   4 +-
 3 files changed, 226 insertions(+), 5 deletions(-)

diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs
index f127d312d24bb9..0909d09f25438b 100644
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -1,3 +1,4 @@
+use core::str;
 use std::cell::RefCell;
 use std::collections::HashSet;
 use std::ops::Deref;
@@ -9,6 +10,8 @@ use calloop::generic::{FdWrapper, Generic};
 use calloop::{EventLoop, LoopHandle, RegistrationToken};
 
 use collections::HashMap;
+use http_client::Url;
+use smallvec::SmallVec;
 use util::ResultExt;
 
 use x11rb::connection::{Connection, RequestConnection};
@@ -17,9 +20,13 @@ use x11rb::errors::ConnectionError;
 use x11rb::protocol::randr::ConnectionExt as _;
 use x11rb::protocol::xinput::ConnectionExt;
 use x11rb::protocol::xkb::ConnectionExt as _;
-use x11rb::protocol::xproto::{ChangeWindowAttributesAux, ConnectionExt as _, KeyPressEvent};
+use x11rb::protocol::xproto::{
+    AtomEnum, ChangeWindowAttributesAux, ClientMessageData, ClientMessageEvent, ConnectionExt as _,
+    EventMask, KeyPressEvent,
+};
 use x11rb::protocol::{randr, render, xinput, xkb, xproto, Event};
 use x11rb::resource_manager::Database;
+use x11rb::wrapper::ConnectionExt as _;
 use x11rb::xcb_ffi::XCBConnection;
 use xim::{x11rb::X11rbClient, Client};
 use xim::{AttributeName, InputStyle};
@@ -30,8 +37,8 @@ use crate::platform::linux::LinuxClient;
 use crate::platform::{LinuxCommon, PlatformWindow};
 use crate::{
     modifiers_from_xinput_info, point, px, AnyWindowHandle, Bounds, ClipboardItem, CursorStyle,
-    DisplayId, Keystroke, Modifiers, ModifiersChangedEvent, Pixels, Platform, PlatformDisplay,
-    PlatformInput, Point, ScrollDelta, Size, TouchPhase, WindowParams, X11Window,
+    DisplayId, FileDropEvent, Keystroke, Modifiers, ModifiersChangedEvent, Pixels, Platform,
+    PlatformDisplay, PlatformInput, Point, ScrollDelta, Size, TouchPhase, WindowParams, X11Window,
 };
 
 use super::{button_of_key, modifiers_from_state, pressed_button_from_mask};
@@ -101,6 +108,14 @@ struct XKBStateNotiy {
     locked_layout: LayoutIndex,
 }
 
+#[derive(Debug, Default)]
+pub struct Xdnd {
+    other_window: xproto::Window,
+    drag_type: u32,
+    retrieved: bool,
+    position: Point<Pixels>,
+}
+
 pub struct X11ClientState {
     pub(crate) loop_handle: LoopHandle<'static, X11Client>,
     pub(crate) event_loop: Option<calloop::EventLoop<'static, X11Client>>,
@@ -142,6 +157,7 @@ pub struct X11ClientState {
     pub(crate) common: LinuxCommon,
     pub(crate) clipboard: x11_clipboard::Clipboard,
     pub(crate) clipboard_item: Option<ClipboardItem>,
+    pub(crate) xdnd_state: Xdnd,
 }
 
 #[derive(Clone)]
@@ -423,6 +439,7 @@ impl X11Client {
 
             clipboard,
             clipboard_item: None,
+            xdnd_state: Xdnd::default(),
         })))
     }
 
@@ -611,7 +628,7 @@ impl X11Client {
         match event {
             Event::ClientMessage(event) => {
                 let window = self.get_window(event.window)?;
-                let [atom, _arg1, arg2, arg3, _arg4] = event.data.as_data32();
+                let [atom, arg1, arg2, arg3, arg4] = event.data.as_data32();
                 let mut state = self.0.borrow_mut();
 
                 if atom == state.atoms.WM_DELETE_WINDOW {
@@ -627,6 +644,106 @@ impl X11Client {
                             hi: arg3 as i32,
                         })
                 }
+
+                if event.type_ == state.atoms.XdndEnter {
+                    state.xdnd_state.other_window = atom;
+                    if (arg1 & 0x1) == 0x1 {
+                        state.xdnd_state.drag_type = xdnd_get_supported_atom(
+                            &state.xcb_connection,
+                            &state.atoms,
+                            state.xdnd_state.other_window,
+                        );
+                    } else {
+                        if let Some(atom) = [arg2, arg3, arg4]
+                            .into_iter()
+                            .find(|atom| xdnd_is_atom_supported(*atom, &state.atoms))
+                        {
+                            state.xdnd_state.drag_type = atom;
+                        }
+                    }
+                } else if event.type_ == state.atoms.XdndLeave {
+                    window.handle_input(PlatformInput::FileDrop(FileDropEvent::Pending {
+                        position: state.xdnd_state.position,
+                    }));
+                    window.handle_input(PlatformInput::FileDrop(FileDropEvent::Exited {}));
+                    state.xdnd_state = Xdnd::default();
+                } else if event.type_ == state.atoms.XdndPosition {
+                    if let Ok(pos) = state
+                        .xcb_connection
+                        .query_pointer(event.window)
+                        .unwrap()
+                        .reply()
+                    {
+                        state.xdnd_state.position =
+                            Point::new(Pixels(pos.win_x as f32), Pixels(pos.win_y as f32));
+                    }
+                    if !state.xdnd_state.retrieved {
+                        state
+                            .xcb_connection
+                            .convert_selection(
+                                event.window,
+                                state.atoms.XdndSelection,
+                                state.xdnd_state.drag_type,
+                                state.atoms.XDND_DATA,
+                                arg3,
+                            )
+                            .unwrap();
+                    }
+                    xdnd_send_status(
+                        &state.xcb_connection,
+                        &state.atoms,
+                        event.window,
+                        state.xdnd_state.other_window,
+                        arg4,
+                    );
+                    window.handle_input(PlatformInput::FileDrop(FileDropEvent::Pending {
+                        position: state.xdnd_state.position,
+                    }));
+                } else if event.type_ == state.atoms.XdndDrop {
+                    xdnd_send_finished(
+                        &state.xcb_connection,
+                        &state.atoms,
+                        event.window,
+                        state.xdnd_state.other_window,
+                    );
+                    window.handle_input(PlatformInput::FileDrop(FileDropEvent::Submit {
+                        position: state.xdnd_state.position,
+                    }));
+                    state.xdnd_state = Xdnd::default();
+                }
+            }
+            Event::SelectionNotify(event) => {
+                let window = self.get_window(event.requestor)?;
+                let mut state = self.0.borrow_mut();
+                let property = state.xcb_connection.get_property(
+                    false,
+                    event.requestor,
+                    state.atoms.XDND_DATA,
+                    AtomEnum::ANY,
+                    0,
+                    1024,
+                );
+                if property.as_ref().log_err().is_none() {
+                    return Some(());
+                }
+                if let Ok(reply) = property.unwrap().reply() {
+                    match str::from_utf8(&reply.value) {
+                        Ok(file_list) => {
+                            let paths: SmallVec<[_; 2]> = file_list
+                                .lines()
+                                .filter_map(|path| Url::parse(path).log_err())
+                                .filter_map(|url| url.to_file_path().log_err())
+                                .collect();
+                            let input = PlatformInput::FileDrop(FileDropEvent::Entered {
+                                position: state.xdnd_state.position,
+                                paths: crate::ExternalPaths(paths),
+                            });
+                            window.handle_input(input);
+                            state.xdnd_state.retrieved = true;
+                        }
+                        Err(_) => {}
+                    }
+                }
             }
             Event::ConfigureNotify(event) => {
                 let bounds = Bounds {
@@ -1179,6 +1296,16 @@ impl LinuxClient for X11Client {
             state.scale_factor,
             state.common.appearance,
         )?;
+        state
+            .xcb_connection
+            .change_property32(
+                xproto::PropMode::REPLACE,
+                x_window,
+                state.atoms.XdndAware,
+                state.atoms.XA_ATOM,
+                &[5],
+            )
+            .unwrap();
 
         let screen_resources = state
             .xcb_connection
@@ -1540,3 +1667,78 @@ fn check_gtk_frame_extents_supported(
 
     supported_atoms.contains(&atoms._GTK_FRAME_EXTENTS)
 }
+
+fn xdnd_is_atom_supported(atom: u32, atoms: &XcbAtoms) -> bool {
+    return atom == atoms.TEXT
+        || atom == atoms.STRING
+        || atom == atoms.UTF8_STRING
+        || atom == atoms.TEXT_PLAIN
+        || atom == atoms.TEXT_PLAIN_UTF8
+        || atom == atoms.TextUriList;
+}
+
+fn xdnd_get_supported_atom(
+    xcb_connection: &XCBConnection,
+    supported_atoms: &XcbAtoms,
+    target: xproto::Window,
+) -> u32 {
+    let property = xcb_connection
+        .get_property(
+            false,
+            target,
+            supported_atoms.XdndTypeList,
+            AtomEnum::ANY,
+            0,
+            1024,
+        )
+        .unwrap();
+    if let Ok(reply) = property.reply() {
+        if let Some(atoms) = reply.value32() {
+            for atom in atoms {
+                if xdnd_is_atom_supported(atom, &supported_atoms) {
+                    return atom;
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+fn xdnd_send_finished(
+    xcb_connection: &XCBConnection,
+    atoms: &XcbAtoms,
+    source: xproto::Window,
+    target: xproto::Window,
+) {
+    let message = ClientMessageEvent {
+        format: 32,
+        window: target,
+        type_: atoms.XdndFinished,
+        data: ClientMessageData::from([source, 1, atoms.XdndActionCopy, 0, 0]),
+        sequence: 0,
+        response_type: xproto::CLIENT_MESSAGE_EVENT,
+    };
+    xcb_connection
+        .send_event(false, target, EventMask::default(), message)
+        .unwrap();
+}
+
+fn xdnd_send_status(
+    xcb_connection: &XCBConnection,
+    atoms: &XcbAtoms,
+    source: xproto::Window,
+    target: xproto::Window,
+    action: u32,
+) {
+    let message = ClientMessageEvent {
+        format: 32,
+        window: target,
+        type_: atoms.XdndStatus,
+        data: ClientMessageData::from([source, 1, 0, 0, action]),
+        sequence: 0,
+        response_type: xproto::CLIENT_MESSAGE_EVENT,
+    };
+    xcb_connection
+        .send_event(false, target, EventMask::default(), message)
+        .unwrap();
+}
diff --git a/crates/gpui/src/platform/linux/x11/window.rs b/crates/gpui/src/platform/linux/x11/window.rs
index f1aa10f31152ea..b0cf82d605ffff 100644
--- a/crates/gpui/src/platform/linux/x11/window.rs
+++ b/crates/gpui/src/platform/linux/x11/window.rs
@@ -32,7 +32,24 @@ use std::{
 use super::{X11Display, XINPUT_MASTER_DEVICE};
 x11rb::atom_manager! {
     pub XcbAtoms: AtomsCookie {
+        XA_ATOM,
+        XdndAware,
+        XdndStatus,
+        XdndEnter,
+        XdndLeave,
+        XdndPosition,
+        XdndSelection,
+        XdndDrop,
+        XdndFinished,
+        XdndTypeList,
+        XdndActionCopy,
+        TextUriList: b"text/uri-list",
         UTF8_STRING,
+        TEXT,
+        STRING,
+        TEXT_PLAIN_UTF8: b"text/plain;charset=utf-8",
+        TEXT_PLAIN: b"text/plain",
+        XDND_DATA,
         WM_PROTOCOLS,
         WM_DELETE_WINDOW,
         WM_CHANGE_STATE,
diff --git a/typos.toml b/typos.toml
index 2bbb4907a72ad4..1b5c82b9069806 100644
--- a/typos.toml
+++ b/typos.toml
@@ -56,6 +56,8 @@ extend-ignore-re = [
     "rename = \"sesssion_id\"",
     "doas",
     # ProtoLS crate with tree-sitter Protobuf grammar.
-    "protols"
+    "protols",
+    # x11rb SelectionNotifyEvent struct field
+    "requestor"
 ]
 check-filename = true

From f92d0de58d1d14faf1eb1f68d8cdff3792613927 Mon Sep 17 00:00:00 2001
From: Taras Martyniuk <tarabopm@gmail.com>
Date: Tue, 10 Sep 2024 00:31:57 +0300
Subject: [PATCH 006/762] terraform: Update indents (#17200)

Closes #15988

Fixed indent configuration for terraform/HCL

Release Notes:
- N/A



https://github.com/user-attachments/assets/09b44ac9-ef09-463c-876d-0fbcdd1f09c9

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 extensions/terraform/languages/hcl/config.toml            | 1 +
 extensions/terraform/languages/hcl/indents.scm            | 8 +++++---
 extensions/terraform/languages/terraform-vars/config.toml | 1 +
 extensions/terraform/languages/terraform-vars/indents.scm | 8 +++++---
 extensions/terraform/languages/terraform/indents.scm      | 8 +++++---
 5 files changed, 17 insertions(+), 9 deletions(-)

diff --git a/extensions/terraform/languages/hcl/config.toml b/extensions/terraform/languages/hcl/config.toml
index 891b2f38d4182c..be7e601e014482 100644
--- a/extensions/terraform/languages/hcl/config.toml
+++ b/extensions/terraform/languages/hcl/config.toml
@@ -12,3 +12,4 @@ brackets = [
     { start = "'", end = "'", close = true, newline = false, not_in = ["comment", "string"] },
     { start = "/*", end = " */", close = true, newline = false, not_in = ["comment", "string"] },
 ]
+tab_size = 2
diff --git a/extensions/terraform/languages/hcl/indents.scm b/extensions/terraform/languages/hcl/indents.scm
index 74edb66bdf28d8..be12af1d0cd686 100644
--- a/extensions/terraform/languages/hcl/indents.scm
+++ b/extensions/terraform/languages/hcl/indents.scm
@@ -6,6 +6,8 @@
   (function_call)
 ] @indent
 
-(_ "[" "]" @end) @indent
-(_ "(" ")" @end) @indent
-(_ "{" "}" @end) @indent
+[
+  "]"
+  "}"
+  ")"
+] @outdent
diff --git a/extensions/terraform/languages/terraform-vars/config.toml b/extensions/terraform/languages/terraform-vars/config.toml
index 12ed7e236c4fea..4d803ee36e934d 100644
--- a/extensions/terraform/languages/terraform-vars/config.toml
+++ b/extensions/terraform/languages/terraform-vars/config.toml
@@ -12,3 +12,4 @@ brackets = [
     { start = "'", end = "'", close = true, newline = false, not_in = ["comment", "string"] },
     { start = "/*", end = " */", close = true, newline = false, not_in = ["comment", "string"] },
 ]
+tab_size = 2
diff --git a/extensions/terraform/languages/terraform-vars/indents.scm b/extensions/terraform/languages/terraform-vars/indents.scm
index 95ad93df1da98b..b9ba0ad56a3ed0 100644
--- a/extensions/terraform/languages/terraform-vars/indents.scm
+++ b/extensions/terraform/languages/terraform-vars/indents.scm
@@ -6,9 +6,11 @@
   (function_call)
 ] @indent
 
-(_ "[" "]" @end) @indent
-(_ "(" ")" @end) @indent
-(_ "{" "}" @end) @indent
+[
+  "]"
+  "}"
+  ")"
+] @outdent
 
 ; https://github.com/nvim-treesitter/nvim-treesitter/blob/ce4adf11cfe36fc5b0e5bcdce0c7c6e8fbc9798a/queries/terraform/indents.scm
 ; inherits: hcl
diff --git a/extensions/terraform/languages/terraform/indents.scm b/extensions/terraform/languages/terraform/indents.scm
index 95ad93df1da98b..b9ba0ad56a3ed0 100644
--- a/extensions/terraform/languages/terraform/indents.scm
+++ b/extensions/terraform/languages/terraform/indents.scm
@@ -6,9 +6,11 @@
   (function_call)
 ] @indent
 
-(_ "[" "]" @end) @indent
-(_ "(" ")" @end) @indent
-(_ "{" "}" @end) @indent
+[
+  "]"
+  "}"
+  ")"
+] @outdent
 
 ; https://github.com/nvim-treesitter/nvim-treesitter/blob/ce4adf11cfe36fc5b0e5bcdce0c7c6e8fbc9798a/queries/terraform/indents.scm
 ; inherits: hcl

From c1193875e8e93746379514e9ce4fa3db5a0b6503 Mon Sep 17 00:00:00 2001
From: Sergio Nonide <60042926+senonide@users.noreply.github.com>
Date: Mon, 9 Sep 2024 23:44:02 +0200
Subject: [PATCH 007/762] Fix blurry cursor on Wayland at a scale other than
 100% (#17496)

Closes #13258

Release Notes:

- Fixed blurry mouse cursor on wayland when the screen scale is other
than 100%

Before:
![Screenshot from 2024-09-06
14-38-30](https://github.com/user-attachments/assets/e4553503-ecea-4b53-b80d-43732d34fa62)

After:
![Screenshot from 2024-09-06
14-38-56](https://github.com/user-attachments/assets/ce563d3a-2b44-44b9-9f59-f0042609924e)
---
 .../gpui/src/platform/linux/wayland/client.rs |  3 +-
 .../gpui/src/platform/linux/wayland/cursor.rs | 33 +++++++++++++++----
 2 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/crates/gpui/src/platform/linux/wayland/client.rs b/crates/gpui/src/platform/linux/wayland/client.rs
index 67cd1dcbd43b70..57c43a7e46a0c0 100644
--- a/crates/gpui/src/platform/linux/wayland/client.rs
+++ b/crates/gpui/src/platform/linux/wayland/client.rs
@@ -476,7 +476,8 @@ impl WaylandClient {
             .as_ref()
             .map(|primary_selection_manager| primary_selection_manager.get_device(&seat, &qh, ()));
 
-        let mut cursor = Cursor::new(&conn, &globals, 24);
+        // FIXME: Determine the scaling factor dynamically by the compositor
+        let mut cursor = Cursor::new(&conn, &globals, 24, 2);
 
         handle
             .insert_source(XDPEventSource::new(&common.background_executor), {
diff --git a/crates/gpui/src/platform/linux/wayland/cursor.rs b/crates/gpui/src/platform/linux/wayland/cursor.rs
index 6a527650429a4e..ea29eee73c71f4 100644
--- a/crates/gpui/src/platform/linux/wayland/cursor.rs
+++ b/crates/gpui/src/platform/linux/wayland/cursor.rs
@@ -11,6 +11,7 @@ pub(crate) struct Cursor {
     theme_name: Option<String>,
     surface: WlSurface,
     size: u32,
+    scale: u32,
     shm: WlShm,
     connection: Connection,
 }
@@ -23,7 +24,7 @@ impl Drop for Cursor {
 }
 
 impl Cursor {
-    pub fn new(connection: &Connection, globals: &Globals, size: u32) -> Self {
+    pub fn new(connection: &Connection, globals: &Globals, size: u32, scale: u32) -> Self {
         Self {
             theme: CursorTheme::load(&connection, globals.shm.clone(), size).log_err(),
             theme_name: None,
@@ -31,6 +32,7 @@ impl Cursor {
             shm: globals.shm.clone(),
             connection: connection.clone(),
             size,
+            scale,
         }
     }
 
@@ -38,14 +40,18 @@ impl Cursor {
         if let Some(size) = size {
             self.size = size;
         }
-        if let Some(theme) =
-            CursorTheme::load_from_name(&self.connection, self.shm.clone(), theme_name, self.size)
-                .log_err()
+        if let Some(theme) = CursorTheme::load_from_name(
+            &self.connection,
+            self.shm.clone(),
+            theme_name,
+            self.size * self.scale,
+        )
+        .log_err()
         {
             self.theme = Some(theme);
             self.theme_name = Some(theme_name.to_string());
         } else if let Some(theme) =
-            CursorTheme::load(&self.connection, self.shm.clone(), self.size).log_err()
+            CursorTheme::load(&self.connection, self.shm.clone(), self.size * self.scale).log_err()
         {
             self.theme = Some(theme);
             self.theme_name = None;
@@ -91,9 +97,22 @@ impl Cursor {
                 let (width, height) = buffer.dimensions();
                 let (hot_x, hot_y) = buffer.hotspot();
 
-                wl_pointer.set_cursor(serial_id, Some(&self.surface), hot_x as i32, hot_y as i32);
+                let scaled_width = width / self.scale;
+                let scaled_height = height / self.scale;
+                let scaled_hot_x = hot_x / self.scale;
+                let scaled_hot_y = hot_y / self.scale;
+
+                self.surface.set_buffer_scale(self.scale as i32);
+
+                wl_pointer.set_cursor(
+                    serial_id,
+                    Some(&self.surface),
+                    scaled_hot_x as i32,
+                    scaled_hot_y as i32,
+                );
                 self.surface.attach(Some(&buffer), 0, 0);
-                self.surface.damage(0, 0, width as i32, height as i32);
+                self.surface
+                    .damage(0, 0, scaled_width as i32, scaled_height as i32);
                 self.surface.commit();
             }
         } else {

From da9601c69851b2b9c2997611d4834307a2d6b5f9 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 9 Sep 2024 17:49:40 -0400
Subject: [PATCH 008/762] markdown: Handle definition lists in parser (#17617)

Resolves https://github.com/zed-industries/zed/issues/17607.

This PR makes it so the Markdown parser can handle Markdown containing
definition lists.

Note that this is just parser support, we aren't yet doing anything with
the definition lists themselves.

Release Notes:

- N/A
---
 crates/markdown/src/parser.rs | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/crates/markdown/src/parser.rs b/crates/markdown/src/parser.rs
index cb83b2356e61ea..3dd11be9838a91 100644
--- a/crates/markdown/src/parser.rs
+++ b/crates/markdown/src/parser.rs
@@ -232,6 +232,10 @@ pub enum MarkdownTag {
 
     /// A metadata block.
     MetadataBlock(MetadataBlockKind),
+
+    DefinitionList,
+    DefinitionListTitle,
+    DefinitionListDefinition,
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -317,11 +321,9 @@ impl From<pulldown_cmark::Tag<'_>> for MarkdownTag {
             },
             pulldown_cmark::Tag::HtmlBlock => MarkdownTag::HtmlBlock,
             pulldown_cmark::Tag::MetadataBlock(kind) => MarkdownTag::MetadataBlock(kind),
-            pulldown_cmark::Tag::DefinitionList
-            | pulldown_cmark::Tag::DefinitionListTitle
-            | pulldown_cmark::Tag::DefinitionListDefinition => {
-                unimplemented!("definition lists are not yet supported")
-            }
+            pulldown_cmark::Tag::DefinitionList => MarkdownTag::DefinitionList,
+            pulldown_cmark::Tag::DefinitionListTitle => MarkdownTag::DefinitionListTitle,
+            pulldown_cmark::Tag::DefinitionListDefinition => MarkdownTag::DefinitionListDefinition,
         }
     }
 }

From f71cb14d7a3c876b1a5a69949a5a198ed3bfbd5a Mon Sep 17 00:00:00 2001
From: ZZzzaaKK <66885975+ZZzzaaKK@users.noreply.github.com>
Date: Mon, 9 Sep 2024 23:52:43 +0200
Subject: [PATCH 009/762] Add ',' to word chars for line wrapping (#17590)

Closes #16407

Adds ',' to the is_word_char() matches for line wrapping, so that commas
aren't wrapped to the start of a new line.

Release Notes:

- N/A
---
 crates/gpui/src/text_system/line_wrapper.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/gpui/src/text_system/line_wrapper.rs b/crates/gpui/src/text_system/line_wrapper.rs
index 31e852afdf5178..3d38ca315c04ae 100644
--- a/crates/gpui/src/text_system/line_wrapper.rs
+++ b/crates/gpui/src/text_system/line_wrapper.rs
@@ -153,7 +153,7 @@ impl LineWrapper {
         matches!(c, '\u{0400}'..='\u{04FF}') ||
         // Some other known special characters that should be treated as word characters,
         // e.g. `a-b`, `var_name`, `I'm`, '@mention`, `#hashtag`, `100%`, `3.1415`, `2^3`, `a~b`, etc.
-        matches!(c, '-' | '_' | '.' | '\'' | '$' | '%' | '@' | '#' | '^' | '~') ||
+        matches!(c, '-' | '_' | '.' | '\'' | '$' | '%' | '@' | '#' | '^' | '~' | ',') ||
         // Characters that used in URL, e.g. `https://github.com/zed-industries/zed?a=1&b=2` for better wrapping a long URL.
         matches!(c,  '/' | ':' | '?' | '&' | '=') ||
         // `⋯` character is special used in Zed, to keep this at the end of the line.

From 2fc74a1b7132db1d9c20b1405b4bd3b9d030230f Mon Sep 17 00:00:00 2001
From: Kenichi Kamiya <kachick1@gmail.com>
Date: Tue, 10 Sep 2024 19:50:43 +0900
Subject: [PATCH 010/762] Update doc comments with tabs.file_icons default
 (#17629)

The diff only contains doc comments changes, however I expect this also
fixes generating JSON Schema which generated by
[schemars](https://github.com/GREsau/schemars/blob/092dc17ae4831d42974653588cebcc089d07493e/docs/examples/6-doc_comments.md).

This default value is actually true at first.

1818fef32f24f24f082c6f34a4c3100add6d328c

However, it was changed in the following commit.

bf7e474bbcc2fadf002adb273e2584c77c1573e3

Closes #17628

Release Notes:

- N/A
---
 crates/workspace/src/item.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/workspace/src/item.rs b/crates/workspace/src/item.rs
index 422ed1f165c73a..935f0268b62ffe 100644
--- a/crates/workspace/src/item.rs
+++ b/crates/workspace/src/item.rs
@@ -79,7 +79,7 @@ pub struct ItemSettingsContent {
     close_position: Option<ClosePosition>,
     /// Whether to show the file icon for a tab.
     ///
-    /// Default: true
+    /// Default: false
     file_icons: Option<bool>,
 }
 

From 56bc3c36ad1140562c4ded64536c65f17e0d173f Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Tue, 10 Sep 2024 12:55:46 +0200
Subject: [PATCH 011/762] project search: make sorting comparator comply with
 Ord preconditions (#17604)

Closes #17493
/cc @SomeoneToIgnore /cc @ConradIrwin

Release Notes:

- N/A
---
 crates/project_panel/src/project_panel.rs | 38 +++++++++---------
 crates/util/src/paths.rs                  | 42 +++++++++++---------
 crates/util/src/util.rs                   | 48 +++++++++++------------
 3 files changed, 65 insertions(+), 63 deletions(-)

diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 9add77c864db97..32ccd47a89db2e 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -3519,9 +3519,9 @@ mod tests {
                 "    > .git",
                 "    > a",
                 "    v b",
-                "        > [EDITOR: '']  <== selected",
                 "        > 3",
                 "        > 4",
+                "        > [EDITOR: '']  <== selected",
                 "          a-different-filename.tar.gz",
                 "    > C",
                 "      .dockerignore",
@@ -3542,10 +3542,10 @@ mod tests {
                 "    > .git",
                 "    > a",
                 "    v b",
-                "        > [PROCESSING: 'new-dir']",
-                "        > 3  <== selected",
+                "        > 3",
                 "        > 4",
-                "          a-different-filename.tar.gz",
+                "        > [PROCESSING: 'new-dir']",
+                "          a-different-filename.tar.gz  <== selected",
                 "    > C",
                 "      .dockerignore",
             ]
@@ -3559,10 +3559,10 @@ mod tests {
                 "    > .git",
                 "    > a",
                 "    v b",
-                "        > 3  <== selected",
+                "        > 3",
                 "        > 4",
                 "        > new-dir",
-                "          a-different-filename.tar.gz",
+                "          a-different-filename.tar.gz  <== selected",
                 "    > C",
                 "      .dockerignore",
             ]
@@ -3576,10 +3576,10 @@ mod tests {
                 "    > .git",
                 "    > a",
                 "    v b",
-                "        > [EDITOR: '3']  <== selected",
+                "        > 3",
                 "        > 4",
                 "        > new-dir",
-                "          a-different-filename.tar.gz",
+                "          [EDITOR: 'a-different-filename.tar.gz']  <== selected",
                 "    > C",
                 "      .dockerignore",
             ]
@@ -3594,10 +3594,10 @@ mod tests {
                 "    > .git",
                 "    > a",
                 "    v b",
-                "        > 3  <== selected",
+                "        > 3",
                 "        > 4",
                 "        > new-dir",
-                "          a-different-filename.tar.gz",
+                "          a-different-filename.tar.gz  <== selected",
                 "    > C",
                 "      .dockerignore",
             ]
@@ -3844,8 +3844,8 @@ mod tests {
             &[
                 //
                 "v root1",
-                "      one.two.txt  <== selected",
-                "      one.txt",
+                "      one.txt  <== selected",
+                "      one.two.txt",
             ]
         );
 
@@ -3862,9 +3862,9 @@ mod tests {
             &[
                 //
                 "v root1",
-                "      one.two copy.txt  <== selected",
-                "      one.two.txt",
                 "      one.txt",
+                "      one copy.txt  <== selected",
+                "      one.two.txt",
             ]
         );
 
@@ -3878,10 +3878,10 @@ mod tests {
             &[
                 //
                 "v root1",
-                "      one.two copy 1.txt  <== selected",
-                "      one.two copy.txt",
-                "      one.two.txt",
                 "      one.txt",
+                "      one copy.txt",
+                "      one copy 1.txt  <== selected",
+                "      one.two.txt",
             ]
         );
     }
@@ -4074,8 +4074,8 @@ mod tests {
                 "    > b",
                 "      four.txt",
                 "      one.txt",
-                "      three copy.txt  <== selected",
                 "      three.txt",
+                "      three copy.txt  <== selected",
                 "      two.txt",
             ]
         );
@@ -4105,8 +4105,8 @@ mod tests {
                 "    > b",
                 "      four.txt",
                 "      one.txt",
-                "      three copy.txt",
                 "      three.txt",
+                "      three copy.txt",
                 "      two.txt",
             ]
         );
diff --git a/crates/util/src/paths.rs b/crates/util/src/paths.rs
index 3143cb49e3e7cd..cd5beedf47b2cb 100644
--- a/crates/util/src/paths.rs
+++ b/crates/util/src/paths.rs
@@ -9,9 +9,8 @@ use std::{
 use globset::{Glob, GlobSet, GlobSetBuilder};
 use regex::Regex;
 use serde::{Deserialize, Serialize};
-use unicase::UniCase;
 
-use crate::{maybe, NumericPrefixWithSuffix};
+use crate::NumericPrefixWithSuffix;
 
 /// Returns the path to the user's home directory.
 pub fn home_dir() -> &'static PathBuf {
@@ -282,34 +281,29 @@ pub fn compare_paths(
                 let a_is_file = components_a.peek().is_none() && a_is_file;
                 let b_is_file = components_b.peek().is_none() && b_is_file;
                 let ordering = a_is_file.cmp(&b_is_file).then_with(|| {
-                    let maybe_numeric_ordering = maybe!({
-                        let path_a = Path::new(component_a.as_os_str());
-                        let num_and_remainder_a = if a_is_file {
+                    let path_a = Path::new(component_a.as_os_str());
+                    let num_and_remainder_a = NumericPrefixWithSuffix::from_numeric_prefixed_str(
+                        if a_is_file {
                             path_a.file_stem()
                         } else {
                             path_a.file_name()
                         }
                         .and_then(|s| s.to_str())
-                        .and_then(NumericPrefixWithSuffix::from_numeric_prefixed_str)?;
+                        .unwrap_or_default(),
+                    );
 
-                        let path_b = Path::new(component_b.as_os_str());
-                        let num_and_remainder_b = if b_is_file {
+                    let path_b = Path::new(component_b.as_os_str());
+                    let num_and_remainder_b = NumericPrefixWithSuffix::from_numeric_prefixed_str(
+                        if b_is_file {
                             path_b.file_stem()
                         } else {
                             path_b.file_name()
                         }
                         .and_then(|s| s.to_str())
-                        .and_then(NumericPrefixWithSuffix::from_numeric_prefixed_str)?;
+                        .unwrap_or_default(),
+                    );
 
-                        num_and_remainder_a.partial_cmp(&num_and_remainder_b)
-                    });
-
-                    maybe_numeric_ordering.unwrap_or_else(|| {
-                        let name_a = UniCase::new(component_a.as_os_str().to_string_lossy());
-                        let name_b = UniCase::new(component_b.as_os_str().to_string_lossy());
-
-                        name_a.cmp(&name_b)
-                    })
+                    num_and_remainder_a.cmp(&num_and_remainder_b)
                 });
                 if !ordering.is_eq() {
                     return ordering;
@@ -350,6 +344,18 @@ mod tests {
                 (Path::new("test_dirs/1.46/bar_2"), true),
             ]
         );
+        let mut paths = vec![
+            (Path::new("root1/one.txt"), true),
+            (Path::new("root1/one.two.txt"), true),
+        ];
+        paths.sort_by(|&a, &b| compare_paths(a, b));
+        assert_eq!(
+            paths,
+            vec![
+                (Path::new("root1/one.txt"), true),
+                (Path::new("root1/one.two.txt"), true),
+            ]
+        );
     }
 
     #[test]
diff --git a/crates/util/src/util.rs b/crates/util/src/util.rs
index 25ef3630352ba0..40a5cf6212e443 100644
--- a/crates/util/src/util.rs
+++ b/crates/util/src/util.rs
@@ -644,27 +644,27 @@ impl<T: Ord + Clone> RangeExt<T> for RangeInclusive<T> {
 /// This is useful for turning regular alphanumerically sorted sequences as `1-abc, 10, 11-def, .., 2, 21-abc`
 /// into `1-abc, 2, 10, 11-def, .., 21-abc`
 #[derive(Debug, PartialEq, Eq)]
-pub struct NumericPrefixWithSuffix<'a>(i32, &'a str);
+pub struct NumericPrefixWithSuffix<'a>(Option<u32>, &'a str);
 
 impl<'a> NumericPrefixWithSuffix<'a> {
-    pub fn from_numeric_prefixed_str(str: &'a str) -> Option<Self> {
+    pub fn from_numeric_prefixed_str(str: &'a str) -> Self {
         let i = str.chars().take_while(|c| c.is_ascii_digit()).count();
         let (prefix, remainder) = str.split_at(i);
 
-        match prefix.parse::<i32>() {
-            Ok(prefix) => Some(NumericPrefixWithSuffix(prefix, remainder)),
-            Err(_) => None,
-        }
+        let prefix = prefix.parse().ok();
+        Self(prefix, remainder)
     }
 }
-
 impl Ord for NumericPrefixWithSuffix<'_> {
     fn cmp(&self, other: &Self) -> Ordering {
-        let NumericPrefixWithSuffix(num_a, remainder_a) = self;
-        let NumericPrefixWithSuffix(num_b, remainder_b) = other;
-        num_a
-            .cmp(num_b)
-            .then_with(|| UniCase::new(remainder_a).cmp(&UniCase::new(remainder_b)))
+        match (self.0, other.0) {
+            (None, None) => UniCase::new(self.1).cmp(&UniCase::new(other.1)),
+            (None, Some(_)) => Ordering::Greater,
+            (Some(_), None) => Ordering::Less,
+            (Some(a), Some(b)) => a
+                .cmp(&b)
+                .then_with(|| UniCase::new(self.1).cmp(&UniCase::new(other.1))),
+        }
     }
 }
 
@@ -737,66 +737,62 @@ mod tests {
         let target = "1a";
         assert_eq!(
             NumericPrefixWithSuffix::from_numeric_prefixed_str(target),
-            Some(NumericPrefixWithSuffix(1, "a"))
+            NumericPrefixWithSuffix(Some(1), "a")
         );
 
         let target = "12ab";
         assert_eq!(
             NumericPrefixWithSuffix::from_numeric_prefixed_str(target),
-            Some(NumericPrefixWithSuffix(12, "ab"))
+            NumericPrefixWithSuffix(Some(12), "ab")
         );
 
         let target = "12_ab";
         assert_eq!(
             NumericPrefixWithSuffix::from_numeric_prefixed_str(target),
-            Some(NumericPrefixWithSuffix(12, "_ab"))
+            NumericPrefixWithSuffix(Some(12), "_ab")
         );
 
         let target = "1_2ab";
         assert_eq!(
             NumericPrefixWithSuffix::from_numeric_prefixed_str(target),
-            Some(NumericPrefixWithSuffix(1, "_2ab"))
+            NumericPrefixWithSuffix(Some(1), "_2ab")
         );
 
         let target = "1.2";
         assert_eq!(
             NumericPrefixWithSuffix::from_numeric_prefixed_str(target),
-            Some(NumericPrefixWithSuffix(1, ".2"))
+            NumericPrefixWithSuffix(Some(1), ".2")
         );
 
         let target = "1.2_a";
         assert_eq!(
             NumericPrefixWithSuffix::from_numeric_prefixed_str(target),
-            Some(NumericPrefixWithSuffix(1, ".2_a"))
+            NumericPrefixWithSuffix(Some(1), ".2_a")
         );
 
         let target = "12.2_a";
         assert_eq!(
             NumericPrefixWithSuffix::from_numeric_prefixed_str(target),
-            Some(NumericPrefixWithSuffix(12, ".2_a"))
+            NumericPrefixWithSuffix(Some(12), ".2_a")
         );
 
         let target = "12a.2_a";
         assert_eq!(
             NumericPrefixWithSuffix::from_numeric_prefixed_str(target),
-            Some(NumericPrefixWithSuffix(12, "a.2_a"))
+            NumericPrefixWithSuffix(Some(12), "a.2_a")
         );
     }
 
     #[test]
     fn test_numeric_prefix_with_suffix() {
         let mut sorted = vec!["1-abc", "10", "11def", "2", "21-abc"];
-        sorted.sort_by_key(|s| {
-            NumericPrefixWithSuffix::from_numeric_prefixed_str(s).unwrap_or_else(|| {
-                panic!("Cannot convert string `{s}` into NumericPrefixWithSuffix")
-            })
-        });
+        sorted.sort_by_key(|s| NumericPrefixWithSuffix::from_numeric_prefixed_str(s));
         assert_eq!(sorted, ["1-abc", "2", "10", "11def", "21-abc"]);
 
         for numeric_prefix_less in ["numeric_prefix_less", "aaa", "~™£"] {
             assert_eq!(
                 NumericPrefixWithSuffix::from_numeric_prefixed_str(numeric_prefix_less),
-                None,
+                NumericPrefixWithSuffix(None, numeric_prefix_less),
                 "String without numeric prefix `{numeric_prefix_less}` should not be converted into NumericPrefixWithSuffix"
             )
         }

From 75256bdfe1b054688d79a0b6fb4900888ea16279 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Tue, 10 Sep 2024 14:41:02 +0200
Subject: [PATCH 012/762] lsp: Add support for workspace/workspaceFolders
 request (#17639)

Related to: #17574

Release Notes:

- N/A
---
 crates/project/src/lsp_store.rs | 26 +++++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 5b4dbd1deaff92..1d9ca98c064720 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -40,7 +40,7 @@ use lsp::{
     CompletionContext, DiagnosticSeverity, DiagnosticTag, DidChangeWatchedFilesRegistrationOptions,
     Edit, FileSystemWatcher, InsertTextFormat, LanguageServer, LanguageServerBinary,
     LanguageServerId, LspRequestFuture, MessageActionItem, MessageType, OneOf, ServerHealthStatus,
-    ServerStatus, SymbolKind, TextEdit, WorkDoneProgressCancelParams,
+    ServerStatus, SymbolKind, TextEdit, Url, WorkDoneProgressCancelParams, WorkspaceFolder,
 };
 use parking_lot::{Mutex, RwLock};
 use postage::watch;
@@ -4774,6 +4774,30 @@ impl LspStore {
             })
             .detach();
 
+        let id = language_server.server_id();
+        language_server
+            .on_request::<lsp::request::WorkspaceFoldersRequest, _, _>({
+                let this = this.clone();
+                move |_, mut cx| {
+                    let this = this.clone();
+                    async move {
+                        let Some(server) =
+                            this.update(&mut cx, |this, _| this.language_server_for_id(id))?
+                        else {
+                            return Ok(None);
+                        };
+                        let root = server.root_path();
+                        let Ok(uri) = Url::from_file_path(&root) else {
+                            return Ok(None);
+                        };
+                        Ok(Some(vec![WorkspaceFolder {
+                            uri,
+                            name: Default::default(),
+                        }]))
+                    }
+                }
+            })
+            .detach();
         // Even though we don't have handling for these requests, respond to them to
         // avoid stalling any language server like `gopls` which waits for a response
         // to these requests when initializing.

From 929eff815cd7a03811536375b71de110ae53db60 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Tue, 10 Sep 2024 14:50:23 +0200
Subject: [PATCH 013/762] project panel: Get rid of unwrap in autofolding code
 (#17641)

@WeetHet spotted a crash in recently-introduced project panel
autofolding that relates to unwrapping.

Release Notes:

- N/A
---
 crates/project_panel/src/project_panel.rs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 32ccd47a89db2e..56d524cdc7130c 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -115,7 +115,6 @@ struct EntryDetails {
     is_cut: bool,
     git_status: Option<GitFileStatus>,
     is_private: bool,
-    is_auto_folded: bool,
     worktree_id: WorktreeId,
     canonical_path: Option<Box<Path>>,
 }
@@ -2099,7 +2098,6 @@ impl ProjectPanel {
                             .map_or(false, |e| e.is_cut() && e.items().contains(&selection)),
                         git_status: status,
                         is_private: entry.is_private,
-                        is_auto_folded: difference > 1,
                         worktree_id: *worktree_id,
                         canonical_path: entry.canonical_path.clone(),
                     };
@@ -2212,7 +2210,6 @@ impl ProjectPanel {
             active_selection: selection,
             marked_selections: selections,
         };
-        let is_auto_folded = details.is_auto_folded;
         div()
             .id(entry_id.to_proto() as usize)
             .on_drag_move::<ExternalPaths>(cx.listener(
@@ -2314,8 +2311,9 @@ impl ProjectPanel {
                             h_flex().h_6().w_full().child(editor.clone())
                         } else {
                             h_flex().h_6().map(|this| {
-                                if is_auto_folded && is_active {
-                                    let folded_ancestors = self.ancestors.get(&entry_id).unwrap();
+                                if let Some(folded_ancestors) =
+                                    is_active.then(|| self.ancestors.get(&entry_id)).flatten()
+                                {
                                     let Some(part_to_highlight) = Path::new(&file_name)
                                         .ancestors()
                                         .nth(folded_ancestors.current_ancestor_depth)

From bf64c0899f076b8a62071ffae22fb9b35af667c0 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 10 Sep 2024 10:22:12 -0400
Subject: [PATCH 014/762] go: Fix regression by restoring regex to match tests
 (#17645)

This fixes a regression that snuck in with #17108.

When running a single test with `go test` the
regex wouldn't be used anymore.

This restores the old behavior.

Release Notes:

- Fixed a regression when running Go tests. A recent change dropped the
regex used to match single test names when using `go test` in tasks to
run tests. That could lead to more or the wrong tests being run. This
restores the old behavior.
---
 crates/languages/src/go.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/crates/languages/src/go.rs b/crates/languages/src/go.rs
index c22a4e3eda9220..a528f4f70cdc44 100644
--- a/crates/languages/src/go.rs
+++ b/crates/languages/src/go.rs
@@ -518,7 +518,13 @@ impl ContextProvider for GoContextProvider {
                     GO_PACKAGE_TASK_VARIABLE.template_value(),
                     VariableName::Symbol.template_value(),
                 ),
-                command: format!("go test -run {}", VariableName::Symbol.template_value(),),
+                command: "go".into(),
+                args: vec![
+                    "test".into(),
+                    GO_PACKAGE_TASK_VARIABLE.template_value(),
+                    "-run".into(),
+                    format!("^{}\\$", VariableName::Symbol.template_value(),),
+                ],
                 tags: vec!["go-test".to_owned()],
                 cwd: package_cwd.clone(),
                 ..TaskTemplate::default()

From 93b3520c11cd645d595f6158bc0cc178238105c5 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Tue, 10 Sep 2024 11:03:44 -0400
Subject: [PATCH 015/762] assistant: Prevent possible execution of generated
 terminal commands (#17647)

Closes #17424

Release Notes:

- Fixed an issue where commands generated by the terminal command could
sometimes be executed without confirmation
---
 crates/assistant/src/terminal_inline_assistant.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/assistant/src/terminal_inline_assistant.rs b/crates/assistant/src/terminal_inline_assistant.rs
index 479925b060633e..bb3f9d36bffbb5 100644
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -988,7 +988,7 @@ impl TerminalTransaction {
 
     pub fn push(&mut self, hunk: String, cx: &mut AppContext) {
         // Ensure that the assistant cannot accidentally execute commands that are streamed into the terminal
-        let input = hunk.replace(CARRIAGE_RETURN, " ");
+        let input = Self::sanitize_input(hunk);
         self.terminal
             .update(cx, |terminal, _| terminal.input(input));
     }
@@ -1003,6 +1003,10 @@ impl TerminalTransaction {
             terminal.input(CARRIAGE_RETURN.to_string())
         });
     }
+
+    fn sanitize_input(input: String) -> String {
+        input.replace(['\r', '\n'], "")
+    }
 }
 
 pub struct Codegen {

From a078cb104c01d59442bc52f192e14807723f1278 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 10 Sep 2024 11:16:27 -0400
Subject: [PATCH 016/762] Disable definition lists in Markdown (#17648)

This PR disables definition list support in `pulldown_cmark`, as it is
has been causing a number of issues.

I opened an issue upstream with the panic we were seeing:
https://github.com/pulldown-cmark/pulldown-cmark/issues/957.

Release Notes:

- N/A
---
 crates/language/src/markdown.rs                | 2 ++
 crates/markdown/src/parser.rs                  | 5 ++++-
 crates/markdown_preview/src/markdown_parser.rs | 4 +++-
 crates/rich_text/src/rich_text.rs              | 4 +++-
 4 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/crates/language/src/markdown.rs b/crates/language/src/markdown.rs
index 98b9ba53b106dc..b9393a16ab3cee 100644
--- a/crates/language/src/markdown.rs
+++ b/crates/language/src/markdown.rs
@@ -166,6 +166,7 @@ pub async fn parse_markdown_block(
     let mut list_stack = Vec::new();
 
     let mut options = pulldown_cmark::Options::all();
+    options.remove(pulldown_cmark::Options::ENABLE_DEFINITION_LIST);
     options.remove(pulldown_cmark::Options::ENABLE_YAML_STYLE_METADATA_BLOCKS);
 
     for event in Parser::new_ext(markdown, options) {
@@ -384,6 +385,7 @@ public: void format(const int &, const std::tm &, int &dest)
 "#;
 
         let mut options = pulldown_cmark::Options::all();
+        options.remove(pulldown_cmark::Options::ENABLE_DEFINITION_LIST);
         options.remove(pulldown_cmark::Options::ENABLE_YAML_STYLE_METADATA_BLOCKS);
 
         let parser = pulldown_cmark::Parser::new_ext(input, options);
diff --git a/crates/markdown/src/parser.rs b/crates/markdown/src/parser.rs
index 3dd11be9838a91..7d349e29efce92 100644
--- a/crates/markdown/src/parser.rs
+++ b/crates/markdown/src/parser.rs
@@ -5,10 +5,13 @@ use pulldown_cmark::{Alignment, HeadingLevel, LinkType, MetadataBlockKind, Optio
 use std::ops::Range;
 
 pub fn parse_markdown(text: &str) -> Vec<(Range<usize>, MarkdownEvent)> {
+    let mut options = Options::all();
+    options.remove(pulldown_cmark::Options::ENABLE_DEFINITION_LIST);
+
     let mut events = Vec::new();
     let mut within_link = false;
     let mut within_metadata = false;
-    for (pulldown_event, mut range) in Parser::new_ext(text, Options::all()).into_offset_iter() {
+    for (pulldown_event, mut range) in Parser::new_ext(text, options).into_offset_iter() {
         if within_metadata {
             if let pulldown_cmark::Event::End(pulldown_cmark::TagEnd::MetadataBlock { .. }) =
                 pulldown_event
diff --git a/crates/markdown_preview/src/markdown_parser.rs b/crates/markdown_preview/src/markdown_parser.rs
index 4a607f4d726117..7e503fb609efa9 100644
--- a/crates/markdown_preview/src/markdown_parser.rs
+++ b/crates/markdown_preview/src/markdown_parser.rs
@@ -11,7 +11,9 @@ pub async fn parse_markdown(
     file_location_directory: Option<PathBuf>,
     language_registry: Option<Arc<LanguageRegistry>>,
 ) -> ParsedMarkdown {
-    let options = Options::all();
+    let mut options = Options::all();
+    options.remove(pulldown_cmark::Options::ENABLE_DEFINITION_LIST);
+
     let parser = Parser::new_ext(markdown_input, options);
     let parser = MarkdownParser::new(
         parser.into_offset_iter().collect(),
diff --git a/crates/rich_text/src/rich_text.rs b/crates/rich_text/src/rich_text.rs
index 2c4b2ca8ee3132..80b7786c2422d7 100644
--- a/crates/rich_text/src/rich_text.rs
+++ b/crates/rich_text/src/rich_text.rs
@@ -195,7 +195,9 @@ pub fn render_markdown_mut(
     let mut current_language = None;
     let mut list_stack = Vec::new();
 
-    let options = Options::all();
+    let mut options = Options::all();
+    options.remove(pulldown_cmark::Options::ENABLE_DEFINITION_LIST);
+
     for (event, source_range) in Parser::new_ext(block, options).into_offset_iter() {
         let prev_len = text.len();
         match event {

From a7ac37156c98bf3a48c9506b8c65284089b76b72 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Tue, 10 Sep 2024 11:23:50 -0400
Subject: [PATCH 017/762] assistant: Fix configuration page showing incorrect
 Anthropic API key label (#17650)

Release Notes:

- N/A
---
 crates/language_model/src/provider/anthropic.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/language_model/src/provider/anthropic.rs b/crates/language_model/src/provider/anthropic.rs
index 37ee2faf405bbf..eac4ad3021ee1d 100644
--- a/crates/language_model/src/provider/anthropic.rs
+++ b/crates/language_model/src/provider/anthropic.rs
@@ -695,7 +695,7 @@ impl Render for ConfigurationView {
                 )
                 .child(
                     Label::new(
-                        "You can also assign the {ANTHROPIC_API_KEY_VAR} environment variable and restart Zed.",
+                        format!("You can also assign the {ANTHROPIC_API_KEY_VAR} environment variable and restart Zed."),
                     )
                     .size(LabelSize::Small),
                 )

From d5498c52f8205d8e02e0a489ae3707960476a425 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Tue, 10 Sep 2024 11:45:21 -0400
Subject: [PATCH 018/762] assistant: Fix terminal inline assistant not showing
 retry on error (#17651)

Release Notes:

- Fixed an issue where a failed inline assistant prompt could not be
restarted
---
 crates/assistant/src/terminal_inline_assistant.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/assistant/src/terminal_inline_assistant.rs b/crates/assistant/src/terminal_inline_assistant.rs
index bb3f9d36bffbb5..61a8813f6c55ed 100644
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -465,7 +465,8 @@ impl EventEmitter<PromptEditorEvent> for PromptEditor {}
 
 impl Render for PromptEditor {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
-        let buttons = match &self.codegen.read(cx).status {
+        let status = &self.codegen.read(cx).status;
+        let buttons = match status {
             CodegenStatus::Idle => {
                 vec![
                     IconButton::new("cancel", IconName::Close)
@@ -516,7 +517,8 @@ impl Render for PromptEditor {
                     .tooltip(|cx| Tooltip::for_action("Cancel Assist", &menu::Cancel, cx))
                     .on_click(cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::CancelRequested)));
 
-                if self.edited_since_done {
+                let has_error = matches!(status, CodegenStatus::Error(_));
+                if has_error || self.edited_since_done {
                     vec![
                         cancel,
                         IconButton::new("restart", IconName::RotateCw)

From 5f61e3140f14f0411f4a39dbeb59af57b6810555 Mon Sep 17 00:00:00 2001
From: Eric Andres <emandres@users.noreply.github.com>
Date: Tue, 10 Sep 2024 09:49:04 -0600
Subject: [PATCH 019/762] Fix vim surround behavior around text objects
 (#17603)

Performing `ysa")` on `"Hello World"` should produce `("Hello World")`.
Instead it places the parens inside the quotes (i.e. `"(Hello World)"`).
This PR fixes the behavior by preserving the `around` flag from the
operator sequence.

Closes #12976 and partially fixes #13841

Release Notes:

- Fixed the behavior of surrounding a text object in vim.
---
 crates/vim/src/normal.rs    |  2 +-
 crates/vim/src/surrounds.rs | 40 ++++++++++++++++++++++++++++++++++---
 2 files changed, 38 insertions(+), 4 deletions(-)

diff --git a/crates/vim/src/normal.rs b/crates/vim/src/normal.rs
index ae560acc2999e5..8198c0da53b4f0 100644
--- a/crates/vim/src/normal.rs
+++ b/crates/vim/src/normal.rs
@@ -248,7 +248,7 @@ impl Vim {
                 }
                 Some(Operator::AddSurrounds { target: None }) => {
                     waiting_operator = Some(Operator::AddSurrounds {
-                        target: Some(SurroundsType::Object(object)),
+                        target: Some(SurroundsType::Object(object, around)),
                     });
                 }
                 Some(Operator::ToggleComments) => self.toggle_comments_object(object, around, cx),
diff --git a/crates/vim/src/surrounds.rs b/crates/vim/src/surrounds.rs
index 137801c3ee81d1..81025103fb7ca4 100644
--- a/crates/vim/src/surrounds.rs
+++ b/crates/vim/src/surrounds.rs
@@ -13,7 +13,7 @@ use ui::ViewContext;
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum SurroundsType {
     Motion(Motion),
-    Object(Object),
+    Object(Object, bool),
     Selection,
 }
 
@@ -59,8 +59,8 @@ impl Vim {
 
                 for selection in &display_selections {
                     let range = match &target {
-                        SurroundsType::Object(object) => {
-                            object.range(&display_map, selection.clone(), false)
+                        SurroundsType::Object(object, around) => {
+                            object.range(&display_map, selection.clone(), *around)
                         }
                         SurroundsType::Motion(motion) => {
                             motion
@@ -697,6 +697,40 @@ mod test {
             the lazy dog."},
             Mode::Normal,
         );
+
+        // test add surrounds around object
+        cx.set_state(
+            indoc! {"
+            The [quˇick] brown
+            fox jumps over
+            the lazy dog."},
+            Mode::Normal,
+        );
+        cx.simulate_keystrokes("y s a ] )");
+        cx.assert_state(
+            indoc! {"
+            The ˇ([quick]) brown
+            fox jumps over
+            the lazy dog."},
+            Mode::Normal,
+        );
+
+        // test add surrounds inside object
+        cx.set_state(
+            indoc! {"
+            The [quˇick] brown
+            fox jumps over
+            the lazy dog."},
+            Mode::Normal,
+        );
+        cx.simulate_keystrokes("y s i ] )");
+        cx.assert_state(
+            indoc! {"
+            The [ˇ(quick)] brown
+            fox jumps over
+            the lazy dog."},
+            Mode::Normal,
+        );
     }
 
     #[gpui::test]

From 0b0cd9005e3f40865cd37ce32a4938570755ba16 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Tue, 10 Sep 2024 11:58:16 -0400
Subject: [PATCH 020/762] assistant: Fix file slash command not allowing to
 select multiple files when pressing tab (#17652)

Release Notes:

- Allow to add multiple files in a single `/file` command when pressing
tab
---
 crates/assistant/src/slash_command/file_command.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/crates/assistant/src/slash_command/file_command.rs b/crates/assistant/src/slash_command/file_command.rs
index c253e5b91c0297..e5d8f1b2d6bbb2 100644
--- a/crates/assistant/src/slash_command/file_command.rs
+++ b/crates/assistant/src/slash_command/file_command.rs
@@ -164,11 +164,7 @@ impl SlashCommand for FileSlashCommand {
                     Some(ArgumentCompletion {
                         label,
                         new_text: text,
-                        after_completion: if path_match.is_dir {
-                            AfterCompletion::Compose
-                        } else {
-                            AfterCompletion::Run
-                        },
+                        after_completion: AfterCompletion::Compose,
                         replace_previous_arguments: false,
                     })
                 })

From 85f4c96feff44d2070b2b520de9f4620ecc84b02 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 10 Sep 2024 12:40:54 -0400
Subject: [PATCH 021/762] Ubuntu 22 (Linux arm runner) fixes (#17643)

Our GitHub Actions Linux ARM hosted runner was running Ubuntu 20 was EOL'd.

This gets builds working on the Ubuntu 22 Linux ARM runner which have spun to replace the EOL'd one. It pushes forward our Glibc requirement for Linux ARM users (was >= 2.29, now >= 2.35; sorry!) but also uses a newer version of clang/llvm (was 10, now 15; yay!).
---
 .github/workflows/ci.yml |  6 +++---
 docs/src/linux.md        | 16 +++++++++++-----
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 37e80e5a8d32ce..02bec287144357 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -339,7 +339,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-  bundle-linux-aarch64:
+  bundle-linux-aarch64: # this runs on ubuntu22.04
     timeout-minutes: 60
     name: Create arm64 Linux bundle
     runs-on:
@@ -360,8 +360,8 @@ jobs:
       - name: Set up Clang
         run: |
           sudo apt-get update
-          sudo apt-get install -y llvm-10 clang-10 build-essential cmake pkg-config libasound2-dev libfontconfig-dev libwayland-dev libxkbcommon-x11-dev libssl-dev libsqlite3-dev libzstd-dev libvulkan1 libgit2-dev
-          echo "/usr/lib/llvm-10/bin" >> $GITHUB_PATH
+          sudo apt-get install -y llvm-15 clang-15 build-essential cmake pkg-config libasound2-dev libfontconfig-dev libwayland-dev libxkbcommon-x11-dev libssl-dev libsqlite3-dev libzstd-dev libvulkan1 libgit2-dev
+          echo "/usr/lib/llvm-15/bin" >> $GITHUB_PATH
 
       - uses: rui314/setup-mold@0bf4f07ef9048ec62a45f9dbf2f098afa49695f0 # v1
         with:
diff --git a/docs/src/linux.md b/docs/src/linux.md
index 2b9a66d51e67f0..812a3707d01b1b 100644
--- a/docs/src/linux.md
+++ b/docs/src/linux.md
@@ -12,15 +12,21 @@ We also offer a preview build of Zed which receives updates about a week ahead o
 curl -f https://zed.dev/install.sh | ZED_CHANNEL=preview sh
 ```
 
-The Zed installed by the script does not work on systems that:
+The Zed installed by the script works best on systems that:
 
-- have no Vulkan compatible GPU available (for example Linux on an M-series macBook)
-- have no system-wide glibc (for example on NixOS or Alpine by default)
-- have a glibc older than version 2.29 (for example Amazon Linux 2 or Ubuntu 18 and earlier)
-- use an architecture other than 64-bit Intel or 64-bit ARM (for example a 32-bit or RISC-V machine)
+- have a Vulkan compatible GPU available (for example Linux on an M-series macBook)
+- have a system-wide glibc (NixOS and Alpine do not by default)
+  - x86_64 (Intel/AMD): glibc version >= 2.29 (Ubuntu 20 and newer; Amazon Linux >2023)
+  - aarch64 (ARM): glibc version >= 2.35 (Ubuntu 22 and newer)
 
 Both Nix and Alpine have third-party Zed packages available (though they are currently a few weeks out of date). If you'd like to use our builds they do work if you install a glibc compatibility layer. On NixOS you can try [nix-ld](https://github.com/Mic92/nix-ld), and on Alpine [gcompat](https://wiki.alpinelinux.org/wiki/Running_glibc_programs).
 
+You will need to build from source for:
+
+- architectures other than 64-bit Intel or 64-bit ARM (for example a 32-bit or RISC-V machine)
+- Amazon Linux 2 on x86_64
+- Rocky Linux 9.3
+
 ## Other ways to install Zed on Linux
 
 Zed is open source, and [you can install from source](./development/linux.md).

From fb9d01b0d5c23a1f057bac06c86d5dbaa9a7c39d Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 10 Sep 2024 13:41:06 -0400
Subject: [PATCH 022/762] assistant: Add display_name for OpenAI and Gemini
 (#17508)

---
 crates/assistant/src/assistant_settings.rs    |  2 ++
 crates/google_ai/src/google_ai.rs             | 11 +++++++++--
 crates/language_model/src/provider/cloud.rs   |  2 ++
 crates/language_model/src/provider/google.rs  |  2 ++
 crates/language_model/src/provider/open_ai.rs |  8 +++-----
 crates/language_model/src/settings.rs         |  2 ++
 crates/open_ai/src/open_ai.rs                 |  6 +++++-
 docs/src/assistant/configuration.md           | 17 +++++++++--------
 8 files changed, 34 insertions(+), 16 deletions(-)

diff --git a/crates/assistant/src/assistant_settings.rs b/crates/assistant/src/assistant_settings.rs
index d57c1f19b685c0..3e326886d50d71 100644
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -160,10 +160,12 @@ impl AssistantSettingsContent {
                                             .filter_map(|model| match model {
                                                 OpenAiModel::Custom {
                                                     name,
+                                                    display_name,
                                                     max_tokens,
                                                     max_output_tokens,
                                                 } => Some(open_ai::AvailableModel {
                                                     name,
+                                                    display_name,
                                                     max_tokens,
                                                     max_output_tokens,
                                                 }),
diff --git a/crates/google_ai/src/google_ai.rs b/crates/google_ai/src/google_ai.rs
index f0803b402947f3..f1dcedf5b31e0c 100644
--- a/crates/google_ai/src/google_ai.rs
+++ b/crates/google_ai/src/google_ai.rs
@@ -304,7 +304,12 @@ pub enum Model {
     #[serde(rename = "gemini-1.5-flash")]
     Gemini15Flash,
     #[serde(rename = "custom")]
-    Custom { name: String, max_tokens: usize },
+    Custom {
+        name: String,
+        /// The name displayed in the UI, such as in the assistant panel model dropdown menu.
+        display_name: Option<String>,
+        max_tokens: usize,
+    },
 }
 
 impl Model {
@@ -320,7 +325,9 @@ impl Model {
         match self {
             Model::Gemini15Pro => "Gemini 1.5 Pro",
             Model::Gemini15Flash => "Gemini 1.5 Flash",
-            Model::Custom { name, .. } => name,
+            Self::Custom {
+                name, display_name, ..
+            } => display_name.as_ref().unwrap_or(name),
         }
     }
 
diff --git a/crates/language_model/src/provider/cloud.rs b/crates/language_model/src/provider/cloud.rs
index 3db155393d6277..0de7fb3feb49e2 100644
--- a/crates/language_model/src/provider/cloud.rs
+++ b/crates/language_model/src/provider/cloud.rs
@@ -254,11 +254,13 @@ impl LanguageModelProvider for CloudLanguageModelProvider {
                 }),
                 AvailableProvider::OpenAi => CloudModel::OpenAi(open_ai::Model::Custom {
                     name: model.name.clone(),
+                    display_name: model.display_name.clone(),
                     max_tokens: model.max_tokens,
                     max_output_tokens: model.max_output_tokens,
                 }),
                 AvailableProvider::Google => CloudModel::Google(google_ai::Model::Custom {
                     name: model.name.clone(),
+                    display_name: model.display_name.clone(),
                     max_tokens: model.max_tokens,
                 }),
             };
diff --git a/crates/language_model/src/provider/google.rs b/crates/language_model/src/provider/google.rs
index 1b24e8eda9864f..fc4a7a7a3405a0 100644
--- a/crates/language_model/src/provider/google.rs
+++ b/crates/language_model/src/provider/google.rs
@@ -37,6 +37,7 @@ pub struct GoogleSettings {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct AvailableModel {
     name: String,
+    display_name: Option<String>,
     max_tokens: usize,
 }
 
@@ -170,6 +171,7 @@ impl LanguageModelProvider for GoogleLanguageModelProvider {
                 model.name.clone(),
                 google_ai::Model::Custom {
                     name: model.name.clone(),
+                    display_name: model.display_name.clone(),
                     max_tokens: model.max_tokens,
                 },
             );
diff --git a/crates/language_model/src/provider/open_ai.rs b/crates/language_model/src/provider/open_ai.rs
index 6b1790c1a17bae..15d84f6cca2efc 100644
--- a/crates/language_model/src/provider/open_ai.rs
+++ b/crates/language_model/src/provider/open_ai.rs
@@ -40,6 +40,7 @@ pub struct OpenAiSettings {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct AvailableModel {
     pub name: String,
+    pub display_name: Option<String>,
     pub max_tokens: usize,
     pub max_output_tokens: Option<u32>,
 }
@@ -171,6 +172,7 @@ impl LanguageModelProvider for OpenAiLanguageModelProvider {
                 model.name.clone(),
                 open_ai::Model::Custom {
                     name: model.name.clone(),
+                    display_name: model.display_name.clone(),
                     max_tokens: model.max_tokens,
                     max_output_tokens: model.max_output_tokens,
                 },
@@ -368,11 +370,7 @@ pub fn count_open_ai_tokens(
                 })
                 .collect::<Vec<_>>();
 
-            if let open_ai::Model::Custom { .. } = model {
-                tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)
-            } else {
-                tiktoken_rs::num_tokens_from_messages(model.id(), &messages)
-            }
+            tiktoken_rs::num_tokens_from_messages(model.id(), &messages)
         })
         .boxed()
 }
diff --git a/crates/language_model/src/settings.rs b/crates/language_model/src/settings.rs
index 8d3838d2369c62..0059ed56c4c63b 100644
--- a/crates/language_model/src/settings.rs
+++ b/crates/language_model/src/settings.rs
@@ -175,12 +175,14 @@ impl OpenAiSettingsContent {
                             .filter_map(|model| match model {
                                 open_ai::Model::Custom {
                                     name,
+                                    display_name,
                                     max_tokens,
                                     max_output_tokens,
                                 } => Some(provider::open_ai::AvailableModel {
                                     name,
                                     max_tokens,
                                     max_output_tokens,
+                                    display_name,
                                 }),
                                 _ => None,
                             })
diff --git a/crates/open_ai/src/open_ai.rs b/crates/open_ai/src/open_ai.rs
index 6be5327c04f630..5b621d6bb844c3 100644
--- a/crates/open_ai/src/open_ai.rs
+++ b/crates/open_ai/src/open_ai.rs
@@ -68,6 +68,8 @@ pub enum Model {
     #[serde(rename = "custom")]
     Custom {
         name: String,
+        /// The name displayed in the UI, such as in the assistant panel model dropdown menu.
+        display_name: Option<String>,
         max_tokens: usize,
         max_output_tokens: Option<u32>,
     },
@@ -103,7 +105,9 @@ impl Model {
             Self::FourTurbo => "gpt-4-turbo",
             Self::FourOmni => "gpt-4o",
             Self::FourOmniMini => "gpt-4o-mini",
-            Self::Custom { name, .. } => name,
+            Self::Custom {
+                name, display_name, ..
+            } => display_name.as_ref().unwrap_or(name),
         }
     }
 
diff --git a/docs/src/assistant/configuration.md b/docs/src/assistant/configuration.md
index eaf5ed13b4c246..0fd242c6191b4d 100644
--- a/docs/src/assistant/configuration.md
+++ b/docs/src/assistant/configuration.md
@@ -77,7 +77,7 @@ You can use Gemini 1.5 Pro/Flash with the Zed assistant by choosing it via the m
 
 1. Go the Google AI Studio site and [create an API key](https://aistudio.google.com/app/apikey).
 2. Open the configuration view (`assistant: show configuration`) and navigate to the Google AI section
-3. Enter your Google AI API key
+3. Enter your Google AI API key and press enter.
 
 The Google AI API key will be saved in your keychain.
 
@@ -85,7 +85,7 @@ Zed will also use the `GOOGLE_AI_API_KEY` environment variable if it's defined.
 
 #### Google AI custom models {#google-ai-custom-models}
 
-You can add custom models to the Google AI provider by adding the following to your Zed `settings.json`:
+By default Zed will use `stable` versions of models, but you can use specific versions of models, including [experimental models](https://ai.google.dev/gemini-api/docs/models/experimental-models) with the Google AI provider by adding the following to your Zed `settings.json`:
 
 ```json
 {
@@ -93,8 +93,9 @@ You can add custom models to the Google AI provider by adding the following to y
     "google": {
       "available_models": [
         {
-          "name": "custom-model",
-          "max_tokens": 128000
+          "name": "gemini-1.5-flash-latest",
+          "display_name": "Gemini 1.5 Flash (Latest)",
+          "max_tokens": 1000000
         }
       ]
     }
@@ -164,16 +165,16 @@ Zed will also use the `OPENAI_API_KEY` environment variable if it's defined.
 
 #### OpenAI Custom Models {#openai-custom-models}
 
-You can add custom models to the OpenAI provider, by adding the following to your Zed `settings.json`:
+The Zed Assistant comes pre-configured to use the latest version for common models (GPT-3.5 Turbo, GPT-4, GPT-4 Turbo, GPT-4o, GPT-4o mini). If you wish to use alternate models, perhaps a preview release or a dated model release, you can do so by adding the following to your Zed `settings.json`:
 
 ```json
 {
   "language_models": {
     "openai": {
-      "version": "1",
       "available_models": [
         {
-          "name": "custom-model",
+          "provider": "openai",
+          "name": "gpt-4o-2024-08-06",
           "max_tokens": 128000
         }
       ]
@@ -182,7 +183,7 @@ You can add custom models to the OpenAI provider, by adding the following to you
 }
 ```
 
-Custom models will be listed in the model dropdown in the assistant panel.
+You must provide the model's Context Window in the `max_tokens` parameter, this can be found [OpenAI Model Docs](https://platform.openai.com/docs/models). Custom models will be listed in the model dropdown in the assistant panel.
 
 ### Advanced configuration {#advanced-configuration}
 

From 06142f975b13f78455c31fae54bced9b82f308a3 Mon Sep 17 00:00:00 2001
From: Niklas Haas <github-daiK1o@haasn.dev>
Date: Tue, 10 Sep 2024 20:26:48 +0200
Subject: [PATCH 023/762] Use the configured UI font size for the inline
 assistant (#17542)

---
 crates/assistant/src/inline_assistant.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index bfd85d2525aaae..7bd74ccabf4763 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -1921,7 +1921,7 @@ impl PromptEditor {
             font_family: settings.ui_font.family.clone(),
             font_features: settings.ui_font.features.clone(),
             font_fallbacks: settings.ui_font.fallbacks.clone(),
-            font_size: rems(0.875).into(),
+            font_size: settings.ui_font_size.into(),
             font_weight: settings.ui_font.weight,
             line_height: relative(1.3),
             ..Default::default()

From ae3880e71a86ef1ddc6218d4a87d683a95672c68 Mon Sep 17 00:00:00 2001
From: KorigamiK <72932688+KorigamiK@users.noreply.github.com>
Date: Wed, 11 Sep 2024 00:06:36 +0530
Subject: [PATCH 024/762] Add ability to open files with system default
 application (#17231)

---
 assets/keymaps/default-linux.json            |  1 +
 assets/keymaps/default-macos.json            |  2 +-
 assets/keymaps/vim.json                      |  1 +
 crates/gpui/src/app.rs                       |  5 +++++
 crates/gpui/src/platform.rs                  |  1 +
 crates/gpui/src/platform/linux/platform.rs   | 13 +++++++++++++
 crates/gpui/src/platform/mac/platform.rs     | 14 ++++++++++++++
 crates/gpui/src/platform/test/platform.rs    |  4 ++++
 crates/gpui/src/platform/windows/platform.rs | 13 +++++++++++++
 crates/project_panel/src/project_panel.rs    | 10 ++++++++++
 10 files changed, 63 insertions(+), 1 deletion(-)

diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index bd2ade4246b17c..3c627d7803e1d5 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -553,6 +553,7 @@
       "ctrl-backspace": ["project_panel::Delete", { "skip_prompt": false }],
       "ctrl-delete": ["project_panel::Delete", { "skip_prompt": false }],
       "alt-ctrl-r": "project_panel::RevealInFileManager",
+      "ctrl-shift-enter": "project_panel::OpenWithSystem",
       "alt-shift-f": "project_panel::NewSearchInDirectory",
       "shift-down": "menu::SelectNext",
       "shift-up": "menu::SelectPrev",
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index dec5cbd9f398b9..ed6ece0556e038 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -563,8 +563,8 @@
       "cmd-backspace": ["project_panel::Trash", { "skip_prompt": true }],
       "cmd-delete": ["project_panel::Delete", { "skip_prompt": false }],
       "alt-cmd-r": "project_panel::RevealInFileManager",
+      "ctrl-shift-enter": "project_panel::OpenWithSystem",
       "cmd-alt-backspace": ["project_panel::Delete", { "skip_prompt": false }],
-
       "alt-shift-f": "project_panel::NewSearchInDirectory",
       "shift-down": "menu::SelectNext",
       "shift-up": "menu::SelectPrev",
diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index f863e8488a0e28..54905b22678cd1 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -493,6 +493,7 @@
       "v": "project_panel::OpenPermanent",
       "p": "project_panel::Open",
       "x": "project_panel::RevealInFileManager",
+      "s": "project_panel::OpenWithSystem",
       "shift-g": "menu::SelectLast",
       "g g": "menu::SelectFirst",
       "-": "project_panel::SelectParent",
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index 2157f97634daaf..564b8934897734 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -657,6 +657,11 @@ impl AppContext {
         self.platform.reveal_path(path)
     }
 
+    /// Opens the specified path with the system's default application.
+    pub fn open_with_system(&self, path: &Path) {
+        self.platform.open_with_system(path)
+    }
+
     /// Returns whether the user has configured scrollbars to auto-hide at the platform level.
     pub fn should_auto_hide_scrollbars(&self) -> bool {
         self.platform.should_auto_hide_scrollbars()
diff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rs
index cb54d9d47a0873..680c813078b86d 100644
--- a/crates/gpui/src/platform.rs
+++ b/crates/gpui/src/platform.rs
@@ -149,6 +149,7 @@ pub(crate) trait Platform: 'static {
     ) -> oneshot::Receiver<Result<Option<Vec<PathBuf>>>>;
     fn prompt_for_new_path(&self, directory: &Path) -> oneshot::Receiver<Result<Option<PathBuf>>>;
     fn reveal_path(&self, path: &Path);
+    fn open_with_system(&self, path: &Path);
 
     fn on_quit(&self, callback: Box<dyn FnMut()>);
     fn on_reopen(&self, callback: Box<dyn FnMut()>);
diff --git a/crates/gpui/src/platform/linux/platform.rs b/crates/gpui/src/platform/linux/platform.rs
index 0aa17e534ab760..a0bd6b1d33d176 100644
--- a/crates/gpui/src/platform/linux/platform.rs
+++ b/crates/gpui/src/platform/linux/platform.rs
@@ -351,6 +351,19 @@ impl<P: LinuxClient + 'static> Platform for P {
         self.reveal_path(path.to_owned());
     }
 
+    fn open_with_system(&self, path: &Path) {
+        let executor = self.background_executor().clone();
+        let path = path.to_owned();
+        executor
+            .spawn(async move {
+                let _ = std::process::Command::new("xdg-open")
+                    .arg(path)
+                    .spawn()
+                    .expect("Failed to open file with xdg-open");
+            })
+            .detach();
+    }
+
     fn on_quit(&self, callback: Box<dyn FnMut()>) {
         self.with_common(|common| {
             common.callbacks.quit = Some(callback);
diff --git a/crates/gpui/src/platform/mac/platform.rs b/crates/gpui/src/platform/mac/platform.rs
index d03d8f0571f9b1..5873d8fe396d71 100644
--- a/crates/gpui/src/platform/mac/platform.rs
+++ b/crates/gpui/src/platform/mac/platform.rs
@@ -718,6 +718,20 @@ impl Platform for MacPlatform {
         }
     }
 
+    fn open_with_system(&self, path: &Path) {
+        let path = path.to_path_buf();
+        self.0
+            .lock()
+            .background_executor
+            .spawn(async move {
+                std::process::Command::new("open")
+                    .arg(path)
+                    .spawn()
+                    .expect("Failed to open file");
+            })
+            .detach();
+    }
+
     fn on_quit(&self, callback: Box<dyn FnMut()>) {
         self.0.lock().quit = Some(callback);
     }
diff --git a/crates/gpui/src/platform/test/platform.rs b/crates/gpui/src/platform/test/platform.rs
index 58ca694d89ee02..3258ae9af59ab2 100644
--- a/crates/gpui/src/platform/test/platform.rs
+++ b/crates/gpui/src/platform/test/platform.rs
@@ -318,6 +318,10 @@ impl Platform for TestPlatform {
     fn register_url_scheme(&self, _: &str) -> Task<anyhow::Result<()>> {
         unimplemented!()
     }
+
+    fn open_with_system(&self, _path: &Path) {
+        unimplemented!()
+    }
 }
 
 #[cfg(target_os = "windows")]
diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs
index 2dcaf72ef25162..f8b3924e6282b1 100644
--- a/crates/gpui/src/platform/windows/platform.rs
+++ b/crates/gpui/src/platform/windows/platform.rs
@@ -400,6 +400,19 @@ impl Platform for WindowsPlatform {
             .detach();
     }
 
+    fn open_with_system(&self, path: &Path) {
+        let executor = self.background_executor().clone();
+        let path = path.to_owned();
+        executor
+            .spawn(async move {
+                let _ = std::process::Command::new("cmd")
+                    .args(&["/c", "start", "", path.to_str().expect("path to string")])
+                    .spawn()
+                    .expect("Failed to open file");
+            })
+            .detach();
+    }
+
     fn on_quit(&self, callback: Box<dyn FnMut()>) {
         self.state.borrow_mut().callbacks.quit = Some(callback);
     }
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 56d524cdc7130c..c77a2170dd01cd 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -146,6 +146,7 @@ actions!(
         CopyRelativePath,
         Duplicate,
         RevealInFileManager,
+        OpenWithSystem,
         Cut,
         Paste,
         Rename,
@@ -500,6 +501,7 @@ impl ProjectPanel {
                             .when(cfg!(not(target_os = "macos")), |menu| {
                                 menu.action("Reveal in File Manager", Box::new(RevealInFileManager))
                             })
+                            .action("Open in Default App", Box::new(OpenWithSystem))
                             .action("Open in Terminal", Box::new(OpenInTerminal))
                             .when(is_dir, |menu| {
                                 menu.separator()
@@ -1497,6 +1499,13 @@ impl ProjectPanel {
         }
     }
 
+    fn open_system(&mut self, _: &OpenWithSystem, cx: &mut ViewContext<Self>) {
+        if let Some((worktree, entry)) = self.selected_entry(cx) {
+            let abs_path = worktree.abs_path().join(&entry.path);
+            cx.open_with_system(&abs_path);
+        }
+    }
+
     fn open_in_terminal(&mut self, _: &OpenInTerminal, cx: &mut ViewContext<Self>) {
         if let Some((worktree, entry)) = self.selected_sub_entry(cx) {
             let abs_path = worktree.abs_path().join(&entry.path);
@@ -2711,6 +2720,7 @@ impl Render for ProjectPanel {
                 })
                 .when(project.is_local_or_ssh(), |el| {
                     el.on_action(cx.listener(Self::reveal_in_finder))
+                        .on_action(cx.listener(Self::open_system))
                         .on_action(cx.listener(Self::open_in_terminal))
                 })
                 .on_mouse_down(

From 1b627925d3874b8461212945e8b41a28c5022aad Mon Sep 17 00:00:00 2001
From: Joseph T Lyons <JosephTLyons@gmail.com>
Date: Tue, 10 Sep 2024 14:40:51 -0400
Subject: [PATCH 025/762] v0.154.x dev

---
 Cargo.lock            | 2 +-
 crates/zed/Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4f34f055ad6692..f9d3240d682a93 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14197,7 +14197,7 @@ dependencies = [
 
 [[package]]
 name = "zed"
-version = "0.153.0"
+version = "0.154.0"
 dependencies = [
  "activity_indicator",
  "anyhow",
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index de8bc1f7678378..ad02d4f38879ef 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -2,7 +2,7 @@
 description = "The fast, collaborative code editor."
 edition = "2021"
 name = "zed"
-version = "0.153.0"
+version = "0.154.0"
 publish = false
 license = "GPL-3.0-or-later"
 authors = ["Zed Team <hi@zed.dev>"]

From a23e381096c623951212608119fc497101e281f1 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 10 Sep 2024 15:25:57 -0400
Subject: [PATCH 026/762] assistant: Pass up tool results in LLM request
 messages (#17656)

This PR makes it so we pass up the tool results in the `tool_results`
field in the request message to the LLM.

This required reworking how we track non-text content in the context
editor.

We also removed serialization of images in context history, as we were
never deserializing it, and thus it was unneeded.

Release Notes:

- N/A

---------

Co-authored-by: Antonio <antonio@zed.dev>
---
 crates/assistant/src/assistant_panel.rs |  39 ++-
 crates/assistant/src/context.rs         | 381 +++++++++++-------------
 crates/paths/src/paths.rs               |   6 -
 3 files changed, 215 insertions(+), 211 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 82888b498a3c80..22843d41cd6207 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -11,7 +11,7 @@ use crate::{
     },
     slash_command_picker,
     terminal_inline_assistant::TerminalInlineAssistant,
-    Assist, CacheStatus, ConfirmCommand, Context, ContextEvent, ContextId, ContextStore,
+    Assist, CacheStatus, ConfirmCommand, Content, Context, ContextEvent, ContextId, ContextStore,
     ContextStoreEvent, CycleMessageRole, DeployHistory, DeployPromptLibrary, InlineAssistId,
     InlineAssistant, InsertDraggedFiles, InsertIntoEditor, Message, MessageId, MessageMetadata,
     MessageStatus, ModelPickerDelegate, ModelSelector, NewContext, PendingSlashCommand,
@@ -46,6 +46,7 @@ use indexed_docs::IndexedDocsStore;
 use language::{
     language_settings::SoftWrap, Capability, LanguageRegistry, LspAdapterDelegate, Point, ToOffset,
 };
+use language_model::LanguageModelToolUse;
 use language_model::{
     provider::cloud::PROVIDER_ID, LanguageModelProvider, LanguageModelProviderId,
     LanguageModelRegistry, Role,
@@ -1995,6 +1996,20 @@ impl ContextEditor {
                             let buffer_row = MultiBufferRow(start.to_point(&buffer).row);
                             buffer_rows_to_fold.insert(buffer_row);
 
+                            self.context.update(cx, |context, cx| {
+                                context.insert_content(
+                                    Content::ToolUse {
+                                        range: tool_use.source_range.clone(),
+                                        tool_use: LanguageModelToolUse {
+                                            id: tool_use.id.to_string(),
+                                            name: tool_use.name.clone(),
+                                            input: tool_use.input.clone(),
+                                        },
+                                    },
+                                    cx,
+                                );
+                            });
+
                             Crease::new(
                                 start..end,
                                 placeholder,
@@ -3538,7 +3553,7 @@ impl ContextEditor {
                     let image_id = image.id();
                     context.insert_image(image, cx);
                     for image_position in image_positions.iter() {
-                        context.insert_image_anchor(image_id, image_position.text_anchor, cx);
+                        context.insert_image_content(image_id, image_position.text_anchor, cx);
                     }
                 }
             });
@@ -3553,11 +3568,23 @@ impl ContextEditor {
             let new_blocks = self
                 .context
                 .read(cx)
-                .images(cx)
-                .filter_map(|image| {
+                .contents(cx)
+                .filter_map(|content| {
+                    if let Content::Image {
+                        anchor,
+                        render_image,
+                        ..
+                    } = content
+                    {
+                        Some((anchor, render_image))
+                    } else {
+                        None
+                    }
+                })
+                .filter_map(|(anchor, render_image)| {
                     const MAX_HEIGHT_IN_LINES: u32 = 8;
-                    let anchor = buffer.anchor_in_excerpt(excerpt_id, image.anchor).unwrap();
-                    let image = image.render_image.clone();
+                    let anchor = buffer.anchor_in_excerpt(excerpt_id, anchor).unwrap();
+                    let image = render_image.clone();
                     anchor.is_valid(&buffer).then(|| BlockProperties {
                         position: anchor,
                         height: MAX_HEIGHT_IN_LINES,
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index 1bf846369b7627..e43ec203e96752 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -17,7 +17,6 @@ use feature_flags::{FeatureFlag, FeatureFlagAppExt};
 use fs::{Fs, RemoveOptions};
 use futures::{
     future::{self, Shared},
-    stream::FuturesUnordered,
     FutureExt, StreamExt,
 };
 use gpui::{
@@ -29,10 +28,11 @@ use language::{AnchorRangeExt, Bias, Buffer, LanguageRegistry, OffsetRangeExt, P
 use language_model::{
     LanguageModel, LanguageModelCacheConfiguration, LanguageModelCompletionEvent,
     LanguageModelImage, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
-    LanguageModelRequestTool, MessageContent, Role, StopReason,
+    LanguageModelRequestTool, LanguageModelToolResult, LanguageModelToolUse, MessageContent, Role,
+    StopReason,
 };
 use open_ai::Model as OpenAiModel;
-use paths::{context_images_dir, contexts_dir};
+use paths::contexts_dir;
 use project::Project;
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
@@ -377,23 +377,8 @@ impl MessageMetadata {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct MessageImage {
-    image_id: u64,
-    image: Shared<Task<Option<LanguageModelImage>>>,
-}
-
-impl PartialEq for MessageImage {
-    fn eq(&self, other: &Self) -> bool {
-        self.image_id == other.image_id
-    }
-}
-
-impl Eq for MessageImage {}
-
 #[derive(Clone, Debug)]
 pub struct Message {
-    pub image_offsets: SmallVec<[(usize, MessageImage); 1]>,
     pub offset_range: Range<usize>,
     pub index_range: Range<usize>,
     pub anchor_range: Range<language::Anchor>,
@@ -403,62 +388,45 @@ pub struct Message {
     pub cache: Option<MessageCacheMetadata>,
 }
 
-impl Message {
-    fn to_request_message(&self, buffer: &Buffer) -> Option<LanguageModelRequestMessage> {
-        let mut content = Vec::new();
-
-        let mut range_start = self.offset_range.start;
-        for (image_offset, message_image) in self.image_offsets.iter() {
-            if *image_offset != range_start {
-                if let Some(text) = Self::collect_text_content(buffer, range_start..*image_offset) {
-                    content.push(text);
-                }
-            }
-
-            if let Some(image) = message_image.image.clone().now_or_never().flatten() {
-                content.push(language_model::MessageContent::Image(image));
-            }
-
-            range_start = *image_offset;
-        }
-
-        if range_start != self.offset_range.end {
-            if let Some(text) =
-                Self::collect_text_content(buffer, range_start..self.offset_range.end)
-            {
-                content.push(text);
-            }
-        }
+#[derive(Debug, Clone)]
+pub enum Content {
+    Image {
+        anchor: language::Anchor,
+        image_id: u64,
+        render_image: Arc<RenderImage>,
+        image: Shared<Task<Option<LanguageModelImage>>>,
+    },
+    ToolUse {
+        range: Range<language::Anchor>,
+        tool_use: LanguageModelToolUse,
+    },
+    ToolResult {
+        range: Range<language::Anchor>,
+        tool_use_id: Arc<str>,
+    },
+}
 
-        if content.is_empty() {
-            return None;
+impl Content {
+    fn range(&self) -> Range<language::Anchor> {
+        match self {
+            Self::Image { anchor, .. } => *anchor..*anchor,
+            Self::ToolUse { range, .. } | Self::ToolResult { range, .. } => range.clone(),
         }
-
-        Some(LanguageModelRequestMessage {
-            role: self.role,
-            content,
-            cache: self.cache.as_ref().map_or(false, |cache| cache.is_anchor),
-        })
     }
 
-    fn collect_text_content(buffer: &Buffer, range: Range<usize>) -> Option<MessageContent> {
-        let text: String = buffer.text_for_range(range.clone()).collect();
-        if text.trim().is_empty() {
-            None
+    fn cmp(&self, other: &Self, buffer: &BufferSnapshot) -> Ordering {
+        let self_range = self.range();
+        let other_range = other.range();
+        if self_range.end.cmp(&other_range.start, buffer).is_lt() {
+            Ordering::Less
+        } else if self_range.start.cmp(&other_range.end, buffer).is_gt() {
+            Ordering::Greater
         } else {
-            Some(MessageContent::Text(text))
+            Ordering::Equal
         }
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct ImageAnchor {
-    pub anchor: language::Anchor,
-    pub image_id: u64,
-    pub render_image: Arc<RenderImage>,
-    pub image: Shared<Task<Option<LanguageModelImage>>>,
-}
-
 struct PendingCompletion {
     id: usize,
     assistant_message_id: MessageId,
@@ -501,7 +469,7 @@ pub struct Context {
     pending_tool_uses_by_id: HashMap<Arc<str>, PendingToolUse>,
     message_anchors: Vec<MessageAnchor>,
     images: HashMap<u64, (Arc<RenderImage>, Shared<Task<Option<LanguageModelImage>>>)>,
-    image_anchors: Vec<ImageAnchor>,
+    contents: Vec<Content>,
     messages_metadata: HashMap<MessageId, MessageMetadata>,
     summary: Option<ContextSummary>,
     pending_summary: Task<Option<()>>,
@@ -595,7 +563,7 @@ impl Context {
             pending_ops: Vec::new(),
             operations: Vec::new(),
             message_anchors: Default::default(),
-            image_anchors: Default::default(),
+            contents: Default::default(),
             images: Default::default(),
             messages_metadata: Default::default(),
             pending_slash_commands: Vec::new(),
@@ -659,11 +627,6 @@ impl Context {
                     id: message.id,
                     start: message.offset_range.start,
                     metadata: self.messages_metadata[&message.id].clone(),
-                    image_offsets: message
-                        .image_offsets
-                        .iter()
-                        .map(|image_offset| (image_offset.0, image_offset.1.image_id))
-                        .collect(),
                 })
                 .collect(),
             summary: self
@@ -1957,6 +1920,14 @@ impl Context {
                             output_range
                         });
 
+                        this.insert_content(
+                            Content::ToolResult {
+                                range: anchor_range.clone(),
+                                tool_use_id: tool_use_id.clone(),
+                            },
+                            cx,
+                        );
+
                         cx.emit(ContextEvent::ToolFinished {
                             tool_use_id,
                             output_range: anchor_range,
@@ -2038,6 +2009,7 @@ impl Context {
                 let stream_completion = async {
                     let request_start = Instant::now();
                     let mut events = stream.await?;
+                    let mut stop_reason = StopReason::EndTurn;
 
                     while let Some(event) = events.next().await {
                         if response_latency.is_none() {
@@ -2050,7 +2022,7 @@ impl Context {
                                 .message_anchors
                                 .iter()
                                 .position(|message| message.id == assistant_message_id)?;
-                            let event_to_emit = this.buffer.update(cx, |buffer, cx| {
+                            this.buffer.update(cx, |buffer, cx| {
                                 let message_old_end_offset = this.message_anchors[message_ix + 1..]
                                     .iter()
                                     .find(|message| message.start.is_valid(buffer))
@@ -2059,13 +2031,9 @@ impl Context {
                                     });
 
                                 match event {
-                                    LanguageModelCompletionEvent::Stop(reason) => match reason {
-                                        StopReason::ToolUse => {
-                                            return Some(ContextEvent::UsePendingTools);
-                                        }
-                                        StopReason::EndTurn => {}
-                                        StopReason::MaxTokens => {}
-                                    },
+                                    LanguageModelCompletionEvent::Stop(reason) => {
+                                        stop_reason = reason;
+                                    }
                                     LanguageModelCompletionEvent::Text(chunk) => {
                                         buffer.edit(
                                             [(
@@ -2116,14 +2084,9 @@ impl Context {
                                         );
                                     }
                                 }
-
-                                None
                             });
 
                             cx.emit(ContextEvent::StreamedCompletion);
-                            if let Some(event) = event_to_emit {
-                                cx.emit(event);
-                            }
 
                             Some(())
                         })?;
@@ -2136,13 +2099,14 @@ impl Context {
                         this.update_cache_status_for_completion(cx);
                     })?;
 
-                    anyhow::Ok(())
+                    anyhow::Ok(stop_reason)
                 };
 
                 let result = stream_completion.await;
 
                 this.update(&mut cx, |this, cx| {
                     let error_message = result
+                        .as_ref()
                         .err()
                         .map(|error| error.to_string().trim().to_string());
 
@@ -2170,6 +2134,16 @@ impl Context {
                             error_message,
                         );
                     }
+
+                    if let Ok(stop_reason) = result {
+                        match stop_reason {
+                            StopReason::ToolUse => {
+                                cx.emit(ContextEvent::UsePendingTools);
+                            }
+                            StopReason::EndTurn => {}
+                            StopReason::MaxTokens => {}
+                        }
+                    }
                 })
                 .ok();
             }
@@ -2186,18 +2160,94 @@ impl Context {
 
     pub fn to_completion_request(&self, cx: &AppContext) -> LanguageModelRequest {
         let buffer = self.buffer.read(cx);
-        let request_messages = self
-            .messages(cx)
-            .filter(|message| message.status == MessageStatus::Done)
-            .filter_map(|message| message.to_request_message(&buffer))
-            .collect();
 
-        LanguageModelRequest {
-            messages: request_messages,
+        let mut contents = self.contents(cx).peekable();
+
+        fn collect_text_content(buffer: &Buffer, range: Range<usize>) -> Option<String> {
+            let text: String = buffer.text_for_range(range.clone()).collect();
+            if text.trim().is_empty() {
+                None
+            } else {
+                Some(text)
+            }
+        }
+
+        let mut completion_request = LanguageModelRequest {
+            messages: Vec::new(),
             tools: Vec::new(),
             stop: Vec::new(),
             temperature: 1.0,
+        };
+        for message in self.messages(cx) {
+            if message.status != MessageStatus::Done {
+                continue;
+            }
+
+            let mut offset = message.offset_range.start;
+            let mut request_message = LanguageModelRequestMessage {
+                role: message.role,
+                content: Vec::new(),
+                cache: message
+                    .cache
+                    .as_ref()
+                    .map_or(false, |cache| cache.is_anchor),
+            };
+
+            while let Some(content) = contents.peek() {
+                if content
+                    .range()
+                    .end
+                    .cmp(&message.anchor_range.end, buffer)
+                    .is_lt()
+                {
+                    let content = contents.next().unwrap();
+                    let range = content.range().to_offset(buffer);
+                    request_message.content.extend(
+                        collect_text_content(buffer, offset..range.start).map(MessageContent::Text),
+                    );
+
+                    match content {
+                        Content::Image { image, .. } => {
+                            if let Some(image) = image.clone().now_or_never().flatten() {
+                                request_message
+                                    .content
+                                    .push(language_model::MessageContent::Image(image));
+                            }
+                        }
+                        Content::ToolUse { tool_use, .. } => {
+                            request_message
+                                .content
+                                .push(language_model::MessageContent::ToolUse(tool_use.clone()));
+                        }
+                        Content::ToolResult { tool_use_id, .. } => {
+                            request_message.content.push(
+                                language_model::MessageContent::ToolResult(
+                                    LanguageModelToolResult {
+                                        tool_use_id: tool_use_id.to_string(),
+                                        is_error: false,
+                                        content: collect_text_content(buffer, range.clone())
+                                            .unwrap_or_default(),
+                                    },
+                                ),
+                            );
+                        }
+                    }
+
+                    offset = range.end;
+                } else {
+                    break;
+                }
+            }
+
+            request_message.content.extend(
+                collect_text_content(buffer, offset..message.offset_range.end)
+                    .map(MessageContent::Text),
+            );
+
+            completion_request.messages.push(request_message);
         }
+
+        completion_request
     }
 
     pub fn cancel_last_assist(&mut self, cx: &mut ModelContext<Self>) -> bool {
@@ -2335,42 +2385,50 @@ impl Context {
         Some(())
     }
 
-    pub fn insert_image_anchor(
+    pub fn insert_image_content(
         &mut self,
         image_id: u64,
         anchor: language::Anchor,
         cx: &mut ModelContext<Self>,
-    ) -> bool {
-        cx.emit(ContextEvent::MessagesEdited);
-
-        let buffer = self.buffer.read(cx);
-        let insertion_ix = match self
-            .image_anchors
-            .binary_search_by(|existing_anchor| anchor.cmp(&existing_anchor.anchor, buffer))
-        {
-            Ok(ix) => ix,
-            Err(ix) => ix,
-        };
-
+    ) {
         if let Some((render_image, image)) = self.images.get(&image_id) {
-            self.image_anchors.insert(
-                insertion_ix,
-                ImageAnchor {
+            self.insert_content(
+                Content::Image {
                     anchor,
                     image_id,
                     image: image.clone(),
                     render_image: render_image.clone(),
                 },
+                cx,
             );
-
-            true
-        } else {
-            false
         }
     }
 
-    pub fn images<'a>(&'a self, _cx: &'a AppContext) -> impl 'a + Iterator<Item = ImageAnchor> {
-        self.image_anchors.iter().cloned()
+    pub fn insert_content(&mut self, content: Content, cx: &mut ModelContext<Self>) {
+        let buffer = self.buffer.read(cx);
+        let insertion_ix = match self
+            .contents
+            .binary_search_by(|probe| probe.cmp(&content, buffer))
+        {
+            Ok(ix) => {
+                self.contents.remove(ix);
+                ix
+            }
+            Err(ix) => ix,
+        };
+        self.contents.insert(insertion_ix, content);
+        cx.emit(ContextEvent::MessagesEdited);
+    }
+
+    pub fn contents<'a>(&'a self, cx: &'a AppContext) -> impl 'a + Iterator<Item = Content> {
+        let buffer = self.buffer.read(cx);
+        self.contents
+            .iter()
+            .filter(|content| {
+                let range = content.range();
+                range.start.is_valid(buffer) && range.end.is_valid(buffer)
+            })
+            .cloned()
     }
 
     pub fn split_message(
@@ -2533,22 +2591,14 @@ impl Context {
                 return;
             }
 
-            let messages = self
-                .messages(cx)
-                .filter_map(|message| message.to_request_message(self.buffer.read(cx)))
-                .chain(Some(LanguageModelRequestMessage {
-                    role: Role::User,
-                    content: vec![
-                        "Summarize the context into a short title without punctuation.".into(),
-                    ],
-                    cache: false,
-                }));
-            let request = LanguageModelRequest {
-                messages: messages.collect(),
-                tools: Vec::new(),
-                stop: Vec::new(),
-                temperature: 1.0,
-            };
+            let mut request = self.to_completion_request(cx);
+            request.messages.push(LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec![
+                    "Summarize the context into a short title without punctuation.".into(),
+                ],
+                cache: false,
+            });
 
             self.pending_summary = cx.spawn(|this, mut cx| {
                 async move {
@@ -2648,10 +2698,8 @@ impl Context {
         cx: &'a AppContext,
     ) -> impl 'a + Iterator<Item = Message> {
         let buffer = self.buffer.read(cx);
-        let messages = message_anchors.enumerate();
-        let images = self.image_anchors.iter();
 
-        Self::messages_from_iters(buffer, &self.messages_metadata, messages, images)
+        Self::messages_from_iters(buffer, &self.messages_metadata, message_anchors.enumerate())
     }
 
     pub fn messages<'a>(&'a self, cx: &'a AppContext) -> impl 'a + Iterator<Item = Message> {
@@ -2662,10 +2710,8 @@ impl Context {
         buffer: &'a Buffer,
         metadata: &'a HashMap<MessageId, MessageMetadata>,
         messages: impl Iterator<Item = (usize, &'a MessageAnchor)> + 'a,
-        images: impl Iterator<Item = &'a ImageAnchor> + 'a,
     ) -> impl 'a + Iterator<Item = Message> {
         let mut messages = messages.peekable();
-        let mut images = images.peekable();
 
         iter::from_fn(move || {
             if let Some((start_ix, message_anchor)) = messages.next() {
@@ -2686,22 +2732,6 @@ impl Context {
                 let message_end_anchor = message_end.unwrap_or(language::Anchor::MAX);
                 let message_end = message_end_anchor.to_offset(buffer);
 
-                let mut image_offsets = SmallVec::new();
-                while let Some(image_anchor) = images.peek() {
-                    if image_anchor.anchor.cmp(&message_end_anchor, buffer).is_lt() {
-                        image_offsets.push((
-                            image_anchor.anchor.to_offset(buffer),
-                            MessageImage {
-                                image_id: image_anchor.image_id,
-                                image: image_anchor.image.clone(),
-                            },
-                        ));
-                        images.next();
-                    } else {
-                        break;
-                    }
-                }
-
                 return Some(Message {
                     index_range: start_ix..end_ix,
                     offset_range: message_start..message_end,
@@ -2710,7 +2740,6 @@ impl Context {
                     role: metadata.role,
                     status: metadata.status.clone(),
                     cache: metadata.cache.clone(),
-                    image_offsets,
                 });
             }
             None
@@ -2748,9 +2777,6 @@ impl Context {
             })?;
 
             if let Some(summary) = summary {
-                this.read_with(&cx, |this, cx| this.serialize_images(fs.clone(), cx))?
-                    .await;
-
                 let context = this.read_with(&cx, |this, cx| this.serialize(cx))?;
                 let mut discriminant = 1;
                 let mut new_path;
@@ -2790,45 +2816,6 @@ impl Context {
         });
     }
 
-    pub fn serialize_images(&self, fs: Arc<dyn Fs>, cx: &AppContext) -> Task<()> {
-        let mut images_to_save = self
-            .images
-            .iter()
-            .map(|(id, (_, llm_image))| {
-                let fs = fs.clone();
-                let llm_image = llm_image.clone();
-                let id = *id;
-                async move {
-                    if let Some(llm_image) = llm_image.await {
-                        let path: PathBuf =
-                            context_images_dir().join(&format!("{}.png.base64", id));
-                        if fs
-                            .metadata(path.as_path())
-                            .await
-                            .log_err()
-                            .flatten()
-                            .is_none()
-                        {
-                            fs.atomic_write(path, llm_image.source.to_string())
-                                .await
-                                .log_err();
-                        }
-                    }
-                }
-            })
-            .collect::<FuturesUnordered<_>>();
-        cx.background_executor().spawn(async move {
-            if fs
-                .create_dir(context_images_dir().as_ref())
-                .await
-                .log_err()
-                .is_some()
-            {
-                while let Some(_) = images_to_save.next().await {}
-            }
-        })
-    }
-
     pub(crate) fn custom_summary(&mut self, custom_summary: String, cx: &mut ModelContext<Self>) {
         let timestamp = self.next_timestamp();
         let summary = self.summary.get_or_insert(ContextSummary::default());
@@ -2914,9 +2901,6 @@ pub struct SavedMessage {
     pub id: MessageId,
     pub start: usize,
     pub metadata: MessageMetadata,
-    #[serde(default)]
-    // This is defaulted for backwards compatibility with JSON files created before August 2024. We didn't always have this field.
-    pub image_offsets: Vec<(usize, u64)>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -3102,7 +3086,6 @@ impl SavedContextV0_3_0 {
                             timestamp,
                             cache: None,
                         },
-                        image_offsets: Vec::new(),
                     })
                 })
                 .collect(),
diff --git a/crates/paths/src/paths.rs b/crates/paths/src/paths.rs
index 4d6a3b6d92eb54..b80bef5f2d623e 100644
--- a/crates/paths/src/paths.rs
+++ b/crates/paths/src/paths.rs
@@ -170,12 +170,6 @@ pub fn contexts_dir() -> &'static PathBuf {
     })
 }
 
-/// Returns the path within the contexts directory where images from contexts are stored.
-pub fn context_images_dir() -> &'static PathBuf {
-    static CONTEXT_IMAGES_DIR: OnceLock<PathBuf> = OnceLock::new();
-    CONTEXT_IMAGES_DIR.get_or_init(|| contexts_dir().join("images"))
-}
-
 /// Returns the path to the contexts directory.
 ///
 /// This is where the prompts for use with the Assistant are stored.

From bd1ff476b987ed2570f90b76e8c028d7e7951543 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 10 Sep 2024 15:38:27 -0400
Subject: [PATCH 027/762] Revert tokenizer for custom OpenAI models (#17660)

Fix for custom openai models tokenizer settings.
---
 crates/language_model/src/provider/open_ai.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/language_model/src/provider/open_ai.rs b/crates/language_model/src/provider/open_ai.rs
index 15d84f6cca2efc..a7a962e9251671 100644
--- a/crates/language_model/src/provider/open_ai.rs
+++ b/crates/language_model/src/provider/open_ai.rs
@@ -370,7 +370,11 @@ pub fn count_open_ai_tokens(
                 })
                 .collect::<Vec<_>>();
 
-            tiktoken_rs::num_tokens_from_messages(model.id(), &messages)
+            if let open_ai::Model::Custom { .. } = model {
+                tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)
+            } else {
+                tiktoken_rs::num_tokens_from_messages(model.id(), &messages)
+            }
         })
         .boxed()
 }

From 130f19d8f953ca43bf6c833ac0e0c7362a170850 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 10 Sep 2024 15:50:51 -0400
Subject: [PATCH 028/762] Correctly merge settings for vtsls (#17657)

Release Notes:

- Fixed vtsls initialization_options in project settings files
---
 crates/languages/src/vtsls.rs | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/crates/languages/src/vtsls.rs b/crates/languages/src/vtsls.rs
index d38ee85f313891..3dca82688cb81d 100644
--- a/crates/languages/src/vtsls.rs
+++ b/crates/languages/src/vtsls.rs
@@ -7,14 +7,14 @@ use lsp::{CodeActionKind, LanguageServerBinary};
 use node_runtime::NodeRuntime;
 use project::project_settings::{BinarySettings, ProjectSettings};
 use serde_json::{json, Value};
-use settings::Settings;
+use settings::{Settings, SettingsLocation};
 use std::{
     any::Any,
     ffi::OsString,
     path::{Path, PathBuf},
     sync::Arc,
 };
-use util::{maybe, ResultExt};
+use util::{maybe, merge_json_value_into, ResultExt};
 
 fn typescript_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
     vec![server_path.into(), "--stdio".into()]
@@ -274,17 +274,29 @@ impl LspAdapter for VtslsLspAdapter {
         cx: &mut AsyncAppContext,
     ) -> Result<Value> {
         let override_options = cx.update(|cx| {
-            ProjectSettings::get_global(cx)
-                .lsp
-                .get(SERVER_NAME)
-                .and_then(|s| s.initialization_options.clone())
+            ProjectSettings::get(
+                Some(SettingsLocation {
+                    worktree_id: adapter.worktree_id(),
+                    path: adapter.worktree_root_path(),
+                }),
+                cx,
+            )
+            .lsp
+            .get(SERVER_NAME)
+            .and_then(|s| s.initialization_options.clone())
         })?;
         if let Some(options) = override_options {
             return Ok(options);
         }
-        self.initialization_options(adapter)
+        let mut initialization_options = self
+            .initialization_options(adapter)
             .await
-            .map(|o| o.unwrap())
+            .map(|o| o.unwrap())?;
+
+        if let Some(override_options) = override_options {
+            merge_json_value_into(override_options, &mut initialization_options)
+        }
+        Ok(initialization_options)
     }
 
     fn language_ids(&self) -> HashMap<String, String> {

From 36eb1c15eaf7bff72bf120e1fccc7a73326ad8e9 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 10 Sep 2024 15:51:01 -0400
Subject: [PATCH 029/762] use ssh lsp store (#17655)

Release Notes:

- ssh remoting: Added support for booting langauge servers (in limited
circumstances)

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 crates/assistant/src/assistant_panel.rs       |   15 +-
 crates/assistant/src/inline_assistant.rs      |    4 +-
 crates/assistant/src/prompts.rs               |    6 +-
 crates/collab/src/tests/integration_tests.rs  |   10 +-
 .../remote_editing_collaboration_tests.rs     |    2 +-
 crates/editor/src/clangd_ext.rs               |    2 +-
 crates/editor/src/editor.rs                   |    2 +-
 crates/editor/src/editor_tests.rs             |   10 +-
 crates/editor/src/items.rs                    |    4 +-
 crates/editor/src/rust_analyzer_ext.rs        |    2 +-
 .../src/test/editor_lsp_test_context.rs       |    2 +-
 crates/extension/src/extension_lsp_adapter.rs |    1 -
 crates/extension/src/extension_manifest.rs    |    8 +-
 crates/extension/src/extension_store.rs       |    5 +-
 crates/extension/src/extension_store_test.rs  |    2 +-
 .../src/wasm_host/wit/since_v0_1_0.rs         |    4 +-
 crates/gpui/src/app.rs                        |    6 +
 crates/language/src/buffer_tests.rs           |   56 +-
 crates/language/src/language.rs               |   59 +-
 crates/language/src/language_registry.rs      |  211 ++-
 crates/language/src/language_settings.rs      |   12 +-
 .../src/active_buffer_language.rs             |    4 +-
 .../src/language_selector.rs                  |    2 +-
 crates/language_tools/src/lsp_log.rs          |    2 +-
 crates/language_tools/src/syntax_tree_view.rs |    2 +-
 crates/languages/src/rust.rs                  |    2 +-
 crates/languages/src/yaml.rs                  |    2 +-
 crates/lsp/src/lsp.rs                         |   10 +
 .../src/markdown_preview_view.rs              |    2 +-
 .../project/src/lsp_command/signature_help.rs |    2 +-
 crates/project/src/lsp_store.rs               | 1358 ++++++++++++-----
 crates/project/src/project.rs                 |  122 +-
 crates/project/src/project_settings.rs        |    2 +-
 crates/project/src/project_tests.rs           |   14 +-
 crates/project/src/task_inventory.rs          |    4 +-
 crates/proto/proto/zed.proto                  |   37 +-
 crates/proto/src/proto.rs                     |    7 +-
 crates/quick_action_bar/src/repl_menu.rs      |    2 +-
 crates/recent_projects/src/ssh_connections.rs |   21 +-
 crates/remote/src/ssh_session.rs              |   10 +-
 crates/remote_server/src/headless_project.rs  |   29 +-
 .../remote_server/src/remote_editing_tests.rs |  122 +-
 crates/repl/src/repl_editor.rs                |    8 +-
 crates/worktree/src/worktree.rs               |    7 +
 crates/zed/src/zed.rs                         |   20 +-
 45 files changed, 1548 insertions(+), 666 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 22843d41cd6207..7eebc97b1d91e8 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -53,7 +53,8 @@ use language_model::{
 };
 use multi_buffer::MultiBufferRow;
 use picker::{Picker, PickerDelegate};
-use project::{Project, ProjectLspAdapterDelegate, Worktree};
+use project::lsp_store::ProjectLspAdapterDelegate;
+use project::{Project, Worktree};
 use search::{buffer_search::DivRegistrar, BufferSearchBar};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings};
@@ -5340,9 +5341,17 @@ fn make_lsp_adapter_delegate(
             .worktrees(cx)
             .next()
             .ok_or_else(|| anyhow!("no worktrees when constructing ProjectLspAdapterDelegate"))?;
+        let fs = if project.is_local() {
+            Some(project.fs().clone())
+        } else {
+            None
+        };
+        let http_client = project.client().http_client().clone();
         project.lsp_store().update(cx, |lsp_store, cx| {
-            Ok(ProjectLspAdapterDelegate::new(lsp_store, &worktree, cx)
-                as Arc<dyn LspAdapterDelegate>)
+            Ok(
+                ProjectLspAdapterDelegate::new(lsp_store, &worktree, http_client, fs, cx)
+                    as Arc<dyn LspAdapterDelegate>,
+            )
         })
     })
 }
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index 7bd74ccabf4763..051db0f2476bf3 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -2377,7 +2377,7 @@ impl Codegen {
         // If Markdown or No Language is Known, increase the randomness for more creative output
         // If Code, decrease temperature to get more deterministic outputs
         let temperature = if let Some(language) = language_name.clone() {
-            if language.as_ref() == "Markdown" {
+            if language == "Markdown".into() {
                 1.0
             } else {
                 0.5
@@ -2386,7 +2386,7 @@ impl Codegen {
             1.0
         };
 
-        let language_name = language_name.as_deref();
+        let language_name = language_name.as_ref();
         let start = buffer.point_to_buffer_offset(edit_range.start);
         let end = buffer.point_to_buffer_offset(edit_range.end);
         let (buffer, range) = if let Some((start, end)) = start.zip(end) {
diff --git a/crates/assistant/src/prompts.rs b/crates/assistant/src/prompts.rs
index 068bf7158de08c..83e894f7978746 100644
--- a/crates/assistant/src/prompts.rs
+++ b/crates/assistant/src/prompts.rs
@@ -4,7 +4,7 @@ use fs::Fs;
 use futures::StreamExt;
 use gpui::AssetSource;
 use handlebars::{Handlebars, RenderError};
-use language::BufferSnapshot;
+use language::{BufferSnapshot, LanguageName};
 use parking_lot::Mutex;
 use serde::Serialize;
 use std::{ops::Range, path::PathBuf, sync::Arc, time::Duration};
@@ -204,11 +204,11 @@ impl PromptBuilder {
     pub fn generate_content_prompt(
         &self,
         user_prompt: String,
-        language_name: Option<&str>,
+        language_name: Option<&LanguageName>,
         buffer: BufferSnapshot,
         range: Range<usize>,
     ) -> Result<String, RenderError> {
-        let content_type = match language_name {
+        let content_type = match language_name.as_ref().map(|l| l.0.as_ref()) {
             None | Some("Markdown" | "Plain Text") => "text",
             Some(_) => "code",
         };
diff --git a/crates/collab/src/tests/integration_tests.rs b/crates/collab/src/tests/integration_tests.rs
index e012fce8c26794..b6d7aca2e078a0 100644
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -2328,11 +2328,11 @@ async fn test_propagate_saves_and_fs_changes(
         .unwrap();
 
     buffer_b.read_with(cx_b, |buffer, _| {
-        assert_eq!(&*buffer.language().unwrap().name(), "Rust");
+        assert_eq!(buffer.language().unwrap().name(), "Rust".into());
     });
 
     buffer_c.read_with(cx_c, |buffer, _| {
-        assert_eq!(&*buffer.language().unwrap().name(), "Rust");
+        assert_eq!(buffer.language().unwrap().name(), "Rust".into());
     });
     buffer_b.update(cx_b, |buf, cx| buf.edit([(0..0, "i-am-b, ")], None, cx));
     buffer_c.update(cx_c, |buf, cx| buf.edit([(0..0, "i-am-c, ")], None, cx));
@@ -2432,17 +2432,17 @@ async fn test_propagate_saves_and_fs_changes(
 
     buffer_a.read_with(cx_a, |buffer, _| {
         assert_eq!(buffer.file().unwrap().path().to_str(), Some("file1.js"));
-        assert_eq!(&*buffer.language().unwrap().name(), "JavaScript");
+        assert_eq!(buffer.language().unwrap().name(), "JavaScript".into());
     });
 
     buffer_b.read_with(cx_b, |buffer, _| {
         assert_eq!(buffer.file().unwrap().path().to_str(), Some("file1.js"));
-        assert_eq!(&*buffer.language().unwrap().name(), "JavaScript");
+        assert_eq!(buffer.language().unwrap().name(), "JavaScript".into());
     });
 
     buffer_c.read_with(cx_c, |buffer, _| {
         assert_eq!(buffer.file().unwrap().path().to_str(), Some("file1.js"));
-        assert_eq!(&*buffer.language().unwrap().name(), "JavaScript");
+        assert_eq!(buffer.language().unwrap().name(), "JavaScript".into());
     });
 
     let new_buffer_a = project_a
diff --git a/crates/collab/src/tests/remote_editing_collaboration_tests.rs b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
index 21e7f9dd9e87f6..c4410fd776be7d 100644
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -100,7 +100,7 @@ async fn test_sharing_an_ssh_remote_project(
         let file = buffer_b.read(cx).file();
         assert_eq!(
             all_language_settings(file, cx)
-                .language(Some("Rust"))
+                .language(Some(&("Rust".into())))
                 .language_servers,
             ["override-rust-analyzer".into()]
         )
diff --git a/crates/editor/src/clangd_ext.rs b/crates/editor/src/clangd_ext.rs
index 7fbb8f5f41b11d..2f0f7aaee47e7a 100644
--- a/crates/editor/src/clangd_ext.rs
+++ b/crates/editor/src/clangd_ext.rs
@@ -12,7 +12,7 @@ use crate::{element::register_action, Editor, SwitchSourceHeader};
 static CLANGD_SERVER_NAME: &str = "clangd";
 
 fn is_c_language(language: &Language) -> bool {
-    return language.name().as_ref() == "C++" || language.name().as_ref() == "C";
+    return language.name() == "C++".into() || language.name() == "C".into();
 }
 
 pub fn switch_source_header(
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index cb4ae63afcd9a6..3466888c942de1 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -12465,7 +12465,7 @@ fn inlay_hint_settings(
     let language = snapshot.language_at(location);
     let settings = all_language_settings(file, cx);
     settings
-        .language(language.map(|l| l.name()).as_deref())
+        .language(language.map(|l| l.name()).as_ref())
         .inlay_hints
 }
 
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index c8c509fd984927..0b1e0385ded4ad 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -20,8 +20,8 @@ use language::{
     },
     BracketPairConfig,
     Capability::ReadWrite,
-    FakeLspAdapter, IndentGuide, LanguageConfig, LanguageConfigOverride, LanguageMatcher, Override,
-    ParsedMarkdown, Point,
+    FakeLspAdapter, IndentGuide, LanguageConfig, LanguageConfigOverride, LanguageMatcher,
+    LanguageName, Override, ParsedMarkdown, Point,
 };
 use language_settings::{Formatter, FormatterList, IndentGuideSettings};
 use multi_buffer::MultiBufferIndentGuide;
@@ -9587,12 +9587,12 @@ async fn test_language_server_restart_due_to_settings_change(cx: &mut gpui::Test
     let server_restarts = Arc::new(AtomicUsize::new(0));
     let closure_restarts = Arc::clone(&server_restarts);
     let language_server_name = "test language server";
-    let language_name: Arc<str> = "Rust".into();
+    let language_name: LanguageName = "Rust".into();
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(Arc::new(Language::new(
         LanguageConfig {
-            name: Arc::clone(&language_name),
+            name: language_name.clone(),
             matcher: LanguageMatcher {
                 path_suffixes: vec!["rs".to_string()],
                 ..Default::default()
@@ -9629,7 +9629,7 @@ async fn test_language_server_restart_due_to_settings_change(cx: &mut gpui::Test
     let _fake_server = fake_servers.next().await.unwrap();
     update_test_language_settings(cx, |language_settings| {
         language_settings.languages.insert(
-            Arc::clone(&language_name),
+            language_name.clone(),
             LanguageSettingsContent {
                 tab_size: NonZeroU32::new(8),
                 ..Default::default()
diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index 23293469dd4e58..1be2092d7dd79b 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -1705,8 +1705,8 @@ mod tests {
 
                 let buffer = editor.buffer().read(cx).as_singleton().unwrap().read(cx);
                 assert_eq!(
-                    buffer.language().map(|lang| lang.name()).as_deref(),
-                    Some("Rust")
+                    buffer.language().map(|lang| lang.name()),
+                    Some("Rust".into())
                 ); // Language should be set to Rust
                 assert!(buffer.file().is_none()); // The buffer should not have an associated file
             });
diff --git a/crates/editor/src/rust_analyzer_ext.rs b/crates/editor/src/rust_analyzer_ext.rs
index a152f3c453b4a6..db17eaab282fae 100644
--- a/crates/editor/src/rust_analyzer_ext.rs
+++ b/crates/editor/src/rust_analyzer_ext.rs
@@ -13,7 +13,7 @@ use crate::{
 static RUST_ANALYZER_NAME: &str = "rust-analyzer";
 
 fn is_rust_language(language: &Language) -> bool {
-    language.name().as_ref() == "Rust"
+    language.name() == "Rust".into()
 }
 
 pub fn apply_related_actions(editor: &View<Editor>, cx: &mut WindowContext) {
diff --git a/crates/editor/src/test/editor_lsp_test_context.rs b/crates/editor/src/test/editor_lsp_test_context.rs
index ec1eccb8643f93..16735760bff5bf 100644
--- a/crates/editor/src/test/editor_lsp_test_context.rs
+++ b/crates/editor/src/test/editor_lsp_test_context.rs
@@ -58,7 +58,7 @@ impl EditorLspTestContext {
 
         let language_registry = project.read_with(cx, |project, _| project.languages().clone());
         let mut fake_servers = language_registry.register_fake_lsp_adapter(
-            language.name().as_ref(),
+            language.name(),
             FakeLspAdapter {
                 capabilities,
                 ..Default::default()
diff --git a/crates/extension/src/extension_lsp_adapter.rs b/crates/extension/src/extension_lsp_adapter.rs
index 41a35cb6177f35..f82b6c9e0e9eb4 100644
--- a/crates/extension/src/extension_lsp_adapter.rs
+++ b/crates/extension/src/extension_lsp_adapter.rs
@@ -38,7 +38,6 @@ impl LspAdapter for ExtensionLspAdapter {
 
     fn get_language_server_command<'a>(
         self: Arc<Self>,
-        _: Arc<Language>,
         _: Arc<Path>,
         delegate: Arc<dyn LspAdapterDelegate>,
         _: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
diff --git a/crates/extension/src/extension_manifest.rs b/crates/extension/src/extension_manifest.rs
index 9d8a841686feb5..3dfd7e0d41f34b 100644
--- a/crates/extension/src/extension_manifest.rs
+++ b/crates/extension/src/extension_manifest.rs
@@ -1,7 +1,7 @@
 use anyhow::{anyhow, Context, Result};
 use collections::{BTreeMap, HashMap};
 use fs::Fs;
-use language::LanguageServerName;
+use language::{LanguageName, LanguageServerName};
 use semantic_version::SemanticVersion;
 use serde::{Deserialize, Serialize};
 use std::{
@@ -106,10 +106,10 @@ pub struct GrammarManifestEntry {
 pub struct LanguageServerManifestEntry {
     /// Deprecated in favor of `languages`.
     #[serde(default)]
-    language: Option<Arc<str>>,
+    language: Option<LanguageName>,
     /// The list of languages this language server should work with.
     #[serde(default)]
-    languages: Vec<Arc<str>>,
+    languages: Vec<LanguageName>,
     #[serde(default)]
     pub language_ids: HashMap<String, String>,
     #[serde(default)]
@@ -124,7 +124,7 @@ impl LanguageServerManifestEntry {
     ///
     /// We can replace this with just field access for the `languages` field once
     /// we have removed `language`.
-    pub fn languages(&self) -> impl IntoIterator<Item = Arc<str>> + '_ {
+    pub fn languages(&self) -> impl IntoIterator<Item = LanguageName> + '_ {
         let language = if self.languages.is_empty() {
             self.language.clone()
         } else {
diff --git a/crates/extension/src/extension_store.rs b/crates/extension/src/extension_store.rs
index 2558dca93ea117..3ebc4f20d36975 100644
--- a/crates/extension/src/extension_store.rs
+++ b/crates/extension/src/extension_store.rs
@@ -36,7 +36,8 @@ use gpui::{
 use http_client::{AsyncBody, HttpClient, HttpClientWithUrl};
 use indexed_docs::{IndexedDocsRegistry, ProviderId};
 use language::{
-    LanguageConfig, LanguageMatcher, LanguageQueries, LanguageRegistry, QUERY_FILENAME_PREFIXES,
+    LanguageConfig, LanguageMatcher, LanguageName, LanguageQueries, LanguageRegistry,
+    QUERY_FILENAME_PREFIXES,
 };
 use node_runtime::NodeRuntime;
 use project::ContextProviderWithTasks;
@@ -148,7 +149,7 @@ impl Global for GlobalExtensionStore {}
 pub struct ExtensionIndex {
     pub extensions: BTreeMap<Arc<str>, ExtensionIndexEntry>,
     pub themes: BTreeMap<Arc<str>, ExtensionIndexThemeEntry>,
-    pub languages: BTreeMap<Arc<str>, ExtensionIndexLanguageEntry>,
+    pub languages: BTreeMap<LanguageName, ExtensionIndexLanguageEntry>,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
diff --git a/crates/extension/src/extension_store_test.rs b/crates/extension/src/extension_store_test.rs
index 70ea7ac9093bc2..da530306d17101 100644
--- a/crates/extension/src/extension_store_test.rs
+++ b/crates/extension/src/extension_store_test.rs
@@ -609,7 +609,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
         .await
         .unwrap();
 
-    let mut fake_servers = language_registry.fake_language_servers("Gleam");
+    let mut fake_servers = language_registry.fake_language_servers("Gleam".into());
 
     let buffer = project
         .update(cx, |project, cx| {
diff --git a/crates/extension/src/wasm_host/wit/since_v0_1_0.rs b/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
index 68550a44cfdfc7..337bb8afb04a1d 100644
--- a/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
+++ b/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
@@ -9,6 +9,7 @@ use futures::{io::BufReader, FutureExt as _};
 use futures::{lock::Mutex, AsyncReadExt};
 use indexed_docs::IndexedDocsDatabase;
 use isahc::config::{Configurable, RedirectPolicy};
+use language::LanguageName;
 use language::{
     language_settings::AllLanguageSettings, LanguageServerBinaryStatus, LspAdapterDelegate,
 };
@@ -399,8 +400,9 @@ impl ExtensionImports for WasmState {
 
                 cx.update(|cx| match category.as_str() {
                     "language" => {
+                        let key = key.map(|k| LanguageName::new(&k));
                         let settings =
-                            AllLanguageSettings::get(location, cx).language(key.as_deref());
+                            AllLanguageSettings::get(location, cx).language(key.as_ref());
                         Ok(serde_json::to_string(&settings::LanguageSettings {
                             tab_size: settings.tab_size,
                         })?)
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index 564b8934897734..ac7d5eb47bb99e 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -1504,3 +1504,9 @@ pub struct KeystrokeEvent {
     /// The action that was resolved for the keystroke, if any
     pub action: Option<Box<dyn Action>>,
 }
+
+impl Drop for AppContext {
+    fn drop(&mut self) {
+        println!("Dropping the App Context");
+    }
+}
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index 8584eee4c7d493..77a1079d3ad56f 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -72,7 +72,7 @@ fn test_select_language(cx: &mut AppContext) {
     let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
     registry.add(Arc::new(Language::new(
         LanguageConfig {
-            name: "Rust".into(),
+            name: LanguageName::new("Rust"),
             matcher: LanguageMatcher {
                 path_suffixes: vec!["rs".to_string()],
                 ..Default::default()
@@ -83,7 +83,7 @@ fn test_select_language(cx: &mut AppContext) {
     )));
     registry.add(Arc::new(Language::new(
         LanguageConfig {
-            name: "Make".into(),
+            name: LanguageName::new("Make"),
             matcher: LanguageMatcher {
                 path_suffixes: vec!["Makefile".to_string(), "mk".to_string()],
                 ..Default::default()
@@ -97,15 +97,13 @@ fn test_select_language(cx: &mut AppContext) {
     assert_eq!(
         registry
             .language_for_file(&file("src/lib.rs"), None, cx)
-            .now_or_never()
-            .and_then(|l| Some(l.ok()?.name())),
+            .map(|l| l.name()),
         Some("Rust".into())
     );
     assert_eq!(
         registry
             .language_for_file(&file("src/lib.mk"), None, cx)
-            .now_or_never()
-            .and_then(|l| Some(l.ok()?.name())),
+            .map(|l| l.name()),
         Some("Make".into())
     );
 
@@ -113,8 +111,7 @@ fn test_select_language(cx: &mut AppContext) {
     assert_eq!(
         registry
             .language_for_file(&file("src/Makefile"), None, cx)
-            .now_or_never()
-            .and_then(|l| Some(l.ok()?.name())),
+            .map(|l| l.name()),
         Some("Make".into())
     );
 
@@ -122,22 +119,19 @@ fn test_select_language(cx: &mut AppContext) {
     assert_eq!(
         registry
             .language_for_file(&file("zed/cars"), None, cx)
-            .now_or_never()
-            .and_then(|l| Some(l.ok()?.name())),
+            .map(|l| l.name()),
         None
     );
     assert_eq!(
         registry
             .language_for_file(&file("zed/a.cars"), None, cx)
-            .now_or_never()
-            .and_then(|l| Some(l.ok()?.name())),
+            .map(|l| l.name()),
         None
     );
     assert_eq!(
         registry
             .language_for_file(&file("zed/sumk"), None, cx)
-            .now_or_never()
-            .and_then(|l| Some(l.ok()?.name())),
+            .map(|l| l.name()),
         None
     );
 }
@@ -158,23 +152,22 @@ async fn test_first_line_pattern(cx: &mut TestAppContext) {
         ..Default::default()
     });
 
-    cx.read(|cx| languages.language_for_file(&file("the/script"), None, cx))
-        .await
-        .unwrap_err();
-    cx.read(|cx| languages.language_for_file(&file("the/script"), Some(&"nothing".into()), cx))
-        .await
-        .unwrap_err();
+    assert!(cx
+        .read(|cx| languages.language_for_file(&file("the/script"), None, cx))
+        .is_none());
+    assert!(cx
+        .read(|cx| languages.language_for_file(&file("the/script"), Some(&"nothing".into()), cx))
+        .is_none());
+
     assert_eq!(
         cx.read(|cx| languages.language_for_file(
             &file("the/script"),
             Some(&"#!/bin/env node".into()),
             cx
         ))
-        .await
         .unwrap()
-        .name()
-        .as_ref(),
-        "JavaScript"
+        .name(),
+        "JavaScript".into()
     );
 }
 
@@ -242,19 +235,16 @@ async fn test_language_for_file_with_custom_file_types(cx: &mut TestAppContext)
 
     let language = cx
         .read(|cx| languages.language_for_file(&file("foo.js"), None, cx))
-        .await
         .unwrap();
-    assert_eq!(language.name().as_ref(), "TypeScript");
+    assert_eq!(language.name(), "TypeScript".into());
     let language = cx
         .read(|cx| languages.language_for_file(&file("foo.c"), None, cx))
-        .await
         .unwrap();
-    assert_eq!(language.name().as_ref(), "C++");
+    assert_eq!(language.name(), "C++".into());
     let language = cx
         .read(|cx| languages.language_for_file(&file("Dockerfile.dev"), None, cx))
-        .await
         .unwrap();
-    assert_eq!(language.name().as_ref(), "Dockerfile");
+    assert_eq!(language.name(), "Dockerfile".into());
 }
 
 fn file(path: &str) -> Arc<dyn File> {
@@ -2245,10 +2235,10 @@ fn test_language_at_with_hidden_languages(cx: &mut AppContext) {
 
         for point in [Point::new(0, 4), Point::new(0, 16)] {
             let config = snapshot.language_scope_at(point).unwrap();
-            assert_eq!(config.language_name().as_ref(), "Markdown");
+            assert_eq!(config.language_name(), "Markdown".into());
 
             let language = snapshot.language_at(point).unwrap();
-            assert_eq!(language.name().as_ref(), "Markdown");
+            assert_eq!(language.name().0.as_ref(), "Markdown");
         }
 
         buffer
@@ -2757,7 +2747,7 @@ fn ruby_lang() -> Language {
 fn html_lang() -> Language {
     Language::new(
         LanguageConfig {
-            name: "HTML".into(),
+            name: LanguageName::new("HTML"),
             block_comment: Some(("<!--".into(), "-->".into())),
             ..Default::default()
         },
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index 7e8fcc655dc43f..6424da8a54280e 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -28,6 +28,7 @@ use futures::Future;
 use gpui::{AppContext, AsyncAppContext, Model, SharedString, Task};
 pub use highlight_map::HighlightMap;
 use http_client::HttpClient;
+pub use language_registry::LanguageName;
 use lsp::{CodeActionKind, LanguageServerBinary};
 use parking_lot::Mutex;
 use regex::Regex;
@@ -67,8 +68,8 @@ pub use buffer::Operation;
 pub use buffer::*;
 pub use diagnostic_set::DiagnosticEntry;
 pub use language_registry::{
-    LanguageNotFound, LanguageQueries, LanguageRegistry, LanguageServerBinaryStatus,
-    PendingLanguageServer, QUERY_FILENAME_PREFIXES,
+    AvailableLanguage, LanguageNotFound, LanguageQueries, LanguageRegistry,
+    LanguageServerBinaryStatus, PendingLanguageServer, QUERY_FILENAME_PREFIXES,
 };
 pub use lsp::LanguageServerId;
 pub use outline::*;
@@ -140,6 +141,12 @@ pub trait ToLspPosition {
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize)]
 pub struct LanguageServerName(pub Arc<str>);
 
+impl LanguageServerName {
+    pub fn from_proto(s: String) -> Self {
+        Self(Arc::from(s))
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Location {
     pub buffer: Model<Buffer>,
@@ -195,9 +202,12 @@ impl CachedLspAdapter {
         })
     }
 
+    pub fn name(&self) -> Arc<str> {
+        self.adapter.name().0.clone()
+    }
+
     pub async fn get_language_server_command(
         self: Arc<Self>,
-        language: Arc<Language>,
         container_dir: Arc<Path>,
         delegate: Arc<dyn LspAdapterDelegate>,
         cx: &mut AsyncAppContext,
@@ -205,18 +215,10 @@ impl CachedLspAdapter {
         let cached_binary = self.cached_binary.lock().await;
         self.adapter
             .clone()
-            .get_language_server_command(language, container_dir, delegate, cached_binary, cx)
+            .get_language_server_command(container_dir, delegate, cached_binary, cx)
             .await
     }
 
-    pub fn will_start_server(
-        &self,
-        delegate: &Arc<dyn LspAdapterDelegate>,
-        cx: &mut AsyncAppContext,
-    ) -> Option<Task<Result<()>>> {
-        self.adapter.will_start_server(delegate, cx)
-    }
-
     pub fn can_be_reinstalled(&self) -> bool {
         self.adapter.can_be_reinstalled()
     }
@@ -262,11 +264,11 @@ impl CachedLspAdapter {
             .await
     }
 
-    pub fn language_id(&self, language: &Language) -> String {
+    pub fn language_id(&self, language_name: &LanguageName) -> String {
         self.language_ids
-            .get(language.name().as_ref())
+            .get(language_name.0.as_ref())
             .cloned()
-            .unwrap_or_else(|| language.lsp_id())
+            .unwrap_or_else(|| language_name.lsp_id())
     }
 
     #[cfg(any(test, feature = "test-support"))]
@@ -296,7 +298,6 @@ pub trait LspAdapter: 'static + Send + Sync {
 
     fn get_language_server_command<'a>(
         self: Arc<Self>,
-        language: Arc<Language>,
         container_dir: Arc<Path>,
         delegate: Arc<dyn LspAdapterDelegate>,
         mut cached_binary: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
@@ -317,7 +318,7 @@ pub trait LspAdapter: 'static + Send + Sync {
             if let Some(binary) = self.check_if_user_installed(delegate.as_ref(), cx).await {
                 log::info!(
                     "found user-installed language server for {}. path: {:?}, arguments: {:?}",
-                    language.name(),
+                    self.name().0,
                     binary.path,
                     binary.arguments
                 );
@@ -387,14 +388,6 @@ pub trait LspAdapter: 'static + Send + Sync {
         None
     }
 
-    fn will_start_server(
-        &self,
-        _: &Arc<dyn LspAdapterDelegate>,
-        _: &mut AsyncAppContext,
-    ) -> Option<Task<Result<()>>> {
-        None
-    }
-
     async fn fetch_server_binary(
         &self,
         latest_version: Box<dyn 'static + Send + Any>,
@@ -562,7 +555,7 @@ pub struct CodeLabel {
 #[derive(Clone, Deserialize, JsonSchema)]
 pub struct LanguageConfig {
     /// Human-readable name of the language.
-    pub name: Arc<str>,
+    pub name: LanguageName,
     /// The name of this language for a Markdown code fence block
     pub code_fence_block_name: Option<Arc<str>>,
     // The name of the grammar in a WASM bundle (experimental).
@@ -699,7 +692,7 @@ impl<T> Override<T> {
 impl Default for LanguageConfig {
     fn default() -> Self {
         Self {
-            name: Arc::default(),
+            name: LanguageName::new(""),
             code_fence_block_name: None,
             grammar: None,
             matcher: LanguageMatcher::default(),
@@ -1335,7 +1328,7 @@ impl Language {
         Arc::get_mut(self.grammar.as_mut()?)
     }
 
-    pub fn name(&self) -> Arc<str> {
+    pub fn name(&self) -> LanguageName {
         self.config.name.clone()
     }
 
@@ -1343,7 +1336,7 @@ impl Language {
         self.config
             .code_fence_block_name
             .clone()
-            .unwrap_or_else(|| self.config.name.to_lowercase().into())
+            .unwrap_or_else(|| self.config.name.0.to_lowercase().into())
     }
 
     pub fn context_provider(&self) -> Option<Arc<dyn ContextProvider>> {
@@ -1408,10 +1401,7 @@ impl Language {
     }
 
     pub fn lsp_id(&self) -> String {
-        match self.config.name.as_ref() {
-            "Plain Text" => "plaintext".to_string(),
-            language_name => language_name.to_lowercase(),
-        }
+        self.config.name.lsp_id()
     }
 
     pub fn prettier_parser_name(&self) -> Option<&str> {
@@ -1420,7 +1410,7 @@ impl Language {
 }
 
 impl LanguageScope {
-    pub fn language_name(&self) -> Arc<str> {
+    pub fn language_name(&self) -> LanguageName {
         self.language.config.name.clone()
     }
 
@@ -1663,7 +1653,6 @@ impl LspAdapter for FakeLspAdapter {
 
     fn get_language_server_command<'a>(
         self: Arc<Self>,
-        _: Arc<Language>,
         _: Arc<Path>,
         _: Arc<dyn LspAdapterDelegate>,
         _: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index a558b942d69390..a65d20019f3da0 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -6,9 +6,9 @@ use crate::{
     with_parser, CachedLspAdapter, File, Language, LanguageConfig, LanguageId, LanguageMatcher,
     LanguageServerName, LspAdapter, LspAdapterDelegate, PLAIN_TEXT,
 };
-use anyhow::{anyhow, Context as _, Result};
+use anyhow::{anyhow, Context, Result};
 use collections::{hash_map, HashMap, HashSet};
-use futures::TryFutureExt;
+
 use futures::{
     channel::{mpsc, oneshot},
     future::Shared,
@@ -19,8 +19,10 @@ use gpui::{AppContext, BackgroundExecutor, Task};
 use lsp::LanguageServerId;
 use parking_lot::{Mutex, RwLock};
 use postage::watch;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
 use std::{
-    borrow::Cow,
+    borrow::{Borrow, Cow},
     ffi::OsStr,
     ops::Not,
     path::{Path, PathBuf},
@@ -32,6 +34,48 @@ use theme::Theme;
 use unicase::UniCase;
 use util::{maybe, paths::PathExt, post_inc, ResultExt};
 
+#[derive(
+    Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, JsonSchema,
+)]
+pub struct LanguageName(pub Arc<str>);
+
+impl LanguageName {
+    pub fn new(s: &str) -> Self {
+        Self(Arc::from(s))
+    }
+
+    pub fn from_proto(s: String) -> Self {
+        Self(Arc::from(s))
+    }
+    pub fn to_proto(self) -> String {
+        self.0.to_string()
+    }
+    pub fn lsp_id(&self) -> String {
+        match self.0.as_ref() {
+            "Plain Text" => "plaintext".to_string(),
+            language_name => language_name.to_lowercase(),
+        }
+    }
+}
+
+impl Borrow<str> for LanguageName {
+    fn borrow(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+
+impl std::fmt::Display for LanguageName {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl<'a> From<&'a str> for LanguageName {
+    fn from(str: &'a str) -> LanguageName {
+        LanguageName(str.into())
+    }
+}
+
 pub struct LanguageRegistry {
     state: RwLock<LanguageRegistryState>,
     language_server_download_dir: Option<Arc<Path>>,
@@ -46,7 +90,7 @@ struct LanguageRegistryState {
     language_settings: AllLanguageSettingsContent,
     available_languages: Vec<AvailableLanguage>,
     grammars: HashMap<Arc<str>, AvailableGrammar>,
-    lsp_adapters: HashMap<Arc<str>, Vec<Arc<CachedLspAdapter>>>,
+    lsp_adapters: HashMap<LanguageName, Vec<Arc<CachedLspAdapter>>>,
     available_lsp_adapters:
         HashMap<LanguageServerName, Arc<dyn Fn() -> Arc<CachedLspAdapter> + 'static + Send + Sync>>,
     loading_languages: HashMap<LanguageId, Vec<oneshot::Sender<Result<Arc<Language>>>>>,
@@ -56,8 +100,10 @@ struct LanguageRegistryState {
     reload_count: usize,
 
     #[cfg(any(test, feature = "test-support"))]
-    fake_server_txs:
-        HashMap<Arc<str>, Vec<futures::channel::mpsc::UnboundedSender<lsp::FakeLanguageServer>>>,
+    fake_server_txs: HashMap<
+        LanguageName,
+        Vec<futures::channel::mpsc::UnboundedSender<lsp::FakeLanguageServer>>,
+    >,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -75,9 +121,9 @@ pub struct PendingLanguageServer {
 }
 
 #[derive(Clone)]
-struct AvailableLanguage {
+pub struct AvailableLanguage {
     id: LanguageId,
-    name: Arc<str>,
+    name: LanguageName,
     grammar: Option<Arc<str>>,
     matcher: LanguageMatcher,
     load: Arc<
@@ -93,6 +139,16 @@ struct AvailableLanguage {
     loaded: bool,
 }
 
+impl AvailableLanguage {
+    pub fn name(&self) -> LanguageName {
+        self.name.clone()
+    }
+
+    pub fn matcher(&self) -> &LanguageMatcher {
+        &self.matcher
+    }
+}
+
 enum AvailableGrammar {
     Native(tree_sitter::Language),
     Loaded(#[allow(unused)] PathBuf, tree_sitter::Language),
@@ -196,7 +252,7 @@ impl LanguageRegistry {
     /// appended to the end.
     pub fn reorder_language_servers(
         &self,
-        language: &Arc<Language>,
+        language: &LanguageName,
         ordered_lsp_adapters: Vec<Arc<CachedLspAdapter>>,
     ) {
         self.state
@@ -207,7 +263,7 @@ impl LanguageRegistry {
     /// Removes the specified languages and grammars from the registry.
     pub fn remove_languages(
         &self,
-        languages_to_remove: &[Arc<str>],
+        languages_to_remove: &[LanguageName],
         grammars_to_remove: &[Arc<str>],
     ) {
         self.state
@@ -215,7 +271,7 @@ impl LanguageRegistry {
             .remove_languages(languages_to_remove, grammars_to_remove)
     }
 
-    pub fn remove_lsp_adapter(&self, language_name: &str, name: &LanguageServerName) {
+    pub fn remove_lsp_adapter(&self, language_name: &LanguageName, name: &LanguageServerName) {
         let mut state = self.state.write();
         if let Some(adapters) = state.lsp_adapters.get_mut(language_name) {
             adapters.retain(|adapter| &adapter.name != name)
@@ -267,7 +323,7 @@ impl LanguageRegistry {
         Some(load_lsp_adapter())
     }
 
-    pub fn register_lsp_adapter(&self, language_name: Arc<str>, adapter: Arc<dyn LspAdapter>) {
+    pub fn register_lsp_adapter(&self, language_name: LanguageName, adapter: Arc<dyn LspAdapter>) {
         self.state
             .write()
             .lsp_adapters
@@ -279,13 +335,14 @@ impl LanguageRegistry {
     #[cfg(any(feature = "test-support", test))]
     pub fn register_fake_lsp_adapter(
         &self,
-        language_name: &str,
+        language_name: impl Into<LanguageName>,
         adapter: crate::FakeLspAdapter,
     ) -> futures::channel::mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
+        let language_name = language_name.into();
         self.state
             .write()
             .lsp_adapters
-            .entry(language_name.into())
+            .entry(language_name.clone())
             .or_default()
             .push(CachedLspAdapter::new(Arc::new(adapter)));
         self.fake_language_servers(language_name)
@@ -294,13 +351,13 @@ impl LanguageRegistry {
     #[cfg(any(feature = "test-support", test))]
     pub fn fake_language_servers(
         &self,
-        language_name: &str,
+        language_name: LanguageName,
     ) -> futures::channel::mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
         let (servers_tx, servers_rx) = futures::channel::mpsc::unbounded();
         self.state
             .write()
             .fake_server_txs
-            .entry(language_name.into())
+            .entry(language_name)
             .or_default()
             .push(servers_tx);
         servers_rx
@@ -309,7 +366,7 @@ impl LanguageRegistry {
     /// Adds a language to the registry, which can be loaded if needed.
     pub fn register_language(
         &self,
-        name: Arc<str>,
+        name: LanguageName,
         grammar_name: Option<Arc<str>>,
         matcher: LanguageMatcher,
         load: impl Fn() -> Result<(
@@ -445,7 +502,7 @@ impl LanguageRegistry {
     ) -> impl Future<Output = Result<Arc<Language>>> {
         let name = UniCase::new(name);
         let rx = self.get_or_load_language(|language_name, _| {
-            if UniCase::new(language_name) == name {
+            if UniCase::new(&language_name.0) == name {
                 1
             } else {
                 0
@@ -460,7 +517,7 @@ impl LanguageRegistry {
     ) -> impl Future<Output = Result<Arc<Language>>> {
         let string = UniCase::new(string);
         let rx = self.get_or_load_language(|name, config| {
-            if UniCase::new(name) == string
+            if UniCase::new(&name.0) == string
                 || config
                     .path_suffixes
                     .iter()
@@ -474,13 +531,26 @@ impl LanguageRegistry {
         async move { rx.await? }
     }
 
+    pub fn available_language_for_name(
+        self: &Arc<Self>,
+        name: &LanguageName,
+    ) -> Option<AvailableLanguage> {
+        let state = self.state.read();
+        state
+            .available_languages
+            .iter()
+            .find(|l| &l.name == name)
+            .cloned()
+    }
+
     pub fn language_for_file(
         self: &Arc<Self>,
         file: &Arc<dyn File>,
         content: Option<&Rope>,
         cx: &AppContext,
-    ) -> impl Future<Output = Result<Arc<Language>>> {
+    ) -> Option<AvailableLanguage> {
         let user_file_types = all_language_settings(Some(file), cx);
+
         self.language_for_file_internal(
             &file.full_path(cx),
             content,
@@ -492,8 +562,16 @@ impl LanguageRegistry {
         self: &Arc<Self>,
         path: &'a Path,
     ) -> impl Future<Output = Result<Arc<Language>>> + 'a {
-        self.language_for_file_internal(path, None, None)
-            .map_err(|error| error.context(format!("language for file path {}", path.display())))
+        let available_language = self.language_for_file_internal(path, None, None);
+
+        let this = self.clone();
+        async move {
+            if let Some(language) = available_language {
+                this.load_language(&language).await?
+            } else {
+                Err(anyhow!(LanguageNotFound))
+            }
+        }
     }
 
     fn language_for_file_internal(
@@ -501,19 +579,19 @@ impl LanguageRegistry {
         path: &Path,
         content: Option<&Rope>,
         user_file_types: Option<&HashMap<Arc<str>, GlobSet>>,
-    ) -> impl Future<Output = Result<Arc<Language>>> {
+    ) -> Option<AvailableLanguage> {
         let filename = path.file_name().and_then(|name| name.to_str());
         let extension = path.extension_or_hidden_file_name();
         let path_suffixes = [extension, filename, path.to_str()];
         let empty = GlobSet::empty();
 
-        let rx = self.get_or_load_language(move |language_name, config| {
+        self.find_matching_language(move |language_name, config| {
             let path_matches_default_suffix = config
                 .path_suffixes
                 .iter()
                 .any(|suffix| path_suffixes.contains(&Some(suffix.as_str())));
             let custom_suffixes = user_file_types
-                .and_then(|types| types.get(language_name))
+                .and_then(|types| types.get(&language_name.0))
                 .unwrap_or(&empty);
             let path_matches_custom_suffix = path_suffixes
                 .iter()
@@ -535,18 +613,15 @@ impl LanguageRegistry {
             } else {
                 0
             }
-        });
-        async move { rx.await? }
+        })
     }
 
-    fn get_or_load_language(
+    fn find_matching_language(
         self: &Arc<Self>,
-        callback: impl Fn(&str, &LanguageMatcher) -> usize,
-    ) -> oneshot::Receiver<Result<Arc<Language>>> {
-        let (tx, rx) = oneshot::channel();
-
-        let mut state = self.state.write();
-        let Some((language, _)) = state
+        callback: impl Fn(&LanguageName, &LanguageMatcher) -> usize,
+    ) -> Option<AvailableLanguage> {
+        let state = self.state.read();
+        let available_language = state
             .available_languages
             .iter()
             .filter_map(|language| {
@@ -559,15 +634,23 @@ impl LanguageRegistry {
             })
             .max_by_key(|e| e.1)
             .clone()
-        else {
-            let _ = tx.send(Err(anyhow!(LanguageNotFound)));
-            return rx;
-        };
+            .map(|(available_language, _)| available_language);
+        drop(state);
+        available_language
+    }
+
+    pub fn load_language(
+        self: &Arc<Self>,
+        language: &AvailableLanguage,
+    ) -> oneshot::Receiver<Result<Arc<Language>>> {
+        let (tx, rx) = oneshot::channel();
+
+        let mut state = self.state.write();
 
         // If the language is already loaded, resolve with it immediately.
         for loaded_language in state.languages.iter() {
             if loaded_language.id == language.id {
-                let _ = tx.send(Ok(loaded_language.clone()));
+                tx.send(Ok(loaded_language.clone())).unwrap();
                 return rx;
             }
         }
@@ -580,12 +663,15 @@ impl LanguageRegistry {
             // Otherwise, start loading the language.
             hash_map::Entry::Vacant(entry) => {
                 let this = self.clone();
+
+                let id = language.id;
+                let name = language.name.clone();
+                let language_load = language.load.clone();
+
                 self.executor
                     .spawn(async move {
-                        let id = language.id;
-                        let name = language.name.clone();
                         let language = async {
-                            let (config, queries, provider) = (language.load)()?;
+                            let (config, queries, provider) = (language_load)()?;
 
                             if let Some(grammar) = config.grammar.clone() {
                                 let grammar = Some(this.get_or_load_grammar(grammar).await?);
@@ -629,13 +715,28 @@ impl LanguageRegistry {
                         };
                     })
                     .detach();
+
                 entry.insert(vec![tx]);
             }
         }
 
+        drop(state);
         rx
     }
 
+    fn get_or_load_language(
+        self: &Arc<Self>,
+        callback: impl Fn(&LanguageName, &LanguageMatcher) -> usize,
+    ) -> oneshot::Receiver<Result<Arc<Language>>> {
+        let Some(language) = self.find_matching_language(callback) else {
+            let (tx, rx) = oneshot::channel();
+            let _ = tx.send(Err(anyhow!(LanguageNotFound)));
+            return rx;
+        };
+
+        self.load_language(&language)
+    }
+
     fn get_or_load_grammar(
         self: &Arc<Self>,
         name: Arc<str>,
@@ -702,11 +803,11 @@ impl LanguageRegistry {
         self.state.read().languages.to_vec()
     }
 
-    pub fn lsp_adapters(&self, language: &Arc<Language>) -> Vec<Arc<CachedLspAdapter>> {
+    pub fn lsp_adapters(&self, language_name: &LanguageName) -> Vec<Arc<CachedLspAdapter>> {
         self.state
             .read()
             .lsp_adapters
-            .get(&language.config.name)
+            .get(language_name)
             .cloned()
             .unwrap_or_default()
     }
@@ -723,7 +824,7 @@ impl LanguageRegistry {
     pub fn create_pending_language_server(
         self: &Arc<Self>,
         stderr_capture: Arc<Mutex<Option<String>>>,
-        language: Arc<Language>,
+        _language_name_for_tests: LanguageName,
         adapter: Arc<CachedLspAdapter>,
         root_path: Arc<Path>,
         delegate: Arc<dyn LspAdapterDelegate>,
@@ -741,7 +842,6 @@ impl LanguageRegistry {
             .clone()
             .ok_or_else(|| anyhow!("language server download directory has not been assigned before starting server"))
             .log_err()?;
-        let language = language.clone();
         let container_dir: Arc<Path> = Arc::from(download_dir.join(adapter.name.0.as_ref()));
         let root_path = root_path.clone();
         let login_shell_env_loaded = self.login_shell_env_loaded.clone();
@@ -756,12 +856,7 @@ impl LanguageRegistry {
 
                 let binary_result = adapter
                     .clone()
-                    .get_language_server_command(
-                        language.clone(),
-                        container_dir,
-                        delegate.clone(),
-                        &mut cx,
-                    )
+                    .get_language_server_command(container_dir, delegate.clone(), &mut cx)
                     .await;
 
                 delegate.update_status(adapter.name.clone(), LanguageServerBinaryStatus::None);
@@ -785,10 +880,6 @@ impl LanguageRegistry {
                     .initialization_options(&delegate)
                     .await?;
 
-                if let Some(task) = adapter.will_start_server(&delegate, &mut cx) {
-                    task.await?;
-                }
-
                 #[cfg(any(test, feature = "test-support"))]
                 if true {
                     let capabilities = adapter
@@ -825,7 +916,7 @@ impl LanguageRegistry {
                                         .state
                                         .write()
                                         .fake_server_txs
-                                        .get_mut(language.name().as_ref())
+                                        .get_mut(&_language_name_for_tests)
                                     {
                                         for tx in txs {
                                             tx.unbounded_send(fake_server.clone()).ok();
@@ -935,10 +1026,10 @@ impl LanguageRegistryState {
     /// appended to the end.
     fn reorder_language_servers(
         &mut self,
-        language: &Arc<Language>,
+        language_name: &LanguageName,
         ordered_lsp_adapters: Vec<Arc<CachedLspAdapter>>,
     ) {
-        let Some(lsp_adapters) = self.lsp_adapters.get_mut(&language.config.name) else {
+        let Some(lsp_adapters) = self.lsp_adapters.get_mut(language_name) else {
             return;
         };
 
@@ -959,7 +1050,7 @@ impl LanguageRegistryState {
 
     fn remove_languages(
         &mut self,
-        languages_to_remove: &[Arc<str>],
+        languages_to_remove: &[LanguageName],
         grammars_to_remove: &[Arc<str>],
     ) {
         if languages_to_remove.is_empty() && grammars_to_remove.is_empty() {
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index ac3c9eb6ca4e08..e1fcaaba28b4f1 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -1,6 +1,6 @@
 //! Provides `language`-related settings.
 
-use crate::{File, Language, LanguageServerName};
+use crate::{File, Language, LanguageName, LanguageServerName};
 use anyhow::Result;
 use collections::{HashMap, HashSet};
 use core::slice;
@@ -32,7 +32,7 @@ pub fn language_settings<'a>(
     cx: &'a AppContext,
 ) -> &'a LanguageSettings {
     let language_name = language.map(|l| l.name());
-    all_language_settings(file, cx).language(language_name.as_deref())
+    all_language_settings(file, cx).language(language_name.as_ref())
 }
 
 /// Returns the settings for all languages from the provided file.
@@ -53,7 +53,7 @@ pub struct AllLanguageSettings {
     /// The inline completion settings.
     pub inline_completions: InlineCompletionSettings,
     defaults: LanguageSettings,
-    languages: HashMap<Arc<str>, LanguageSettings>,
+    languages: HashMap<LanguageName, LanguageSettings>,
     pub(crate) file_types: HashMap<Arc<str>, GlobSet>,
 }
 
@@ -204,7 +204,7 @@ pub struct AllLanguageSettingsContent {
     pub defaults: LanguageSettingsContent,
     /// The settings for individual languages.
     #[serde(default)]
-    pub languages: HashMap<Arc<str>, LanguageSettingsContent>,
+    pub languages: HashMap<LanguageName, LanguageSettingsContent>,
     /// Settings for associating file extensions and filenames
     /// with languages.
     #[serde(default)]
@@ -791,7 +791,7 @@ impl InlayHintSettings {
 
 impl AllLanguageSettings {
     /// Returns the [`LanguageSettings`] for the language with the specified name.
-    pub fn language<'a>(&'a self, language_name: Option<&str>) -> &'a LanguageSettings {
+    pub fn language<'a>(&'a self, language_name: Option<&LanguageName>) -> &'a LanguageSettings {
         if let Some(name) = language_name {
             if let Some(overrides) = self.languages.get(name) {
                 return overrides;
@@ -821,7 +821,7 @@ impl AllLanguageSettings {
             }
         }
 
-        self.language(language.map(|l| l.name()).as_deref())
+        self.language(language.map(|l| l.name()).as_ref())
             .show_inline_completions
     }
 }
diff --git a/crates/language_selector/src/active_buffer_language.rs b/crates/language_selector/src/active_buffer_language.rs
index 647ff93b818f37..6aa31d7ff81ae8 100644
--- a/crates/language_selector/src/active_buffer_language.rs
+++ b/crates/language_selector/src/active_buffer_language.rs
@@ -1,13 +1,13 @@
 use editor::Editor;
 use gpui::{div, IntoElement, ParentElement, Render, Subscription, View, ViewContext, WeakView};
-use std::sync::Arc;
+use language::LanguageName;
 use ui::{Button, ButtonCommon, Clickable, FluentBuilder, LabelSize, Tooltip};
 use workspace::{item::ItemHandle, StatusItemView, Workspace};
 
 use crate::LanguageSelector;
 
 pub struct ActiveBufferLanguage {
-    active_language: Option<Option<Arc<str>>>,
+    active_language: Option<Option<LanguageName>>,
     workspace: WeakView<Workspace>,
     _observe_active_editor: Option<Subscription>,
 }
diff --git a/crates/language_selector/src/language_selector.rs b/crates/language_selector/src/language_selector.rs
index 6bdf5a67d00a28..489f6fd141b927 100644
--- a/crates/language_selector/src/language_selector.rs
+++ b/crates/language_selector/src/language_selector.rs
@@ -217,7 +217,7 @@ impl PickerDelegate for LanguageSelectorDelegate {
         let mat = &self.matches[ix];
         let buffer_language_name = self.buffer.read(cx).language().map(|l| l.name());
         let mut label = mat.string.clone();
-        if buffer_language_name.as_deref() == Some(mat.string.as_str()) {
+        if buffer_language_name.map(|n| n.0).as_deref() == Some(mat.string.as_str()) {
             label.push_str(" (current)");
         }
 
diff --git a/crates/language_tools/src/lsp_log.rs b/crates/language_tools/src/lsp_log.rs
index 5cf800d306e8e8..53def5eb2a1195 100644
--- a/crates/language_tools/src/lsp_log.rs
+++ b/crates/language_tools/src/lsp_log.rs
@@ -683,7 +683,7 @@ impl LspLogView {
                 self.project
                     .read(cx)
                     .supplementary_language_servers(cx)
-                    .filter_map(|(&server_id, name)| {
+                    .filter_map(|(server_id, name)| {
                         let state = log_store.language_servers.get(&server_id)?;
                         Some(LogMenuItem {
                             server_id,
diff --git a/crates/language_tools/src/syntax_tree_view.rs b/crates/language_tools/src/syntax_tree_view.rs
index 1d98c3d0b0b82f..e2c4903e191cef 100644
--- a/crates/language_tools/src/syntax_tree_view.rs
+++ b/crates/language_tools/src/syntax_tree_view.rs
@@ -471,7 +471,7 @@ impl SyntaxTreeToolbarItemView {
 
     fn render_header(active_layer: &OwnedSyntaxLayer) -> ButtonLike {
         ButtonLike::new("syntax tree header")
-            .child(Label::new(active_layer.language.name()))
+            .child(Label::new(active_layer.language.name().0))
             .child(Label::new(format_node_range(active_layer.node())))
     }
 }
diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs
index 6ed20abe17b038..46b6ce475d5283 100644
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -451,7 +451,7 @@ impl ContextProvider for RustContextProvider {
     ) -> Option<TaskTemplates> {
         const DEFAULT_RUN_NAME_STR: &str = "RUST_DEFAULT_PACKAGE_RUN";
         let package_to_run = all_language_settings(file.as_ref(), cx)
-            .language(Some("Rust"))
+            .language(Some(&"Rust".into()))
             .tasks
             .variables
             .get(DEFAULT_RUN_NAME_STR);
diff --git a/crates/languages/src/yaml.rs b/crates/languages/src/yaml.rs
index 4f0270fb266cb5..51a9913b249e9f 100644
--- a/crates/languages/src/yaml.rs
+++ b/crates/languages/src/yaml.rs
@@ -141,7 +141,7 @@ impl LspAdapter for YamlLspAdapter {
 
         let tab_size = cx.update(|cx| {
             AllLanguageSettings::get(Some(location), cx)
-                .language(Some("YAML"))
+                .language(Some(&"YAML".into()))
                 .tab_size
         })?;
         let mut options = serde_json::json!({"[yaml]": {"editor.tabSize": tab_size}});
diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs
index 30feffad971b7c..061291757512bf 100644
--- a/crates/lsp/src/lsp.rs
+++ b/crates/lsp/src/lsp.rs
@@ -89,6 +89,16 @@ pub struct LanguageServer {
 #[repr(transparent)]
 pub struct LanguageServerId(pub usize);
 
+impl LanguageServerId {
+    pub fn from_proto(id: u64) -> Self {
+        Self(id as usize)
+    }
+
+    pub fn to_proto(self) -> u64 {
+        self.0 as u64
+    }
+}
+
 /// Handle to a language server RPC activity subscription.
 pub enum Subscription {
     Notification {
diff --git a/crates/markdown_preview/src/markdown_preview_view.rs b/crates/markdown_preview/src/markdown_preview_view.rs
index d73e2054837b49..1aa60e2a3b71b9 100644
--- a/crates/markdown_preview/src/markdown_preview_view.rs
+++ b/crates/markdown_preview/src/markdown_preview_view.rs
@@ -282,7 +282,7 @@ impl MarkdownPreviewView {
         let buffer = editor.read(cx).buffer().read(cx);
         if let Some(buffer) = buffer.as_singleton() {
             if let Some(language) = buffer.read(cx).language() {
-                return language.name().as_ref() == "Markdown";
+                return language.name() == "Markdown".into();
             }
         }
         false
diff --git a/crates/project/src/lsp_command/signature_help.rs b/crates/project/src/lsp_command/signature_help.rs
index 163c6ae1346a9a..bf197a11ba1ee8 100644
--- a/crates/project/src/lsp_command/signature_help.rs
+++ b/crates/project/src/lsp_command/signature_help.rs
@@ -86,7 +86,7 @@ impl SignatureHelp {
         } else {
             let markdown = markdown.join(str_for_join);
             let language_name = language
-                .map(|n| n.name().to_lowercase())
+                .map(|n| n.name().0.to_lowercase())
                 .unwrap_or_default();
 
             let markdown = if function_options_count >= 2 {
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 1d9ca98c064720..b218ac58042f11 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -15,7 +15,7 @@ use async_trait::async_trait;
 use client::{proto, TypedEnvelope};
 use collections::{btree_map, BTreeMap, HashMap, HashSet};
 use futures::{
-    future::{join_all, Shared},
+    future::{join_all, BoxFuture, Shared},
     select,
     stream::FuturesUnordered,
     Future, FutureExt, StreamExt,
@@ -25,22 +25,26 @@ use gpui::{
     AppContext, AsyncAppContext, Context, Entity, EventEmitter, Model, ModelContext, PromptLevel,
     Task, WeakModel,
 };
-use http_client::HttpClient;
+use http_client::{AsyncBody, Error, HttpClient, Request, Response, Uri};
 use itertools::Itertools;
 use language::{
-    language_settings::{language_settings, AllLanguageSettings, LanguageSettings},
+    language_settings::{
+        all_language_settings, language_settings, AllLanguageSettings, LanguageSettings,
+    },
     markdown, point_to_lsp, prepare_completion_documentation,
     proto::{deserialize_anchor, deserialize_version, serialize_anchor, serialize_version},
     range_from_lsp, Bias, Buffer, BufferSnapshot, CachedLspAdapter, CodeLabel, Diagnostic,
-    DiagnosticEntry, DiagnosticSet, Documentation, File as _, Language, LanguageRegistry,
-    LanguageServerName, LocalFile, LspAdapterDelegate, Patch, PendingLanguageServer, PointUtf16,
-    TextBufferSnapshot, ToOffset, ToPointUtf16, Transaction, Unclipped,
+    DiagnosticEntry, DiagnosticSet, Documentation, File as _, Language, LanguageConfig,
+    LanguageMatcher, LanguageName, LanguageRegistry, LanguageServerName, LocalFile, LspAdapter,
+    LspAdapterDelegate, Patch, PendingLanguageServer, PointUtf16, TextBufferSnapshot, ToOffset,
+    ToPointUtf16, Transaction, Unclipped,
 };
 use lsp::{
-    CompletionContext, DiagnosticSeverity, DiagnosticTag, DidChangeWatchedFilesRegistrationOptions,
-    Edit, FileSystemWatcher, InsertTextFormat, LanguageServer, LanguageServerBinary,
-    LanguageServerId, LspRequestFuture, MessageActionItem, MessageType, OneOf, ServerHealthStatus,
-    ServerStatus, SymbolKind, TextEdit, Url, WorkDoneProgressCancelParams, WorkspaceFolder,
+    CodeActionKind, CompletionContext, DiagnosticSeverity, DiagnosticTag,
+    DidChangeWatchedFilesRegistrationOptions, Edit, FileSystemWatcher, InsertTextFormat,
+    LanguageServer, LanguageServerBinary, LanguageServerId, LspRequestFuture, MessageActionItem,
+    MessageType, OneOf, ServerHealthStatus, ServerStatus, SymbolKind, TextEdit, Url,
+    WorkDoneProgressCancelParams, WorkspaceFolder,
 };
 use parking_lot::{Mutex, RwLock};
 use postage::watch;
@@ -54,6 +58,7 @@ use similar::{ChangeTag, TextDiff};
 use smol::channel::Sender;
 use snippet::Snippet;
 use std::{
+    any::Any,
     cmp::Ordering,
     convert::TryInto,
     ffi::OsStr,
@@ -85,27 +90,86 @@ const SERVER_REINSTALL_DEBOUNCE_TIMEOUT: Duration = Duration::from_secs(1);
 const SERVER_LAUNCHING_BEFORE_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(5);
 pub const SERVER_PROGRESS_THROTTLE_TIMEOUT: Duration = Duration::from_millis(100);
 
+pub struct LocalLspStore {
+    http_client: Option<Arc<dyn HttpClient>>,
+    environment: Model<ProjectEnvironment>,
+    fs: Arc<dyn Fs>,
+    yarn: Model<YarnPathStore>,
+    pub language_servers: HashMap<LanguageServerId, LanguageServerState>,
+    last_workspace_edits_by_language_server: HashMap<LanguageServerId, ProjectTransaction>,
+    language_server_watched_paths: HashMap<LanguageServerId, Model<LanguageServerWatchedPaths>>,
+    language_server_watcher_registrations:
+        HashMap<LanguageServerId, HashMap<String, Vec<FileSystemWatcher>>>,
+    supplementary_language_servers:
+        HashMap<LanguageServerId, (LanguageServerName, Arc<LanguageServer>)>,
+    _subscription: gpui::Subscription,
+}
+
+impl LocalLspStore {
+    fn shutdown_language_servers(
+        &mut self,
+        _cx: &mut ModelContext<LspStore>,
+    ) -> impl Future<Output = ()> {
+        let shutdown_futures = self
+            .language_servers
+            .drain()
+            .map(|(_, server_state)| async {
+                use LanguageServerState::*;
+                match server_state {
+                    Running { server, .. } => server.shutdown()?.await,
+                    Starting(task) => task.await?.shutdown()?.await,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        async move {
+            futures::future::join_all(shutdown_futures).await;
+        }
+    }
+}
+
+pub struct RemoteLspStore {
+    upstream_client: AnyProtoClient,
+}
+
+impl RemoteLspStore {}
+
+pub struct SshLspStore {
+    upstream_client: AnyProtoClient,
+}
+
+#[allow(clippy::large_enum_variant)]
+pub enum LspStoreMode {
+    Local(LocalLspStore),   // ssh host and collab host
+    Remote(RemoteLspStore), // collab guest
+    Ssh(SshLspStore),       // ssh client
+}
+
+impl LspStoreMode {
+    fn is_local(&self) -> bool {
+        matches!(self, LspStoreMode::Local(_))
+    }
+
+    fn is_ssh(&self) -> bool {
+        matches!(self, LspStoreMode::Ssh(_))
+    }
+
+    fn is_remote(&self) -> bool {
+        matches!(self, LspStoreMode::Remote(_))
+    }
+}
+
 pub struct LspStore {
+    mode: LspStoreMode,
     downstream_client: Option<AnyProtoClient>,
-    upstream_client: Option<AnyProtoClient>,
     project_id: u64,
-    http_client: Option<Arc<dyn HttpClient>>,
-    fs: Arc<dyn Fs>,
     nonce: u128,
     buffer_store: Model<BufferStore>,
     worktree_store: Model<WorktreeStore>,
     buffer_snapshots: HashMap<BufferId, HashMap<LanguageServerId, Vec<LspBufferSnapshot>>>, // buffer_id -> server_id -> vec of snapshots
-    environment: Option<Model<ProjectEnvironment>>,
-    supplementary_language_servers:
-        HashMap<LanguageServerId, (LanguageServerName, Arc<LanguageServer>)>,
-    languages: Arc<LanguageRegistry>,
-    language_servers: HashMap<LanguageServerId, LanguageServerState>,
+    pub languages: Arc<LanguageRegistry>,
     language_server_ids: HashMap<(WorktreeId, LanguageServerName), LanguageServerId>,
-    language_server_statuses: BTreeMap<LanguageServerId, LanguageServerStatus>,
-    last_workspace_edits_by_language_server: HashMap<LanguageServerId, ProjectTransaction>,
-    language_server_watched_paths: HashMap<LanguageServerId, Model<LanguageServerWatchedPaths>>,
-    language_server_watcher_registrations:
-        HashMap<LanguageServerId, HashMap<String, Vec<FileSystemWatcher>>>,
+    pub language_server_statuses: BTreeMap<LanguageServerId, LanguageServerStatus>,
     active_entry: Option<ProjectEntryId>,
     _maintain_workspace_config: Task<Result<()>>,
     _maintain_buffer_languages: Task<()>,
@@ -122,8 +186,6 @@ pub struct LspStore {
             )>,
         >,
     >,
-    yarn: Model<YarnPathStore>,
-    _subscription: gpui::Subscription,
 }
 
 pub enum LspStoreEvent {
@@ -209,17 +271,53 @@ impl LspStore {
         client.add_model_request_handler(Self::handle_lsp_command::<LinkedEditingRange>);
     }
 
-    #[allow(clippy::too_many_arguments)]
-    pub fn new(
+    pub fn as_remote(&self) -> Option<&RemoteLspStore> {
+        match &self.mode {
+            LspStoreMode::Remote(remote_lsp_store) => Some(remote_lsp_store),
+            _ => None,
+        }
+    }
+
+    pub fn as_ssh(&self) -> Option<&SshLspStore> {
+        match &self.mode {
+            LspStoreMode::Ssh(ssh_lsp_store) => Some(ssh_lsp_store),
+            _ => None,
+        }
+    }
+
+    pub fn as_local(&self) -> Option<&LocalLspStore> {
+        match &self.mode {
+            LspStoreMode::Local(local_lsp_store) => Some(local_lsp_store),
+            _ => None,
+        }
+    }
+
+    pub fn as_local_mut(&mut self) -> Option<&mut LocalLspStore> {
+        match &mut self.mode {
+            LspStoreMode::Local(local_lsp_store) => Some(local_lsp_store),
+            _ => None,
+        }
+    }
+
+    pub fn upstream_client(&self) -> Option<AnyProtoClient> {
+        match &self.mode {
+            LspStoreMode::Ssh(SshLspStore {
+                upstream_client, ..
+            })
+            | LspStoreMode::Remote(RemoteLspStore {
+                upstream_client, ..
+            }) => Some(upstream_client.clone()),
+            LspStoreMode::Local(_) => None,
+        }
+    }
+
+    pub fn new_local(
         buffer_store: Model<BufferStore>,
         worktree_store: Model<WorktreeStore>,
-        environment: Option<Model<ProjectEnvironment>>,
+        environment: Model<ProjectEnvironment>,
         languages: Arc<LanguageRegistry>,
         http_client: Option<Arc<dyn HttpClient>>,
         fs: Arc<dyn Fs>,
-        downstream_client: Option<AnyProtoClient>,
-        upstream_client: Option<AnyProtoClient>,
-        remote_id: Option<u64>,
         cx: &mut ModelContext<Self>,
     ) -> Self {
         let yarn = YarnPathStore::new(fs.clone(), cx);
@@ -229,32 +327,118 @@ impl LspStore {
             .detach();
 
         Self {
-            downstream_client,
-            upstream_client,
-            http_client,
-            fs,
-            project_id: remote_id.unwrap_or(0),
+            mode: LspStoreMode::Local(LocalLspStore {
+                supplementary_language_servers: Default::default(),
+                language_servers: Default::default(),
+                last_workspace_edits_by_language_server: Default::default(),
+                language_server_watched_paths: Default::default(),
+                language_server_watcher_registrations: Default::default(),
+                environment,
+                http_client,
+                fs,
+                yarn,
+                _subscription: cx.on_app_quit(|this, cx| {
+                    this.as_local_mut().unwrap().shutdown_language_servers(cx)
+                }),
+            }),
+            downstream_client: None,
+            project_id: 0,
+            buffer_store,
+            worktree_store,
+            languages: languages.clone(),
+            language_server_ids: Default::default(),
+            language_server_statuses: Default::default(),
+            nonce: StdRng::from_entropy().gen(),
+            buffer_snapshots: Default::default(),
+            next_diagnostic_group_id: Default::default(),
+            diagnostic_summaries: Default::default(),
+            diagnostics: Default::default(),
+            active_entry: None,
+            _maintain_workspace_config: Self::maintain_workspace_config(cx),
+            _maintain_buffer_languages: Self::maintain_buffer_languages(languages.clone(), cx),
+        }
+    }
+
+    fn send_lsp_proto_request<R: LspCommand>(
+        &self,
+        buffer: Model<Buffer>,
+        client: AnyProtoClient,
+        request: R,
+        cx: &mut ModelContext<'_, LspStore>,
+    ) -> Task<anyhow::Result<<R as LspCommand>::Response>> {
+        let message = request.to_proto(self.project_id, buffer.read(cx));
+        cx.spawn(move |this, cx| async move {
+            let response = client.request(message).await?;
+            let this = this.upgrade().context("project dropped")?;
+            request
+                .response_from_proto(response, this, buffer, cx)
+                .await
+        })
+    }
+
+    pub fn new_ssh(
+        buffer_store: Model<BufferStore>,
+        worktree_store: Model<WorktreeStore>,
+        languages: Arc<LanguageRegistry>,
+        upstream_client: AnyProtoClient,
+        project_id: u64,
+        cx: &mut ModelContext<Self>,
+    ) -> Self {
+        cx.subscribe(&buffer_store, Self::on_buffer_store_event)
+            .detach();
+        cx.subscribe(&worktree_store, Self::on_worktree_store_event)
+            .detach();
+
+        Self {
+            mode: LspStoreMode::Ssh(SshLspStore { upstream_client }),
+            downstream_client: None,
+            project_id,
             buffer_store,
             worktree_store,
             languages: languages.clone(),
-            environment,
+            language_server_ids: Default::default(),
+            language_server_statuses: Default::default(),
             nonce: StdRng::from_entropy().gen(),
             buffer_snapshots: Default::default(),
-            supplementary_language_servers: Default::default(),
-            language_servers: Default::default(),
+            next_diagnostic_group_id: Default::default(),
+            diagnostic_summaries: Default::default(),
+            diagnostics: Default::default(),
+            active_entry: None,
+            _maintain_workspace_config: Self::maintain_workspace_config(cx),
+            _maintain_buffer_languages: Self::maintain_buffer_languages(languages.clone(), cx),
+        }
+    }
+
+    pub fn new_remote(
+        buffer_store: Model<BufferStore>,
+        worktree_store: Model<WorktreeStore>,
+        languages: Arc<LanguageRegistry>,
+        upstream_client: AnyProtoClient,
+        project_id: u64,
+        cx: &mut ModelContext<Self>,
+    ) -> Self {
+        cx.subscribe(&buffer_store, Self::on_buffer_store_event)
+            .detach();
+        cx.subscribe(&worktree_store, Self::on_worktree_store_event)
+            .detach();
+
+        Self {
+            mode: LspStoreMode::Remote(RemoteLspStore { upstream_client }),
+            downstream_client: None,
+            project_id,
+            buffer_store,
+            worktree_store,
+            languages: languages.clone(),
             language_server_ids: Default::default(),
             language_server_statuses: Default::default(),
-            last_workspace_edits_by_language_server: Default::default(),
-            language_server_watched_paths: Default::default(),
-            language_server_watcher_registrations: Default::default(),
+            nonce: StdRng::from_entropy().gen(),
+            buffer_snapshots: Default::default(),
             next_diagnostic_group_id: Default::default(),
             diagnostic_summaries: Default::default(),
             diagnostics: Default::default(),
             active_entry: None,
-            yarn,
             _maintain_workspace_config: Self::maintain_workspace_config(cx),
             _maintain_buffer_languages: Self::maintain_buffer_languages(languages.clone(), cx),
-            _subscription: cx.on_app_quit(Self::shutdown_language_servers),
         }
     }
 
@@ -273,7 +457,6 @@ impl LspStore {
                     self.unregister_buffer_from_language_servers(buffer, old_file, cx);
                 }
 
-                self.detect_language_for_buffer(buffer, cx);
                 self.register_buffer_with_language_servers(buffer, cx);
             }
             BufferStoreEvent::BufferDropped(_) => {}
@@ -338,7 +521,6 @@ impl LspStore {
         })
         .detach();
 
-        self.detect_language_for_buffer(buffer, cx);
         self.register_buffer_with_language_servers(buffer, cx);
         cx.observe_release(buffer, |this, buffer, cx| {
             if let Some(file) = File::from_dyn(buffer.file()) {
@@ -406,9 +588,7 @@ impl LspStore {
                                 buffers_with_unknown_injections.push(handle);
                             }
                         }
-
                         for buffer in plain_text_buffers {
-                            this.detect_language_for_buffer(&buffer, cx);
                             this.register_buffer_with_language_servers(&buffer, cx);
                         }
 
@@ -426,34 +606,29 @@ impl LspStore {
         &mut self,
         buffer_handle: &Model<Buffer>,
         cx: &mut ModelContext<Self>,
-    ) {
+    ) -> Option<language::AvailableLanguage> {
         // If the buffer has a language, set it and start the language server if we haven't already.
         let buffer = buffer_handle.read(cx);
-        let Some(file) = buffer.file() else {
-            return;
-        };
-        let content = buffer.as_rope();
-        let Some(new_language_result) = self
-            .languages
-            .language_for_file(file, Some(content), cx)
-            .now_or_never()
-        else {
-            return;
-        };
+        let file = buffer.file()?;
 
-        match new_language_result {
-            Err(e) => {
-                if e.is::<language::LanguageNotFound>() {
-                    cx.emit(LspStoreEvent::LanguageDetected {
-                        buffer: buffer_handle.clone(),
-                        new_language: None,
-                    });
-                }
-            }
-            Ok(new_language) => {
+        let content = buffer.as_rope();
+        let available_language = self.languages.language_for_file(file, Some(content), cx);
+        if let Some(available_language) = &available_language {
+            if let Some(Ok(Ok(new_language))) = self
+                .languages
+                .load_language(available_language)
+                .now_or_never()
+            {
                 self.set_language_for_buffer(buffer_handle, new_language, cx);
             }
-        };
+        } else {
+            cx.emit(LspStoreEvent::LanguageDetected {
+                buffer: buffer_handle.clone(),
+                new_language: None,
+            });
+        }
+
+        available_language
     }
 
     pub fn set_language_for_buffer(
@@ -475,9 +650,7 @@ impl LspStore {
 
         if let Some(file) = buffer_file {
             let worktree = file.worktree.clone();
-            if worktree.read(cx).is_local() {
-                self.start_language_servers(&worktree, new_language.clone(), cx)
-            }
+            self.start_language_servers(&worktree, new_language.name(), cx)
         }
 
         cx.emit(LspStoreEvent::LanguageDetected {
@@ -494,27 +667,6 @@ impl LspStore {
         self.active_entry = active_entry;
     }
 
-    fn shutdown_language_servers(
-        &mut self,
-        _cx: &mut ModelContext<Self>,
-    ) -> impl Future<Output = ()> {
-        let shutdown_futures = self
-            .language_servers
-            .drain()
-            .map(|(_, server_state)| async {
-                use LanguageServerState::*;
-                match server_state {
-                    Running { server, .. } => server.shutdown()?.await,
-                    Starting(task) => task.await?.shutdown()?.await,
-                }
-            })
-            .collect::<Vec<_>>();
-
-        async move {
-            futures::future::join_all(shutdown_futures).await;
-        }
-    }
-
     pub(crate) fn send_diagnostic_summaries(
         &self,
         worktree: &mut Worktree,
@@ -547,9 +699,11 @@ impl LspStore {
         <R::LspRequest as lsp::request::Request>::Params: Send,
     {
         let buffer = buffer_handle.read(cx);
-        if self.upstream_client.is_some() {
-            return self.send_lsp_proto_request(buffer_handle, self.project_id, request, cx);
+
+        if let Some(upstream_client) = self.upstream_client() {
+            return self.send_lsp_proto_request(buffer_handle, upstream_client, request, cx);
         }
+
         let language_server = match server {
             LanguageServerToQuery::Primary => {
                 match self.primary_language_server_for_buffer(buffer, cx) {
@@ -635,26 +789,6 @@ impl LspStore {
         Task::ready(Ok(Default::default()))
     }
 
-    fn send_lsp_proto_request<R: LspCommand>(
-        &self,
-        buffer: Model<Buffer>,
-        project_id: u64,
-        request: R,
-        cx: &mut ModelContext<'_, Self>,
-    ) -> Task<anyhow::Result<<R as LspCommand>::Response>> {
-        let Some(upstream_client) = self.upstream_client.clone() else {
-            return Task::ready(Err(anyhow!("disconnected before completing request")));
-        };
-        let message = request.to_proto(project_id, buffer.read(cx));
-        cx.spawn(move |this, cx| async move {
-            let response = upstream_client.request(message).await?;
-            let this = this.upgrade().context("project dropped")?;
-            request
-                .response_from_proto(response, this, buffer, cx)
-                .await
-        })
-    }
-
     pub async fn execute_code_actions_on_servers(
         this: &WeakModel<LspStore>,
         adapters_and_servers: &[(Arc<CachedLspAdapter>, Arc<LanguageServer>)],
@@ -702,8 +836,10 @@ impl LspStore {
 
                 if let Some(command) = action.lsp_action.command {
                     this.update(cx, |this, _| {
-                        this.last_workspace_edits_by_language_server
-                            .remove(&language_server.server_id());
+                        if let LspStoreMode::Local(mode) = &mut this.mode {
+                            mode.last_workspace_edits_by_language_server
+                                .remove(&language_server.server_id());
+                        }
                     })?;
 
                     language_server
@@ -715,12 +851,14 @@ impl LspStore {
                         .await?;
 
                     this.update(cx, |this, _| {
-                        project_transaction.0.extend(
-                            this.last_workspace_edits_by_language_server
-                                .remove(&language_server.server_id())
-                                .unwrap_or_default()
-                                .0,
-                        )
+                        if let LspStoreMode::Local(mode) = &mut this.mode {
+                            project_transaction.0.extend(
+                                mode.last_workspace_edits_by_language_server
+                                    .remove(&language_server.server_id())
+                                    .unwrap_or_default()
+                                    .0,
+                            )
+                        }
                     })?;
                 }
             }
@@ -752,7 +890,7 @@ impl LspStore {
         push_to_history: bool,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<ProjectTransaction>> {
-        if let Some(upstream_client) = self.upstream_client.clone() {
+        if let Some(upstream_client) = self.upstream_client() {
             let request = proto::ApplyCodeAction {
                 project_id: self.project_id,
                 buffer_id: buffer_handle.read(cx).remote_id().into(),
@@ -801,7 +939,9 @@ impl LspStore {
 
                 if let Some(command) = action.lsp_action.command {
                     this.update(&mut cx, |this, _| {
-                        this.last_workspace_edits_by_language_server
+                        this.as_local_mut()
+                            .unwrap()
+                            .last_workspace_edits_by_language_server
                             .remove(&lang_server.server_id());
                     })?;
 
@@ -816,7 +956,9 @@ impl LspStore {
                     result?;
 
                     return this.update(&mut cx, |this, _| {
-                        this.last_workspace_edits_by_language_server
+                        this.as_local_mut()
+                            .unwrap()
+                            .last_workspace_edits_by_language_server
                             .remove(&lang_server.server_id())
                             .unwrap_or_default()
                     });
@@ -834,7 +976,7 @@ impl LspStore {
         server_id: LanguageServerId,
         cx: &mut ModelContext<Self>,
     ) -> Task<anyhow::Result<InlayHint>> {
-        if let Some(upstream_client) = self.upstream_client.clone() {
+        if let Some(upstream_client) = self.upstream_client() {
             let request = proto::ResolveInlayHint {
                 project_id: self.project_id,
                 buffer_id: buffer_handle.read(cx).remote_id().into(),
@@ -912,7 +1054,7 @@ impl LspStore {
             .map(|(_, server)| LanguageServerToQuery::Other(server.server_id()))
             .next()
             .or_else(|| {
-                self.upstream_client
+                self.upstream_client()
                     .is_some()
                     .then_some(LanguageServerToQuery::Primary)
             })
@@ -945,7 +1087,7 @@ impl LspStore {
         trigger: String,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Option<Transaction>>> {
-        if let Some(client) = self.upstream_client.clone() {
+        if let Some(client) = self.upstream_client() {
             let request = proto::OnTypeFormatting {
                 project_id: self.project_id,
                 buffer_id: buffer.read(cx).remote_id().into(),
@@ -1095,7 +1237,7 @@ impl LspStore {
         range: Range<Anchor>,
         cx: &mut ModelContext<Self>,
     ) -> Task<Vec<CodeAction>> {
-        if let Some(upstream_client) = self.upstream_client.as_ref() {
+        if let Some(upstream_client) = self.upstream_client() {
             let request_task = upstream_client.request(proto::MultiLspQuery {
                 buffer_id: buffer_handle.read(cx).remote_id().into(),
                 version: serialize_version(&buffer_handle.read(cx).version()),
@@ -1175,10 +1317,10 @@ impl LspStore {
     ) -> Task<Result<Vec<Completion>>> {
         let language_registry = self.languages.clone();
 
-        if let Some(_) = self.upstream_client.clone() {
+        if let Some(upstream_client) = self.upstream_client() {
             let task = self.send_lsp_proto_request(
                 buffer.clone(),
-                self.project_id,
+                upstream_client,
                 GetCompletions { position, context },
                 cx,
             );
@@ -1187,9 +1329,12 @@ impl LspStore {
             // In the future, we should provide project guests with the names of LSP adapters,
             // so that they can use the correct LSP adapter when computing labels. For now,
             // guests just use the first LSP adapter associated with the buffer's language.
-            let lsp_adapter = language
-                .as_ref()
-                .and_then(|language| language_registry.lsp_adapters(language).first().cloned());
+            let lsp_adapter = language.as_ref().and_then(|language| {
+                language_registry
+                    .lsp_adapters(&language.name())
+                    .first()
+                    .cloned()
+            });
 
             cx.foreground_executor().spawn(async move {
                 let completions = task.await?;
@@ -1269,7 +1414,7 @@ impl LspStore {
         completions: Arc<RwLock<Box<[Completion]>>>,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<bool>> {
-        let client = self.upstream_client.clone();
+        let client = self.upstream_client();
         let language_registry = self.languages.clone();
         let project_id = self.project_id;
 
@@ -1478,7 +1623,7 @@ impl LspStore {
         let buffer = buffer_handle.read(cx);
         let buffer_id = buffer.remote_id();
 
-        if let Some(client) = self.upstream_client.clone() {
+        if let Some(client) = self.upstream_client() {
             let project_id = self.project_id;
             cx.spawn(move |_, mut cx| async move {
                 let response = client
@@ -1594,7 +1739,7 @@ impl LspStore {
         let buffer_id = buffer.remote_id().into();
         let lsp_request = InlayHints { range };
 
-        if let Some(client) = self.upstream_client.clone() {
+        if let Some(client) = self.upstream_client() {
             let request = proto::InlayHints {
                 project_id: self.project_id,
                 buffer_id,
@@ -1644,7 +1789,7 @@ impl LspStore {
     ) -> Task<Vec<SignatureHelp>> {
         let position = position.to_point_utf16(buffer.read(cx));
 
-        if let Some(client) = self.upstream_client.clone() {
+        if let Some(client) = self.upstream_client() {
             let request_task = client.request(proto::MultiLspQuery {
                 buffer_id: buffer.read(cx).remote_id().into(),
                 version: serialize_version(&buffer.read(cx).version()),
@@ -1716,7 +1861,7 @@ impl LspStore {
         position: PointUtf16,
         cx: &mut ModelContext<Self>,
     ) -> Task<Vec<Hover>> {
-        if let Some(client) = self.upstream_client.clone() {
+        if let Some(client) = self.upstream_client() {
             let request_task = client.request(proto::MultiLspQuery {
                 buffer_id: buffer.read(cx).remote_id().into(),
                 version: serialize_version(&buffer.read(cx).version()),
@@ -1790,7 +1935,7 @@ impl LspStore {
     pub fn symbols(&self, query: &str, cx: &mut ModelContext<Self>) -> Task<Result<Vec<Symbol>>> {
         let language_registry = self.languages.clone();
 
-        if let Some(upstream_client) = self.upstream_client.as_ref() {
+        if let Some(upstream_client) = self.upstream_client().as_ref() {
             let request = upstream_client.request(proto::GetProjectSymbols {
                 project_id: self.project_id,
                 query: query.to_string(),
@@ -1816,7 +1961,7 @@ impl LspStore {
         } else {
             struct WorkspaceSymbolsResult {
                 lsp_adapter: Arc<CachedLspAdapter>,
-                language: Arc<Language>,
+                language: LanguageName,
                 worktree: WeakModel<Worktree>,
                 worktree_abs_path: Arc<Path>,
                 lsp_symbols: Vec<(String, SymbolKind, lsp::Location)>,
@@ -1837,16 +1982,17 @@ impl LspStore {
                 }
                 let worktree_abs_path = worktree.abs_path().clone();
 
-                let (lsp_adapter, language, server) = match self.language_servers.get(server_id) {
-                    Some(LanguageServerState::Running {
-                        adapter,
-                        language,
-                        server,
-                        ..
-                    }) => (adapter.clone(), language.clone(), server),
+                let (lsp_adapter, language, server) =
+                    match self.as_local().unwrap().language_servers.get(server_id) {
+                        Some(LanguageServerState::Running {
+                            adapter,
+                            language,
+                            server,
+                            ..
+                        }) => (adapter.clone(), language.clone(), server),
 
-                    _ => continue,
-                };
+                        _ => continue,
+                    };
 
                 requests.push(
                     server
@@ -2105,7 +2251,7 @@ impl LspStore {
             uri: lsp::Url::from_file_path(abs_path).log_err()?,
         };
 
-        for (_, _, server) in self.language_servers_for_worktree(worktree_id) {
+        for server in self.language_servers_for_worktree(worktree_id) {
             if let Some(include_text) = include_text(server.as_ref()) {
                 let text = if include_text {
                     Some(buffer.read(cx).text())
@@ -2148,8 +2294,9 @@ impl LspStore {
                                 .worktree_store
                                 .read(cx)
                                 .worktree_for_id(*worktree_id, cx)?;
-                            let state = this.language_servers.get(server_id)?;
-                            let delegate = ProjectLspAdapterDelegate::new(this, &worktree, cx);
+                            let state = this.as_local()?.language_servers.get(server_id)?;
+                            let delegate =
+                                ProjectLspAdapterDelegate::for_local(this, &worktree, cx);
                             match state {
                                 LanguageServerState::Starting(_) => None,
                                 LanguageServerState::Running {
@@ -2204,19 +2351,15 @@ impl LspStore {
     fn language_servers_for_worktree(
         &self,
         worktree_id: WorktreeId,
-    ) -> impl Iterator<Item = (&Arc<CachedLspAdapter>, &Arc<Language>, &Arc<LanguageServer>)> {
+    ) -> impl Iterator<Item = &Arc<LanguageServer>> {
         self.language_server_ids
             .iter()
             .filter_map(move |((language_server_worktree_id, _), id)| {
                 if *language_server_worktree_id == worktree_id {
-                    if let Some(LanguageServerState::Running {
-                        adapter,
-                        language,
-                        server,
-                        ..
-                    }) = self.language_servers.get(id)
+                    if let Some(LanguageServerState::Running { server, .. }) =
+                        self.as_local()?.language_servers.get(id)
                     {
-                        return Some((adapter, language, server));
+                        return Some(server);
                     }
                 }
                 None
@@ -2241,11 +2384,17 @@ impl LspStore {
             self.language_server_ids
                 .remove(&(id_to_remove, server_name));
             self.language_server_statuses.remove(&server_id_to_remove);
-            self.language_server_watched_paths
-                .remove(&server_id_to_remove);
-            self.last_workspace_edits_by_language_server
-                .remove(&server_id_to_remove);
-            self.language_servers.remove(&server_id_to_remove);
+            if let Some(local_lsp_store) = self.as_local_mut() {
+                local_lsp_store
+                    .language_server_watched_paths
+                    .remove(&server_id_to_remove);
+                local_lsp_store
+                    .last_workspace_edits_by_language_server
+                    .remove(&server_id_to_remove);
+                local_lsp_store
+                    .language_servers
+                    .remove(&server_id_to_remove);
+            }
             cx.emit(LspStoreEvent::LanguageServerRemoved(server_id_to_remove));
         }
     }
@@ -2306,11 +2455,14 @@ impl LspStore {
             .insert((worktree_id, language_server_name), language_server_id);
     }
 
+    #[track_caller]
     pub(crate) fn register_buffer_with_language_servers(
         &mut self,
         buffer_handle: &Model<Buffer>,
         cx: &mut ModelContext<Self>,
     ) {
+        let available_language = self.detect_language_for_buffer(buffer_handle, cx);
+
         let buffer = buffer_handle.read(cx);
         let buffer_id = buffer.remote_id();
 
@@ -2324,7 +2476,6 @@ impl LspStore {
                 return;
             };
             let initial_snapshot = buffer.text_snapshot();
-            let language = buffer.language().cloned();
             let worktree_id = file.worktree_id(cx);
 
             if let Some(diagnostics) = self.diagnostics.get(&worktree_id) {
@@ -2336,12 +2487,12 @@ impl LspStore {
                 }
             }
 
-            if let Some(language) = language {
-                for adapter in self.languages.lsp_adapters(&language) {
+            if let Some(language) = available_language {
+                for adapter in self.languages.lsp_adapters(&language.name()) {
                     let server = self
                         .language_server_ids
                         .get(&(worktree_id, adapter.name.clone()))
-                        .and_then(|id| self.language_servers.get(id))
+                        .and_then(|id| self.as_local()?.language_servers.get(id))
                         .and_then(|server_state| {
                             if let LanguageServerState::Running { server, .. } = server_state {
                                 Some(server.clone())
@@ -2359,7 +2510,7 @@ impl LspStore {
                             lsp::DidOpenTextDocumentParams {
                                 text_document: lsp::TextDocumentItem::new(
                                     uri.clone(),
-                                    adapter.language_id(&language),
+                                    adapter.language_id(&language.name()),
                                     0,
                                     initial_snapshot.text(),
                                 ),
@@ -2409,7 +2560,7 @@ impl LspStore {
             let ids = &self.language_server_ids;
 
             if let Some(language) = buffer.language().cloned() {
-                for adapter in self.languages.lsp_adapters(&language) {
+                for adapter in self.languages.lsp_adapters(&language.name()) {
                     if let Some(server_id) = ids.get(&(worktree_id, adapter.name.clone())) {
                         buffer.update_diagnostics(*server_id, Default::default(), cx);
                     }
@@ -2537,7 +2688,7 @@ impl LspStore {
         symbol: &Symbol,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Model<Buffer>>> {
-        if let Some(client) = self.upstream_client.clone() {
+        if let Some(client) = self.upstream_client() {
             let request = client.request(proto::OpenBufferForSymbol {
                 project_id: self.project_id,
                 symbol: Some(Self::serialize_symbol(symbol)),
@@ -2605,7 +2756,7 @@ impl LspStore {
             let p = abs_path.clone();
             let yarn_worktree = this
                 .update(&mut cx, move |this, cx| {
-                    this.yarn.update(cx, |_, cx| {
+                    this.as_local().unwrap().yarn.update(cx, |_, cx| {
                         cx.spawn(|this, mut cx| async move {
                             let t = this
                                 .update(&mut cx, |this, cx| {
@@ -2755,7 +2906,7 @@ impl LspStore {
         <R::LspRequest as lsp::request::Request>::Result: Send,
         <R::LspRequest as lsp::request::Request>::Params: Send,
     {
-        debug_assert!(self.upstream_client.is_none());
+        debug_assert!(self.upstream_client().is_none());
 
         let snapshot = buffer.read(cx).snapshot();
         let scope = position.and_then(|position| snapshot.language_scope_at(position));
@@ -2801,7 +2952,7 @@ impl LspStore {
         <T::LspRequest as lsp::request::Request>::Params: Send,
         <T::LspRequest as lsp::request::Request>::Result: Send,
     {
-        let sender_id = envelope.original_sender_id()?;
+        let sender_id = envelope.original_sender_id().unwrap_or_default();
         let buffer_id = T::buffer_id_from_proto(&envelope.payload)?;
         let buffer_handle = this.update(&mut cx, |this, cx| {
             this.buffer_store.read(cx).get_existing(buffer_id)
@@ -2839,7 +2990,7 @@ impl LspStore {
         envelope: TypedEnvelope<proto::MultiLspQuery>,
         mut cx: AsyncAppContext,
     ) -> Result<proto::MultiLspQueryResponse> {
-        let sender_id = envelope.original_sender_id()?;
+        let sender_id = envelope.original_sender_id().unwrap_or_default();
         let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
         let version = deserialize_version(&envelope.payload.version);
         let buffer = this.update(&mut cx, |this, cx| {
@@ -2979,7 +3130,7 @@ impl LspStore {
         envelope: TypedEnvelope<proto::ApplyCodeAction>,
         mut cx: AsyncAppContext,
     ) -> Result<proto::ApplyCodeActionResponse> {
-        let sender_id = envelope.original_sender_id()?;
+        let sender_id = envelope.original_sender_id().unwrap_or_default();
         let action = Self::deserialize_code_action(
             envelope
                 .payload
@@ -3184,7 +3335,9 @@ impl LspStore {
             simulate_disk_based_diagnostics_completion,
             adapter,
             ..
-        }) = self.language_servers.get_mut(&language_server_id)
+        }) = self
+            .as_local_mut()
+            .and_then(|local_store| local_store.language_servers.get_mut(&language_server_id))
         else {
             return;
         };
@@ -3205,8 +3358,9 @@ impl LspStore {
                     if let Some(LanguageServerState::Running {
                         simulate_disk_based_diagnostics_completion,
                         ..
-                    }) = this.language_servers.get_mut(&language_server_id)
-                    {
+                    }) = this.as_local_mut().and_then(|local_store| {
+                        local_store.language_servers.get_mut(&language_server_id)
+                    }) {
                         *simulate_disk_based_diagnostics_completion = None;
                     }
                 })
@@ -3264,7 +3418,20 @@ impl LspStore {
         language_server_id: LanguageServerId,
         cx: &mut ModelContext<Self>,
     ) {
-        let Some(watchers) = self
+        let worktrees = self
+            .worktree_store
+            .read(cx)
+            .worktrees()
+            .filter_map(|worktree| {
+                self.language_servers_for_worktree(worktree.read(cx).id())
+                    .find(|server| server.server_id() == language_server_id)
+                    .map(|_| worktree)
+            })
+            .collect::<Vec<_>>();
+
+        let local_lsp_store = self.as_local_mut().unwrap();
+
+        let Some(watchers) = local_lsp_store
             .language_server_watcher_registrations
             .get(&language_server_id)
         else {
@@ -3278,17 +3445,6 @@ impl LspStore {
             language_server_id
         );
 
-        let worktrees = self
-            .worktree_store
-            .read(cx)
-            .worktrees()
-            .filter_map(|worktree| {
-                self.language_servers_for_worktree(worktree.read(cx).id())
-                    .find(|(_, _, server)| server.server_id() == language_server_id)
-                    .map(|_| worktree)
-            })
-            .collect::<Vec<_>>();
-
         enum PathToWatch {
             Worktree {
                 literal_prefix: Arc<Path>,
@@ -3438,20 +3594,29 @@ impl LspStore {
                 watch_builder.watch_abs_path(abs_path, globset);
             }
         }
-        let watcher = watch_builder.build(self.fs.clone(), language_server_id, cx);
-        self.language_server_watched_paths
+        let watcher = watch_builder.build(local_lsp_store.fs.clone(), language_server_id, cx);
+        local_lsp_store
+            .language_server_watched_paths
             .insert(language_server_id, watcher);
 
         cx.notify();
     }
 
     pub fn language_server_for_id(&self, id: LanguageServerId) -> Option<Arc<LanguageServer>> {
-        if let Some(LanguageServerState::Running { server, .. }) = self.language_servers.get(&id) {
-            Some(server.clone())
-        } else if let Some((_, server)) = self.supplementary_language_servers.get(&id) {
-            Some(Arc::clone(server))
-        } else {
-            None
+        if let Some(local_lsp_store) = self.as_local() {
+            if let Some(LanguageServerState::Running { server, .. }) =
+                local_lsp_store.language_servers.get(&id)
+            {
+                Some(server.clone())
+            } else if let Some((_, server)) =
+                local_lsp_store.supplementary_language_servers.get(&id)
+            {
+                Some(Arc::clone(server))
+            } else {
+                None
+            }
+        } else {
+            None
         }
     }
 
@@ -3480,7 +3645,9 @@ impl LspStore {
         .log_err();
         this.update(&mut cx, |this, _| {
             if let Some(transaction) = transaction {
-                this.last_workspace_edits_by_language_server
+                this.as_local_mut()
+                    .unwrap()
+                    .last_workspace_edits_by_language_server
                     .insert(server_id, transaction);
             }
         })?;
@@ -3665,14 +3832,16 @@ impl LspStore {
         params: DidChangeWatchedFilesRegistrationOptions,
         cx: &mut ModelContext<Self>,
     ) {
-        let registrations = self
-            .language_server_watcher_registrations
-            .entry(language_server_id)
-            .or_default();
+        if let Some(local) = self.as_local_mut() {
+            let registrations = local
+                .language_server_watcher_registrations
+                .entry(language_server_id)
+                .or_default();
 
-        registrations.insert(registration_id.to_string(), params.watchers);
+            registrations.insert(registration_id.to_string(), params.watchers);
 
-        self.rebuild_watched_paths(language_server_id, cx);
+            self.rebuild_watched_paths(language_server_id, cx);
+        }
     }
 
     fn on_lsp_unregister_did_change_watched_files(
@@ -3681,26 +3850,28 @@ impl LspStore {
         registration_id: &str,
         cx: &mut ModelContext<Self>,
     ) {
-        let registrations = self
-            .language_server_watcher_registrations
-            .entry(language_server_id)
-            .or_default();
+        if let Some(local) = self.as_local_mut() {
+            let registrations = local
+                .language_server_watcher_registrations
+                .entry(language_server_id)
+                .or_default();
 
-        if registrations.remove(registration_id).is_some() {
-            log::info!(
+            if registrations.remove(registration_id).is_some() {
+                log::info!(
                 "language server {}: unregistered workspace/DidChangeWatchedFiles capability with id {}",
                 language_server_id,
                 registration_id
             );
-        } else {
-            log::warn!(
+            } else {
+                log::warn!(
                 "language server {}: failed to unregister workspace/DidChangeWatchedFiles capability with id {}. not registered.",
                 language_server_id,
                 registration_id
             );
-        }
+            }
 
-        self.rebuild_watched_paths(language_server_id, cx);
+            self.rebuild_watched_paths(language_server_id, cx);
+        }
     }
 
     #[allow(clippy::type_complexity)]
@@ -3915,7 +4086,7 @@ impl LspStore {
         envelope: TypedEnvelope<proto::InlayHints>,
         mut cx: AsyncAppContext,
     ) -> Result<proto::InlayHintsResponse> {
-        let sender_id = envelope.original_sender_id()?;
+        let sender_id = envelope.original_sender_id().unwrap_or_default();
         let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
         let buffer = this.update(&mut cx, |this, cx| {
             this.buffer_store.read(cx).get_existing(buffer_id)
@@ -3991,7 +4162,7 @@ impl LspStore {
         envelope: TypedEnvelope<proto::OpenBufferForSymbol>,
         mut cx: AsyncAppContext,
     ) -> Result<proto::OpenBufferForSymbolResponse> {
-        let peer_id = envelope.original_sender_id()?;
+        let peer_id = envelope.original_sender_id().unwrap_or_default();
         let symbol = envelope
             .payload
             .symbol
@@ -4093,6 +4264,76 @@ impl LspStore {
         Ok(proto::Ack {})
     }
 
+    pub async fn handle_create_language_server(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::CreateLanguageServer>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::Ack> {
+        let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
+        let name = LanguageServerName::from_proto(envelope.payload.name);
+
+        let binary = envelope
+            .payload
+            .binary
+            .ok_or_else(|| anyhow!("missing binary"))?;
+        let binary = LanguageServerBinary {
+            path: PathBuf::from(binary.path),
+            env: None,
+            arguments: binary.arguments.into_iter().map(Into::into).collect(),
+        };
+        let language = envelope
+            .payload
+            .language
+            .ok_or_else(|| anyhow!("missing language"))?;
+        let language_name = LanguageName::from_proto(language.name);
+        let matcher: LanguageMatcher = serde_json::from_str(&language.matcher)?;
+        this.update(&mut cx, |this, cx| {
+            this.languages
+                .register_language(language_name.clone(), None, matcher.clone(), {
+                    let language_name = language_name.clone();
+                    move || {
+                        Ok((
+                            LanguageConfig {
+                                name: language_name.clone(),
+                                matcher: matcher.clone(),
+                                ..Default::default()
+                            },
+                            Default::default(),
+                            Default::default(),
+                        ))
+                    }
+                });
+            cx.background_executor()
+                .spawn(this.languages.language_for_name(language_name.0.as_ref()))
+                .detach();
+
+            let adapter = Arc::new(SshLspAdapter::new(
+                name,
+                binary,
+                envelope.payload.initialization_options,
+                envelope.payload.code_action_kinds,
+            ));
+
+            this.languages
+                .register_lsp_adapter(language_name.clone(), adapter.clone());
+            let Some(worktree) = this
+                .worktree_store
+                .read(cx)
+                .worktree_for_id(worktree_id, cx)
+            else {
+                return Err(anyhow!("worktree not found"));
+            };
+            this.start_language_server(
+                &worktree,
+                CachedLspAdapter::new(adapter),
+                language_name,
+                cx,
+            );
+            Ok(())
+        })??;
+        Ok(proto::Ack {})
+    }
+
     async fn handle_apply_additional_edits_for_completion(
         this: Model<Self>,
         envelope: TypedEnvelope<proto::ApplyCompletionAdditionalEdits>,
@@ -4139,16 +4380,24 @@ impl LspStore {
         })
     }
 
+    fn language_settings<'a>(
+        &'a self,
+        worktree: &'a Model<Worktree>,
+        language: &LanguageName,
+        cx: &'a mut ModelContext<Self>,
+    ) -> &'a LanguageSettings {
+        let root_file = worktree.update(cx, |tree, cx| tree.root_file(cx));
+        all_language_settings(root_file.map(|f| f as _).as_ref(), cx).language(Some(language))
+    }
+
     pub fn start_language_servers(
         &mut self,
         worktree: &Model<Worktree>,
-        language: Arc<Language>,
+        language: LanguageName,
         cx: &mut ModelContext<Self>,
     ) {
-        let (root_file, is_local) =
-            worktree.update(cx, |tree, cx| (tree.root_file(cx), tree.is_local()));
-        let settings = language_settings(Some(&language), root_file.map(|f| f as _).as_ref(), cx);
-        if !settings.enable_language_server || !is_local {
+        let settings = self.language_settings(worktree, &language, cx);
+        if !settings.enable_language_server || self.mode.is_remote() {
             return;
         }
 
@@ -4176,7 +4425,7 @@ impl LspStore {
                 .load_available_lsp_adapter(&desired_language_server)
             {
                 self.languages
-                    .register_lsp_adapter(language.name(), adapter.adapter.clone());
+                    .register_lsp_adapter(language.clone(), adapter.adapter.clone());
                 enabled_lsp_adapters.push(adapter);
                 continue;
             }
@@ -4189,7 +4438,6 @@ impl LspStore {
 
         log::info!(
             "starting language servers for {language}: {adapters}",
-            language = language.name(),
             adapters = enabled_lsp_adapters
                 .iter()
                 .map(|adapter| adapter.name.0.as_ref())
@@ -4210,14 +4458,108 @@ impl LspStore {
             .reorder_language_servers(&language, enabled_lsp_adapters);
     }
 
+    /*
+    ssh client owns the lifecycle of the language servers
+    ssh host actually runs the binaries
+
+    in the future: ssh client will use the local extensions to get the downloads etc.
+        and send them up over the ssh connection (but today) we'll just the static config
+
+        languages::() <-- registers lsp adapters
+        on the ssh host we won't have adapters for the LSPs
+    */
+
+    fn start_language_server_on_ssh_host(
+        &mut self,
+        worktree: &Model<Worktree>,
+        adapter: Arc<CachedLspAdapter>,
+        language: LanguageName,
+        cx: &mut ModelContext<Self>,
+    ) {
+        let ssh = self.as_ssh().unwrap();
+
+        let configured_binary = ProjectSettings::get(
+            Some(worktree.update(cx, |worktree, cx| worktree.settings_location(cx))),
+            cx,
+        )
+        .lsp
+        .get(&adapter.name())
+        .and_then(|c| c.binary.as_ref())
+        .and_then(|config| {
+            if let Some(path) = &config.path {
+                Some((path.clone(), config.arguments.clone().unwrap_or_default()))
+            } else {
+                None
+            }
+        });
+        let delegate =
+            ProjectLspAdapterDelegate::for_ssh(self, worktree, cx) as Arc<dyn LspAdapterDelegate>;
+        let project_id = self.project_id;
+        let worktree_id = worktree.read(cx).id().to_proto();
+        let upstream_client = ssh.upstream_client.clone();
+        let name = adapter.name().to_string();
+        let Some((path, arguments)) = configured_binary else {
+            cx.emit(LspStoreEvent::Notification(format!(
+                "ssh-remoting currently requires manually configuring {} in your settings",
+                adapter.name()
+            )));
+            return;
+        };
+        let Some(available_language) = self.languages.available_language_for_name(&language) else {
+            log::error!("failed to find available language {language}");
+            return;
+        };
+        let task = cx.spawn(|_, _| async move {
+            let delegate = delegate;
+            let name = adapter.name().to_string();
+            let code_action_kinds = adapter
+                .adapter
+                .code_action_kinds()
+                .map(|kinds| serde_json::to_string(&kinds))
+                .transpose()?;
+            let get_options = adapter.adapter.clone().initialization_options(&delegate);
+            let initialization_options = get_options
+                .await?
+                .map(|options| serde_json::to_string(&options))
+                .transpose()?;
+
+            upstream_client
+                .request(proto::CreateLanguageServer {
+                    project_id,
+                    worktree_id,
+                    name,
+                    binary: Some(proto::LanguageServerCommand { path, arguments }),
+                    initialization_options,
+                    code_action_kinds,
+                    language: Some(proto::AvailableLanguage {
+                        name: language.to_proto(),
+                        matcher: serde_json::to_string(&available_language.matcher())?,
+                    }),
+                })
+                .await
+        });
+        cx.spawn(|this, mut cx| async move {
+            if let Err(e) = task.await {
+                this.update(&mut cx, |_this, cx| {
+                    cx.emit(LspStoreEvent::Notification(format!(
+                        "failed to start {}: {}",
+                        name, e
+                    )))
+                })
+                .ok();
+            }
+        })
+        .detach();
+    }
+
     fn start_language_server(
         &mut self,
         worktree_handle: &Model<Worktree>,
         adapter: Arc<CachedLspAdapter>,
-        language: Arc<Language>,
+        language: LanguageName,
         cx: &mut ModelContext<Self>,
     ) {
-        if adapter.reinstall_attempt_count.load(SeqCst) > MAX_SERVER_REINSTALL_ATTEMPT_COUNT {
+        if self.mode.is_remote() {
             return;
         }
 
@@ -4229,12 +4571,24 @@ impl LspStore {
             return;
         }
 
+        if self.mode.is_ssh() {
+            self.start_language_server_on_ssh_host(worktree_handle, adapter, language, cx);
+            return;
+        }
+
+        if adapter.reinstall_attempt_count.load(SeqCst) > MAX_SERVER_REINSTALL_ATTEMPT_COUNT {
+            return;
+        }
+
         let stderr_capture = Arc::new(Mutex::new(Some(String::new())));
-        let lsp_adapter_delegate = ProjectLspAdapterDelegate::new(self, worktree_handle, cx);
+        let lsp_adapter_delegate = ProjectLspAdapterDelegate::for_local(self, worktree_handle, cx);
         let cli_environment = self
+            .as_local()
+            .unwrap()
             .environment
-            .as_ref()
-            .and_then(|environment| environment.read(cx).get_cli_environment());
+            .read(cx)
+            .get_cli_environment();
+
         let pending_server = match self.languages.create_pending_language_server(
             stderr_capture.clone(),
             language.clone(),
@@ -4255,6 +4609,8 @@ impl LspStore {
             }),
             cx,
         );
+
+        // We need some on the SSH client, and some on SSH host
         let lsp = project_settings.lsp.get(&adapter.name.0);
         let override_options = lsp.and_then(|s| s.initialization_options.clone());
 
@@ -4329,7 +4685,10 @@ impl LspStore {
             })
         });
 
-        self.language_servers.insert(server_id, state);
+        self.as_local_mut()
+            .unwrap()
+            .language_servers
+            .insert(server_id, state);
         self.language_server_ids.insert(key, server_id);
     }
 
@@ -4340,7 +4699,7 @@ impl LspStore {
         override_initialization_options: Option<serde_json::Value>,
         pending_server: PendingLanguageServer,
         adapter: Arc<CachedLspAdapter>,
-        language: Arc<Language>,
+        language: LanguageName,
         server_id: LanguageServerId,
         key: (WorktreeId, LanguageServerName),
         cx: &mut AsyncAppContext,
@@ -4377,51 +4736,63 @@ impl LspStore {
 
     fn reinstall_language_server(
         &mut self,
-        language: Arc<Language>,
+        language: LanguageName,
         adapter: Arc<CachedLspAdapter>,
         server_id: LanguageServerId,
         cx: &mut ModelContext<Self>,
     ) -> Option<Task<()>> {
         log::info!("beginning to reinstall server");
 
-        let existing_server = match self.language_servers.remove(&server_id) {
-            Some(LanguageServerState::Running { server, .. }) => Some(server),
-            _ => None,
-        };
+        if let Some(local) = self.as_local_mut() {
+            let existing_server = match local.language_servers.remove(&server_id) {
+                Some(LanguageServerState::Running { server, .. }) => Some(server),
+                _ => None,
+            };
 
-        self.worktree_store.update(cx, |store, cx| {
-            for worktree in store.worktrees() {
-                let key = (worktree.read(cx).id(), adapter.name.clone());
-                self.language_server_ids.remove(&key);
-            }
-        });
+            self.worktree_store.update(cx, |store, cx| {
+                for worktree in store.worktrees() {
+                    let key = (worktree.read(cx).id(), adapter.name.clone());
+                    self.language_server_ids.remove(&key);
+                }
+            });
 
-        Some(cx.spawn(move |this, mut cx| async move {
-            if let Some(task) = existing_server.and_then(|server| server.shutdown()) {
-                log::info!("shutting down existing server");
+            Some(cx.spawn(move |this, mut cx| async move {
+                if let Some(task) = existing_server.and_then(|server| server.shutdown()) {
+                    log::info!("shutting down existing server");
+                    task.await;
+                }
+
+                // TODO: This is race-safe with regards to preventing new instances from
+                // starting while deleting, but existing instances in other projects are going
+                // to be very confused and messed up
+                let Some(task) = this
+                    .update(&mut cx, |this, cx| {
+                        this.languages.delete_server_container(adapter.clone(), cx)
+                    })
+                    .log_err()
+                else {
+                    return;
+                };
                 task.await;
-            }
 
-            // TODO: This is race-safe with regards to preventing new instances from
-            // starting while deleting, but existing instances in other projects are going
-            // to be very confused and messed up
-            let Some(task) = this
-                .update(&mut cx, |this, cx| {
-                    this.languages.delete_server_container(adapter.clone(), cx)
+                this.update(&mut cx, |this, cx| {
+                    for worktree in this.worktree_store.read(cx).worktrees().collect::<Vec<_>>() {
+                        this.start_language_server(
+                            &worktree,
+                            adapter.clone(),
+                            language.clone(),
+                            cx,
+                        );
+                    }
                 })
-                .log_err()
-            else {
-                return;
-            };
-            task.await;
-
-            this.update(&mut cx, |this, cx| {
-                for worktree in this.worktree_store.read(cx).worktrees().collect::<Vec<_>>() {
-                    this.start_language_server(&worktree, adapter.clone(), language.clone(), cx);
-                }
-            })
-            .ok();
-        }))
+                .ok();
+            }))
+        } else if let Some(_ssh_store) = self.as_ssh() {
+            // TODO
+            None
+        } else {
+            None
+        }
     }
 
     async fn shutdown_language_server(
@@ -4469,76 +4840,90 @@ impl LspStore {
         cx: &mut ModelContext<Self>,
     ) -> Task<Vec<WorktreeId>> {
         let key = (worktree_id, adapter_name);
-        if let Some(server_id) = self.language_server_ids.remove(&key) {
-            let name = key.1 .0;
-            log::info!("stopping language server {name}");
-
-            // Remove other entries for this language server as well
-            let mut orphaned_worktrees = vec![worktree_id];
-            let other_keys = self.language_server_ids.keys().cloned().collect::<Vec<_>>();
-            for other_key in other_keys {
-                if self.language_server_ids.get(&other_key) == Some(&server_id) {
-                    self.language_server_ids.remove(&other_key);
-                    orphaned_worktrees.push(other_key.0);
+        if self.mode.is_local() {
+            if let Some(server_id) = self.language_server_ids.remove(&key) {
+                let name = key.1 .0;
+                log::info!("stopping language server {name}");
+
+                // Remove other entries for this language server as well
+                let mut orphaned_worktrees = vec![worktree_id];
+                let other_keys = self.language_server_ids.keys().cloned().collect::<Vec<_>>();
+                for other_key in other_keys {
+                    if self.language_server_ids.get(&other_key) == Some(&server_id) {
+                        self.language_server_ids.remove(&other_key);
+                        orphaned_worktrees.push(other_key.0);
+                    }
                 }
-            }
 
-            self.buffer_store.update(cx, |buffer_store, cx| {
-                for buffer in buffer_store.buffers() {
-                    buffer.update(cx, |buffer, cx| {
-                        buffer.update_diagnostics(server_id, Default::default(), cx);
+                self.buffer_store.update(cx, |buffer_store, cx| {
+                    for buffer in buffer_store.buffers() {
+                        buffer.update(cx, |buffer, cx| {
+                            buffer.update_diagnostics(server_id, Default::default(), cx);
+                        });
+                    }
+                });
+
+                let project_id = self.project_id;
+                for (worktree_id, summaries) in self.diagnostic_summaries.iter_mut() {
+                    summaries.retain(|path, summaries_by_server_id| {
+                        if summaries_by_server_id.remove(&server_id).is_some() {
+                            if let Some(downstream_client) = self.downstream_client.clone() {
+                                downstream_client
+                                    .send(proto::UpdateDiagnosticSummary {
+                                        project_id,
+                                        worktree_id: worktree_id.to_proto(),
+                                        summary: Some(proto::DiagnosticSummary {
+                                            path: path.to_string_lossy().to_string(),
+                                            language_server_id: server_id.0 as u64,
+                                            error_count: 0,
+                                            warning_count: 0,
+                                        }),
+                                    })
+                                    .log_err();
+                            }
+                            !summaries_by_server_id.is_empty()
+                        } else {
+                            true
+                        }
                     });
                 }
-            });
 
-            let project_id = self.project_id;
-            for (worktree_id, summaries) in self.diagnostic_summaries.iter_mut() {
-                summaries.retain(|path, summaries_by_server_id| {
-                    if summaries_by_server_id.remove(&server_id).is_some() {
-                        if let Some(downstream_client) = self.downstream_client.clone() {
-                            downstream_client
-                                .send(proto::UpdateDiagnosticSummary {
-                                    project_id,
-                                    worktree_id: worktree_id.to_proto(),
-                                    summary: Some(proto::DiagnosticSummary {
-                                        path: path.to_string_lossy().to_string(),
-                                        language_server_id: server_id.0 as u64,
-                                        error_count: 0,
-                                        warning_count: 0,
-                                    }),
-                                })
-                                .log_err();
+                for diagnostics in self.diagnostics.values_mut() {
+                    diagnostics.retain(|_, diagnostics_by_server_id| {
+                        if let Ok(ix) =
+                            diagnostics_by_server_id.binary_search_by_key(&server_id, |e| e.0)
+                        {
+                            diagnostics_by_server_id.remove(ix);
+                            !diagnostics_by_server_id.is_empty()
+                        } else {
+                            true
                         }
-                        !summaries_by_server_id.is_empty()
-                    } else {
-                        true
-                    }
-                });
-            }
+                    });
+                }
 
-            for diagnostics in self.diagnostics.values_mut() {
-                diagnostics.retain(|_, diagnostics_by_server_id| {
-                    if let Ok(ix) =
-                        diagnostics_by_server_id.binary_search_by_key(&server_id, |e| e.0)
-                    {
-                        diagnostics_by_server_id.remove(ix);
-                        !diagnostics_by_server_id.is_empty()
-                    } else {
-                        true
-                    }
-                });
+                self.as_local_mut()
+                    .unwrap()
+                    .language_server_watched_paths
+                    .remove(&server_id);
+                self.language_server_statuses.remove(&server_id);
+                cx.notify();
+
+                let server_state = self
+                    .as_local_mut()
+                    .unwrap()
+                    .language_servers
+                    .remove(&server_id);
+                cx.emit(LspStoreEvent::LanguageServerRemoved(server_id));
+                cx.spawn(move |_, cx| async move {
+                    Self::shutdown_language_server(server_state, name, cx).await;
+                    orphaned_worktrees
+                })
+            } else {
+                Task::ready(Vec::new())
             }
-
-            self.language_server_watched_paths.remove(&server_id);
-            self.language_server_statuses.remove(&server_id);
-            cx.notify();
-
-            let server_state = self.language_servers.remove(&server_id);
-            cx.emit(LspStoreEvent::LanguageServerRemoved(server_id));
-            cx.spawn(move |_, cx| async move {
-                Self::shutdown_language_server(server_state, name, cx).await;
-                orphaned_worktrees
-            })
+        } else if self.mode.is_ssh() {
+            // TODO ssh
+            Task::ready(Vec::new())
         } else {
             Task::ready(Vec::new())
         }
@@ -4549,7 +4934,7 @@ impl LspStore {
         buffers: impl IntoIterator<Item = Model<Buffer>>,
         cx: &mut ModelContext<Self>,
     ) {
-        if let Some(client) = self.upstream_client.clone() {
+        if let Some(client) = self.upstream_client() {
             let request = client.request(proto::RestartLanguageServers {
                 project_id: self.project_id,
                 buffer_ids: buffers
@@ -4562,18 +4947,17 @@ impl LspStore {
                 .detach_and_log_err(cx);
         } else {
             #[allow(clippy::mutable_key_type)]
-            let language_server_lookup_info: HashSet<(Model<Worktree>, Arc<Language>)> = buffers
+            let language_server_lookup_info: HashSet<(Model<Worktree>, LanguageName)> = buffers
                 .into_iter()
                 .filter_map(|buffer| {
                     let buffer = buffer.read(cx);
                     let file = buffer.file()?;
                     let worktree = File::from_dyn(Some(file))?.worktree.clone();
-                    let language = self
-                        .languages
-                        .language_for_file(file, Some(buffer.as_rope()), cx)
-                        .now_or_never()?
-                        .ok()?;
-                    Some((worktree, language))
+                    let language =
+                        self.languages
+                            .language_for_file(file, Some(buffer.as_rope()), cx)?;
+
+                    Some((worktree, language.name()))
                 })
                 .collect();
 
@@ -4586,7 +4970,7 @@ impl LspStore {
     pub fn restart_language_servers(
         &mut self,
         worktree: Model<Worktree>,
-        language: Arc<Language>,
+        language: LanguageName,
         cx: &mut ModelContext<Self>,
     ) {
         let worktree_id = worktree.read(cx).id();
@@ -4637,7 +5021,7 @@ impl LspStore {
     }
 
     fn check_errored_server(
-        language: Arc<Language>,
+        language: LanguageName,
         adapter: Arc<CachedLspAdapter>,
         server_id: LanguageServerId,
         installation_test_binary: Option<LanguageServerBinary>,
@@ -4719,6 +5103,7 @@ impl LspStore {
             .clone()
             .workspace_configuration(&delegate, cx)
             .await?;
+        // This has to come from the server
         let (language_server, mut initialization_options) = pending_server.task.await?;
 
         let name = language_server.name();
@@ -4730,6 +5115,7 @@ impl LspStore {
                     let adapter = adapter.clone();
                     if let Some(this) = this.upgrade() {
                         adapter.process_diagnostics(&mut params);
+                        // Everything else has to be on the server, Can we make it on the client?
                         this.update(&mut cx, |this, cx| {
                             this.update_diagnostics(
                                 server_id,
@@ -5341,7 +5727,7 @@ impl LspStore {
 
     fn insert_newly_running_language_server(
         &mut self,
-        language: Arc<Language>,
+        language: LanguageName,
         adapter: Arc<CachedLspAdapter>,
         language_server: Arc<LanguageServer>,
         server_id: LanguageServerId,
@@ -5361,15 +5747,17 @@ impl LspStore {
 
         // Update language_servers collection with Running variant of LanguageServerState
         // indicating that the server is up and running and ready
-        self.language_servers.insert(
-            server_id,
-            LanguageServerState::Running {
-                adapter: adapter.clone(),
-                language: language.clone(),
-                server: language_server.clone(),
-                simulate_disk_based_diagnostics_completion: None,
-            },
-        );
+        if let Some(local) = self.as_local_mut() {
+            local.language_servers.insert(
+                server_id,
+                LanguageServerState::Running {
+                    adapter: adapter.clone(),
+                    language: language.clone(),
+                    server: language_server.clone(),
+                    simulate_disk_based_diagnostics_completion: None,
+                },
+            );
+        }
 
         self.language_server_statuses.insert(
             server_id,
@@ -5409,7 +5797,7 @@ impl LspStore {
                 if file.worktree.read(cx).id() != key.0
                     || !self
                         .languages
-                        .lsp_adapters(language)
+                        .lsp_adapters(&language.name())
                         .iter()
                         .any(|a| a.name == key.1)
                 {
@@ -5441,7 +5829,7 @@ impl LspStore {
                     lsp::DidOpenTextDocumentParams {
                         text_document: lsp::TextDocumentItem::new(
                             uri,
-                            adapter.language_id(language),
+                            adapter.language_id(&language.name()),
                             version,
                             initial_snapshot.text(),
                         ),
@@ -5521,12 +5909,14 @@ impl LspStore {
     ) -> impl Iterator<Item = (&'a Arc<CachedLspAdapter>, &'a Arc<LanguageServer>)> {
         self.language_server_ids_for_buffer(buffer, cx)
             .into_iter()
-            .filter_map(|server_id| match self.language_servers.get(&server_id)? {
-                LanguageServerState::Running {
-                    adapter, server, ..
-                } => Some((adapter, server)),
-                _ => None,
-            })
+            .filter_map(
+                |server_id| match self.as_local()?.language_servers.get(&server_id)? {
+                    LanguageServerState::Running {
+                        adapter, server, ..
+                    } => Some((adapter, server)),
+                    _ => None,
+                },
+            )
     }
 
     pub(crate) fn cancel_language_server_work_for_buffers(
@@ -5564,9 +5954,12 @@ impl LspStore {
         server: Arc<LanguageServer>,
         cx: &mut ModelContext<Self>,
     ) {
-        self.supplementary_language_servers
-            .insert(id, (name, server));
-        cx.emit(LspStoreEvent::LanguageServerAdded(id));
+        if let Some(local) = self.as_local_mut() {
+            local
+                .supplementary_language_servers
+                .insert(id, (name, server));
+            cx.emit(LspStoreEvent::LanguageServerAdded(id));
+        }
     }
 
     pub fn unregister_supplementary_language_server(
@@ -5574,27 +5967,33 @@ impl LspStore {
         id: LanguageServerId,
         cx: &mut ModelContext<Self>,
     ) {
-        self.supplementary_language_servers.remove(&id);
-        cx.emit(LspStoreEvent::LanguageServerRemoved(id));
+        if let Some(local) = self.as_local_mut() {
+            local.supplementary_language_servers.remove(&id);
+            cx.emit(LspStoreEvent::LanguageServerRemoved(id));
+        }
     }
 
     pub fn supplementary_language_servers(
         &self,
-    ) -> impl '_ + Iterator<Item = (&LanguageServerId, &LanguageServerName)> {
-        self.supplementary_language_servers
-            .iter()
-            .map(|(id, (name, _))| (id, name))
+    ) -> impl '_ + Iterator<Item = (LanguageServerId, LanguageServerName)> {
+        self.as_local().into_iter().flat_map(|local| {
+            local
+                .supplementary_language_servers
+                .iter()
+                .map(|(id, (name, _))| (*id, name.clone()))
+        })
     }
 
     pub fn language_server_adapter_for_id(
         &self,
         id: LanguageServerId,
     ) -> Option<Arc<CachedLspAdapter>> {
-        if let Some(LanguageServerState::Running { adapter, .. }) = self.language_servers.get(&id) {
-            Some(adapter.clone())
-        } else {
-            None
-        }
+        self.as_local()
+            .and_then(|local| local.language_servers.get(&id))
+            .and_then(|language_server_state| match language_server_state {
+                LanguageServerState::Running { adapter, .. } => Some(adapter.clone()),
+                _ => None,
+            })
     }
 
     pub(super) fn update_local_worktree_language_servers(
@@ -5607,6 +6006,8 @@ impl LspStore {
             return;
         }
 
+        let Some(local) = self.as_local() else { return };
+
         let worktree_id = worktree_handle.read(cx).id();
         let mut language_server_ids = self
             .language_server_ids
@@ -5621,9 +6022,9 @@ impl LspStore {
         let abs_path = worktree_handle.read(cx).abs_path();
         for server_id in &language_server_ids {
             if let Some(LanguageServerState::Running { server, .. }) =
-                self.language_servers.get(server_id)
+                local.language_servers.get(server_id)
             {
-                if let Some(watched_paths) = self
+                if let Some(watched_paths) = local
                     .language_server_watched_paths
                     .get(server_id)
                     .and_then(|paths| paths.read(cx).worktree_paths.get(&worktree_id))
@@ -5665,8 +6066,11 @@ impl LspStore {
         token_to_cancel: Option<String>,
         _cx: &mut ModelContext<Self>,
     ) {
+        let Some(local) = self.as_local() else {
+            return;
+        };
         let status = self.language_server_statuses.get(&server_id);
-        let server = self.language_servers.get(&server_id);
+        let server = local.language_servers.get(&server_id);
         if let Some((LanguageServerState::Running { server, .. }, status)) = server.zip(status) {
             for (token, progress) in &status.pending_work {
                 if let Some(token_to_cancel) = token_to_cancel.as_ref() {
@@ -5715,7 +6119,7 @@ impl LspStore {
         if let Some((file, language)) = File::from_dyn(buffer.file()).zip(buffer.language()) {
             let worktree_id = file.worktree_id(cx);
             self.languages
-                .lsp_adapters(language)
+                .lsp_adapters(&language.name())
                 .iter()
                 .flat_map(|adapter| {
                     let key = (worktree_id, adapter.name.clone());
@@ -5777,7 +6181,8 @@ impl LspStore {
         language_server: Arc<LanguageServer>,
         cx: &mut AsyncAppContext,
     ) -> Result<ProjectTransaction> {
-        let fs = this.update(cx, |this, _| this.fs.clone())?;
+        let fs = this.read_with(cx, |this, _| this.as_local().unwrap().fs.clone())?;
+
         let mut operations = Vec::new();
         if let Some(document_changes) = edit.document_changes {
             match document_changes {
@@ -6207,7 +6612,10 @@ impl LanguageServerWatchedPathsBuilder {
                                 while let Some(update) = push_updates.0.next().await {
                                     let action = lsp_store
                                         .update(&mut cx, |this, cx| {
-                                            let Some(watcher) = this
+                                            let Some(local) = this.as_local() else {
+                                                return ControlFlow::Break(());
+                                            };
+                                            let Some(watcher) = local
                                                 .language_server_watched_paths
                                                 .get(&language_server_id)
                                             else {
@@ -6297,13 +6705,27 @@ pub enum LanguageServerState {
     Starting(Task<Option<Arc<LanguageServer>>>),
 
     Running {
-        language: Arc<Language>,
+        language: LanguageName,
         adapter: Arc<CachedLspAdapter>,
         server: Arc<LanguageServer>,
         simulate_disk_based_diagnostics_completion: Option<Task<()>>,
     },
 }
 
+impl std::fmt::Debug for LanguageServerState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LanguageServerState::Starting(_) => {
+                f.debug_struct("LanguageServerState::Starting").finish()
+            }
+            LanguageServerState::Running { language, .. } => f
+                .debug_struct("LanguageServerState::Running")
+                .field("language", &language)
+                .finish(),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Serialize)]
 pub struct LanguageServerProgress {
     pub is_disk_based_diagnostics_progress: bool,
@@ -6378,24 +6800,136 @@ fn glob_literal_prefix(glob: &str) -> &str {
     &glob[..literal_end]
 }
 
+pub struct SshLspAdapter {
+    name: LanguageServerName,
+    binary: LanguageServerBinary,
+    initialization_options: Option<String>,
+    code_action_kinds: Option<Vec<CodeActionKind>>,
+}
+
+impl SshLspAdapter {
+    pub fn new(
+        name: LanguageServerName,
+        binary: LanguageServerBinary,
+        initialization_options: Option<String>,
+        code_action_kinds: Option<String>,
+    ) -> Self {
+        Self {
+            name,
+            binary,
+            initialization_options,
+            code_action_kinds: code_action_kinds
+                .as_ref()
+                .and_then(|c| serde_json::from_str(c).ok()),
+        }
+    }
+}
+
+#[async_trait(?Send)]
+impl LspAdapter for SshLspAdapter {
+    fn name(&self) -> LanguageServerName {
+        self.name.clone()
+    }
+
+    async fn initialization_options(
+        self: Arc<Self>,
+        _: &Arc<dyn LspAdapterDelegate>,
+    ) -> Result<Option<serde_json::Value>> {
+        let Some(options) = &self.initialization_options else {
+            return Ok(None);
+        };
+        let result = serde_json::from_str(options)?;
+        Ok(result)
+    }
+
+    fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
+        self.code_action_kinds.clone()
+    }
+
+    async fn check_if_user_installed(
+        &self,
+        _: &dyn LspAdapterDelegate,
+        _: &AsyncAppContext,
+    ) -> Option<LanguageServerBinary> {
+        Some(self.binary.clone())
+    }
+
+    async fn cached_server_binary(
+        &self,
+        _: PathBuf,
+        _: &dyn LspAdapterDelegate,
+    ) -> Option<LanguageServerBinary> {
+        None
+    }
+
+    async fn fetch_latest_server_version(
+        &self,
+        _: &dyn LspAdapterDelegate,
+    ) -> Result<Box<dyn 'static + Send + Any>> {
+        anyhow::bail!("SshLspAdapter does not support fetch_latest_server_version")
+    }
+
+    async fn fetch_server_binary(
+        &self,
+        _: Box<dyn 'static + Send + Any>,
+        _: PathBuf,
+        _: &dyn LspAdapterDelegate,
+    ) -> Result<LanguageServerBinary> {
+        anyhow::bail!("SshLspAdapter does not support fetch_server_binary")
+    }
+
+    async fn installation_test_binary(&self, _: PathBuf) -> Option<LanguageServerBinary> {
+        None
+    }
+}
+
 pub struct ProjectLspAdapterDelegate {
     lsp_store: WeakModel<LspStore>,
     worktree: worktree::Snapshot,
-    fs: Arc<dyn Fs>,
+    fs: Option<Arc<dyn Fs>>,
     http_client: Arc<dyn HttpClient>,
     language_registry: Arc<LanguageRegistry>,
     load_shell_env_task: Shared<Task<Option<HashMap<String, String>>>>,
 }
 
 impl ProjectLspAdapterDelegate {
+    fn for_local(
+        lsp_store: &LspStore,
+        worktree: &Model<Worktree>,
+        cx: &mut ModelContext<LspStore>,
+    ) -> Arc<Self> {
+        let local = lsp_store
+            .as_local()
+            .expect("ProjectLspAdapterDelegate cannot be constructed on a remote");
+
+        let http_client = local
+            .http_client
+            .clone()
+            .unwrap_or_else(|| Arc::new(BlockedHttpClient));
+
+        Self::new(lsp_store, worktree, http_client, Some(local.fs.clone()), cx)
+    }
+
+    fn for_ssh(
+        lsp_store: &LspStore,
+        worktree: &Model<Worktree>,
+        cx: &mut ModelContext<LspStore>,
+    ) -> Arc<Self> {
+        Self::new(lsp_store, worktree, Arc::new(BlockedHttpClient), None, cx)
+    }
+
     pub fn new(
         lsp_store: &LspStore,
         worktree: &Model<Worktree>,
+        http_client: Arc<dyn HttpClient>,
+        fs: Option<Arc<dyn Fs>>,
         cx: &mut ModelContext<LspStore>,
     ) -> Arc<Self> {
         let worktree_id = worktree.read(cx).id();
         let worktree_abs_path = worktree.read(cx).abs_path();
-        let load_shell_env_task = if let Some(environment) = &lsp_store.environment {
+        let load_shell_env_task = if let Some(environment) =
+            &lsp_store.as_local().map(|local| local.environment.clone())
+        {
             environment.update(cx, |env, cx| {
                 env.get_environment(Some(worktree_id), Some(worktree_abs_path), cx)
             })
@@ -6403,14 +6937,10 @@ impl ProjectLspAdapterDelegate {
             Task::ready(None).shared()
         };
 
-        let Some(http_client) = lsp_store.http_client.clone() else {
-            panic!("ProjectLspAdapterDelegate cannot be constructedd on an ssh-remote yet")
-        };
-
         Arc::new(Self {
             lsp_store: cx.weak_model(),
             worktree: worktree.read(cx).snapshot(),
-            fs: lsp_store.fs.clone(),
+            fs,
             http_client,
             language_registry: lsp_store.languages.clone(),
             load_shell_env_task,
@@ -6418,6 +6948,26 @@ impl ProjectLspAdapterDelegate {
     }
 }
 
+struct BlockedHttpClient;
+
+impl HttpClient for BlockedHttpClient {
+    fn send(
+        &self,
+        _req: Request<AsyncBody>,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>> {
+        Box::pin(async {
+            Err(std::io::Error::new(
+                std::io::ErrorKind::PermissionDenied,
+                "ssh host blocked http connection",
+            )
+            .into())
+        })
+    }
+
+    fn proxy(&self) -> Option<&Uri> {
+        None
+    }
+}
 #[async_trait]
 impl LspAdapterDelegate for ProjectLspAdapterDelegate {
     fn show_notification(&self, message: &str, cx: &mut AppContext) {
@@ -6447,6 +6997,7 @@ impl LspAdapterDelegate for ProjectLspAdapterDelegate {
 
     #[cfg(not(target_os = "windows"))]
     async fn which(&self, command: &OsStr) -> Option<PathBuf> {
+        self.fs.as_ref()?;
         let worktree_abs_path = self.worktree.abs_path();
         let shell_path = self.shell_env().await.get("PATH").cloned();
         which::which_in(command, shell_path.as_ref(), worktree_abs_path).ok()
@@ -6454,6 +7005,8 @@ impl LspAdapterDelegate for ProjectLspAdapterDelegate {
 
     #[cfg(target_os = "windows")]
     async fn which(&self, command: &OsStr) -> Option<PathBuf> {
+        self.fs.as_ref()?;
+
         // todo(windows) Getting the shell env variables in a current directory on Windows is more complicated than other platforms
         //               there isn't a 'default shell' necessarily. The closest would be the default profile on the windows terminal
         //               SEE: https://learn.microsoft.com/en-us/windows/terminal/customize-settings/startup
@@ -6472,17 +7025,20 @@ impl LspAdapterDelegate for ProjectLspAdapterDelegate {
     async fn read_text_file(&self, path: PathBuf) -> Result<String> {
         if self.worktree.entry_for_path(&path).is_none() {
             return Err(anyhow!("no such path {path:?}"));
+        };
+        if let Some(fs) = &self.fs {
+            let content = fs.load(&path).await?;
+            Ok(content)
+        } else {
+            return Err(anyhow!("cannot open {path:?} on ssh host (yet!)"));
         }
-        let path = self.worktree.absolutize(path.as_ref())?;
-        let content = self.fs.load(&path).await?;
-        Ok(content)
     }
 }
 
 async fn populate_labels_for_symbols(
     symbols: Vec<CoreSymbol>,
     language_registry: &Arc<LanguageRegistry>,
-    default_language: Option<Arc<Language>>,
+    default_language: Option<LanguageName>,
     lsp_adapter: Option<Arc<CachedLspAdapter>>,
     output: &mut Vec<Symbol>,
 ) {
@@ -6497,7 +7053,12 @@ async fn populate_labels_for_symbols(
             .ok()
             .or_else(|| {
                 unknown_path.get_or_insert(symbol.path.path.clone());
-                default_language.clone()
+                default_language.as_ref().and_then(|name| {
+                    language_registry
+                        .language_for_name(&name.0)
+                        .now_or_never()?
+                        .ok()
+                })
             });
         symbols_by_language
             .entry(language)
@@ -6523,9 +7084,12 @@ async fn populate_labels_for_symbols(
 
         let mut labels = Vec::new();
         if let Some(language) = language {
-            let lsp_adapter = lsp_adapter
-                .clone()
-                .or_else(|| language_registry.lsp_adapters(&language).first().cloned());
+            let lsp_adapter = lsp_adapter.clone().or_else(|| {
+                language_registry
+                    .lsp_adapters(&language.name())
+                    .first()
+                    .cloned()
+            });
             if let Some(lsp_adapter) = lsp_adapter {
                 labels = lsp_adapter
                     .labels_for_symbols(&label_params, &language)
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index ed489af687d753..f67423b0738514 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -107,7 +107,7 @@ pub use buffer_store::ProjectTransaction;
 pub use lsp_store::{
     DiagnosticSummary, LanguageServerLogType, LanguageServerProgress, LanguageServerPromptRequest,
     LanguageServerStatus, LanguageServerToQuery, LspStore, LspStoreEvent,
-    ProjectLspAdapterDelegate, SERVER_PROGRESS_THROTTLE_TIMEOUT,
+    SERVER_PROGRESS_THROTTLE_TIMEOUT,
 };
 
 const MAX_PROJECT_SEARCH_HISTORY_SIZE: usize = 500;
@@ -643,16 +643,13 @@ impl Project {
 
             let environment = ProjectEnvironment::new(&worktree_store, env, cx);
             let lsp_store = cx.new_model(|cx| {
-                LspStore::new(
+                LspStore::new_local(
                     buffer_store.clone(),
                     worktree_store.clone(),
-                    Some(environment.clone()),
+                    environment.clone(),
                     languages.clone(),
                     Some(client.http_client()),
                     fs.clone(),
-                    None,
-                    None,
-                    None,
                     cx,
                 )
             });
@@ -712,16 +709,89 @@ impl Project {
         fs: Arc<dyn Fs>,
         cx: &mut AppContext,
     ) -> Model<Self> {
-        let this = Self::local(client, node, user_store, languages, fs, None, cx);
-        this.update(cx, |this, cx| {
-            let client: AnyProtoClient = ssh.clone().into();
+        cx.new_model(|cx: &mut ModelContext<Self>| {
+            let (tx, rx) = mpsc::unbounded();
+            cx.spawn(move |this, cx| Self::send_buffer_ordered_messages(this, rx, cx))
+                .detach();
+            let tasks = Inventory::new(cx);
+            let global_snippets_dir = paths::config_dir().join("snippets");
+            let snippets =
+                SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
+
+            let worktree_store = cx.new_model(|_| {
+                let mut worktree_store = WorktreeStore::new(false, fs.clone());
+                worktree_store.set_upstream_client(ssh.clone().into());
+                worktree_store
+            });
+            cx.subscribe(&worktree_store, Self::on_worktree_store_event)
+                .detach();
+
+            let buffer_store =
+                cx.new_model(|cx| BufferStore::new(worktree_store.clone(), None, cx));
+            cx.subscribe(&buffer_store, Self::on_buffer_store_event)
+                .detach();
 
-            this.worktree_store.update(cx, |store, _cx| {
-                store.set_upstream_client(client.clone());
+            let settings_observer = cx.new_model(|cx| {
+                SettingsObserver::new_ssh(ssh.clone().into(), worktree_store.clone(), cx)
             });
-            this.settings_observer = cx.new_model(|cx| {
-                SettingsObserver::new_ssh(ssh.clone().into(), this.worktree_store.clone(), cx)
+
+            let environment = ProjectEnvironment::new(&worktree_store, None, cx);
+            let lsp_store = cx.new_model(|cx| {
+                LspStore::new_ssh(
+                    buffer_store.clone(),
+                    worktree_store.clone(),
+                    languages.clone(),
+                    ssh.clone().into(),
+                    0,
+                    cx,
+                )
             });
+            cx.subscribe(&lsp_store, Self::on_lsp_store_event).detach();
+
+            let this = Self {
+                buffer_ordered_messages_tx: tx,
+                collaborators: Default::default(),
+                worktree_store,
+                buffer_store,
+                lsp_store,
+                current_lsp_settings: ProjectSettings::get_global(cx).lsp.clone(),
+                join_project_response_message_id: 0,
+                client_state: ProjectClientState::Local,
+                client_subscriptions: Vec::new(),
+                _subscriptions: vec![
+                    cx.observe_global::<SettingsStore>(Self::on_settings_changed),
+                    cx.on_release(Self::release),
+                ],
+                active_entry: None,
+                snippets,
+                languages,
+                client,
+                user_store,
+                settings_observer,
+                fs,
+                ssh_session: Some(ssh.clone()),
+                buffers_needing_diff: Default::default(),
+                git_diff_debouncer: DebouncedDelay::new(),
+                terminals: Terminals {
+                    local_handles: Vec::new(),
+                },
+                node: Some(node),
+                default_prettier: DefaultPrettier::default(),
+                prettiers_per_worktree: HashMap::default(),
+                prettier_instances: HashMap::default(),
+                tasks,
+                hosted_project_id: None,
+                dev_server_project_id: None,
+                search_history: Self::new_search_history(),
+                environment,
+                remotely_created_buffers: Default::default(),
+                last_formatting_failure: None,
+                buffers_being_formatted: Default::default(),
+                search_included_history: Self::new_search_history(),
+                search_excluded_history: Self::new_search_history(),
+            };
+
+            let client: AnyProtoClient = ssh.clone().into();
 
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &cx.handle());
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.buffer_store);
@@ -735,9 +805,8 @@ impl Project {
             LspStore::init(&client);
             SettingsObserver::init(&client);
 
-            this.ssh_session = Some(ssh);
-        });
-        this
+            this
+        })
     }
 
     pub async fn remote(
@@ -820,16 +889,12 @@ impl Project {
             cx.new_model(|cx| BufferStore::new(worktree_store.clone(), Some(remote_id), cx))?;
 
         let lsp_store = cx.new_model(|cx| {
-            let mut lsp_store = LspStore::new(
+            let mut lsp_store = LspStore::new_remote(
                 buffer_store.clone(),
                 worktree_store.clone(),
-                None,
                 languages.clone(),
-                Some(client.http_client()),
-                fs.clone(),
-                None,
-                Some(client.clone().into()),
-                Some(remote_id),
+                client.clone().into(),
+                remote_id,
                 cx,
             );
             lsp_store.set_language_server_statuses_from_proto(response.payload.language_servers);
@@ -1125,8 +1190,7 @@ impl Project {
             if let Some(language) = buffer_language {
                 if settings.enable_language_server {
                     if let Some(file) = buffer_file {
-                        language_servers_to_start
-                            .push((file.worktree.clone(), Arc::clone(language)));
+                        language_servers_to_start.push((file.worktree.clone(), language.name()));
                     }
                 }
                 language_formatters_to_check
@@ -1144,7 +1208,7 @@ impl Project {
             let language = languages.iter().find_map(|l| {
                 let adapter = self
                     .languages
-                    .lsp_adapters(l)
+                    .lsp_adapters(&l.name())
                     .iter()
                     .find(|adapter| adapter.name == started_lsp_name)?
                     .clone();
@@ -1165,11 +1229,11 @@ impl Project {
                     ) {
                         (None, None) => {}
                         (Some(_), None) | (None, Some(_)) => {
-                            language_servers_to_restart.push((worktree, Arc::clone(language)));
+                            language_servers_to_restart.push((worktree, language.name()));
                         }
                         (Some(current_lsp_settings), Some(new_lsp_settings)) => {
                             if current_lsp_settings != new_lsp_settings {
-                                language_servers_to_restart.push((worktree, Arc::clone(language)));
+                                language_servers_to_restart.push((worktree, language.name()));
                             }
                         }
                     }
@@ -4777,7 +4841,7 @@ impl Project {
     pub fn supplementary_language_servers<'a>(
         &'a self,
         cx: &'a AppContext,
-    ) -> impl '_ + Iterator<Item = (&'a LanguageServerId, &'a LanguageServerName)> {
+    ) -> impl '_ + Iterator<Item = (LanguageServerId, LanguageServerName)> {
         self.lsp_store.read(cx).supplementary_language_servers()
     }
 
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index c2af1c3597d1e9..70b2eccf237c62 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -19,7 +19,7 @@ use worktree::{PathChange, UpdatedEntriesSet, Worktree, WorktreeId};
 
 use crate::worktree_store::{WorktreeStore, WorktreeStoreEvent};
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
 pub struct ProjectSettings {
     /// Configuration for language servers.
     ///
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index ffa206684fbadc..4662c75477d45f 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -6,7 +6,7 @@ use http_client::Url;
 use language::{
     language_settings::{AllLanguageSettings, LanguageSettingsContent},
     tree_sitter_rust, tree_sitter_typescript, Diagnostic, DiagnosticSet, FakeLspAdapter,
-    LanguageConfig, LanguageMatcher, LineEnding, OffsetRangeExt, Point, ToPoint,
+    LanguageConfig, LanguageMatcher, LanguageName, LineEnding, OffsetRangeExt, Point, ToPoint,
 };
 use lsp::{DiagnosticSeverity, NumberOrString};
 use parking_lot::Mutex;
@@ -1559,7 +1559,7 @@ async fn test_toggling_enable_language_server(cx: &mut gpui::TestAppContext) {
         SettingsStore::update_global(cx, |settings, cx| {
             settings.update_user_settings::<AllLanguageSettings>(cx, |settings| {
                 settings.languages.insert(
-                    Arc::from("Rust"),
+                    "Rust".into(),
                     LanguageSettingsContent {
                         enable_language_server: Some(false),
                         ..Default::default()
@@ -1578,14 +1578,14 @@ async fn test_toggling_enable_language_server(cx: &mut gpui::TestAppContext) {
         SettingsStore::update_global(cx, |settings, cx| {
             settings.update_user_settings::<AllLanguageSettings>(cx, |settings| {
                 settings.languages.insert(
-                    Arc::from("Rust"),
+                    LanguageName::new("Rust"),
                     LanguageSettingsContent {
                         enable_language_server: Some(true),
                         ..Default::default()
                     },
                 );
                 settings.languages.insert(
-                    Arc::from("JavaScript"),
+                    LanguageName::new("JavaScript"),
                     LanguageSettingsContent {
                         enable_language_server: Some(false),
                         ..Default::default()
@@ -2983,7 +2983,7 @@ async fn test_save_as(cx: &mut gpui::TestAppContext) {
         buffer.edit([(0..0, "abc")], None, cx);
         assert!(buffer.is_dirty());
         assert!(!buffer.has_conflict());
-        assert_eq!(buffer.language().unwrap().name().as_ref(), "Plain Text");
+        assert_eq!(buffer.language().unwrap().name(), "Plain Text".into());
     });
     project
         .update(cx, |project, cx| {
@@ -3006,7 +3006,7 @@ async fn test_save_as(cx: &mut gpui::TestAppContext) {
         );
         assert!(!buffer.is_dirty());
         assert!(!buffer.has_conflict());
-        assert_eq!(buffer.language().unwrap().name().as_ref(), "Rust");
+        assert_eq!(buffer.language().unwrap().name(), "Rust".into());
     });
 
     let opened_buffer = project
@@ -5308,7 +5308,7 @@ fn json_lang() -> Arc<Language> {
 fn js_lang() -> Arc<Language> {
     Arc::new(Language::new(
         LanguageConfig {
-            name: Arc::from("JavaScript"),
+            name: "JavaScript".into(),
             matcher: LanguageMatcher {
                 path_suffixes: vec!["js".to_string()],
                 ..Default::default()
diff --git a/crates/project/src/task_inventory.rs b/crates/project/src/task_inventory.rs
index 95ae6aee13f71a..314903ec5da439 100644
--- a/crates/project/src/task_inventory.rs
+++ b/crates/project/src/task_inventory.rs
@@ -161,7 +161,7 @@ impl Inventory {
         cx: &AppContext,
     ) -> Vec<(TaskSourceKind, TaskTemplate)> {
         let task_source_kind = language.as_ref().map(|language| TaskSourceKind::Language {
-            name: language.name(),
+            name: language.name().0,
         });
         let language_tasks = language
             .and_then(|language| language.context_provider()?.associated_tasks(file, cx))
@@ -207,7 +207,7 @@ impl Inventory {
             .as_ref()
             .and_then(|location| location.buffer.read(cx).language_at(location.range.start));
         let task_source_kind = language.as_ref().map(|language| TaskSourceKind::Language {
-            name: language.name(),
+            name: language.name().0,
         });
         let file = location
             .as_ref()
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index 3d464904b8bf2d..b24d9399655b11 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -281,7 +281,9 @@ message Envelope {
         FindSearchCandidatesResponse find_search_candidates_response = 244;
 
         CloseBuffer close_buffer = 245;
-        UpdateUserSettings update_user_settings = 246; // current max
+        UpdateUserSettings update_user_settings = 246;
+
+        CreateLanguageServer create_language_server = 247; // current max
     }
 
     reserved 158 to 161;
@@ -2497,3 +2499,36 @@ message UpdateUserSettings {
     uint64 project_id = 1;
     string content = 2;
 }
+
+message LanguageServerCommand {
+   string path = 1;
+   repeated string arguments = 2;
+}
+
+message AvailableLanguage {
+    string name = 7;
+    string matcher = 8;
+}
+
+message CreateLanguageServer {
+    uint64 project_id = 1;
+    uint64 worktree_id = 2;
+    string name = 3;
+
+    LanguageServerCommand binary = 4;
+    optional string initialization_options = 5;
+    optional string code_action_kinds = 6;
+
+    AvailableLanguage language = 7;
+}
+
+// message RestartLanguageServer {
+
+// }
+// message DestroyLanguageServer {
+
+// }
+
+// message LspWorkspaceConfiguration {
+
+// }
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index d8ebf665885b45..44cb91db1080b8 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -366,7 +366,8 @@ messages!(
     (FindSearchCandidates, Background),
     (FindSearchCandidatesResponse, Background),
     (CloseBuffer, Foreground),
-    (UpdateUserSettings, Foreground)
+    (UpdateUserSettings, Foreground),
+    (CreateLanguageServer, Foreground)
 );
 
 request_messages!(
@@ -490,6 +491,7 @@ request_messages!(
     (SynchronizeContexts, SynchronizeContextsResponse),
     (LspExtSwitchSourceHeader, LspExtSwitchSourceHeaderResponse),
     (AddWorktree, AddWorktreeResponse),
+    (CreateLanguageServer, Ack)
 );
 
 entity_messages!(
@@ -562,7 +564,8 @@ entity_messages!(
     UpdateContext,
     SynchronizeContexts,
     LspExtSwitchSourceHeader,
-    UpdateUserSettings
+    UpdateUserSettings,
+    CreateLanguageServer
 );
 
 entity_messages!(
diff --git a/crates/quick_action_bar/src/repl_menu.rs b/crates/quick_action_bar/src/repl_menu.rs
index fbf2ac17e55a99..f4e4cd2d1ad20e 100644
--- a/crates/quick_action_bar/src/repl_menu.rs
+++ b/crates/quick_action_bar/src/repl_menu.rs
@@ -62,7 +62,7 @@ impl QuickActionBar {
                 return self.render_repl_launch_menu(spec, cx);
             }
             SessionSupport::RequiresSetup(language) => {
-                return self.render_repl_setup(&language, cx);
+                return self.render_repl_setup(&language.0, cx);
             }
             SessionSupport::Unsupported => return None,
         };
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 4bee1c5a9fdaa3..8da4284b7f56a7 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -291,11 +291,24 @@ impl SshClientDelegate {
 
             self.update_status(Some("building remote server binary from source"), cx);
             log::info!("building remote server binary from source");
-            run_cmd(Command::new("cargo").args(["build", "--package", "remote_server"])).await?;
-            run_cmd(Command::new("strip").args(["target/debug/remote_server"])).await?;
-            run_cmd(Command::new("gzip").args(["-9", "-f", "target/debug/remote_server"])).await?;
+            run_cmd(Command::new("cargo").args([
+                "build",
+                "--package",
+                "remote_server",
+                "--target-dir",
+                "target/remote_server",
+            ]))
+            .await?;
+            // run_cmd(Command::new("strip").args(["target/remote_server/debug/remote_server"]))
+            // .await?;
+            run_cmd(Command::new("gzip").args([
+                "-9",
+                "-f",
+                "target/remote_server/debug/remote_server",
+            ]))
+            .await?;
 
-            let path = std::env::current_dir()?.join("target/debug/remote_server.gz");
+            let path = std::env::current_dir()?.join("target/remote_server/debug/remote_server.gz");
             return Ok((path, version));
 
             async fn run_cmd(command: &mut Command) -> Result<()> {
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 91f7b330e4a0e3..5ff11fe09931c9 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -41,11 +41,11 @@ pub struct SshSocket {
 
 pub struct SshSession {
     next_message_id: AtomicU32,
-    response_channels: ResponseChannels,
+    response_channels: ResponseChannels, // Lock
     outgoing_tx: mpsc::UnboundedSender<Envelope>,
     spawn_process_tx: mpsc::UnboundedSender<SpawnRequest>,
     client_socket: Option<SshSocket>,
-    state: Mutex<ProtoMessageHandlerSet>,
+    state: Mutex<ProtoMessageHandlerSet>, // Lock
 }
 
 struct SshClientState {
@@ -392,9 +392,9 @@ impl SshSession {
     ) -> impl 'static + Future<Output = Result<proto::Envelope>> {
         envelope.id = self.next_message_id.fetch_add(1, SeqCst);
         let (tx, rx) = oneshot::channel();
-        self.response_channels
-            .lock()
-            .insert(MessageId(envelope.id), tx);
+        let mut response_channels_lock = self.response_channels.lock();
+        response_channels_lock.insert(MessageId(envelope.id), tx);
+        drop(response_channels_lock);
         self.outgoing_tx.unbounded_send(envelope).ok();
         async move { Ok(rx.await.context("connection lost")?.0) }
     }
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 60f29bb573fbf8..ca5fe06e137c7f 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -4,14 +4,13 @@ use gpui::{AppContext, AsyncAppContext, Context, Model, ModelContext, Task};
 use language::LanguageRegistry;
 use project::{
     buffer_store::BufferStore, project_settings::SettingsObserver, search::SearchQuery,
-    worktree_store::WorktreeStore, LspStore, ProjectPath, WorktreeId, WorktreeSettings,
+    worktree_store::WorktreeStore, LspStore, ProjectPath, WorktreeId,
 };
 use remote::SshSession;
 use rpc::{
     proto::{self, AnyProtoClient, SSH_PEER_ID, SSH_PROJECT_ID},
     TypedEnvelope,
 };
-use settings::Settings as _;
 use smol::stream::StreamExt;
 use std::{
     path::{Path, PathBuf},
@@ -33,15 +32,17 @@ impl HeadlessProject {
     pub fn init(cx: &mut AppContext) {
         settings::init(cx);
         language::init(cx);
-        WorktreeSettings::register(cx);
+        project::Project::init_settings(cx);
     }
 
     pub fn new(session: Arc<SshSession>, fs: Arc<dyn Fs>, cx: &mut ModelContext<Self>) -> Self {
         // TODO: we should load the env correctly (as we do in login_shell_env_loaded when stdout is not a pty). Can we re-use the ProjectEnvironment for that?
-        let languages = Arc::new(LanguageRegistry::new(
-            Task::ready(()),
-            cx.background_executor().clone(),
-        ));
+        let mut languages =
+            LanguageRegistry::new(Task::ready(()), cx.background_executor().clone());
+        languages
+            .set_language_server_download_dir(PathBuf::from("/Users/conrad/what-could-go-wrong"));
+
+        let languages = Arc::new(languages);
 
         let worktree_store = cx.new_model(|_| WorktreeStore::new(true, fs.clone()));
         let buffer_store = cx.new_model(|cx| {
@@ -57,18 +58,17 @@ impl HeadlessProject {
         });
         let environment = project::ProjectEnvironment::new(&worktree_store, None, cx);
         let lsp_store = cx.new_model(|cx| {
-            LspStore::new(
+            let mut lsp_store = LspStore::new_local(
                 buffer_store.clone(),
                 worktree_store.clone(),
-                Some(environment),
+                environment,
                 languages,
                 None,
                 fs.clone(),
-                Some(session.clone().into()),
-                None,
-                Some(0),
                 cx,
-            )
+            );
+            lsp_store.shared(SSH_PROJECT_ID, session.clone().into(), cx);
+            lsp_store
         });
 
         let client: AnyProtoClient = session.clone().into();
@@ -88,9 +88,12 @@ impl HeadlessProject {
         client.add_model_request_handler(BufferStore::handle_update_buffer);
         client.add_model_message_handler(BufferStore::handle_close_buffer);
 
+        client.add_model_request_handler(LspStore::handle_create_language_server);
+
         BufferStore::init(&client);
         WorktreeStore::init(&client);
         SettingsObserver::init(&client);
+        LspStore::init(&client);
 
         HeadlessProject {
             session: client,
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 0aea585538f245..67a2f0b57d8cba 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -6,7 +6,7 @@ use gpui::{Context, Model, TestAppContext};
 use http_client::FakeHttpClient;
 use language::{
     language_settings::{all_language_settings, AllLanguageSettings},
-    Buffer, LanguageRegistry,
+    Buffer, FakeLspAdapter, LanguageConfig, LanguageMatcher, LanguageRegistry,
 };
 use node_runtime::FakeNodeRuntime;
 use project::{
@@ -202,15 +202,29 @@ async fn test_remote_settings(cx: &mut TestAppContext, server_cx: &mut TestAppCo
     server_cx.read(|cx| {
         assert_eq!(
             AllLanguageSettings::get_global(cx)
-                .language(Some("Rust"))
+                .language(Some(&"Rust".into()))
                 .language_servers,
             ["custom-rust-analyzer".into()]
         )
     });
 
-    fs.insert_tree("/code/project1/.zed", json!({
-        "settings.json": r#"{"languages":{"Rust":{"language_servers":["override-rust-analyzer"]}}}"#
-    })).await;
+    fs.insert_tree(
+        "/code/project1/.zed",
+        json!({
+            "settings.json": r#"
+                  {
+                    "languages": {"Rust":{"language_servers":["override-rust-analyzer"]}},
+                    "lsp": {
+                      "override-rust-analyzer": {
+                        "binary": {
+                          "path": "~/.cargo/bin/rust-analyzer"
+                        }
+                      }
+                    }
+                  }"#
+        }),
+    )
+    .await;
 
     let worktree_id = project
         .update(cx, |project, cx| {
@@ -247,7 +261,7 @@ async fn test_remote_settings(cx: &mut TestAppContext, server_cx: &mut TestAppCo
                 }),
                 cx
             )
-            .language(Some("Rust"))
+            .language(Some(&"Rust".into()))
             .language_servers,
             ["override-rust-analyzer".into()]
         )
@@ -257,13 +271,107 @@ async fn test_remote_settings(cx: &mut TestAppContext, server_cx: &mut TestAppCo
         let file = buffer.read(cx).file();
         assert_eq!(
             all_language_settings(file, cx)
-                .language(Some("Rust"))
+                .language(Some(&"Rust".into()))
                 .language_servers,
             ["override-rust-analyzer".into()]
         )
     });
 }
 
+#[gpui::test]
+async fn test_remote_lsp(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {
+    let (project, headless, fs) = init_test(cx, server_cx).await;
+
+    fs.insert_tree(
+        "/code/project1/.zed",
+        json!({
+            "settings.json": r#"
+          {
+            "languages": {"Rust":{"language_servers":["rust-analyzer"]}},
+            "lsp": {
+              "rust-analyzer": {
+                "binary": {
+                  "path": "~/.cargo/bin/rust-analyzer"
+                }
+              }
+            }
+          }"#
+        }),
+    )
+    .await;
+
+    cx.update_model(&project, |project, _| {
+        project.languages().register_test_language(LanguageConfig {
+            name: "Rust".into(),
+            matcher: LanguageMatcher {
+                path_suffixes: vec!["rs".into()],
+                ..Default::default()
+            },
+            ..Default::default()
+        });
+        project.languages().register_fake_lsp_adapter(
+            "Rust",
+            FakeLspAdapter {
+                name: "rust-analyzer",
+                ..Default::default()
+            },
+        )
+    });
+    cx.run_until_parked();
+
+    let worktree_id = project
+        .update(cx, |project, cx| {
+            project.find_or_create_worktree("/code/project1", true, cx)
+        })
+        .await
+        .unwrap()
+        .0
+        .read_with(cx, |worktree, _| worktree.id());
+
+    // Wait for the settings to synchronize
+    cx.run_until_parked();
+
+    let buffer = project
+        .update(cx, |project, cx| {
+            project.open_buffer((worktree_id, Path::new("src/lib.rs")), cx)
+        })
+        .await
+        .unwrap();
+    cx.run_until_parked();
+
+    cx.read(|cx| {
+        let file = buffer.read(cx).file();
+        assert_eq!(
+            all_language_settings(file, cx)
+                .language(Some(&"Rust".into()))
+                .language_servers,
+            ["rust-analyzer".into()]
+        )
+    });
+
+    let buffer_id = cx.read(|cx| {
+        let buffer = buffer.read(cx);
+        assert_eq!(buffer.language().unwrap().name(), "Rust".into());
+        buffer.remote_id()
+    });
+
+    server_cx.read(|cx| {
+        let buffer = headless
+            .read(cx)
+            .buffer_store
+            .read(cx)
+            .get(buffer_id)
+            .unwrap();
+
+        assert_eq!(buffer.read(cx).language().unwrap().name(), "Rust".into());
+    });
+
+    server_cx.read(|cx| {
+        let lsp_store = headless.read(cx).lsp_store.read(cx);
+        assert_eq!(lsp_store.as_local().unwrap().language_servers.len(), 1);
+    });
+}
+
 fn init_logger() {
     if std::env::var("RUST_LOG").is_ok() {
         env_logger::try_init().ok();
diff --git a/crates/repl/src/repl_editor.rs b/crates/repl/src/repl_editor.rs
index 112cf591e99398..868594aaf18185 100644
--- a/crates/repl/src/repl_editor.rs
+++ b/crates/repl/src/repl_editor.rs
@@ -6,7 +6,7 @@ use std::sync::Arc;
 use anyhow::{Context, Result};
 use editor::Editor;
 use gpui::{prelude::*, AppContext, Entity, View, WeakView, WindowContext};
-use language::{BufferSnapshot, Language, Point};
+use language::{BufferSnapshot, Language, LanguageName, Point};
 
 use crate::repl_store::ReplStore;
 use crate::session::SessionEvent;
@@ -99,7 +99,7 @@ pub fn run(editor: WeakView<Editor>, move_down: bool, cx: &mut WindowContext) ->
 pub enum SessionSupport {
     ActiveSession(View<Session>),
     Inactive(Box<KernelSpecification>),
-    RequiresSetup(Arc<str>),
+    RequiresSetup(LanguageName),
     Unsupported,
 }
 
@@ -268,7 +268,7 @@ fn runnable_ranges(
     range: Range<Point>,
 ) -> (Vec<Range<Point>>, Option<Point>) {
     if let Some(language) = buffer.language() {
-        if language.name().as_ref() == "Markdown" {
+        if language.name() == "Markdown".into() {
             return (markdown_code_blocks(buffer, range.clone()), None);
         }
     }
@@ -305,7 +305,7 @@ fn markdown_code_blocks(buffer: &BufferSnapshot, range: Range<Point>) -> Vec<Ran
 }
 
 fn language_supported(language: &Arc<Language>) -> bool {
-    match language.name().as_ref() {
+    match language.name().0.as_ref() {
         "TypeScript" | "Python" => true,
         _ => false,
     }
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index 82aad401a4d858..c6e64deb59d1b1 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -564,6 +564,13 @@ impl Worktree {
         !self.is_local()
     }
 
+    pub fn settings_location(&self, _: &ModelContext<Self>) -> SettingsLocation<'static> {
+        SettingsLocation {
+            worktree_id: self.id(),
+            path: Path::new(EMPTY_PATH),
+        }
+    }
+
     pub fn snapshot(&self) -> Snapshot {
         match self {
             Worktree::Local(worktree) => worktree.snapshot.snapshot.clone(),
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index 9ec43d607ae519..93fee57ecdb654 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -2251,14 +2251,8 @@ mod tests {
                     assert!(!editor.is_dirty(cx));
                     assert_eq!(editor.title(cx), "the-new-name.rs");
                     assert_eq!(
-                        editor
-                            .buffer()
-                            .read(cx)
-                            .language_at(0, cx)
-                            .unwrap()
-                            .name()
-                            .as_ref(),
-                        "Rust"
+                        editor.buffer().read(cx).language_at(0, cx).unwrap().name(),
+                        "Rust".into()
                     );
                 });
             })
@@ -2374,14 +2368,8 @@ mod tests {
                 editor.update(cx, |editor, cx| {
                     assert!(!editor.is_dirty(cx));
                     assert_eq!(
-                        editor
-                            .buffer()
-                            .read(cx)
-                            .language_at(0, cx)
-                            .unwrap()
-                            .name()
-                            .as_ref(),
-                        "Rust"
+                        editor.buffer().read(cx).language_at(0, cx).unwrap().name(),
+                        "Rust".into()
                     )
                 });
             })

From 19463b59e2fb9ea2c14bf5f75c16891ca9e204f5 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 10 Sep 2024 16:12:45 -0400
Subject: [PATCH 030/762] Add docs for search settings (#17662)

---
 docs/src/configuring-zed.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index b935a8b824ccf0..82f5a244845b57 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -1134,6 +1134,21 @@ These values take in the same options as the root-level settings with the same n
 
 `boolean` values
 
+## Search
+
+- Description: Search options to enable by default when opening new project and buffer searches.
+- Setting: `search`
+- Default:
+
+```
+"search": {
+  "whole_word": false,
+  "case_sensitive": false,
+  "include_ignored": false,
+  "regex": false
+},
+```
+
 ## Show Call Status Icon
 
 - Description: Whether or not to show the call status icon in the status bar.

From 48a16f9e70715316c0d189d9053963742dd79140 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 10 Sep 2024 16:41:29 -0400
Subject: [PATCH 031/762] ssh: Lookup language servers in env on SSH host
 (#17658)

Release Notes:

- ssh remoting: Lookup language server binaries in environment on SSH
host

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/assistant/src/assistant_panel.rs      |   2 +-
 crates/language/src/language.rs              |   8 +
 crates/project/src/lsp_store.rs              | 159 +++++++++++++++----
 crates/proto/proto/zed.proto                 |  28 +++-
 crates/proto/src/proto.rs                    |  14 +-
 crates/remote_server/src/headless_project.rs |   2 +
 6 files changed, 181 insertions(+), 32 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 7eebc97b1d91e8..a0d4cbcf815dab 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -5349,7 +5349,7 @@ fn make_lsp_adapter_delegate(
         let http_client = project.client().http_client().clone();
         project.lsp_store().update(cx, |lsp_store, cx| {
             Ok(
-                ProjectLspAdapterDelegate::new(lsp_store, &worktree, http_client, fs, cx)
+                ProjectLspAdapterDelegate::new(lsp_store, &worktree, http_client, fs, None, cx)
                     as Arc<dyn LspAdapterDelegate>,
             )
         })
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index 6424da8a54280e..cd39490d0bbdf4 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -1651,6 +1651,14 @@ impl LspAdapter for FakeLspAdapter {
         LanguageServerName(self.name.into())
     }
 
+    async fn check_if_user_installed(
+        &self,
+        _: &dyn LspAdapterDelegate,
+        _: &AsyncAppContext,
+    ) -> Option<LanguageServerBinary> {
+        Some(self.language_server_binary.clone())
+    }
+
     fn get_language_server_command<'a>(
         self: Arc<Self>,
         _: Arc<Path>,
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index b218ac58042f11..3b6b9ebb0a636d 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -442,6 +442,17 @@ impl LspStore {
         }
     }
 
+    fn worktree_for_id(
+        &self,
+        worktree_id: WorktreeId,
+        cx: &ModelContext<Self>,
+    ) -> Result<Model<Worktree>> {
+        self.worktree_store
+            .read(cx)
+            .worktree_for_id(worktree_id, cx)
+            .ok_or_else(|| anyhow!("worktree not found"))
+    }
+
     fn on_buffer_store_event(
         &mut self,
         _: Model<BufferStore>,
@@ -4287,6 +4298,7 @@ impl LspStore {
             .ok_or_else(|| anyhow!("missing language"))?;
         let language_name = LanguageName::from_proto(language.name);
         let matcher: LanguageMatcher = serde_json::from_str(&language.matcher)?;
+
         this.update(&mut cx, |this, cx| {
             this.languages
                 .register_language(language_name.clone(), None, matcher.clone(), {
@@ -4334,6 +4346,47 @@ impl LspStore {
         Ok(proto::Ack {})
     }
 
+    pub async fn handle_which_command(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::WhichCommand>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::WhichCommandResponse> {
+        let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
+        let command = PathBuf::from(envelope.payload.command);
+        let response = this
+            .update(&mut cx, |this, cx| {
+                let worktree = this.worktree_for_id(worktree_id, cx)?;
+                let delegate = ProjectLspAdapterDelegate::for_local(this, &worktree, cx);
+                anyhow::Ok(
+                    cx.spawn(|_, _| async move { delegate.which(command.as_os_str()).await }),
+                )
+            })??
+            .await;
+
+        Ok(proto::WhichCommandResponse {
+            path: response.map(|path| path.to_string_lossy().to_string()),
+        })
+    }
+
+    pub async fn handle_shell_env(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::ShellEnv>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::ShellEnvResponse> {
+        let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
+        let response = this
+            .update(&mut cx, |this, cx| {
+                let worktree = this.worktree_for_id(worktree_id, cx)?;
+                let delegate = ProjectLspAdapterDelegate::for_local(this, &worktree, cx);
+                anyhow::Ok(cx.spawn(|_, _| async move { delegate.shell_env().await }))
+            })??
+            .await;
+
+        Ok(proto::ShellEnvResponse {
+            env: response.into_iter().collect(),
+        })
+    }
+
     async fn handle_apply_additional_edits_for_completion(
         this: Model<Self>,
         envelope: TypedEnvelope<proto::ApplyCompletionAdditionalEdits>,
@@ -4478,39 +4531,34 @@ impl LspStore {
     ) {
         let ssh = self.as_ssh().unwrap();
 
-        let configured_binary = ProjectSettings::get(
-            Some(worktree.update(cx, |worktree, cx| worktree.settings_location(cx))),
-            cx,
-        )
-        .lsp
-        .get(&adapter.name())
-        .and_then(|c| c.binary.as_ref())
-        .and_then(|config| {
-            if let Some(path) = &config.path {
-                Some((path.clone(), config.arguments.clone().unwrap_or_default()))
-            } else {
-                None
-            }
-        });
         let delegate =
-            ProjectLspAdapterDelegate::for_ssh(self, worktree, cx) as Arc<dyn LspAdapterDelegate>;
+            ProjectLspAdapterDelegate::for_ssh(self, worktree, ssh.upstream_client.clone(), cx)
+                as Arc<dyn LspAdapterDelegate>;
+
+        // TODO: We should use `adapter` here instead of reaching through the `CachedLspAdapter`.
+        let lsp_adapter = adapter.adapter.clone();
+
         let project_id = self.project_id;
         let worktree_id = worktree.read(cx).id().to_proto();
         let upstream_client = ssh.upstream_client.clone();
         let name = adapter.name().to_string();
-        let Some((path, arguments)) = configured_binary else {
-            cx.emit(LspStoreEvent::Notification(format!(
-                "ssh-remoting currently requires manually configuring {} in your settings",
-                adapter.name()
-            )));
-            return;
-        };
+
         let Some(available_language) = self.languages.available_language_for_name(&language) else {
             log::error!("failed to find available language {language}");
             return;
         };
-        let task = cx.spawn(|_, _| async move {
-            let delegate = delegate;
+
+        let task = cx.spawn(|_, cx| async move {
+            let user_binary_task = lsp_adapter.check_if_user_installed(delegate.as_ref(), &cx);
+            let binary = match user_binary_task.await {
+                Some(binary) => binary,
+                None => {
+                    return Err(anyhow!(
+                        "Downloading language server for ssh host is not supported yet"
+                    ))
+                }
+            };
+
             let name = adapter.name().to_string();
             let code_action_kinds = adapter
                 .adapter
@@ -4523,12 +4571,22 @@ impl LspStore {
                 .map(|options| serde_json::to_string(&options))
                 .transpose()?;
 
+            let language_server_command = proto::LanguageServerCommand {
+                path: binary.path.to_string_lossy().to_string(),
+                arguments: binary
+                    .arguments
+                    .iter()
+                    .map(|args| args.to_string_lossy().to_string())
+                    .collect(),
+                env: binary.env.unwrap_or_default().into_iter().collect(),
+            };
+
             upstream_client
                 .request(proto::CreateLanguageServer {
                     project_id,
                     worktree_id,
                     name,
-                    binary: Some(proto::LanguageServerCommand { path, arguments }),
+                    binary: Some(language_server_command),
                     initialization_options,
                     code_action_kinds,
                     language: Some(proto::AvailableLanguage {
@@ -6890,6 +6948,7 @@ pub struct ProjectLspAdapterDelegate {
     http_client: Arc<dyn HttpClient>,
     language_registry: Arc<LanguageRegistry>,
     load_shell_env_task: Shared<Task<Option<HashMap<String, String>>>>,
+    upstream_client: Option<AnyProtoClient>,
 }
 
 impl ProjectLspAdapterDelegate {
@@ -6907,15 +6966,30 @@ impl ProjectLspAdapterDelegate {
             .clone()
             .unwrap_or_else(|| Arc::new(BlockedHttpClient));
 
-        Self::new(lsp_store, worktree, http_client, Some(local.fs.clone()), cx)
+        Self::new(
+            lsp_store,
+            worktree,
+            http_client,
+            Some(local.fs.clone()),
+            None,
+            cx,
+        )
     }
 
     fn for_ssh(
         lsp_store: &LspStore,
         worktree: &Model<Worktree>,
+        upstream_client: AnyProtoClient,
         cx: &mut ModelContext<LspStore>,
     ) -> Arc<Self> {
-        Self::new(lsp_store, worktree, Arc::new(BlockedHttpClient), None, cx)
+        Self::new(
+            lsp_store,
+            worktree,
+            Arc::new(BlockedHttpClient),
+            None,
+            Some(upstream_client),
+            cx,
+        )
     }
 
     pub fn new(
@@ -6923,6 +6997,7 @@ impl ProjectLspAdapterDelegate {
         worktree: &Model<Worktree>,
         http_client: Arc<dyn HttpClient>,
         fs: Option<Arc<dyn Fs>>,
+        upstream_client: Option<AnyProtoClient>,
         cx: &mut ModelContext<LspStore>,
     ) -> Arc<Self> {
         let worktree_id = worktree.read(cx).id();
@@ -6942,6 +7017,7 @@ impl ProjectLspAdapterDelegate {
             worktree: worktree.read(cx).snapshot(),
             fs,
             http_client,
+            upstream_client,
             language_registry: lsp_store.languages.clone(),
             load_shell_env_task,
         })
@@ -6991,13 +7067,42 @@ impl LspAdapterDelegate for ProjectLspAdapterDelegate {
     }
 
     async fn shell_env(&self) -> HashMap<String, String> {
+        if let Some(upstream_client) = &self.upstream_client {
+            use rpc::proto::SSH_PROJECT_ID;
+
+            return upstream_client
+                .request(proto::ShellEnv {
+                    project_id: SSH_PROJECT_ID,
+                    worktree_id: self.worktree_id().to_proto(),
+                })
+                .await
+                .map(|response| response.env.into_iter().collect())
+                .unwrap_or_default();
+        }
+
         let task = self.load_shell_env_task.clone();
         task.await.unwrap_or_default()
     }
 
     #[cfg(not(target_os = "windows"))]
     async fn which(&self, command: &OsStr) -> Option<PathBuf> {
+        if let Some(upstream_client) = &self.upstream_client {
+            use rpc::proto::SSH_PROJECT_ID;
+
+            return upstream_client
+                .request(proto::WhichCommand {
+                    project_id: SSH_PROJECT_ID,
+                    worktree_id: self.worktree_id().to_proto(),
+                    command: command.to_string_lossy().to_string(),
+                })
+                .await
+                .log_err()
+                .and_then(|response| response.path)
+                .map(PathBuf::from);
+        }
+
         self.fs.as_ref()?;
+
         let worktree_abs_path = self.worktree.abs_path();
         let shell_path = self.shell_env().await.get("PATH").cloned();
         which::which_in(command, shell_path.as_ref(), worktree_abs_path).ok()
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index b24d9399655b11..e5d767fffb3fae 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -283,7 +283,13 @@ message Envelope {
         CloseBuffer close_buffer = 245;
         UpdateUserSettings update_user_settings = 246;
 
-        CreateLanguageServer create_language_server = 247; // current max
+        CreateLanguageServer create_language_server = 247;
+
+        WhichCommand which_command = 248;
+        WhichCommandResponse which_command_response = 249;
+
+        ShellEnv shell_env = 250;
+        ShellEnvResponse shell_env_response = 251; // current max
     }
 
     reserved 158 to 161;
@@ -2503,6 +2509,7 @@ message UpdateUserSettings {
 message LanguageServerCommand {
    string path = 1;
    repeated string arguments = 2;
+   map<string, string> env = 3;
 }
 
 message AvailableLanguage {
@@ -2522,6 +2529,25 @@ message CreateLanguageServer {
     AvailableLanguage language = 7;
 }
 
+message WhichCommand {
+    uint64 project_id = 1;
+    uint64 worktree_id = 2;
+    string command = 3;
+}
+
+message WhichCommandResponse {
+    optional string path = 1;
+}
+
+message ShellEnv {
+    uint64 project_id = 1;
+    uint64 worktree_id = 2;
+}
+
+message ShellEnvResponse {
+    map<string, string> env = 1;
+}
+
 // message RestartLanguageServer {
 
 // }
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 44cb91db1080b8..7af66a6a6be093 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -367,7 +367,11 @@ messages!(
     (FindSearchCandidatesResponse, Background),
     (CloseBuffer, Foreground),
     (UpdateUserSettings, Foreground),
-    (CreateLanguageServer, Foreground)
+    (CreateLanguageServer, Foreground),
+    (WhichCommand, Foreground),
+    (WhichCommandResponse, Foreground),
+    (ShellEnv, Foreground),
+    (ShellEnvResponse, Foreground),
 );
 
 request_messages!(
@@ -491,7 +495,9 @@ request_messages!(
     (SynchronizeContexts, SynchronizeContextsResponse),
     (LspExtSwitchSourceHeader, LspExtSwitchSourceHeaderResponse),
     (AddWorktree, AddWorktreeResponse),
-    (CreateLanguageServer, Ack)
+    (CreateLanguageServer, Ack),
+    (WhichCommand, WhichCommandResponse),
+    (ShellEnv, ShellEnvResponse)
 );
 
 entity_messages!(
@@ -565,7 +571,9 @@ entity_messages!(
     SynchronizeContexts,
     LspExtSwitchSourceHeader,
     UpdateUserSettings,
-    CreateLanguageServer
+    CreateLanguageServer,
+    WhichCommand,
+    ShellEnv
 );
 
 entity_messages!(
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index ca5fe06e137c7f..e654e2a190ca73 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -89,6 +89,8 @@ impl HeadlessProject {
         client.add_model_message_handler(BufferStore::handle_close_buffer);
 
         client.add_model_request_handler(LspStore::handle_create_language_server);
+        client.add_model_request_handler(LspStore::handle_which_command);
+        client.add_model_request_handler(LspStore::handle_shell_env);
 
         BufferStore::init(&client);
         WorktreeStore::init(&client);

From 3cea7ccbff438c331ce6e11cd9de78a7c3b1e1b0 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Tue, 10 Sep 2024 17:26:06 -0400
Subject: [PATCH 032/762] pane: Fix pinned tabs being persisted after closing
 (#17666)

Release Notes:

- Fixed tabs staying pinned after closing unrelated tabs
---
 crates/workspace/src/pane.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index e2a77402de70a7..23148d6376f456 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -1364,6 +1364,9 @@ impl Pane {
         self.activation_history
             .retain(|entry| entry.entity_id != self.items[item_index].item_id());
 
+        if self.is_tab_pinned(item_index) {
+            self.pinned_tab_count -= 1;
+        }
         if item_index == self.active_item_index {
             let index_to_activate = self
                 .activation_history

From 3ff81c2e864d3bdbc576a099c055478b5ad7f0e6 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 10 Sep 2024 17:37:26 -0400
Subject: [PATCH 033/762] assistant: Simplify image insertion (#17668)

This PR simplifies how images are inserted into the context editor.

We don't need to hold the `images` in a `HashMap` on the `Context`, as
we were only inserting them to pull them out again.

Release Notes:

- N/A
---
 crates/assistant/src/assistant_panel.rs | 19 ++++++++++--
 crates/assistant/src/context.rs         | 39 ++-----------------------
 2 files changed, 19 insertions(+), 39 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index a0d4cbcf815dab..634f2231cd4f51 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -34,6 +34,7 @@ use editor::{
 };
 use editor::{display_map::CreaseId, FoldPlaceholder};
 use fs::Fs;
+use futures::FutureExt;
 use gpui::{
     canvas, div, img, percentage, point, pulsating_between, size, Action, Animation, AnimationExt,
     AnyElement, AnyView, AppContext, AsyncWindowContext, ClipboardEntry, ClipboardItem,
@@ -46,11 +47,11 @@ use indexed_docs::IndexedDocsStore;
 use language::{
     language_settings::SoftWrap, Capability, LanguageRegistry, LspAdapterDelegate, Point, ToOffset,
 };
-use language_model::LanguageModelToolUse;
 use language_model::{
     provider::cloud::PROVIDER_ID, LanguageModelProvider, LanguageModelProviderId,
     LanguageModelRegistry, Role,
 };
+use language_model::{LanguageModelImage, LanguageModelToolUse};
 use multi_buffer::MultiBufferRow;
 use picker::{Picker, PickerDelegate};
 use project::lsp_store::ProjectLspAdapterDelegate;
@@ -3551,10 +3552,22 @@ impl ContextEditor {
 
             self.context.update(cx, |context, cx| {
                 for image in images {
+                    let Some(render_image) = image.to_image_data(cx).log_err() else {
+                        continue;
+                    };
                     let image_id = image.id();
-                    context.insert_image(image, cx);
+                    let image_task = LanguageModelImage::from_image(image, cx).shared();
+
                     for image_position in image_positions.iter() {
-                        context.insert_image_content(image_id, image_position.text_anchor, cx);
+                        context.insert_content(
+                            Content::Image {
+                                anchor: image_position.text_anchor,
+                                image_id,
+                                image: image_task.clone(),
+                                render_image: render_image.clone(),
+                            },
+                            cx,
+                        );
                     }
                 }
             });
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index e43ec203e96752..7702207d8d2ad9 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -20,8 +20,8 @@ use futures::{
     FutureExt, StreamExt,
 };
 use gpui::{
-    AppContext, AsyncAppContext, Context as _, EventEmitter, Image, Model, ModelContext,
-    RenderImage, SharedString, Subscription, Task,
+    AppContext, AsyncAppContext, Context as _, EventEmitter, Model, ModelContext, RenderImage,
+    SharedString, Subscription, Task,
 };
 
 use language::{AnchorRangeExt, Bias, Buffer, LanguageRegistry, OffsetRangeExt, Point, ToOffset};
@@ -38,7 +38,6 @@ use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use std::{
     cmp::{self, max, Ordering},
-    collections::hash_map,
     fmt::Debug,
     iter, mem,
     ops::Range,
@@ -49,7 +48,7 @@ use std::{
 };
 use telemetry_events::AssistantKind;
 use text::BufferSnapshot;
-use util::{post_inc, ResultExt, TryFutureExt};
+use util::{post_inc, TryFutureExt};
 use uuid::Uuid;
 
 #[derive(Clone, Eq, PartialEq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
@@ -468,7 +467,6 @@ pub struct Context {
     slash_command_output_sections: Vec<SlashCommandOutputSection<language::Anchor>>,
     pending_tool_uses_by_id: HashMap<Arc<str>, PendingToolUse>,
     message_anchors: Vec<MessageAnchor>,
-    images: HashMap<u64, (Arc<RenderImage>, Shared<Task<Option<LanguageModelImage>>>)>,
     contents: Vec<Content>,
     messages_metadata: HashMap<MessageId, MessageMetadata>,
     summary: Option<ContextSummary>,
@@ -564,7 +562,6 @@ impl Context {
             operations: Vec::new(),
             message_anchors: Default::default(),
             contents: Default::default(),
-            images: Default::default(),
             messages_metadata: Default::default(),
             pending_slash_commands: Vec::new(),
             finished_slash_commands: HashSet::default(),
@@ -2374,36 +2371,6 @@ impl Context {
         }
     }
 
-    pub fn insert_image(&mut self, image: Image, cx: &mut ModelContext<Self>) -> Option<()> {
-        if let hash_map::Entry::Vacant(entry) = self.images.entry(image.id()) {
-            entry.insert((
-                image.to_image_data(cx).log_err()?,
-                LanguageModelImage::from_image(image, cx).shared(),
-            ));
-        }
-
-        Some(())
-    }
-
-    pub fn insert_image_content(
-        &mut self,
-        image_id: u64,
-        anchor: language::Anchor,
-        cx: &mut ModelContext<Self>,
-    ) {
-        if let Some((render_image, image)) = self.images.get(&image_id) {
-            self.insert_content(
-                Content::Image {
-                    anchor,
-                    image_id,
-                    image: image.clone(),
-                    render_image: render_image.clone(),
-                },
-                cx,
-            );
-        }
-    }
-
     pub fn insert_content(&mut self, content: Content, cx: &mut ModelContext<Self>) {
         let buffer = self.buffer.read(cx);
         let insertion_ix = match self

From b16af138e20d054d7bc4a17be51420dac2bb26f7 Mon Sep 17 00:00:00 2001
From: Fernando Tagawa <fernando.tagawa.gamail.com@gmail.com>
Date: Tue, 10 Sep 2024 18:41:37 -0300
Subject: [PATCH 034/762] php: Add auto-indent (#17545)

Release Notes:

- N/A
---
 extensions/php/languages/php/indents.scm | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 extensions/php/languages/php/indents.scm

diff --git a/extensions/php/languages/php/indents.scm b/extensions/php/languages/php/indents.scm
new file mode 100644
index 00000000000000..e9754690920500
--- /dev/null
+++ b/extensions/php/languages/php/indents.scm
@@ -0,0 +1 @@
+(_ "{" "}" @end) @indent

From d6663fcb29fcc477e4e0a05115561690ad1b7854 Mon Sep 17 00:00:00 2001
From: maan2003 <49202620+maan2003@users.noreply.github.com>
Date: Wed, 11 Sep 2024 03:39:00 +0530
Subject: [PATCH 035/762] Pass temperature to Anthropic (#17509)

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 crates/assistant/src/inline_assistant.rs | 15 +--------------
 crates/language_model/src/request.rs     |  2 +-
 2 files changed, 2 insertions(+), 15 deletions(-)

diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index 051db0f2476bf3..246a408477bb6e 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -2373,19 +2373,6 @@ impl Codegen {
             None
         };
 
-        // Higher Temperature increases the randomness of model outputs.
-        // If Markdown or No Language is Known, increase the randomness for more creative output
-        // If Code, decrease temperature to get more deterministic outputs
-        let temperature = if let Some(language) = language_name.clone() {
-            if language == "Markdown".into() {
-                1.0
-            } else {
-                0.5
-            }
-        } else {
-            1.0
-        };
-
         let language_name = language_name.as_ref();
         let start = buffer.point_to_buffer_offset(edit_range.start);
         let end = buffer.point_to_buffer_offset(edit_range.end);
@@ -2421,7 +2408,7 @@ impl Codegen {
             messages,
             tools: Vec::new(),
             stop: vec!["|END|>".to_string()],
-            temperature,
+            temperature: 1.,
         })
     }
 
diff --git a/crates/language_model/src/request.rs b/crates/language_model/src/request.rs
index 7549785b3bdaad..4162e9df87037a 100644
--- a/crates/language_model/src/request.rs
+++ b/crates/language_model/src/request.rs
@@ -399,7 +399,7 @@ impl LanguageModelRequest {
             tool_choice: None,
             metadata: None,
             stop_sequences: Vec::new(),
-            temperature: None,
+            temperature: Some(self.temperature),
             top_k: None,
             top_p: None,
         }

From d1a47faeb7295a4ec450ad26191e8a65047805c9 Mon Sep 17 00:00:00 2001
From: Bedis Nbiba <bedisnbiba@gmail.com>
Date: Tue, 10 Sep 2024 23:26:11 +0100
Subject: [PATCH 036/762] docs: Update Deno docs (#17579)

add the minimal configuration needed to make deno lsp work

Release Notes:

- N/A
---
 docs/src/languages/deno.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/docs/src/languages/deno.md b/docs/src/languages/deno.md
index 3b5e4a1ff9d746..5b92acfeeb049b 100644
--- a/docs/src/languages/deno.md
+++ b/docs/src/languages/deno.md
@@ -10,6 +10,15 @@ To use the Deno Language Server with TypeScript and TSX files, you will likely w
 
 ```json
 {
+  "lsp": {
+    "deno": {
+      "settings": {
+        "deno": {
+          "enable": true
+        }
+      }
+    }
+  },
   "languages": {
     "TypeScript": {
       "language_servers": [

From f374038da0e9dbe81e29b42df29f6c42ab39c378 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Tue, 10 Sep 2024 19:19:21 -0400
Subject: [PATCH 037/762] pane: Serialize pinned tab state (#17670)

Release Notes:

- Tab pin state is now persisted across Zed runs.
---
 crates/workspace/src/pane.rs              |  8 ++++++
 crates/workspace/src/persistence.rs       | 34 ++++++++++++++++++-----
 crates/workspace/src/persistence/model.rs | 13 +++++++--
 crates/workspace/src/workspace.rs         |  5 ++--
 4 files changed, 49 insertions(+), 11 deletions(-)

diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index 23148d6376f456..cc752f7aec9ff6 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -715,6 +715,14 @@ impl Pane {
         }
     }
 
+    pub(crate) fn set_pinned_count(&mut self, count: usize) {
+        self.pinned_tab_count = count;
+    }
+
+    pub(crate) fn pinned_count(&self) -> usize {
+        self.pinned_tab_count
+    }
+
     pub fn handle_item_edit(&mut self, item_id: EntityId, cx: &AppContext) {
         if let Some(preview_item) = self.preview_item() {
             if preview_item.item_id() == item_id && !preview_item.preserve_preview(cx) {
diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs
index d035b35c1079e1..88ede4228d622d 100644
--- a/crates/workspace/src/persistence.rs
+++ b/crates/workspace/src/persistence.rs
@@ -13,7 +13,7 @@ use sqlez::{
 };
 
 use ui::px;
-use util::ResultExt;
+use util::{maybe, ResultExt};
 use uuid::Uuid;
 
 use crate::WorkspaceId;
@@ -352,6 +352,9 @@ define_connection! {
     sql!(
         ALTER TABLE workspaces ADD COLUMN window_id INTEGER DEFAULT NULL;
     ),
+    sql!(
+        ALTER TABLE panes ADD COLUMN pinned_count INTEGER DEFAULT 0;
+    )
     ];
 }
 
@@ -846,6 +849,7 @@ impl WorkspaceDb {
                 SerializedPaneGroup::Pane(SerializedPane {
                     active: true,
                     children: vec![],
+                    pinned_count: 0,
                 })
             }))
     }
@@ -861,15 +865,17 @@ impl WorkspaceDb {
             Option<SerializedAxis>,
             Option<PaneId>,
             Option<bool>,
+            Option<usize>,
             Option<String>,
         );
         self.select_bound::<GroupKey, GroupOrPane>(sql!(
-            SELECT group_id, axis, pane_id, active, flexes
+            SELECT group_id, axis, pane_id, active, pinned_count, flexes
                 FROM (SELECT
                         group_id,
                         axis,
                         NULL as pane_id,
                         NULL as active,
+                        NULL as pinned_count,
                         position,
                         parent_group_id,
                         workspace_id,
@@ -881,6 +887,7 @@ impl WorkspaceDb {
                         NULL,
                         center_panes.pane_id,
                         panes.active as active,
+                        pinned_count,
                         position,
                         parent_group_id,
                         panes.workspace_id as workspace_id,
@@ -891,7 +898,8 @@ impl WorkspaceDb {
                 ORDER BY position
         ))?((group_id, workspace_id))?
         .into_iter()
-        .map(|(group_id, axis, pane_id, active, flexes)| {
+        .map(|(group_id, axis, pane_id, active, pinned_count, flexes)| {
+            let maybe_pane = maybe!({ Some((pane_id?, active?, pinned_count?)) });
             if let Some((group_id, axis)) = group_id.zip(axis) {
                 let flexes = flexes
                     .map(|flexes: String| serde_json::from_str::<Vec<f32>>(&flexes))
@@ -902,10 +910,11 @@ impl WorkspaceDb {
                     children: self.get_pane_group(workspace_id, Some(group_id))?,
                     flexes,
                 })
-            } else if let Some((pane_id, active)) = pane_id.zip(active) {
+            } else if let Some((pane_id, active, pinned_count)) = maybe_pane {
                 Ok(SerializedPaneGroup::Pane(SerializedPane::new(
                     self.get_items(pane_id)?,
                     active,
+                    pinned_count,
                 )))
             } else {
                 bail!("Pane Group Child was neither a pane group or a pane");
@@ -977,10 +986,10 @@ impl WorkspaceDb {
         parent: Option<(GroupId, usize)>,
     ) -> Result<PaneId> {
         let pane_id = conn.select_row_bound::<_, i64>(sql!(
-            INSERT INTO panes(workspace_id, active)
-            VALUES (?, ?)
+            INSERT INTO panes(workspace_id, active, pinned_count)
+            VALUES (?, ?, ?)
             RETURNING pane_id
-        ))?((workspace_id, pane.active))?
+        ))?((workspace_id, pane.active, pane.pinned_count))?
         .ok_or_else(|| anyhow!("Could not retrieve inserted pane_id"))?;
 
         let (parent_id, order) = parent.unzip();
@@ -1219,6 +1228,7 @@ mod tests {
                                 SerializedItem::new("Terminal", 6, true, false),
                             ],
                             false,
+                            0,
                         )),
                         SerializedPaneGroup::Pane(SerializedPane::new(
                             vec![
@@ -1226,6 +1236,7 @@ mod tests {
                                 SerializedItem::new("Terminal", 8, false, false),
                             ],
                             false,
+                            0,
                         )),
                     ],
                 ),
@@ -1235,6 +1246,7 @@ mod tests {
                         SerializedItem::new("Terminal", 10, true, false),
                     ],
                     false,
+                    0,
                 )),
             ],
         );
@@ -1523,6 +1535,7 @@ mod tests {
                                 SerializedItem::new("Terminal", 2, true, false),
                             ],
                             false,
+                            0,
                         )),
                         SerializedPaneGroup::Pane(SerializedPane::new(
                             vec![
@@ -1530,6 +1543,7 @@ mod tests {
                                 SerializedItem::new("Terminal", 3, true, false),
                             ],
                             true,
+                            0,
                         )),
                     ],
                 ),
@@ -1539,6 +1553,7 @@ mod tests {
                         SerializedItem::new("Terminal", 6, false, false),
                     ],
                     false,
+                    0,
                 )),
             ],
         );
@@ -1570,6 +1585,7 @@ mod tests {
                                 SerializedItem::new("Terminal", 2, true, false),
                             ],
                             false,
+                            0,
                         )),
                         SerializedPaneGroup::Pane(SerializedPane::new(
                             vec![
@@ -1577,6 +1593,7 @@ mod tests {
                                 SerializedItem::new("Terminal", 3, true, false),
                             ],
                             true,
+                            0,
                         )),
                     ],
                 ),
@@ -1586,6 +1603,7 @@ mod tests {
                         SerializedItem::new("Terminal", 6, true, false),
                     ],
                     false,
+                    0,
                 )),
             ],
         );
@@ -1605,6 +1623,7 @@ mod tests {
                         SerializedItem::new("Terminal", 2, true, false),
                     ],
                     false,
+                    0,
                 )),
                 SerializedPaneGroup::Pane(SerializedPane::new(
                     vec![
@@ -1612,6 +1631,7 @@ mod tests {
                         SerializedItem::new("Terminal", 3, false, false),
                     ],
                     true,
+                    0,
                 )),
             ],
         );
diff --git a/crates/workspace/src/persistence/model.rs b/crates/workspace/src/persistence/model.rs
index 8b6d66f3cb4d6e..d6f8001f25fc3e 100644
--- a/crates/workspace/src/persistence/model.rs
+++ b/crates/workspace/src/persistence/model.rs
@@ -297,6 +297,7 @@ impl Default for SerializedPaneGroup {
         Self::Pane(SerializedPane {
             children: vec![SerializedItem::default()],
             active: false,
+            pinned_count: 0,
         })
     }
 }
@@ -379,11 +380,16 @@ impl SerializedPaneGroup {
 pub struct SerializedPane {
     pub(crate) active: bool,
     pub(crate) children: Vec<SerializedItem>,
+    pub(crate) pinned_count: usize,
 }
 
 impl SerializedPane {
-    pub fn new(children: Vec<SerializedItem>, active: bool) -> Self {
-        SerializedPane { children, active }
+    pub fn new(children: Vec<SerializedItem>, active: bool, pinned_count: usize) -> Self {
+        SerializedPane {
+            children,
+            active,
+            pinned_count,
+        }
     }
 
     pub async fn deserialize_to(
@@ -442,6 +448,9 @@ impl SerializedPane {
                 }
             })?;
         }
+        pane.update(cx, |pane, _| {
+            pane.set_pinned_count(self.pinned_count);
+        })?;
 
         anyhow::Ok(items)
     }
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 219f75624c8ffd..7371e56cee2376 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -4025,7 +4025,7 @@ impl Workspace {
         };
 
         fn serialize_pane_handle(pane_handle: &View<Pane>, cx: &WindowContext) -> SerializedPane {
-            let (items, active) = {
+            let (items, active, pinned_count) = {
                 let pane = pane_handle.read(cx);
                 let active_item_id = pane.active_item().map(|item| item.item_id());
                 (
@@ -4042,10 +4042,11 @@ impl Workspace {
                         })
                         .collect::<Vec<_>>(),
                     pane.has_focus(cx),
+                    pane.pinned_count(),
                 )
             };
 
-            SerializedPane::new(items, active)
+            SerializedPane::new(items, active, pinned_count)
         }
 
         fn build_serialized_pane_group(

From 8f284456126d53b69d639b159a33effa57bfa8cd Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 10 Sep 2024 22:57:44 -0400
Subject: [PATCH 038/762] php: Bump to v0.2.0 (#17674)

This PR bumps the PHP extension to v0.2.0.

Changes:

- https://github.com/zed-industries/zed/pull/16720
- https://github.com/zed-industries/zed/pull/16955
- https://github.com/zed-industries/zed/pull/17243
- https://github.com/zed-industries/zed/pull/17545

Release Notes:

- N/A
---
 Cargo.lock                    | 2 +-
 extensions/php/Cargo.toml     | 2 +-
 extensions/php/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f9d3240d682a93..07b97e030df7bc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14441,7 +14441,7 @@ dependencies = [
 
 [[package]]
 name = "zed_php"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
diff --git a/extensions/php/Cargo.toml b/extensions/php/Cargo.toml
index 91f309d9de07ad..d4a8f36cbdf83e 100644
--- a/extensions/php/Cargo.toml
+++ b/extensions/php/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_php"
-version = "0.1.3"
+version = "0.2.0"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/php/extension.toml b/extensions/php/extension.toml
index cb30eb5f0cd55f..92bd7ed85bc465 100644
--- a/extensions/php/extension.toml
+++ b/extensions/php/extension.toml
@@ -1,7 +1,7 @@
 id = "php"
 name = "PHP"
 description = "PHP support."
-version = "0.1.3"
+version = "0.2.0"
 schema_version = 1
 authors = ["Piotr Osiewicz <piotr@zed.dev>"]
 repository = "https://github.com/zed-industries/zed"

From ccf6f27b8f1bdfb803b9cc0da0b0cf5c9e136dd9 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Tue, 10 Sep 2024 22:59:10 -0400
Subject: [PATCH 039/762] settings: Remove auxiliary Content types where
 possible (#16744)

Release Notes:

- N/A
---
 crates/auto_update/src/auto_update.rs         |  23 +-
 crates/call/src/call_settings.rs              |  22 +-
 crates/client/src/client.rs                   |  50 ++-
 crates/collab/src/tests/editor_tests.rs       |   8 +-
 crates/collab/src/tests/following_tests.rs    |   2 +-
 crates/collab_ui/src/chat_panel.rs            |   2 +-
 .../src/chat_panel/message_editor.rs          |   8 +-
 crates/collab_ui/src/collab_panel.rs          |   2 +-
 crates/collab_ui/src/notification_panel.rs    |   2 +-
 crates/collab_ui/src/panel_settings.rs        |  74 ++--
 .../src/project_diagnostics_settings.rs       |  20 +-
 crates/editor/src/editor.rs                   |   4 +-
 crates/editor/src/editor_settings.rs          | 318 +++++++-----------
 crates/editor/src/editor_settings_controls.rs |  22 +-
 crates/editor/src/editor_tests.rs             |  18 +-
 crates/editor/src/element.rs                  |  17 +-
 crates/extension/src/extension_settings.rs    |  13 +-
 crates/extensions_ui/src/extensions_ui.rs     |   2 +-
 crates/go_to_line/src/cursor_position.rs      |  16 +-
 crates/gpui/src/geometry.rs                   |   2 +
 crates/language/src/language_settings.rs      |   8 +-
 crates/languages/src/json.rs                  |  29 +-
 crates/outline_panel/src/outline_panel.rs     |  16 +-
 .../src/outline_panel_settings.rs             |  72 ++--
 crates/performance/src/performance.rs         | 184 ++++++++++
 crates/project/src/project_settings.rs        |  41 +--
 crates/project_panel/src/project_panel.rs     |  28 +-
 .../src/project_panel_settings.rs             |  92 ++---
 crates/recent_projects/src/dev_servers.rs     |   3 +-
 crates/recent_projects/src/ssh_connections.rs |  25 +-
 crates/repl/src/jupyter_settings.rs           |  28 +-
 crates/tasks_ui/src/settings.rs               |  18 +-
 crates/vim/src/digraph.rs                     |   2 +-
 crates/vim/src/normal.rs                      |   6 +-
 crates/vim/src/normal/paste.rs                |  12 +-
 crates/vim/src/normal/scroll.rs               |   2 +-
 crates/vim/src/normal/search.rs               |   4 +-
 crates/vim/src/test.rs                        |   2 +-
 crates/vim/src/test/vim_test_context.rs       |   6 +-
 crates/vim/src/vim.rs                         |  32 +-
 crates/welcome/src/base_keymap_picker.rs      |   2 +-
 crates/welcome/src/base_keymap_setting.rs     |   6 +-
 crates/welcome/src/welcome.rs                 |   2 +-
 crates/workspace/src/item.rs                  |  70 ++--
 crates/workspace/src/workspace.rs             |   8 +-
 crates/workspace/src/workspace_settings.rs    | 132 ++++----
 crates/worktree/src/worktree_settings.rs      |  43 ++-
 crates/worktree/src/worktree_tests.rs         |  11 +-
 crates/zed/src/zed.rs                         |   2 +-
 49 files changed, 829 insertions(+), 682 deletions(-)
 create mode 100644 crates/performance/src/performance.rs

diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index 8063ff4c40fca3..499df7fc298594 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -116,27 +116,30 @@ impl Drop for MacOsUnmounter {
     }
 }
 
-struct AutoUpdateSetting(bool);
-
 /// Whether or not to automatically check for updates.
-///
-/// Default: true
-#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize)]
+#[derive(Clone, Copy, JsonSchema, Deserialize, Serialize)]
+#[serde(default)]
 #[serde(transparent)]
-struct AutoUpdateSettingContent(bool);
+struct AutoUpdateSetting(bool);
+
+impl Default for AutoUpdateSetting {
+    fn default() -> Self {
+        Self(true)
+    }
+}
 
 impl Settings for AutoUpdateSetting {
     const KEY: Option<&'static str> = Some("auto_update");
 
-    type FileContent = Option<AutoUpdateSettingContent>;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         let auto_update = [sources.release_channel, sources.user]
             .into_iter()
-            .find_map(|value| value.copied().flatten())
-            .unwrap_or(sources.default.ok_or_else(Self::missing_default)?);
+            .find_map(|value| value.copied())
+            .unwrap_or(*sources.default);
 
-        Ok(Self(auto_update.0))
+        Ok(auto_update)
     }
 }
 
diff --git a/crates/call/src/call_settings.rs b/crates/call/src/call_settings.rs
index 446178ffb982d0..e10b711734bb6d 100644
--- a/crates/call/src/call_settings.rs
+++ b/crates/call/src/call_settings.rs
@@ -4,30 +4,20 @@ use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-#[derive(Deserialize, Debug)]
-pub struct CallSettings {
-    pub mute_on_join: bool,
-    pub share_on_join: bool,
-}
-
 /// Configuration of voice calls in Zed.
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-pub struct CallSettingsContent {
+#[derive(Clone, Debug, Default, Deserialize, Serialize, JsonSchema)]
+#[serde(default)]
+pub struct CallSettings {
     /// Whether the microphone should be muted when joining a channel or a call.
-    ///
-    /// Default: false
-    pub mute_on_join: Option<bool>,
-
+    pub mute_on_join: bool,
     /// Whether your current project should be shared when joining an empty channel.
-    ///
-    /// Default: true
-    pub share_on_join: Option<bool>,
+    pub share_on_join: bool,
 }
 
 impl Settings for CallSettings {
     const KEY: Option<&'static str> = Some("calls");
 
-    type FileContent = CallSettingsContent;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 8787e2ed9675fe..83eef45be802bb 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -99,20 +99,26 @@ pub const CONNECTION_TIMEOUT: Duration = Duration::from_secs(20);
 
 actions!(client, [SignIn, SignOut, Reconnect]);
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct ClientSettingsContent {
-    server_url: Option<String>,
-}
-
-#[derive(Deserialize)]
+#[derive(Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 pub struct ClientSettings {
+    /// The server to connect to. If the environment variable
+    /// ZED_SERVER_URL is set, it will override this setting.
     pub server_url: String,
 }
 
+impl Default for ClientSettings {
+    fn default() -> Self {
+        Self {
+            server_url: "https://zed.dev".to_owned(),
+        }
+    }
+}
+
 impl Settings for ClientSettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = ClientSettingsContent;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         let mut result = sources.json_merge::<Self>()?;
@@ -124,19 +130,37 @@ impl Settings for ClientSettings {
 }
 
 #[derive(Default, Clone, Serialize, Deserialize, JsonSchema)]
-pub struct ProxySettingsContent {
-    proxy: Option<String>,
-}
-
-#[derive(Deserialize, Default)]
+#[serde(default)]
 pub struct ProxySettings {
+    /// Set a proxy to use. The proxy protocol is specified by the URI scheme.
+    ///
+    /// Supported URI scheme: `http`, `https`, `socks4`, `socks4a`, `socks5`,
+    /// `socks5h`. `http` will be used when no scheme is specified.
+    ///
+    /// By default no proxy will be used, or Zed will try get proxy settings from
+    /// environment variables.
+    ///
+    /// Examples:
+    ///   - "proxy": "socks5://localhost:10808"
+    ///   - "proxy": "http://127.0.0.1:10809"
+    #[schemars(example = "Self::example_1")]
+    #[schemars(example = "Self::example_2")]
     pub proxy: Option<String>,
 }
 
+impl ProxySettings {
+    fn example_1() -> String {
+        "http://127.0.0.1:10809".to_owned()
+    }
+    fn example_2() -> String {
+        "socks5://localhost:10808".to_owned()
+    }
+}
+
 impl Settings for ProxySettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = ProxySettingsContent;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         Ok(Self {
diff --git a/crates/collab/src/tests/editor_tests.rs b/crates/collab/src/tests/editor_tests.rs
index 3f205b7f937c96..a214291752a5ef 100644
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -2261,11 +2261,11 @@ async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestA
     cx_a.update(editor::init);
     cx_b.update(editor::init);
     // Turn inline-blame-off by default so no state is transferred without us explicitly doing so
-    let inline_blame_off_settings = Some(InlineBlameSettings {
+    let inline_blame_off_settings = InlineBlameSettings {
         enabled: false,
-        delay_ms: None,
-        min_column: None,
-    });
+        delay_ms: 0,
+        min_column: 0,
+    };
     cx_a.update(|cx| {
         SettingsStore::update_global(cx, |store, cx| {
             store.update_user_settings::<ProjectSettings>(cx, |settings| {
diff --git a/crates/collab/src/tests/following_tests.rs b/crates/collab/src/tests/following_tests.rs
index e66b66a1b45893..1bc3cd691778d1 100644
--- a/crates/collab/src/tests/following_tests.rs
+++ b/crates/collab/src/tests/following_tests.rs
@@ -1649,7 +1649,7 @@ async fn test_following_into_excluded_file(
         cx.update(|cx| {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |settings| {
-                    settings.file_scan_exclusions = Some(vec!["**/.git".to_string()]);
+                    settings.file_scan_exclusions = vec!["**/.git".to_string()];
                 });
             });
         });
diff --git a/crates/collab_ui/src/chat_panel.rs b/crates/collab_ui/src/chat_panel.rs
index 5a79f364ff571f..f6e6c7321ff80d 100644
--- a/crates/collab_ui/src/chat_panel.rs
+++ b/crates/collab_ui/src/chat_panel.rs
@@ -1108,7 +1108,7 @@ impl Panel for ChatPanel {
         settings::update_settings_file::<ChatPanelSettings>(
             self.fs.clone(),
             cx,
-            move |settings, _| settings.dock = Some(position),
+            move |settings, _| settings.dock = position,
         );
     }
 
diff --git a/crates/collab_ui/src/chat_panel/message_editor.rs b/crates/collab_ui/src/chat_panel/message_editor.rs
index 028e148cbac039..0b1a2dbe69ec0b 100644
--- a/crates/collab_ui/src/chat_panel/message_editor.rs
+++ b/crates/collab_ui/src/chat_panel/message_editor.rs
@@ -113,9 +113,7 @@ impl MessageEditor {
             editor.set_show_indent_guides(false, cx);
             editor.set_completion_provider(Box::new(MessageEditorCompletionProvider(this)));
             editor.set_auto_replace_emoji_shortcode(
-                MessageEditorSettings::get_global(cx)
-                    .auto_replace_emoji_shortcode
-                    .unwrap_or_default(),
+                MessageEditorSettings::get_global(cx).auto_replace_emoji_shortcode,
             );
         });
 
@@ -130,9 +128,7 @@ impl MessageEditor {
         cx.observe_global::<settings::SettingsStore>(|view, cx| {
             view.editor.update(cx, |editor, cx| {
                 editor.set_auto_replace_emoji_shortcode(
-                    MessageEditorSettings::get_global(cx)
-                        .auto_replace_emoji_shortcode
-                        .unwrap_or_default(),
+                    MessageEditorSettings::get_global(cx).auto_replace_emoji_shortcode,
                 )
             })
         })
diff --git a/crates/collab_ui/src/collab_panel.rs b/crates/collab_ui/src/collab_panel.rs
index 72701101816995..3e6483c42dd726 100644
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -2813,7 +2813,7 @@ impl Panel for CollabPanel {
         settings::update_settings_file::<CollaborationPanelSettings>(
             self.fs.clone(),
             cx,
-            move |settings, _| settings.dock = Some(position),
+            move |settings, _| settings.dock = position,
         );
     }
 
diff --git a/crates/collab_ui/src/notification_panel.rs b/crates/collab_ui/src/notification_panel.rs
index 33ca5a2952180c..326e1f0f5bdc2b 100644
--- a/crates/collab_ui/src/notification_panel.rs
+++ b/crates/collab_ui/src/notification_panel.rs
@@ -672,7 +672,7 @@ impl Panel for NotificationPanel {
         settings::update_settings_file::<NotificationPanelSettings>(
             self.fs.clone(),
             cx,
-            move |settings, _| settings.dock = Some(position),
+            move |settings, _| settings.dock = position,
         );
     }
 
diff --git a/crates/collab_ui/src/panel_settings.rs b/crates/collab_ui/src/panel_settings.rs
index f9851d5797306c..a594f023bbcd3e 100644
--- a/crates/collab_ui/src/panel_settings.rs
+++ b/crates/collab_ui/src/panel_settings.rs
@@ -2,58 +2,84 @@ use gpui::Pixels;
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
+use ui::px;
 use workspace::dock::DockPosition;
 
-#[derive(Deserialize, Debug)]
+#[derive(Clone, Deserialize, Debug, JsonSchema, Serialize)]
+#[serde(default)]
 pub struct CollaborationPanelSettings {
+    /// Whether to show the panel button in the status bar.
     pub button: bool,
+    /// Where to dock the panel.
     pub dock: DockPosition,
+    /// Default width of the panel in pixels.
     pub default_width: Pixels,
 }
 
-#[derive(Deserialize, Debug)]
+impl Default for CollaborationPanelSettings {
+    fn default() -> Self {
+        Self {
+            button: true,
+            dock: DockPosition::Left,
+            default_width: px(240.),
+        }
+    }
+}
+
+#[derive(Clone, Deserialize, Debug, JsonSchema, Serialize)]
+#[serde(default)]
 pub struct ChatPanelSettings {
+    /// Whether to show the panel button in the status bar.
     pub button: bool,
+    /// Where to dock the panel.
     pub dock: DockPosition,
+    /// Default width of the panel in pixels.
     pub default_width: Pixels,
 }
 
-#[derive(Deserialize, Debug)]
+impl Default for ChatPanelSettings {
+    fn default() -> Self {
+        Self {
+            button: true,
+            dock: DockPosition::Right,
+            default_width: px(240.),
+        }
+    }
+}
+
+#[derive(Clone, Deserialize, Debug, JsonSchema, Serialize)]
+#[serde(default)]
 pub struct NotificationPanelSettings {
+    /// Whether to show the panel button in the status bar.
     pub button: bool,
+    /// Where to dock the panel.
     pub dock: DockPosition,
+    /// Default width of the panel in pixels.
     pub default_width: Pixels,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-pub struct PanelSettingsContent {
-    /// Whether to show the panel button in the status bar.
-    ///
-    /// Default: true
-    pub button: Option<bool>,
-    /// Where to dock the panel.
-    ///
-    /// Default: left
-    pub dock: Option<DockPosition>,
-    /// Default width of the panel in pixels.
-    ///
-    /// Default: 240
-    pub default_width: Option<f32>,
+impl Default for NotificationPanelSettings {
+    fn default() -> Self {
+        Self {
+            button: true,
+            dock: DockPosition::Right,
+            default_width: px(380.),
+        }
+    }
 }
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
+#[serde(default)]
 pub struct MessageEditorSettings {
     /// Whether to automatically replace emoji shortcodes with emoji characters.
     /// For example: typing `:wave:` gets replaced with `👋`.
-    ///
-    /// Default: false
-    pub auto_replace_emoji_shortcode: Option<bool>,
+    pub auto_replace_emoji_shortcode: bool,
 }
 
 impl Settings for CollaborationPanelSettings {
     const KEY: Option<&'static str> = Some("collaboration_panel");
 
-    type FileContent = PanelSettingsContent;
+    type FileContent = Self;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
@@ -66,7 +92,7 @@ impl Settings for CollaborationPanelSettings {
 impl Settings for ChatPanelSettings {
     const KEY: Option<&'static str> = Some("chat_panel");
 
-    type FileContent = PanelSettingsContent;
+    type FileContent = Self;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
@@ -79,7 +105,7 @@ impl Settings for ChatPanelSettings {
 impl Settings for NotificationPanelSettings {
     const KEY: Option<&'static str> = Some("notification_panel");
 
-    type FileContent = PanelSettingsContent;
+    type FileContent = Self;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
@@ -92,7 +118,7 @@ impl Settings for NotificationPanelSettings {
 impl Settings for MessageEditorSettings {
     const KEY: Option<&'static str> = Some("message_editor");
 
-    type FileContent = MessageEditorSettings;
+    type FileContent = Self;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
diff --git a/crates/diagnostics/src/project_diagnostics_settings.rs b/crates/diagnostics/src/project_diagnostics_settings.rs
index 55879d0c426e2b..34739bcd170adf 100644
--- a/crates/diagnostics/src/project_diagnostics_settings.rs
+++ b/crates/diagnostics/src/project_diagnostics_settings.rs
@@ -4,23 +4,25 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-#[derive(Deserialize, Debug)]
+#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
+#[serde(default)]
+/// Diagnostics configuration.
 pub struct ProjectDiagnosticsSettings {
+    /// Whether to show warnings or not by default.
     pub include_warnings: bool,
 }
 
-/// Diagnostics configuration.
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-pub struct ProjectDiagnosticsSettingsContent {
-    /// Whether to show warnings or not by default.
-    ///
-    /// Default: true
-    include_warnings: Option<bool>,
+impl Default for ProjectDiagnosticsSettings {
+    fn default() -> Self {
+        Self {
+            include_warnings: true,
+        }
+    }
 }
 
 impl Settings for ProjectDiagnosticsSettings {
     const KEY: Option<&'static str> = Some("diagnostics");
-    type FileContent = ProjectDiagnosticsSettingsContent;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 3466888c942de1..f750abd95c76df 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -10639,7 +10639,7 @@ impl Editor {
         let fs = workspace.read(cx).app_state().fs.clone();
         let current_show = TabBarSettings::get_global(cx).show;
         update_settings_file::<TabBarSettings>(fs, cx, move |setting, _| {
-            setting.show = Some(!current_show);
+            setting.show = !current_show;
         });
     }
 
@@ -12562,7 +12562,7 @@ impl EditorSnapshot {
         let show_git_gutter = self.show_git_diff_gutter.unwrap_or_else(|| {
             matches!(
                 ProjectSettings::get_global(cx).git.git_gutter,
-                Some(GitGutterSetting::TrackedFiles)
+                GitGutterSetting::TrackedFiles
             )
         });
         let gutter_settings = EditorSettings::get_global(cx).gutter;
diff --git a/crates/editor/src/editor_settings.rs b/crates/editor/src/editor_settings.rs
index 2614e4ea303d24..0532fd7bdf880c 100644
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -3,38 +3,105 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-#[derive(Deserialize, Clone)]
+#[derive(Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 pub struct EditorSettings {
+    /// Whether the cursor blinks in the editor.
     pub cursor_blink: bool,
+    /// How to highlight the current line in the editor.
     pub current_line_highlight: CurrentLineHighlight,
+    /// Whether to show the informational hover box when moving the mouse
+    /// over symbols in the editor.
     pub hover_popover_enabled: bool,
+    /// Whether to pop the completions menu while typing in an editor without
+    /// explicitly requesting it.
     pub show_completions_on_input: bool,
+    /// Whether to display inline and alongside documentation for items in the
+    /// completions menu.
     pub show_completion_documentation: bool,
+    /// The debounce delay before re-querying the language server for completion
+    /// documentation when not included in original completion list.
     pub completion_documentation_secondary_query_debounce: u64,
+    /// Whether to use additional LSP queries to format (and amend) the code after
+    /// every "trigger" symbol input, defined by LSP server capabilities.
     pub use_on_type_format: bool,
+    /// Toolbar related settings
     pub toolbar: Toolbar,
+    /// Scrollbar related settings
     pub scrollbar: Scrollbar,
+    /// Gutter related settings
     pub gutter: Gutter,
+    /// Whether the editor will scroll beyond the last line.
     pub scroll_beyond_last_line: ScrollBeyondLastLine,
+    /// The number of lines to keep above/below the cursor when auto-scrolling.
     pub vertical_scroll_margin: f32,
+    /// Scroll sensitivity multiplier. This multiplier is applied
+    /// to both the horizontal and vertical delta values while scrolling.
     pub scroll_sensitivity: f32,
+    /// Whether the line numbers on editors gutter are relative or not.
     pub relative_line_numbers: bool,
+    /// When to populate a new search's query based on the text under the cursor.
     pub seed_search_query_from_cursor: SeedQuerySetting,
     pub use_smartcase_search: bool,
+    /// The key to use for adding multiple cursors
     pub multi_cursor_modifier: MultiCursorModifier,
+    /// Hide the values of variables in `private` files, as defined by the
+    /// private_files setting. This only changes the visual representation,
+    /// the values are still present in the file and can be selected / copied / pasted
     pub redact_private_values: bool,
+
+    /// How many lines to expand the multibuffer excerpts by default
     pub expand_excerpt_lines: u32,
     pub middle_click_paste: bool,
+    /// What to do when multibuffer is double clicked in some of its excerpts
+    /// (parts of singleton buffers).
     #[serde(default)]
     pub double_click_in_multibuffer: DoubleClickInMultibuffer,
+    /// Whether the editor search results will loop
     pub search_wrap: bool,
     #[serde(default)]
     pub search: SearchSettings,
+    /// Show method signatures in the editor, when inside parentheses.
     pub auto_signature_help: bool,
+    /// Whether to show the signature help after completion or a bracket pair inserted.
+    /// If `auto_signature_help` is enabled, this setting will be treated as enabled also.
     pub show_signature_help_after_edits: bool,
+    /// Jupyter REPL settings.
     pub jupyter: Jupyter,
 }
 
+impl Default for EditorSettings {
+    fn default() -> Self {
+        Self {
+            cursor_blink: true,
+            current_line_highlight: CurrentLineHighlight::All,
+            hover_popover_enabled: true,
+            show_completions_on_input: true,
+            show_completion_documentation: true,
+            completion_documentation_secondary_query_debounce: 300,
+            use_on_type_format: true,
+            toolbar: Default::default(),
+            scrollbar: Default::default(),
+            gutter: Default::default(),
+            scroll_beyond_last_line: ScrollBeyondLastLine::OnePage,
+            vertical_scroll_margin: 3.,
+            scroll_sensitivity: 1.0,
+            relative_line_numbers: false,
+            seed_search_query_from_cursor: SeedQuerySetting::Always,
+            multi_cursor_modifier: MultiCursorModifier::Alt,
+            redact_private_values: false,
+            expand_excerpt_lines: 3,
+            double_click_in_multibuffer: DoubleClickInMultibuffer::Select,
+            search_wrap: true,
+            auto_signature_help: false,
+            show_signature_help_after_edits: true,
+            jupyter: Default::default(),
+            use_smartcase_search: false,
+            middle_click_paste: true,
+            search: SearchSettings::default(),
+        }
+    }
+}
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum CurrentLineHighlight {
@@ -72,48 +139,93 @@ pub enum DoubleClickInMultibuffer {
     Open,
 }
 
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
 pub struct Jupyter {
     /// Whether the Jupyter feature is enabled.
-    ///
-    /// Default: true
     pub enabled: bool,
 }
 
-#[derive(Default, Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
-#[serde(rename_all = "snake_case")]
-pub struct JupyterContent {
-    /// Whether the Jupyter feature is enabled.
-    ///
-    /// Default: true
-    pub enabled: Option<bool>,
+impl Default for Jupyter {
+    fn default() -> Self {
+        Self { enabled: true }
+    }
 }
 
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+#[serde(default)]
 pub struct Toolbar {
+    /// Whether to display breadcrumbs in the editor toolbar.
     pub breadcrumbs: bool,
+    /// Whether to display quick action buttons in the editor toolbar.
     pub quick_actions: bool,
+    /// Whether to show the selections menu in the editor toolbar
     pub selections_menu: bool,
 }
 
+impl Default for Toolbar {
+    fn default() -> Self {
+        Self {
+            breadcrumbs: true,
+            quick_actions: true,
+            selections_menu: true,
+        }
+    }
+}
+
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 pub struct Scrollbar {
+    /// When to show the scrollbar in the editor.
     pub show: ShowScrollbar,
+    /// Whether to show git diff indicators in the scrollbar.
     pub git_diff: bool,
+    /// Whether to show buffer search result indicators in the scrollbar.
     pub selected_symbol: bool,
+    /// Whether to show selected symbol occurrences in the scrollbar.
     pub search_results: bool,
+    /// Whether to show diagnostic indicators in the scrollbar.
     pub diagnostics: bool,
+    /// Whether to show cursor positions in the scrollbar.
     pub cursors: bool,
 }
 
+impl Default for Scrollbar {
+    fn default() -> Self {
+        Self {
+            show: ShowScrollbar::Auto,
+            git_diff: true,
+            selected_symbol: true,
+            search_results: true,
+            diagnostics: true,
+            cursors: true,
+        }
+    }
+}
+
+/// Gutter-related settings.
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+#[serde(default)]
 pub struct Gutter {
+    /// Whether to show line numbers in the gutter.
     pub line_numbers: bool,
+    /// Whether to show code action buttons in the gutter.
     pub code_actions: bool,
+    /// Whether to show runnable buttons in the gutter.
     pub runnables: bool,
+    /// Whether to show fold buttons in the gutter.
     pub folds: bool,
 }
 
+impl Default for Gutter {
+    fn default() -> Self {
+        Self {
+            line_numbers: true,
+            code_actions: true,
+            runnables: true,
+            folds: true,
+        }
+    }
+}
+
 /// When to show the scrollbar in the editor.
 ///
 /// Default: auto
@@ -171,188 +283,6 @@ pub struct SearchSettings {
     pub regex: bool,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct EditorSettingsContent {
-    /// Whether the cursor blinks in the editor.
-    ///
-    /// Default: true
-    pub cursor_blink: Option<bool>,
-    /// How to highlight the current line in the editor.
-    ///
-    /// Default: all
-    pub current_line_highlight: Option<CurrentLineHighlight>,
-    /// Whether to show the informational hover box when moving the mouse
-    /// over symbols in the editor.
-    ///
-    /// Default: true
-    pub hover_popover_enabled: Option<bool>,
-
-    /// Whether to pop the completions menu while typing in an editor without
-    /// explicitly requesting it.
-    ///
-    /// Default: true
-    pub show_completions_on_input: Option<bool>,
-    /// Whether to display inline and alongside documentation for items in the
-    /// completions menu.
-    ///
-    /// Default: true
-    pub show_completion_documentation: Option<bool>,
-    /// The debounce delay before re-querying the language server for completion
-    /// documentation when not included in original completion list.
-    ///
-    /// Default: 300 ms
-    pub completion_documentation_secondary_query_debounce: Option<u64>,
-    /// Whether to use additional LSP queries to format (and amend) the code after
-    /// every "trigger" symbol input, defined by LSP server capabilities.
-    ///
-    /// Default: true
-    pub use_on_type_format: Option<bool>,
-    /// Toolbar related settings
-    pub toolbar: Option<ToolbarContent>,
-    /// Scrollbar related settings
-    pub scrollbar: Option<ScrollbarContent>,
-    /// Gutter related settings
-    pub gutter: Option<GutterContent>,
-    /// Whether the editor will scroll beyond the last line.
-    ///
-    /// Default: one_page
-    pub scroll_beyond_last_line: Option<ScrollBeyondLastLine>,
-    /// The number of lines to keep above/below the cursor when auto-scrolling.
-    ///
-    /// Default: 3.
-    pub vertical_scroll_margin: Option<f32>,
-    /// Scroll sensitivity multiplier. This multiplier is applied
-    /// to both the horizontal and vertical delta values while scrolling.
-    ///
-    /// Default: 1.0
-    pub scroll_sensitivity: Option<f32>,
-    /// Whether the line numbers on editors gutter are relative or not.
-    ///
-    /// Default: false
-    pub relative_line_numbers: Option<bool>,
-    /// When to populate a new search's query based on the text under the cursor.
-    ///
-    /// Default: always
-    pub seed_search_query_from_cursor: Option<SeedQuerySetting>,
-    pub use_smartcase_search: Option<bool>,
-    /// The key to use for adding multiple cursors
-    ///
-    /// Default: alt
-    pub multi_cursor_modifier: Option<MultiCursorModifier>,
-    /// Hide the values of variables in `private` files, as defined by the
-    /// private_files setting. This only changes the visual representation,
-    /// the values are still present in the file and can be selected / copied / pasted
-    ///
-    /// Default: false
-    pub redact_private_values: Option<bool>,
-
-    /// How many lines to expand the multibuffer excerpts by default
-    ///
-    /// Default: 3
-    pub expand_excerpt_lines: Option<u32>,
-
-    /// Whether to enable middle-click paste on Linux
-    ///
-    /// Default: true
-    pub middle_click_paste: Option<bool>,
-
-    /// What to do when multibuffer is double clicked in some of its excerpts
-    /// (parts of singleton buffers).
-    ///
-    /// Default: select
-    pub double_click_in_multibuffer: Option<DoubleClickInMultibuffer>,
-    /// Whether the editor search results will loop
-    ///
-    /// Default: true
-    pub search_wrap: Option<bool>,
-
-    /// Defaults to use when opening a new buffer and project search items.
-    ///
-    /// Default: nothing is enabled
-    pub search: Option<SearchSettings>,
-
-    /// Whether to automatically show a signature help pop-up or not.
-    ///
-    /// Default: false
-    pub auto_signature_help: Option<bool>,
-
-    /// Whether to show the signature help pop-up after completions or bracket pairs inserted.
-    ///
-    /// Default: true
-    pub show_signature_help_after_edits: Option<bool>,
-
-    /// Jupyter REPL settings.
-    pub jupyter: Option<JupyterContent>,
-}
-
-// Toolbar related settings
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
-pub struct ToolbarContent {
-    /// Whether to display breadcrumbs in the editor toolbar.
-    ///
-    /// Default: true
-    pub breadcrumbs: Option<bool>,
-    /// Whether to display quick action buttons in the editor toolbar.
-    ///
-    /// Default: true
-    pub quick_actions: Option<bool>,
-
-    /// Whether to show the selections menu in the editor toolbar
-    ///
-    /// Default: true
-    pub selections_menu: Option<bool>,
-}
-
-/// Scrollbar related settings
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
-pub struct ScrollbarContent {
-    /// When to show the scrollbar in the editor.
-    ///
-    /// Default: auto
-    pub show: Option<ShowScrollbar>,
-    /// Whether to show git diff indicators in the scrollbar.
-    ///
-    /// Default: true
-    pub git_diff: Option<bool>,
-    /// Whether to show buffer search result indicators in the scrollbar.
-    ///
-    /// Default: true
-    pub search_results: Option<bool>,
-    /// Whether to show selected symbol occurrences in the scrollbar.
-    ///
-    /// Default: true
-    pub selected_symbol: Option<bool>,
-    /// Whether to show diagnostic indicators in the scrollbar.
-    ///
-    /// Default: true
-    pub diagnostics: Option<bool>,
-    /// Whether to show cursor positions in the scrollbar.
-    ///
-    /// Default: true
-    pub cursors: Option<bool>,
-}
-
-/// Gutter related settings
-#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
-pub struct GutterContent {
-    /// Whether to show line numbers in the gutter.
-    ///
-    /// Default: true
-    pub line_numbers: Option<bool>,
-    /// Whether to show code action buttons in the gutter.
-    ///
-    /// Default: true
-    pub code_actions: Option<bool>,
-    /// Whether to show runnable buttons in the gutter.
-    ///
-    /// Default: true
-    pub runnables: Option<bool>,
-    /// Whether to show fold buttons in the gutter.
-    ///
-    /// Default: true
-    pub folds: Option<bool>,
-}
-
 impl EditorSettings {
     pub fn jupyter_enabled(cx: &AppContext) -> bool {
         EditorSettings::get_global(cx).jupyter.enabled
@@ -362,7 +292,7 @@ impl EditorSettings {
 impl Settings for EditorSettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = EditorSettingsContent;
+    type FileContent = Self;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
diff --git a/crates/editor/src/editor_settings_controls.rs b/crates/editor/src/editor_settings_controls.rs
index bbe1b00324a787..36d471dfa28f4b 100644
--- a/crates/editor/src/editor_settings_controls.rs
+++ b/crates/editor/src/editor_settings_controls.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use gpui::{AppContext, FontFeatures, FontWeight};
-use project::project_settings::{InlineBlameSettings, ProjectSettings};
+use project::project_settings::ProjectSettings;
 use settings::{EditableSettingControl, Settings};
 use theme::{FontFamilyCache, ThemeSettings};
 use ui::{
@@ -296,14 +296,7 @@ impl EditableSettingControl for InlineGitBlameControl {
         value: Self::Value,
         _cx: &AppContext,
     ) {
-        if let Some(inline_blame) = settings.git.inline_blame.as_mut() {
-            inline_blame.enabled = value;
-        } else {
-            settings.git.inline_blame = Some(InlineBlameSettings {
-                enabled: false,
-                ..Default::default()
-            });
-        }
+        settings.git.inline_blame.enabled = value;
     }
 }
 
@@ -349,14 +342,7 @@ impl EditableSettingControl for LineNumbersControl {
         value: Self::Value,
         _cx: &AppContext,
     ) {
-        if let Some(gutter) = settings.gutter.as_mut() {
-            gutter.line_numbers = Some(value);
-        } else {
-            settings.gutter = Some(crate::editor_settings::GutterContent {
-                line_numbers: Some(value),
-                ..Default::default()
-            });
-        }
+        settings.gutter.line_numbers = value;
     }
 }
 
@@ -402,7 +388,7 @@ impl EditableSettingControl for RelativeLineNumbersControl {
         value: Self::Value,
         _cx: &AppContext,
     ) {
-        settings.relative_line_numbers = Some(value);
+        settings.relative_line_numbers = value;
     }
 }
 
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 0b1e0385ded4ad..7d42dc7a85d06e 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -6964,7 +6964,7 @@ async fn test_handle_input_for_show_signature_help_auto_signature_help_true(
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.auto_signature_help = Some(true);
+                settings.auto_signature_help = true;
             });
         });
     });
@@ -7105,8 +7105,8 @@ async fn test_handle_input_with_different_show_signature_settings(cx: &mut gpui:
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.auto_signature_help = Some(false);
-                settings.show_signature_help_after_edits = Some(false);
+                settings.auto_signature_help = false;
+                settings.show_signature_help_after_edits = false;
             });
         });
     });
@@ -7232,8 +7232,8 @@ async fn test_handle_input_with_different_show_signature_settings(cx: &mut gpui:
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.auto_signature_help = Some(false);
-                settings.show_signature_help_after_edits = Some(true);
+                settings.auto_signature_help = false;
+                settings.show_signature_help_after_edits = true;
             });
         });
     });
@@ -7274,8 +7274,8 @@ async fn test_handle_input_with_different_show_signature_settings(cx: &mut gpui:
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.auto_signature_help = Some(true);
-                settings.show_signature_help_after_edits = Some(false);
+                settings.auto_signature_help = true;
+                settings.show_signature_help_after_edits = false;
             });
         });
     });
@@ -7318,7 +7318,7 @@ async fn test_signature_help(cx: &mut gpui::TestAppContext) {
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.auto_signature_help = Some(true);
+                settings.auto_signature_help = true;
             });
         });
     });
@@ -7759,7 +7759,7 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.show_completions_on_input = Some(false);
+                settings.show_completions_on_input = false;
             });
         })
     });
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index d4f5c565c27ef0..1c0a325b7620e5 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -1283,10 +1283,7 @@ impl EditorElement {
                 .row,
         );
 
-        let git_gutter_setting = ProjectSettings::get_global(cx)
-            .git
-            .git_gutter
-            .unwrap_or_default();
+        let git_gutter_setting = ProjectSettings::get_global(cx).git.git_gutter;
         let display_hunks = buffer_snapshot
             .git_diff_hunks_in_range(buffer_start_row..buffer_end_row)
             .map(|hunk| diff_hunk_to_display(&hunk, snapshot))
@@ -1366,12 +1363,10 @@ impl EditorElement {
             };
             let padded_line_end = line_end + em_width * INLINE_BLAME_PADDING_EM_WIDTHS;
 
-            let min_column_in_pixels = ProjectSettings::get_global(cx)
-                .git
-                .inline_blame
-                .and_then(|settings| settings.min_column)
-                .map(|col| self.column_pixels(col as usize, cx))
-                .unwrap_or(px(0.));
+            let min_column_in_pixels = self.column_pixels(
+                ProjectSettings::get_global(cx).git.inline_blame.min_column as usize,
+                cx,
+            );
             let min_start = content_origin.x - scroll_pixel_position.x + min_column_in_pixels;
 
             cmp::max(padded_line_end, min_start)
@@ -3331,7 +3326,7 @@ impl EditorElement {
             .unwrap_or_else(|| {
                 matches!(
                     ProjectSettings::get_global(cx).git.git_gutter,
-                    Some(GitGutterSetting::TrackedFiles)
+                    GitGutterSetting::TrackedFiles
                 )
             });
         if show_git_gutter {
diff --git a/crates/extension/src/extension_settings.rs b/crates/extension/src/extension_settings.rs
index a2ab7ac9cca73b..715dc3ca827f51 100644
--- a/crates/extension/src/extension_settings.rs
+++ b/crates/extension/src/extension_settings.rs
@@ -6,18 +6,25 @@ use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 use std::sync::Arc;
 
-#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema)]
+#[derive(Deserialize, Serialize, Debug, Clone, JsonSchema)]
+#[serde(default)]
 pub struct ExtensionSettings {
     /// The extensions that should be automatically installed by Zed.
     ///
     /// This is used to make functionality provided by extensions (e.g., language support)
     /// available out-of-the-box.
-    #[serde(default)]
     pub auto_install_extensions: HashMap<Arc<str>, bool>,
-    #[serde(default)]
     pub auto_update_extensions: HashMap<Arc<str>, bool>,
 }
 
+impl Default for ExtensionSettings {
+    fn default() -> Self {
+        Self {
+            auto_install_extensions: HashMap::from_iter([("html".into(), true)]),
+            auto_update_extensions: Default::default(),
+        }
+    }
+}
 impl ExtensionSettings {
     /// Returns whether the given extension should be auto-installed.
     pub fn should_auto_install(&self, extension_id: &str) -> bool {
diff --git a/crates/extensions_ui/src/extensions_ui.rs b/crates/extensions_ui/src/extensions_ui.rs
index f246e3cf4fb830..b2d6d7f2831720 100644
--- a/crates/extensions_ui/src/extensions_ui.rs
+++ b/crates/extensions_ui/src/extensions_ui.rs
@@ -1000,7 +1000,7 @@ impl ExtensionsPage {
                             this.update_settings::<VimModeSetting>(
                                 selection,
                                 cx,
-                                |setting, value| *setting = Some(value),
+                                |setting, value| *setting = VimModeSetting(value),
                             );
                         }),
                     )),
diff --git a/crates/go_to_line/src/cursor_position.rs b/crates/go_to_line/src/cursor_position.rs
index 63e0f2b07915eb..de3d1dc74d2774 100644
--- a/crates/go_to_line/src/cursor_position.rs
+++ b/crates/go_to_line/src/cursor_position.rs
@@ -180,18 +180,10 @@ pub(crate) enum LineIndicatorFormat {
     Long,
 }
 
-/// Whether or not to automatically check for updates.
-///
-/// Values: short, long
-/// Default: short
-#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize)]
-#[serde(transparent)]
-pub(crate) struct LineIndicatorFormatContent(LineIndicatorFormat);
-
 impl Settings for LineIndicatorFormat {
     const KEY: Option<&'static str> = Some("line_indicator_format");
 
-    type FileContent = Option<LineIndicatorFormatContent>;
+    type FileContent = Self;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
@@ -199,9 +191,9 @@ impl Settings for LineIndicatorFormat {
     ) -> anyhow::Result<Self> {
         let format = [sources.release_channel, sources.user]
             .into_iter()
-            .find_map(|value| value.copied().flatten())
-            .unwrap_or(sources.default.ok_or_else(Self::missing_default)?);
+            .find_map(|value| value.copied())
+            .unwrap_or(*sources.default);
 
-        Ok(format.0)
+        Ok(format)
     }
 }
diff --git a/crates/gpui/src/geometry.rs b/crates/gpui/src/geometry.rs
index 8de9e6f009d733..b2035923605e0c 100644
--- a/crates/gpui/src/geometry.rs
+++ b/crates/gpui/src/geometry.rs
@@ -5,6 +5,7 @@
 use core::fmt::Debug;
 use derive_more::{Add, AddAssign, Div, DivAssign, Mul, Neg, Sub, SubAssign};
 use refineable::Refineable;
+use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
 use std::{
     cmp::{self, PartialOrd},
@@ -2201,6 +2202,7 @@ impl From<Percentage> for Radians {
     PartialEq,
     Serialize,
     Deserialize,
+    JsonSchema,
 )]
 #[repr(transparent)]
 pub struct Pixels(pub f32);
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index e1fcaaba28b4f1..7a6b758a2554ec 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -70,10 +70,10 @@ pub struct LanguageSettings {
     /// The column at which to soft-wrap lines, for buffers where soft-wrap
     /// is enabled.
     pub preferred_line_length: u32,
-    // Whether to show wrap guides (vertical rulers) in the editor.
-    // Setting this to true will show a guide at the 'preferred_line_length' value
-    // if softwrap is set to 'preferred_line_length', and will show any
-    // additional guides as specified by the 'wrap_guides' setting.
+    /// Whether to show wrap guides (vertical rulers) in the editor.
+    /// Setting this to true will show a guide at the 'preferred_line_length' value
+    /// if softwrap is set to 'preferred_line_length', and will show any
+    /// additional guides as specified by the 'wrap_guides' setting.
     pub show_wrap_guides: bool,
     /// Character counts at which to show wrap guides (vertical rulers) in the editor.
     pub wrap_guides: Vec<usize>,
diff --git a/crates/languages/src/json.rs b/crates/languages/src/json.rs
index 6b5f74c2634b45..102eb1ef2f8563 100644
--- a/crates/languages/src/json.rs
+++ b/crates/languages/src/json.rs
@@ -7,10 +7,13 @@ use feature_flags::FeatureFlagAppExt;
 use futures::StreamExt;
 use gpui::{AppContext, AsyncAppContext};
 use http_client::github::{latest_github_release, GitHubLspBinaryVersion};
-use language::{LanguageRegistry, LanguageServerName, LspAdapter, LspAdapterDelegate};
+use language::{
+    CodeLabel, Language, LanguageRegistry, LanguageServerName, LspAdapter, LspAdapterDelegate,
+};
 use lsp::LanguageServerBinary;
 use node_runtime::NodeRuntime;
 use project::ContextProviderWithTasks;
+use rope::Rope;
 use serde_json::{json, Value};
 use settings::{KeymapFile, SettingsJsonSchemaParams, SettingsStore};
 use smol::{
@@ -202,6 +205,30 @@ impl LspAdapter for JsonLspAdapter {
         })))
     }
 
+    async fn label_for_completion(
+        &self,
+        item: &lsp::CompletionItem,
+        language: &Arc<Language>,
+    ) -> Option<CodeLabel> {
+        let text = if let Some(description) = item
+            .label_details
+            .as_ref()
+            .and_then(|label_details| label_details.description.as_ref())
+        {
+            format!("{} {}", item.label, description)
+        } else if let Some(detail) = &item.detail {
+            format!("{} {}", item.label, detail)
+        } else {
+            item.label.clone()
+        };
+        let rope = Rope::from(item.label.as_str());
+        let runs = language.highlight_text(&rope, 0..item.label.len());
+        Some(language::CodeLabel {
+            text,
+            runs,
+            filter_range: 0..item.label.len(),
+        })
+    }
     async fn workspace_configuration(
         self: Arc<Self>,
         _: &Arc<dyn LspAdapterDelegate>,
diff --git a/crates/outline_panel/src/outline_panel.rs b/crates/outline_panel/src/outline_panel.rs
index c5f0187c229fa8..361607533b84b0 100644
--- a/crates/outline_panel/src/outline_panel.rs
+++ b/crates/outline_panel/src/outline_panel.rs
@@ -24,12 +24,12 @@ use editor::{
 use file_icons::FileIcons;
 use fuzzy::{match_strings, StringMatch, StringMatchCandidate};
 use gpui::{
-    actions, anchored, deferred, div, impl_actions, px, uniform_list, Action, AnyElement,
-    AppContext, AssetSource, AsyncWindowContext, ClipboardItem, DismissEvent, Div, ElementId,
-    EventEmitter, FocusHandle, FocusableView, HighlightStyle, InteractiveElement, IntoElement,
-    KeyContext, Model, MouseButton, MouseDownEvent, ParentElement, Pixels, Point, Render,
-    SharedString, Stateful, Styled, Subscription, Task, UniformListScrollHandle, View, ViewContext,
-    VisualContext, WeakView, WindowContext,
+    actions, anchored, deferred, div, impl_actions, uniform_list, Action, AnyElement, AppContext,
+    AssetSource, AsyncWindowContext, ClipboardItem, DismissEvent, Div, ElementId, EventEmitter,
+    FocusHandle, FocusableView, HighlightStyle, InteractiveElement, IntoElement, KeyContext, Model,
+    MouseButton, MouseDownEvent, ParentElement, Pixels, Point, Render, SharedString, Stateful,
+    Styled, Subscription, Task, UniformListScrollHandle, View, ViewContext, VisualContext,
+    WeakView, WindowContext,
 };
 use itertools::Itertools;
 use language::{BufferId, BufferSnapshot, OffsetRangeExt, OutlineItem};
@@ -1938,7 +1938,7 @@ impl OutlinePanel {
             .child(
                 ListItem::new(item_id)
                     .indent_level(depth)
-                    .indent_step_size(px(settings.indent_size))
+                    .indent_step_size(settings.indent_size)
                     .selected(is_active)
                     .when_some(icon_element, |list_item, icon_element| {
                         list_item.child(h_flex().child(icon_element))
@@ -3801,7 +3801,7 @@ impl Panel for OutlinePanel {
                     DockPosition::Left | DockPosition::Bottom => OutlinePanelDockPosition::Left,
                     DockPosition::Right => OutlinePanelDockPosition::Right,
                 };
-                settings.dock = Some(dock);
+                settings.dock = dock;
             },
         );
     }
diff --git a/crates/outline_panel/src/outline_panel_settings.rs b/crates/outline_panel/src/outline_panel_settings.rs
index e19fc3c0084947..a8e51b96c5c3aa 100644
--- a/crates/outline_panel/src/outline_panel_settings.rs
+++ b/crates/outline_panel/src/outline_panel_settings.rs
@@ -1,4 +1,5 @@
-use gpui::Pixels;
+use anyhow;
+use gpui::{px, Pixels};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
@@ -10,66 +11,51 @@ pub enum OutlinePanelDockPosition {
     Right,
 }
 
-#[derive(Deserialize, Debug, Clone, Copy, PartialEq)]
+#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq, JsonSchema)]
 pub struct OutlinePanelSettings {
-    pub button: bool,
-    pub default_width: Pixels,
-    pub dock: OutlinePanelDockPosition,
-    pub file_icons: bool,
-    pub folder_icons: bool,
-    pub git_status: bool,
-    pub indent_size: f32,
-    pub auto_reveal_entries: bool,
-    pub auto_fold_dirs: bool,
-}
-
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-pub struct OutlinePanelSettingsContent {
     /// Whether to show the outline panel button in the status bar.
-    ///
-    /// Default: true
-    pub button: Option<bool>,
+    pub button: bool,
     /// Customize default width (in pixels) taken by outline panel
-    ///
-    /// Default: 240
-    pub default_width: Option<f32>,
+    pub default_width: Pixels,
     /// The position of outline panel
-    ///
-    /// Default: left
-    pub dock: Option<OutlinePanelDockPosition>,
+    pub dock: OutlinePanelDockPosition,
     /// Whether to show file icons in the outline panel.
-    ///
-    /// Default: true
-    pub file_icons: Option<bool>,
+    pub file_icons: bool,
     /// Whether to show folder icons or chevrons for directories in the outline panel.
-    ///
-    /// Default: true
-    pub folder_icons: Option<bool>,
+    pub folder_icons: bool,
     /// Whether to show the git status in the outline panel.
-    ///
-    /// Default: true
-    pub git_status: Option<bool>,
+    pub git_status: bool,
     /// Amount of indentation (in pixels) for nested items.
-    ///
-    /// Default: 20
-    pub indent_size: Option<f32>,
+    pub indent_size: Pixels,
     /// Whether to reveal it in the outline panel automatically,
     /// when a corresponding project entry becomes active.
     /// Gitignored entries are never auto revealed.
-    ///
-    /// Default: true
-    pub auto_reveal_entries: Option<bool>,
+    pub auto_reveal_entries: bool,
     /// Whether to fold directories automatically
     /// when directory has only one directory inside.
-    ///
-    /// Default: true
-    pub auto_fold_dirs: Option<bool>,
+    pub auto_fold_dirs: bool,
+}
+
+impl Default for OutlinePanelSettings {
+    fn default() -> Self {
+        Self {
+            button: true,
+            default_width: px(240.),
+            dock: OutlinePanelDockPosition::Left,
+            file_icons: true,
+            folder_icons: true,
+            auto_fold_dirs: true,
+            auto_reveal_entries: true,
+            indent_size: px(20.),
+            git_status: true,
+        }
+    }
 }
 
 impl Settings for OutlinePanelSettings {
     const KEY: Option<&'static str> = Some("outline_panel");
 
-    type FileContent = OutlinePanelSettingsContent;
+    type FileContent = Self;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
diff --git a/crates/performance/src/performance.rs b/crates/performance/src/performance.rs
new file mode 100644
index 00000000000000..db2388c59ae1c0
--- /dev/null
+++ b/crates/performance/src/performance.rs
@@ -0,0 +1,184 @@
+use std::time::Instant;
+
+use anyhow::Result;
+use gpui::{
+    div, AppContext, InteractiveElement as _, Render, StatefulInteractiveElement as _,
+    Subscription, ViewContext, VisualContext,
+};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use settings::{Settings, SettingsSources, SettingsStore};
+use workspace::{
+    ui::{Label, LabelCommon, LabelSize, Tooltip},
+    ItemHandle, StatusItemView, Workspace,
+};
+
+const SHOW_STARTUP_TIME_DURATION: std::time::Duration = std::time::Duration::from_secs(5);
+
+pub fn init(cx: &mut AppContext) {
+    PerformanceSettings::register(cx);
+
+    let mut enabled = PerformanceSettings::get_global(cx).show_in_status_bar;
+    let start_time = Instant::now();
+    let mut _observe_workspaces = toggle_status_bar_items(enabled, start_time, cx);
+
+    cx.observe_global::<SettingsStore>(move |cx| {
+        let new_value = PerformanceSettings::get_global(cx).show_in_status_bar;
+        if new_value != enabled {
+            enabled = new_value;
+            _observe_workspaces = toggle_status_bar_items(enabled, start_time, cx);
+        }
+    })
+    .detach();
+}
+
+fn toggle_status_bar_items(
+    enabled: bool,
+    start_time: Instant,
+    cx: &mut AppContext,
+) -> Option<Subscription> {
+    for window in cx.windows() {
+        if let Some(workspace) = window.downcast::<Workspace>() {
+            workspace
+                .update(cx, |workspace, cx| {
+                    toggle_status_bar_item(workspace, enabled, start_time, cx);
+                })
+                .ok();
+        }
+    }
+
+    if enabled {
+        log::info!("performance metrics display enabled");
+        Some(cx.observe_new_views::<Workspace>(move |workspace, cx| {
+            toggle_status_bar_item(workspace, true, start_time, cx);
+        }))
+    } else {
+        log::info!("performance metrics display disabled");
+        None
+    }
+}
+
+struct PerformanceStatusBarItem {
+    display_mode: DisplayMode,
+}
+
+#[derive(Copy, Clone, Debug)]
+enum DisplayMode {
+    StartupTime,
+    Fps,
+}
+
+impl PerformanceStatusBarItem {
+    fn new(start_time: Instant, cx: &mut ViewContext<Self>) -> Self {
+        let now = Instant::now();
+        let display_mode = if now < start_time + SHOW_STARTUP_TIME_DURATION {
+            DisplayMode::StartupTime
+        } else {
+            DisplayMode::Fps
+        };
+
+        let this = Self { display_mode };
+
+        if let DisplayMode::StartupTime = display_mode {
+            cx.spawn(|this, mut cx| async move {
+                let now = Instant::now();
+                let remaining_duration =
+                    (start_time + SHOW_STARTUP_TIME_DURATION).saturating_duration_since(now);
+                cx.background_executor().timer(remaining_duration).await;
+                this.update(&mut cx, |this, cx| {
+                    this.display_mode = DisplayMode::Fps;
+                    cx.notify();
+                })
+                .ok();
+            })
+            .detach();
+        }
+
+        this
+    }
+}
+
+impl Render for PerformanceStatusBarItem {
+    fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> impl gpui::IntoElement {
+        let text = match self.display_mode {
+            DisplayMode::StartupTime => cx
+                .time_to_first_window_draw()
+                .map_or("Pending".to_string(), |duration| {
+                    format!("{}ms", duration.as_millis())
+                }),
+            DisplayMode::Fps => cx.fps().map_or("".to_string(), |fps| {
+                format!("{:3} FPS", fps.round() as u32)
+            }),
+        };
+
+        use gpui::ParentElement;
+        let display_mode = self.display_mode;
+        div()
+            .id("performance status")
+            .child(Label::new(text).size(LabelSize::Small))
+            .tooltip(move |cx| match display_mode {
+                DisplayMode::StartupTime => Tooltip::text("Time to first window draw", cx),
+                DisplayMode::Fps => cx
+                    .new_view(|cx| {
+                        let tooltip = Tooltip::new("Current FPS");
+                        if let Some(time_to_first) = cx.time_to_first_window_draw() {
+                            tooltip.meta(format!(
+                                "Time to first window draw: {}ms",
+                                time_to_first.as_millis()
+                            ))
+                        } else {
+                            tooltip
+                        }
+                    })
+                    .into(),
+            })
+    }
+}
+
+impl StatusItemView for PerformanceStatusBarItem {
+    fn set_active_pane_item(
+        &mut self,
+        _active_pane_item: Option<&dyn ItemHandle>,
+        _cx: &mut gpui::ViewContext<Self>,
+    ) {
+        // This is not currently used.
+    }
+}
+
+fn toggle_status_bar_item(
+    workspace: &mut Workspace,
+    enabled: bool,
+    start_time: Instant,
+    cx: &mut ViewContext<Workspace>,
+) {
+    if enabled {
+        workspace.status_bar().update(cx, |bar, cx| {
+            bar.add_right_item(
+                cx.new_view(|cx| PerformanceStatusBarItem::new(start_time, cx)),
+                cx,
+            )
+        });
+    } else {
+        workspace.status_bar().update(cx, |bar, cx| {
+            bar.remove_items_of_type::<PerformanceStatusBarItem>(cx);
+        });
+    }
+}
+
+/// Configuration of the display of performance details.
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
+#[serde(default)]
+pub struct PerformanceSettings {
+    /// Display the time to first window draw and frame rate in the status bar.
+    pub show_in_status_bar: bool,
+}
+
+impl Settings for PerformanceSettings {
+    const KEY: Option<&'static str> = Some("performance");
+
+    type FileContent = Self;
+
+    fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
+        sources.json_merge()
+    }
+}
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index 70b2eccf237c62..3c21b1c5e8caf1 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -20,6 +20,7 @@ use worktree::{PathChange, UpdatedEntriesSet, Worktree, WorktreeId};
 use crate::worktree_store::{WorktreeStore, WorktreeStoreEvent};
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 pub struct ProjectSettings {
     /// Configuration for language servers.
     ///
@@ -41,7 +42,6 @@ pub struct ProjectSettings {
     pub load_direnv: DirenvSettings,
 
     /// Configuration for session-related features
-    #[serde(default)]
     pub session: SessionSettings,
 }
 
@@ -59,36 +59,31 @@ pub enum DirenvSettings {
 }
 
 #[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 pub struct GitSettings {
     /// Whether or not to show the git gutter.
     ///
     /// Default: tracked_files
-    pub git_gutter: Option<GitGutterSetting>,
+    pub git_gutter: GitGutterSetting,
     pub gutter_debounce: Option<u64>,
     /// Whether or not to show git blame data inline in
     /// the currently focused line.
     ///
     /// Default: on
-    pub inline_blame: Option<InlineBlameSettings>,
+    pub inline_blame: InlineBlameSettings,
 }
 
 impl GitSettings {
     pub fn inline_blame_enabled(&self) -> bool {
         #[allow(unknown_lints, clippy::manual_unwrap_or_default)]
-        match self.inline_blame {
-            Some(InlineBlameSettings { enabled, .. }) => enabled,
-            _ => false,
-        }
+        self.inline_blame.enabled
     }
 
     pub fn inline_blame_delay(&self) -> Option<Duration> {
-        match self.inline_blame {
-            Some(InlineBlameSettings {
-                delay_ms: Some(delay_ms),
-                ..
-            }) if delay_ms > 0 => Some(Duration::from_millis(delay_ms)),
-            _ => None,
-        }
+        self.inline_blame
+            .delay_ms
+            .gt(&0)
+            .then(|| Duration::from_millis(self.inline_blame.delay_ms))
     }
 }
 
@@ -102,28 +97,34 @@ pub enum GitGutterSetting {
     Hide,
 }
 
-#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
+#[serde(default)]
 pub struct InlineBlameSettings {
     /// Whether or not to show git blame data inline in
     /// the currently focused line.
     ///
     /// Default: true
-    #[serde(default = "true_value")]
     pub enabled: bool,
     /// Whether to only show the inline blame information
     /// after a delay once the cursor stops moving.
     ///
     /// Default: 0
-    pub delay_ms: Option<u64>,
+    pub delay_ms: u64,
     /// The minimum column number to show the inline blame information at
     ///
     /// Default: 0
-    pub min_column: Option<u32>,
+    pub min_column: u32,
 }
 
-const fn true_value() -> bool {
-    true
+impl Default for InlineBlameSettings {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            delay_ms: 0,
+            min_column: 0,
+        }
+    }
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index c77a2170dd01cd..6ca843875b48a5 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -2289,7 +2289,7 @@ impl ProjectPanel {
             .child(
                 ListItem::new(entry_id.to_proto() as usize)
                     .indent_level(depth)
-                    .indent_step_size(px(settings.indent_size))
+                    .indent_step_size(settings.indent_size)
                     .selected(is_marked || is_active)
                     .when_some(canonical_path, |this, path| {
                         this.end_slot::<AnyElement>(
@@ -2817,7 +2817,7 @@ impl Render for DraggedProjectEntryView {
                 this.bg(cx.theme().colors().background).w(self.width).child(
                     ListItem::new(self.selection.entry_id.to_proto() as usize)
                         .indent_level(self.details.depth)
-                        .indent_step_size(px(settings.indent_size))
+                        .indent_step_size(settings.indent_size)
                         .child(if let Some(icon) = &self.details.icon {
                             div().child(Icon::from_path(icon.clone()))
                         } else {
@@ -2855,7 +2855,7 @@ impl Panel for ProjectPanel {
                     DockPosition::Left | DockPosition::Bottom => ProjectPanelDockPosition::Left,
                     DockPosition::Right => ProjectPanelDockPosition::Right,
                 };
-                settings.dock = Some(dock);
+                settings.dock = dock;
             },
         );
     }
@@ -3029,7 +3029,7 @@ mod tests {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |worktree_settings| {
                     worktree_settings.file_scan_exclusions =
-                        Some(vec!["**/.git".to_string(), "**/4/**".to_string()]);
+                        vec!["**/.git".to_string(), "**/4/**".to_string()];
                 });
             });
         });
@@ -4818,10 +4818,10 @@ mod tests {
         cx.update(|cx| {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |worktree_settings| {
-                    worktree_settings.file_scan_exclusions = Some(Vec::new());
+                    worktree_settings.file_scan_exclusions = Vec::new();
                 });
                 store.update_user_settings::<ProjectPanelSettings>(cx, |project_panel_settings| {
-                    project_panel_settings.auto_reveal_entries = Some(false)
+                    project_panel_settings.auto_reveal_entries = false
                 });
             })
         });
@@ -4940,7 +4940,7 @@ mod tests {
         cx.update(|cx| {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<ProjectPanelSettings>(cx, |project_panel_settings| {
-                    project_panel_settings.auto_reveal_entries = Some(true)
+                    project_panel_settings.auto_reveal_entries = true
                 });
             })
         });
@@ -5054,10 +5054,10 @@ mod tests {
         cx.update(|cx| {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |worktree_settings| {
-                    worktree_settings.file_scan_exclusions = Some(Vec::new());
+                    worktree_settings.file_scan_exclusions = Vec::new();
                 });
                 store.update_user_settings::<ProjectPanelSettings>(cx, |project_panel_settings| {
-                    project_panel_settings.auto_reveal_entries = Some(false)
+                    project_panel_settings.auto_reveal_entries = false
                 });
             })
         });
@@ -5256,7 +5256,7 @@ mod tests {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
                     project_settings.file_scan_exclusions =
-                        Some(vec!["excluded_dir".to_string(), "**/.git".to_string()]);
+                        vec!["excluded_dir".to_string(), "**/.git".to_string()];
                 });
             });
         });
@@ -5569,10 +5569,10 @@ mod tests {
 
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<ProjectPanelSettings>(cx, |project_panel_settings| {
-                    project_panel_settings.auto_fold_dirs = Some(false);
+                    project_panel_settings.auto_fold_dirs = false;
                 });
                 store.update_user_settings::<WorktreeSettings>(cx, |worktree_settings| {
-                    worktree_settings.file_scan_exclusions = Some(Vec::new());
+                    worktree_settings.file_scan_exclusions = Vec::new();
                 });
             });
         });
@@ -5591,10 +5591,10 @@ mod tests {
 
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<ProjectPanelSettings>(cx, |project_panel_settings| {
-                    project_panel_settings.auto_fold_dirs = Some(false);
+                    project_panel_settings.auto_fold_dirs = false;
                 });
                 store.update_user_settings::<WorktreeSettings>(cx, |worktree_settings| {
-                    worktree_settings.file_scan_exclusions = Some(Vec::new());
+                    worktree_settings.file_scan_exclusions = Vec::new();
                 });
             });
         });
diff --git a/crates/project_panel/src/project_panel_settings.rs b/crates/project_panel/src/project_panel_settings.rs
index 4d73ae92456da9..6910b4627a00a0 100644
--- a/crates/project_panel/src/project_panel_settings.rs
+++ b/crates/project_panel/src/project_panel_settings.rs
@@ -2,6 +2,7 @@ use gpui::Pixels;
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
+use ui::px;
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Copy, PartialEq)]
 #[serde(rename_all = "snake_case")]
@@ -10,20 +11,50 @@ pub enum ProjectPanelDockPosition {
     Right,
 }
 
-#[derive(Deserialize, Debug, Clone, Copy, PartialEq)]
+#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq, JsonSchema)]
+#[serde(default)]
 pub struct ProjectPanelSettings {
+    /// Whether to show the project panel button in the status bar.
     pub button: bool,
+    /// Customize default width (in pixels) taken by project panel
     pub default_width: Pixels,
+    /// The position of project panel
     pub dock: ProjectPanelDockPosition,
+    /// Whether to show file icons in the project panel.
     pub file_icons: bool,
+    /// Whether to show folder icons or chevrons for directories in the project panel.
     pub folder_icons: bool,
+    /// Whether to show the git status in the project panel.
     pub git_status: bool,
-    pub indent_size: f32,
+    /// Amount of indentation (in pixels) for nested items.
+    pub indent_size: Pixels,
+    /// Whether to reveal it in the project panel automatically,
+    /// when a corresponding project entry becomes active.
+    /// Gitignored entries are never auto revealed.
     pub auto_reveal_entries: bool,
+    /// Whether to fold directories automatically
+    /// when directory has only one directory inside.
     pub auto_fold_dirs: bool,
+    /// Scrollbar-related settings
     pub scrollbar: ScrollbarSettings,
 }
 
+impl Default for ProjectPanelSettings {
+    fn default() -> Self {
+        Self {
+            button: true,
+            default_width: px(240.),
+            dock: ProjectPanelDockPosition::Left,
+            file_icons: true,
+            folder_icons: true,
+            git_status: true,
+            indent_size: px(20.),
+            auto_reveal_entries: true,
+            auto_fold_dirs: true,
+            scrollbar: Default::default(),
+        }
+    }
+}
 /// When to show the scrollbar in the project panel.
 ///
 /// Default: always
@@ -37,7 +68,7 @@ pub enum ShowScrollbar {
     Never,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+#[derive(Copy, Clone, Default, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 pub struct ScrollbarSettings {
     /// When to show the scrollbar in the project panel.
     ///
@@ -45,63 +76,10 @@ pub struct ScrollbarSettings {
     pub show: ShowScrollbar,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
-pub struct ScrollbarSettingsContent {
-    /// When to show the scrollbar in the project panel.
-    ///
-    /// Default: always
-    pub show: Option<ShowScrollbar>,
-}
-
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-pub struct ProjectPanelSettingsContent {
-    /// Whether to show the project panel button in the status bar.
-    ///
-    /// Default: true
-    pub button: Option<bool>,
-    /// Customize default width (in pixels) taken by project panel
-    ///
-    /// Default: 240
-    pub default_width: Option<f32>,
-    /// The position of project panel
-    ///
-    /// Default: left
-    pub dock: Option<ProjectPanelDockPosition>,
-    /// Whether to show file icons in the project panel.
-    ///
-    /// Default: true
-    pub file_icons: Option<bool>,
-    /// Whether to show folder icons or chevrons for directories in the project panel.
-    ///
-    /// Default: true
-    pub folder_icons: Option<bool>,
-    /// Whether to show the git status in the project panel.
-    ///
-    /// Default: true
-    pub git_status: Option<bool>,
-    /// Amount of indentation (in pixels) for nested items.
-    ///
-    /// Default: 20
-    pub indent_size: Option<f32>,
-    /// Whether to reveal it in the project panel automatically,
-    /// when a corresponding project entry becomes active.
-    /// Gitignored entries are never auto revealed.
-    ///
-    /// Default: true
-    pub auto_reveal_entries: Option<bool>,
-    /// Whether to fold directories automatically
-    /// when directory has only one directory inside.
-    ///
-    /// Default: false
-    pub auto_fold_dirs: Option<bool>,
-    /// Scrollbar-related settings
-    pub scrollbar: Option<ScrollbarSettingsContent>,
-}
-
 impl Settings for ProjectPanelSettings {
     const KEY: Option<&'static str> = Some("project_panel");
 
-    type FileContent = ProjectPanelSettingsContent;
+    type FileContent = Self;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index d8b10f31f9f55e..b7fa6359459290 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -48,7 +48,6 @@ use workspace::{notifications::DetachAndPromptErr, AppState, ModalView, Workspac
 use crate::open_dev_server_project;
 use crate::ssh_connections::connect_over_ssh;
 use crate::ssh_connections::open_ssh_project;
-use crate::ssh_connections::RemoteSettingsContent;
 use crate::ssh_connections::SshConnection;
 use crate::ssh_connections::SshConnectionModal;
 use crate::ssh_connections::SshProject;
@@ -1024,7 +1023,7 @@ impl DevServerProjects {
     fn update_settings_file(
         &mut self,
         cx: &mut ViewContext<Self>,
-        f: impl FnOnce(&mut RemoteSettingsContent) + Send + Sync + 'static,
+        f: impl FnOnce(&mut SshSettings) + Send + Sync + 'static,
     ) {
         let Some(fs) = self
             .workspace
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 8da4284b7f56a7..b54196022dbcde 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -22,8 +22,24 @@ use ui::{
 use util::paths::PathWithPosition;
 use workspace::{AppState, ModalView, Workspace};
 
-#[derive(Deserialize)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 pub struct SshSettings {
+    /// ssh_connections is an array of ssh connections.
+    /// By default this setting is null, which disables the direct ssh connection support.
+    /// You can configure these from `project: Open Remote` in the command palette.
+    /// Zed's ssh support will pull configuration from your ~/.ssh too.
+    /// Examples:
+    /// [
+    ///   {
+    ///     "host": "example-box",
+    ///     "projects": [
+    ///       {
+    ///         "paths": ["/home/user/code/zed"]
+    ///       }
+    ///     ]
+    ///   }
+    /// ]
     pub ssh_connections: Option<Vec<SshConnection>>,
 }
 
@@ -62,15 +78,10 @@ pub struct SshProject {
     pub paths: Vec<String>,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct RemoteSettingsContent {
-    pub ssh_connections: Option<Vec<SshConnection>>,
-}
-
 impl Settings for SshSettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = RemoteSettingsContent;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/repl/src/jupyter_settings.rs b/crates/repl/src/jupyter_settings.rs
index aefef6cec5b44d..f441da4790b804 100644
--- a/crates/repl/src/jupyter_settings.rs
+++ b/crates/repl/src/jupyter_settings.rs
@@ -6,8 +6,10 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 pub struct JupyterSettings {
+    /// Default kernels to select for each language.
     pub kernel_selections: HashMap<String, String>,
 }
 
@@ -20,26 +22,10 @@ impl JupyterSettings {
     }
 }
 
-#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
-pub struct JupyterSettingsContent {
-    /// Default kernels to select for each language.
-    ///
-    /// Default: `{}`
-    pub kernel_selections: Option<HashMap<String, String>>,
-}
-
-impl Default for JupyterSettingsContent {
-    fn default() -> Self {
-        JupyterSettingsContent {
-            kernel_selections: Some(HashMap::new()),
-        }
-    }
-}
-
 impl Settings for JupyterSettings {
     const KEY: Option<&'static str> = Some("jupyter");
 
-    type FileContent = JupyterSettingsContent;
+    type FileContent = Self;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
@@ -51,10 +37,8 @@ impl Settings for JupyterSettings {
         let mut settings = JupyterSettings::default();
 
         for value in sources.defaults_and_customizations() {
-            if let Some(source) = &value.kernel_selections {
-                for (k, v) in source {
-                    settings.kernel_selections.insert(k.clone(), v.clone());
-                }
+            for (k, v) in &value.kernel_selections {
+                settings.kernel_selections.insert(k.clone(), v.clone());
             }
         }
 
diff --git a/crates/tasks_ui/src/settings.rs b/crates/tasks_ui/src/settings.rs
index 1bcd4962644232..4ad6f607b76c3a 100644
--- a/crates/tasks_ui/src/settings.rs
+++ b/crates/tasks_ui/src/settings.rs
@@ -2,22 +2,26 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-#[derive(Serialize, Deserialize, PartialEq, Default)]
+#[derive(Clone, Serialize, Deserialize, PartialEq, JsonSchema)]
+#[serde(default)]
+/// Task-related settings.
 pub(crate) struct TaskSettings {
+    /// Whether to show task status indicator in the status bar. Default: true
     pub(crate) show_status_indicator: bool,
 }
 
-/// Task-related settings.
-#[derive(Serialize, Deserialize, PartialEq, Default, Clone, JsonSchema)]
-pub(crate) struct TaskSettingsContent {
-    /// Whether to show task status indicator in the status bar. Default: true
-    show_status_indicator: Option<bool>,
+impl Default for TaskSettings {
+    fn default() -> Self {
+        Self {
+            show_status_indicator: true,
+        }
+    }
 }
 
 impl Settings for TaskSettings {
     const KEY: Option<&'static str> = Some("task");
 
-    type FileContent = TaskSettingsContent;
+    type FileContent = Self;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
diff --git a/crates/vim/src/digraph.rs b/crates/vim/src/digraph.rs
index 443b7ff37801eb..282016cfdad277 100644
--- a/crates/vim/src/digraph.rs
+++ b/crates/vim/src/digraph.rs
@@ -132,7 +132,7 @@ mod test {
                 let mut custom_digraphs = HashMap::default();
                 custom_digraphs.insert("|-".into(), "⊢".into());
                 custom_digraphs.insert(":)".into(), "👨‍💻".into());
-                s.custom_digraphs = Some(custom_digraphs);
+                s.custom_digraphs = custom_digraphs;
             });
         });
 
diff --git a/crates/vim/src/normal.rs b/crates/vim/src/normal.rs
index 8198c0da53b4f0..815086d0be0470 100644
--- a/crates/vim/src/normal.rs
+++ b/crates/vim/src/normal.rs
@@ -1184,7 +1184,7 @@ mod test {
         let mut cx = VimTestContext::new(cx, true).await;
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_multiline_find = Some(true);
+                s.use_multiline_find = true;
             });
         });
 
@@ -1226,7 +1226,7 @@ mod test {
         let mut cx = VimTestContext::new(cx, true).await;
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_multiline_find = Some(true);
+                s.use_multiline_find = true;
             });
         });
 
@@ -1268,7 +1268,7 @@ mod test {
         let mut cx = VimTestContext::new(cx, true).await;
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_smartcase_find = Some(true);
+                s.use_smartcase_find = true;
             });
         });
 
diff --git a/crates/vim/src/normal/paste.rs b/crates/vim/src/normal/paste.rs
index 05469dbf9f168f..6465e33e0f3b53 100644
--- a/crates/vim/src/normal/paste.rs
+++ b/crates/vim/src/normal/paste.rs
@@ -291,7 +291,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = Some(UseSystemClipboard::Never)
+                s.use_system_clipboard = UseSystemClipboard::Never
             });
         });
 
@@ -327,7 +327,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = Some(UseSystemClipboard::OnYank)
+                s.use_system_clipboard = UseSystemClipboard::OnYank
             });
         });
 
@@ -584,7 +584,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = Some(UseSystemClipboard::Never)
+                s.use_system_clipboard = UseSystemClipboard::Never
             });
         });
 
@@ -630,7 +630,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = Some(UseSystemClipboard::Never)
+                s.use_system_clipboard = UseSystemClipboard::Never
             });
         });
 
@@ -659,7 +659,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = Some(UseSystemClipboard::Never)
+                s.use_system_clipboard = UseSystemClipboard::Never
             });
         });
 
@@ -707,7 +707,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = Some(UseSystemClipboard::Never)
+                s.use_system_clipboard = UseSystemClipboard::Never
             });
         });
 
diff --git a/crates/vim/src/normal/scroll.rs b/crates/vim/src/normal/scroll.rs
index f89faa3748372f..6a20ea4eb33bb1 100644
--- a/crates/vim/src/normal/scroll.rs
+++ b/crates/vim/src/normal/scroll.rs
@@ -294,7 +294,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<EditorSettings>(cx, |s| {
-                s.scroll_beyond_last_line = Some(ScrollBeyondLastLine::Off)
+                s.scroll_beyond_last_line = ScrollBeyondLastLine::Off
             });
         });
 
diff --git a/crates/vim/src/normal/search.rs b/crates/vim/src/normal/search.rs
index 28f33d49d85f20..6418475ad2f576 100644
--- a/crates/vim/src/normal/search.rs
+++ b/crates/vim/src/normal/search.rs
@@ -542,7 +542,7 @@ mod test {
         let mut cx = VimTestContext::new(cx, true).await;
 
         cx.update_global(|store: &mut SettingsStore, cx| {
-            store.update_user_settings::<EditorSettings>(cx, |s| s.search_wrap = Some(false));
+            store.update_user_settings::<EditorSettings>(cx, |s| s.search_wrap = false);
         });
 
         cx.set_state("ˇhi\nhigh\nhi\n", Mode::Normal);
@@ -655,7 +655,7 @@ mod test {
 
         // check that searching with unable search wrap
         cx.update_global(|store: &mut SettingsStore, cx| {
-            store.update_user_settings::<EditorSettings>(cx, |s| s.search_wrap = Some(false));
+            store.update_user_settings::<EditorSettings>(cx, |s| s.search_wrap = false);
         });
         cx.set_state("aa\nbˇb\ncc\ncc\ncc\n", Mode::Normal);
         cx.simulate_keystrokes("/ c c enter");
diff --git a/crates/vim/src/test.rs b/crates/vim/src/test.rs
index 9c61e9cd938292..be7db47315f22d 100644
--- a/crates/vim/src/test.rs
+++ b/crates/vim/src/test.rs
@@ -1300,7 +1300,7 @@ async fn test_command_alias(cx: &mut gpui::TestAppContext) {
         store.update_user_settings::<WorkspaceSettings>(cx, |s| {
             let mut aliases = HashMap::default();
             aliases.insert("Q".to_string(), "upper".to_string());
-            s.command_aliases = Some(aliases)
+            s.command_aliases = aliases
         });
     });
 
diff --git a/crates/vim/src/test/vim_test_context.rs b/crates/vim/src/test/vim_test_context.rs
index c985f68e701eb1..b68d2ede8b09b7 100644
--- a/crates/vim/src/test/vim_test_context.rs
+++ b/crates/vim/src/test/vim_test_context.rs
@@ -57,7 +57,7 @@ impl VimTestContext {
     pub fn new_with_lsp(mut cx: EditorLspTestContext, enabled: bool) -> VimTestContext {
         cx.update(|cx| {
             SettingsStore::update_global(cx, |store, cx| {
-                store.update_user_settings::<VimModeSetting>(cx, |s| *s = Some(enabled));
+                store.update_user_settings::<VimModeSetting>(cx, |s| *s = VimModeSetting(enabled));
             });
             settings::KeymapFile::load_asset("keymaps/default-macos.json", cx).unwrap();
             if enabled {
@@ -105,7 +105,7 @@ impl VimTestContext {
     pub fn enable_vim(&mut self) {
         self.cx.update(|cx| {
             SettingsStore::update_global(cx, |store, cx| {
-                store.update_user_settings::<VimModeSetting>(cx, |s| *s = Some(true));
+                store.update_user_settings::<VimModeSetting>(cx, |s| *s = VimModeSetting(true));
             });
         })
     }
@@ -113,7 +113,7 @@ impl VimTestContext {
     pub fn disable_vim(&mut self) {
         self.cx.update(|cx| {
             SettingsStore::update_global(cx, |store, cx| {
-                store.update_user_settings::<VimModeSetting>(cx, |s| *s = Some(false));
+                store.update_user_settings::<VimModeSetting>(cx, |s| *s = VimModeSetting(false));
             });
         })
     }
diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs
index 6e03374c22595e..6baca17948e8ef 100644
--- a/crates/vim/src/vim.rs
+++ b/crates/vim/src/vim.rs
@@ -46,6 +46,8 @@ use crate::state::ReplayableAction;
 /// Whether or not to enable Vim mode.
 ///
 /// Default: false
+#[derive(Copy, Clone, Default, Deserialize, Serialize, JsonSchema)]
+#[serde(default, transparent)]
 pub struct VimModeSetting(pub bool);
 
 /// An Action to Switch between modes
@@ -99,7 +101,7 @@ pub fn init(cx: &mut AppContext) {
             let fs = workspace.app_state().fs.clone();
             let currently_enabled = Vim::enabled(cx);
             update_settings_file::<VimModeSetting>(fs, cx, move |setting, _| {
-                *setting = Some(!currently_enabled)
+                *setting = VimModeSetting(!currently_enabled);
             })
         });
 
@@ -1068,12 +1070,10 @@ impl Vim {
 impl Settings for VimModeSetting {
     const KEY: Option<&'static str> = Some("vim_mode");
 
-    type FileContent = Option<bool>;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
-        Ok(Self(sources.user.copied().flatten().unwrap_or(
-            sources.default.ok_or_else(Self::missing_default)?,
-        )))
+        Ok(sources.user.copied().unwrap_or(*sources.default))
     }
 }
 
@@ -1089,7 +1089,8 @@ pub enum UseSystemClipboard {
     OnYank,
 }
 
-#[derive(Deserialize)]
+#[derive(Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 struct VimSettings {
     pub toggle_relative_line_numbers: bool,
     pub use_system_clipboard: UseSystemClipboard,
@@ -1098,19 +1099,22 @@ struct VimSettings {
     pub custom_digraphs: HashMap<String, Arc<str>>,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-struct VimSettingsContent {
-    pub toggle_relative_line_numbers: Option<bool>,
-    pub use_system_clipboard: Option<UseSystemClipboard>,
-    pub use_multiline_find: Option<bool>,
-    pub use_smartcase_find: Option<bool>,
-    pub custom_digraphs: Option<HashMap<String, Arc<str>>>,
+impl Default for VimSettings {
+    fn default() -> Self {
+        Self {
+            toggle_relative_line_numbers: false,
+            use_system_clipboard: UseSystemClipboard::Always,
+            use_multiline_find: false,
+            use_smartcase_find: false,
+            custom_digraphs: Default::default(),
+        }
+    }
 }
 
 impl Settings for VimSettings {
     const KEY: Option<&'static str> = Some("vim");
 
-    type FileContent = VimSettingsContent;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/welcome/src/base_keymap_picker.rs b/crates/welcome/src/base_keymap_picker.rs
index 96a9df9c3c8cca..fd7361f9b3d002 100644
--- a/crates/welcome/src/base_keymap_picker.rs
+++ b/crates/welcome/src/base_keymap_picker.rs
@@ -177,7 +177,7 @@ impl PickerDelegate for BaseKeymapSelectorDelegate {
                 .report_setting_event("keymap", base_keymap.to_string());
 
             update_settings_file::<BaseKeymap>(self.fs.clone(), cx, move |setting, _| {
-                *setting = Some(base_keymap)
+                *setting = base_keymap;
             });
         }
 
diff --git a/crates/welcome/src/base_keymap_setting.rs b/crates/welcome/src/base_keymap_setting.rs
index 1b52bbc9f94fbd..0c1724627cf6d9 100644
--- a/crates/welcome/src/base_keymap_setting.rs
+++ b/crates/welcome/src/base_keymap_setting.rs
@@ -87,15 +87,15 @@ impl BaseKeymap {
 impl Settings for BaseKeymap {
     const KEY: Option<&'static str> = Some("base_keymap");
 
-    type FileContent = Option<Self>;
+    type FileContent = Self;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
         _: &mut gpui::AppContext,
     ) -> anyhow::Result<Self> {
-        if let Some(Some(user_value)) = sources.user.copied() {
+        if let Some(user_value) = sources.user.copied() {
             return Ok(user_value);
         }
-        sources.default.ok_or_else(Self::missing_default)
+        Ok(*sources.default)
     }
 }
diff --git a/crates/welcome/src/welcome.rs b/crates/welcome/src/welcome.rs
index fc837c68671a31..787c2e589bb0fe 100644
--- a/crates/welcome/src/welcome.rs
+++ b/crates/welcome/src/welcome.rs
@@ -188,7 +188,7 @@ impl Render for WelcomePage {
                                     this.update_settings::<VimModeSetting>(
                                         selection,
                                         cx,
-                                        |setting, value| *setting = Some(value),
+                                        |setting, value| *setting = VimModeSetting(value),
                                     );
                                 }),
                             ))
diff --git a/crates/workspace/src/item.rs b/crates/workspace/src/item.rs
index 935f0268b62ffe..46b8f3bf7fa90b 100644
--- a/crates/workspace/src/item.rs
+++ b/crates/workspace/src/item.rs
@@ -36,20 +36,49 @@ use util::ResultExt;
 
 pub const LEADER_UPDATE_THROTTLE: Duration = Duration::from_millis(200);
 
-#[derive(Deserialize)]
+#[derive(Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 pub struct ItemSettings {
+    /// Whether to show the Git file status on a tab item.
     pub git_status: bool,
+    /// Position of the close button in a tab.
     pub close_position: ClosePosition,
+    /// Whether to show the file icon for a tab.
     pub file_icons: bool,
 }
 
-#[derive(Deserialize)]
+impl Default for ItemSettings {
+    fn default() -> Self {
+        Self {
+            git_status: false,
+            close_position: ClosePosition::Right,
+            file_icons: false,
+        }
+    }
+}
+
+#[derive(Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 pub struct PreviewTabsSettings {
+    /// Whether to show opened editors as preview tabs.
+    /// Preview tabs do not stay open, are reused until explicitly set to be kept open opened (via double-click or editing) and show file names in italic.
     pub enabled: bool,
+    /// Whether to open tabs in preview mode when selected from the file finder.
     pub enable_preview_from_file_finder: bool,
+    /// Whether a preview tab gets replaced when code navigation is used to navigate away from the tab.
     pub enable_preview_from_code_navigation: bool,
 }
 
+impl Default for PreviewTabsSettings {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            enable_preview_from_file_finder: false,
+            enable_preview_from_code_navigation: false,
+        }
+    }
+}
+
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "lowercase")]
 pub enum ClosePosition {
@@ -67,43 +96,10 @@ impl ClosePosition {
     }
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct ItemSettingsContent {
-    /// Whether to show the Git file status on a tab item.
-    ///
-    /// Default: false
-    git_status: Option<bool>,
-    /// Position of the close button in a tab.
-    ///
-    /// Default: right
-    close_position: Option<ClosePosition>,
-    /// Whether to show the file icon for a tab.
-    ///
-    /// Default: false
-    file_icons: Option<bool>,
-}
-
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct PreviewTabsSettingsContent {
-    /// Whether to show opened editors as preview tabs.
-    /// Preview tabs do not stay open, are reused until explicitly set to be kept open opened (via double-click or editing) and show file names in italic.
-    ///
-    /// Default: true
-    enabled: Option<bool>,
-    /// Whether to open tabs in preview mode when selected from the file finder.
-    ///
-    /// Default: false
-    enable_preview_from_file_finder: Option<bool>,
-    /// Whether a preview tab gets replaced when code navigation is used to navigate away from the tab.
-    ///
-    /// Default: false
-    enable_preview_from_code_navigation: Option<bool>,
-}
-
 impl Settings for ItemSettings {
     const KEY: Option<&'static str> = Some("tabs");
 
-    type FileContent = ItemSettingsContent;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
@@ -113,7 +109,7 @@ impl Settings for ItemSettings {
 impl Settings for PreviewTabsSettings {
     const KEY: Option<&'static str> = Some("preview_tabs");
 
-    type FileContent = PreviewTabsSettingsContent;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 7371e56cee2376..50b92326b28b19 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -6418,7 +6418,7 @@ mod tests {
         item.update(cx, |item, cx| {
             SettingsStore::update_global(cx, |settings, cx| {
                 settings.update_user_settings::<WorkspaceSettings>(cx, |settings| {
-                    settings.autosave = Some(AutosaveSetting::OnWindowChange);
+                    settings.autosave = AutosaveSetting::OnWindowChange;
                 })
             });
             item.is_dirty = true;
@@ -6438,7 +6438,7 @@ mod tests {
             cx.focus_self();
             SettingsStore::update_global(cx, |settings, cx| {
                 settings.update_user_settings::<WorkspaceSettings>(cx, |settings| {
-                    settings.autosave = Some(AutosaveSetting::OnFocusChange);
+                    settings.autosave = AutosaveSetting::OnFocusChange;
                 })
             });
             item.is_dirty = true;
@@ -6461,7 +6461,7 @@ mod tests {
         item.update(cx, |item, cx| {
             SettingsStore::update_global(cx, |settings, cx| {
                 settings.update_user_settings::<WorkspaceSettings>(cx, |settings| {
-                    settings.autosave = Some(AutosaveSetting::AfterDelay { milliseconds: 500 });
+                    settings.autosave = AutosaveSetting::AfterDelay { milliseconds: 500 };
                 })
             });
             item.is_dirty = true;
@@ -6480,7 +6480,7 @@ mod tests {
         item.update(cx, |item, cx| {
             SettingsStore::update_global(cx, |settings, cx| {
                 settings.update_user_settings::<WorkspaceSettings>(cx, |settings| {
-                    settings.autosave = Some(AutosaveSetting::OnFocusChange);
+                    settings.autosave = AutosaveSetting::OnFocusChange;
                 })
             });
             item.is_dirty = true;
diff --git a/crates/workspace/src/workspace_settings.rs b/crates/workspace/src/workspace_settings.rs
index 52827c6941ae7d..f87840eb308388 100644
--- a/crates/workspace/src/workspace_settings.rs
+++ b/crates/workspace/src/workspace_settings.rs
@@ -5,22 +5,58 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-#[derive(Deserialize)]
+#[derive(Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 pub struct WorkspaceSettings {
+    /// Scale by which to zoom the active pane.
+    /// When set to 1.0, the active pane has the same size as others,
+    /// but when set to a larger value, the active pane takes up more space.
     pub active_pane_magnification: f32,
+    /// Direction to split horizontally.
     pub pane_split_direction_horizontal: PaneSplitDirectionHorizontal,
+    /// Direction to split vertically.
     pub pane_split_direction_vertical: PaneSplitDirectionVertical,
+    /// Centered layout related settings.
     pub centered_layout: CenteredLayoutSettings,
+    /// Whether or not to prompt the user to confirm before closing the application.
     pub confirm_quit: bool,
+    /// Whether or not to show the call status icon in the status bar.
     pub show_call_status_icon: bool,
+    /// When to automatically save edited buffers.
     pub autosave: AutosaveSetting,
+    /// Controls previous session restoration in freshly launched Zed instance.
     pub restore_on_startup: RestoreOnStartupBehavior,
+    /// The size of the workspace split drop targets on the outer edges.
+    /// Given as a fraction that will be multiplied by the smaller dimension of the workspace.
     pub drop_target_size: f32,
+    /// Whether to close the window when using 'close active item' on a workspace with no tabs
     pub when_closing_with_no_tabs: CloseWindowWhenNoItems,
+    /// Whether to use the system provided dialogs for Open and Save As.
+    /// When set to false, Zed will use the built-in keyboard-first pickers.
     pub use_system_path_prompts: bool,
+    /// Aliases for the command palette. When you type a key in this map,
+    /// it will be assumed to equal the value.
     pub command_aliases: HashMap<String, String>,
 }
 
+impl Default for WorkspaceSettings {
+    fn default() -> Self {
+        Self {
+            active_pane_magnification: 1.0,
+            pane_split_direction_horizontal: PaneSplitDirectionHorizontal::Up,
+            pane_split_direction_vertical: PaneSplitDirectionVertical::Left,
+            centered_layout: CenteredLayoutSettings::default(),
+            confirm_quit: false,
+            show_call_status_icon: true,
+            autosave: AutosaveSetting::Off,
+            restore_on_startup: RestoreOnStartupBehavior::default(),
+            drop_target_size: 0.2,
+            when_closing_with_no_tabs: CloseWindowWhenNoItems::default(),
+            use_system_path_prompts: true,
+            command_aliases: HashMap::default(),
+        }
+    }
+}
 #[derive(Copy, Clone, Default, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum CloseWindowWhenNoItems {
@@ -55,77 +91,22 @@ pub enum RestoreOnStartupBehavior {
     LastSession,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct WorkspaceSettingsContent {
-    /// Scale by which to zoom the active pane.
-    /// When set to 1.0, the active pane has the same size as others,
-    /// but when set to a larger value, the active pane takes up more space.
-    ///
-    /// Default: `1.0`
-    pub active_pane_magnification: Option<f32>,
-    // Direction to split horizontally.
-    //
-    // Default: "up"
-    pub pane_split_direction_horizontal: Option<PaneSplitDirectionHorizontal>,
-    // Direction to split vertically.
-    //
-    // Default: "left"
-    pub pane_split_direction_vertical: Option<PaneSplitDirectionVertical>,
-    // Centered layout related settings.
-    pub centered_layout: Option<CenteredLayoutSettings>,
-    /// Whether or not to prompt the user to confirm before closing the application.
-    ///
-    /// Default: false
-    pub confirm_quit: Option<bool>,
-    /// Whether or not to show the call status icon in the status bar.
-    ///
-    /// Default: true
-    pub show_call_status_icon: Option<bool>,
-    /// When to automatically save edited buffers.
-    ///
-    /// Default: off
-    pub autosave: Option<AutosaveSetting>,
-    /// Controls previous session restoration in freshly launched Zed instance.
-    /// Values: none, last_workspace, last_session
-    /// Default: last_session
-    pub restore_on_startup: Option<RestoreOnStartupBehavior>,
-    /// The size of the workspace split drop targets on the outer edges.
-    /// Given as a fraction that will be multiplied by the smaller dimension of the workspace.
-    ///
-    /// Default: `0.2` (20% of the smaller dimension of the workspace)
-    pub drop_target_size: Option<f32>,
-    /// Whether to close the window when using 'close active item' on a workspace with no tabs
-    ///
-    /// Default: auto ("on" on macOS, "off" otherwise)
-    pub when_closing_with_no_tabs: Option<CloseWindowWhenNoItems>,
-    /// Whether to use the system provided dialogs for Open and Save As.
-    /// When set to false, Zed will use the built-in keyboard-first pickers.
-    ///
-    /// Default: true
-    pub use_system_path_prompts: Option<bool>,
-    /// Aliases for the command palette. When you type a key in this map,
-    /// it will be assumed to equal the value.
-    ///
-    /// Default: true
-    pub command_aliases: Option<HashMap<String, String>>,
-}
-
-#[derive(Deserialize)]
+#[derive(Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 pub struct TabBarSettings {
+    /// Whether or not to show the tab bar in the editor.
     pub show: bool,
+    /// Whether or not to show the navigation history buttons in the tab bar.
     pub show_nav_history_buttons: bool,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct TabBarSettingsContent {
-    /// Whether or not to show the tab bar in the editor.
-    ///
-    /// Default: true
-    pub show: Option<bool>,
-    /// Whether or not to show the navigation history buttons in the tab bar.
-    ///
-    /// Default: true
-    pub show_nav_history_buttons: Option<bool>,
+impl Default for TabBarSettings {
+    fn default() -> Self {
+        Self {
+            show_nav_history_buttons: true,
+            show: true,
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
@@ -163,17 +144,26 @@ pub struct CenteredLayoutSettings {
     ///
     /// Default: 0.2
     pub left_padding: Option<f32>,
-    // The relative width of the right padding of the central pane from the
-    // workspace when the centered layout is used.
+    /// The relative width of the right padding of the central pane from the
+    /// workspace when the centered layout is used.
     ///
     /// Default: 0.2
     pub right_padding: Option<f32>,
 }
 
+impl Default for CenteredLayoutSettings {
+    fn default() -> Self {
+        Self {
+            left_padding: Some(0.2),
+            right_padding: Some(0.2),
+        }
+    }
+}
+
 impl Settings for WorkspaceSettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = WorkspaceSettingsContent;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
@@ -183,7 +173,7 @@ impl Settings for WorkspaceSettings {
 impl Settings for TabBarSettings {
     const KEY: Option<&'static str> = Some("tab_bar");
 
-    type FileContent = TabBarSettingsContent;
+    type FileContent = Self;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/worktree/src/worktree_settings.rs b/crates/worktree/src/worktree_settings.rs
index 32851d963a1321..82be3a80287928 100644
--- a/crates/worktree/src/worktree_settings.rs
+++ b/crates/worktree/src/worktree_settings.rs
@@ -25,7 +25,8 @@ impl WorktreeSettings {
     }
 }
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
 pub struct WorktreeSettingsContent {
     /// Completely ignore files matching globs from `file_scan_exclusions`
     ///
@@ -39,12 +40,42 @@ pub struct WorktreeSettingsContent {
     ///   "**/.classpath",
     ///   "**/.settings"
     /// ]
-    #[serde(default)]
-    pub file_scan_exclusions: Option<Vec<String>>,
+    pub file_scan_exclusions: Vec<String>,
 
     /// Treat the files matching these globs as `.env` files.
     /// Default: [ "**/.env*" ]
-    pub private_files: Option<Vec<String>>,
+    pub private_files: Vec<String>,
+}
+
+impl Default for WorktreeSettingsContent {
+    fn default() -> Self {
+        Self {
+            private_files: [
+                "**/.env*",
+                "**/*.pem",
+                "**/*.key",
+                "**/*.cert",
+                "**/*.crt",
+                "**/secrets.yml",
+            ]
+            .into_iter()
+            .map(str::to_owned)
+            .collect(),
+            file_scan_exclusions: [
+                "**/.git",
+                "**/.svn",
+                "**/.hg",
+                "**/CVS",
+                "**/.DS_Store",
+                "**/Thumbs.db",
+                "**/.classpath",
+                "**/.settings",
+            ]
+            .into_iter()
+            .map(str::to_owned)
+            .collect(),
+        }
+    }
 }
 
 impl Settings for WorktreeSettings {
@@ -57,8 +88,8 @@ impl Settings for WorktreeSettings {
         _: &mut AppContext,
     ) -> anyhow::Result<Self> {
         let result: WorktreeSettingsContent = sources.json_merge()?;
-        let mut file_scan_exclusions = result.file_scan_exclusions.unwrap_or_default();
-        let mut private_files = result.private_files.unwrap_or_default();
+        let mut file_scan_exclusions = result.file_scan_exclusions;
+        let mut private_files = result.private_files;
         file_scan_exclusions.sort();
         private_files.sort();
         Ok(Self {
diff --git a/crates/worktree/src/worktree_tests.rs b/crates/worktree/src/worktree_tests.rs
index 929dc01c6d17e9..455bc62a79a874 100644
--- a/crates/worktree/src/worktree_tests.rs
+++ b/crates/worktree/src/worktree_tests.rs
@@ -673,7 +673,7 @@ async fn test_rescan_with_gitignore(cx: &mut TestAppContext) {
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|store, cx| {
             store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
-                project_settings.file_scan_exclusions = Some(Vec::new());
+                project_settings.file_scan_exclusions = Vec::new();
             });
         });
     });
@@ -910,7 +910,7 @@ async fn test_file_scan_exclusions(cx: &mut TestAppContext) {
         cx.update_global::<SettingsStore, _>(|store, cx| {
             store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
                 project_settings.file_scan_exclusions =
-                    Some(vec!["**/foo/**".to_string(), "**/.DS_Store".to_string()]);
+                    vec!["**/foo/**".to_string(), "**/.DS_Store".to_string()];
             });
         });
     });
@@ -945,8 +945,7 @@ async fn test_file_scan_exclusions(cx: &mut TestAppContext) {
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|store, cx| {
             store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
-                project_settings.file_scan_exclusions =
-                    Some(vec!["**/node_modules/**".to_string()]);
+                project_settings.file_scan_exclusions = vec!["**/node_modules/**".to_string()];
             });
         });
     });
@@ -1009,11 +1008,11 @@ async fn test_fs_events_in_exclusions(cx: &mut TestAppContext) {
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|store, cx| {
             store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
-                project_settings.file_scan_exclusions = Some(vec![
+                project_settings.file_scan_exclusions = vec![
                     "**/.git".to_string(),
                     "node_modules/".to_string(),
                     "build_output".to_string(),
-                ]);
+                ];
             });
         });
     });
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index 93fee57ecdb654..9f670efcd7c5fe 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -1996,7 +1996,7 @@ mod tests {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
                     project_settings.file_scan_exclusions =
-                        Some(vec!["excluded_dir".to_string(), "**/.git".to_string()]);
+                        vec!["excluded_dir".to_string(), "**/.git".to_string()];
                 });
             });
         });

From ef5a7e1642ecf7c2c4bb123e66e1bb477c55b255 Mon Sep 17 00:00:00 2001
From: Amin Ahmed Khan <amin@sudofy.com>
Date: Wed, 11 Sep 2024 06:14:43 +0300
Subject: [PATCH 040/762] Fix OpenAI key URL (#17675)

Update the create Open AI Key URL

Release Notes:

- Fixed a link in the Assistant panel to the OpenAI console.
---
 crates/language_model/src/provider/open_ai.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/language_model/src/provider/open_ai.rs b/crates/language_model/src/provider/open_ai.rs
index a7a962e9251671..3a371499eb44db 100644
--- a/crates/language_model/src/provider/open_ai.rs
+++ b/crates/language_model/src/provider/open_ai.rs
@@ -491,7 +491,7 @@ impl ConfigurationView {
 
 impl Render for ConfigurationView {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
-        const OPENAI_CONSOLE_URL: &str = "https://console.anthropic.com/settings/keys";
+        const OPENAI_CONSOLE_URL: &str = "https://platform.openai.com/api-keys";
         const INSTRUCTIONS: [&str; 6] = [
             "To use the assistant panel or inline assistant, you need to add your OpenAI API key.",
             " - You can create an API key at: ",

From 8088d1a9b7377cc9ae2a8f94ea9a5ce868ffc1d6 Mon Sep 17 00:00:00 2001
From: "Dairon M." <dairon.medina@gmail.com>
Date: Tue, 10 Sep 2024 23:21:24 -0400
Subject: [PATCH 041/762] erlang: Bump to v0.1.0 (#17679)

Changes:

- https://github.com/zed-industries/zed/pull/14914
- https://github.com/zed-industries/zed/pull/14879
- https://github.com/zed-industries/zed/pull/14923
- https://github.com/zed-industries/zed/pull/15973
- https://github.com/zed-industries/zed/pull/16955

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 Cargo.lock                       | 2 +-
 extensions/erlang/Cargo.toml     | 2 +-
 extensions/erlang/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 07b97e030df7bc..2027c5421f5dda 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14371,7 +14371,7 @@ dependencies = [
 
 [[package]]
 name = "zed_erlang"
-version = "0.0.1"
+version = "0.1.0"
 dependencies = [
  "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
diff --git a/extensions/erlang/Cargo.toml b/extensions/erlang/Cargo.toml
index 1ac6b4b1b641fc..50673448963bf9 100644
--- a/extensions/erlang/Cargo.toml
+++ b/extensions/erlang/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_erlang"
-version = "0.0.1"
+version = "0.1.0"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/erlang/extension.toml b/extensions/erlang/extension.toml
index 863da32dfa71a3..23c7cf6d4a97d0 100644
--- a/extensions/erlang/extension.toml
+++ b/extensions/erlang/extension.toml
@@ -1,7 +1,7 @@
 id = "erlang"
 name = "Erlang"
 description = "Erlang support."
-version = "0.0.1"
+version = "0.1.0"
 schema_version = 1
 authors = ["Dairon M <dairon.medina@gmail.com>", "Fabian Bergström <fabian@fmbb.se>"]
 repository = "https://github.com/zed-industries/zed"

From 331d28d47982d36c317c80c12851a49422b6468e Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 10 Sep 2024 23:37:37 -0400
Subject: [PATCH 042/762] php: Remove invalid node types from highlights
 queries (#17680)

This PR removes some invalid node types from the PHP highlights queries.

Release Notes:

- N/A
---
 extensions/php/languages/php/highlights.scm | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/extensions/php/languages/php/highlights.scm b/extensions/php/languages/php/highlights.scm
index ab1fdf662cf695..6afeb1090b7a0b 100644
--- a/extensions/php/languages/php/highlights.scm
+++ b/extensions/php/languages/php/highlights.scm
@@ -133,8 +133,5 @@
 "trait" @keyword
 "try" @keyword
 "use" @keyword
-"var" @keyword
 "while" @keyword
 "xor" @keyword
-"yield" @keyword
-"yield from" @keyword

From ec189fe884f48109d17ca3f2984c49c933b46253 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Tue, 10 Sep 2024 23:58:57 -0400
Subject: [PATCH 043/762] Add a way to join all panes into one (#17673)

Closes https://github.com/zed-industries/zed/issues/17536
Closes https://github.com/zed-industries/zed/pull/17548


Release Notes:

- Added a way to join all panes into one with `pane::JoinAll` action
([#17536](https://github.com/zed-industries/zed/issues/17536))

---------

Co-authored-by: Yogesh Dhamija <ydhamija96@gmail.com>
---
 crates/workspace/src/pane.rs      |  19 +--
 crates/workspace/src/workspace.rs | 201 ++++++++++++++++++++++++------
 2 files changed, 173 insertions(+), 47 deletions(-)

diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index cc752f7aec9ff6..d0fa411381a6d6 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -3,6 +3,7 @@ use crate::{
         ClosePosition, Item, ItemHandle, ItemSettings, PreviewTabsSettings, TabContentParams,
         WeakItemHandle,
     },
+    move_item,
     notifications::NotifyResultExt,
     toolbar::Toolbar,
     workspace_settings::{AutosaveSetting, TabBarSettings, WorkspaceSettings},
@@ -149,6 +150,7 @@ actions!(
         GoBack,
         GoForward,
         JoinIntoNext,
+        JoinAll,
         ReopenClosedItem,
         SplitLeft,
         SplitUp,
@@ -188,6 +190,7 @@ pub enum Event {
         item_id: EntityId,
     },
     Split(SplitDirection),
+    JoinAll,
     JoinIntoNext,
     ChangeItemTitle,
     Focus,
@@ -220,6 +223,7 @@ impl fmt::Debug for Event {
                 .debug_struct("Split")
                 .field("direction", direction)
                 .finish(),
+            Event::JoinAll => f.write_str("JoinAll"),
             Event::JoinIntoNext => f.write_str("JoinIntoNext"),
             Event::ChangeItemTitle => f.write_str("ChangeItemTitle"),
             Event::Focus => f.write_str("Focus"),
@@ -679,6 +683,10 @@ impl Pane {
         cx.emit(Event::JoinIntoNext);
     }
 
+    fn join_all(&mut self, cx: &mut ViewContext<Self>) {
+        cx.emit(Event::JoinAll);
+    }
+
     fn history_updated(&mut self, cx: &mut ViewContext<Self>) {
         self.toolbar.update(cx, |_, cx| cx.notify());
     }
@@ -1757,9 +1765,7 @@ impl Pane {
 
             self.workspace
                 .update(cx, |_, cx| {
-                    cx.defer(move |this, cx| {
-                        this.move_item(pane.clone(), pane, id, destination_index, cx)
-                    });
+                    cx.defer(move |_, cx| move_item(&pane, &pane, id, destination_index, cx));
                 })
                 .ok()?;
 
@@ -1777,9 +1783,7 @@ impl Pane {
 
             self.workspace
                 .update(cx, |_, cx| {
-                    cx.defer(move |this, cx| {
-                        this.move_item(pane.clone(), pane, id, destination_index, cx)
-                    });
+                    cx.defer(move |_, cx| move_item(&pane, &pane, id, destination_index, cx));
                 })
                 .ok()?;
 
@@ -2349,7 +2353,7 @@ impl Pane {
                             }
                         })
                     }
-                    workspace.move_item(from_pane.clone(), to_pane.clone(), item_id, ix, cx);
+                    move_item(&from_pane, &to_pane, item_id, ix, cx);
                 });
             })
             .log_err();
@@ -2556,6 +2560,7 @@ impl Render for Pane {
             .on_action(cx.listener(|pane, _: &GoBack, cx| pane.navigate_backward(cx)))
             .on_action(cx.listener(|pane, _: &GoForward, cx| pane.navigate_forward(cx)))
             .on_action(cx.listener(|pane, _: &JoinIntoNext, cx| pane.join_into_next(cx)))
+            .on_action(cx.listener(|pane, _: &JoinAll, cx| pane.join_all(cx)))
             .on_action(cx.listener(Pane::toggle_zoom))
             .on_action(cx.listener(|pane: &mut Pane, action: &ActivateItem, cx| {
                 pane.activate_item(action.0, true, true, cx);
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 50b92326b28b19..e6358cfdb95595 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -2965,6 +2965,7 @@ impl Workspace {
                 self.split_and_clone(pane, *direction, cx);
             }
             pane::Event::JoinIntoNext => self.join_pane_into_next(pane, cx),
+            pane::Event::JoinAll => self.join_all_panes(cx),
             pane::Event::Remove { focus_on_pane } => {
                 self.remove_pane(pane, focus_on_pane.clone(), cx)
             }
@@ -3094,7 +3095,7 @@ impl Workspace {
         };
 
         let new_pane = self.add_pane(cx);
-        self.move_item(from.clone(), new_pane.clone(), item_id_to_move, 0, cx);
+        move_item(&from, &new_pane, item_id_to_move, 0, cx);
         self.center
             .split(&pane_to_split, &new_pane, split_direction)
             .unwrap();
@@ -3122,6 +3123,17 @@ impl Workspace {
         }))
     }
 
+    pub fn join_all_panes(&mut self, cx: &mut ViewContext<Self>) {
+        let active_item = self.active_pane.read(cx).active_item();
+        for pane in &self.panes {
+            join_pane_into_active(&self.active_pane, pane, cx);
+        }
+        if let Some(active_item) = active_item {
+            self.activate_item(active_item.as_ref(), true, true, cx);
+        }
+        cx.notify();
+    }
+
     pub fn join_pane_into_next(&mut self, pane: View<Pane>, cx: &mut ViewContext<Self>) {
         let next_pane = self
             .find_pane_in_direction(SplitDirection::Right, cx)
@@ -3131,48 +3143,10 @@ impl Workspace {
         let Some(next_pane) = next_pane else {
             return;
         };
-
-        let item_ids: Vec<EntityId> = pane.read(cx).items().map(|item| item.item_id()).collect();
-        for item_id in item_ids {
-            self.move_item(pane.clone(), next_pane.clone(), item_id, 0, cx);
-        }
+        move_all_items(&pane, &next_pane, cx);
         cx.notify();
     }
 
-    pub fn move_item(
-        &mut self,
-        source: View<Pane>,
-        destination: View<Pane>,
-        item_id_to_move: EntityId,
-        destination_index: usize,
-        cx: &mut ViewContext<Self>,
-    ) {
-        let Some((item_ix, item_handle)) = source
-            .read(cx)
-            .items()
-            .enumerate()
-            .find(|(_, item_handle)| item_handle.item_id() == item_id_to_move)
-        else {
-            // Tab was closed during drag
-            return;
-        };
-
-        let item_handle = item_handle.clone();
-
-        if source != destination {
-            // Close item from previous pane
-            source.update(cx, |source, cx| {
-                source.remove_item_and_focus_on_pane(item_ix, false, destination.clone(), cx);
-            });
-        }
-
-        // This automatically removes duplicate items in the pane
-        destination.update(cx, |destination, cx| {
-            destination.add_item(item_handle, true, true, Some(destination_index), cx);
-            destination.focus(cx)
-        });
-    }
-
     fn remove_pane(
         &mut self,
         pane: View<Pane>,
@@ -5944,6 +5918,79 @@ fn resize_edge(
     }
 }
 
+fn join_pane_into_active(active_pane: &View<Pane>, pane: &View<Pane>, cx: &mut WindowContext<'_>) {
+    if pane == active_pane {
+        return;
+    } else if pane.read(cx).items_len() == 0 {
+        pane.update(cx, |_, cx| {
+            cx.emit(pane::Event::Remove {
+                focus_on_pane: None,
+            });
+        })
+    } else {
+        move_all_items(pane, active_pane, cx);
+    }
+}
+
+fn move_all_items(from_pane: &View<Pane>, to_pane: &View<Pane>, cx: &mut WindowContext<'_>) {
+    let destination_is_different = from_pane != to_pane;
+    let mut moved_items = 0;
+    for (item_ix, item_handle) in from_pane
+        .read(cx)
+        .items()
+        .enumerate()
+        .map(|(ix, item)| (ix, item.clone()))
+        .collect::<Vec<_>>()
+    {
+        let ix = item_ix - moved_items;
+        if destination_is_different {
+            // Close item from previous pane
+            from_pane.update(cx, |source, cx| {
+                source.remove_item_and_focus_on_pane(ix, false, to_pane.clone(), cx);
+            });
+            moved_items += 1;
+        }
+
+        // This automatically removes duplicate items in the pane
+        to_pane.update(cx, |destination, cx| {
+            destination.add_item(item_handle, true, true, None, cx);
+            destination.focus(cx)
+        });
+    }
+}
+
+pub fn move_item(
+    source: &View<Pane>,
+    destination: &View<Pane>,
+    item_id_to_move: EntityId,
+    destination_index: usize,
+    cx: &mut WindowContext<'_>,
+) {
+    let Some((item_ix, item_handle)) = source
+        .read(cx)
+        .items()
+        .enumerate()
+        .find(|(_, item_handle)| item_handle.item_id() == item_id_to_move)
+        .map(|(ix, item)| (ix, item.clone()))
+    else {
+        // Tab was closed during drag
+        return;
+    };
+
+    if source != destination {
+        // Close item from previous pane
+        source.update(cx, |source, cx| {
+            source.remove_item_and_focus_on_pane(item_ix, false, destination.clone(), cx);
+        });
+    }
+
+    // This automatically removes duplicate items in the pane
+    destination.update(cx, |destination, cx| {
+        destination.add_item(item_handle, true, true, Some(destination_index), cx);
+        destination.focus(cx)
+    });
+}
+
 #[cfg(test)]
 mod tests {
     use std::{cell::RefCell, rc::Rc};
@@ -6855,6 +6902,80 @@ mod tests {
         });
     }
 
+    fn add_an_item_to_active_pane(
+        cx: &mut VisualTestContext,
+        workspace: &View<Workspace>,
+        item_id: u64,
+    ) -> View<TestItem> {
+        let item = cx.new_view(|cx| {
+            TestItem::new(cx).with_project_items(&[TestProjectItem::new(
+                item_id,
+                "item{item_id}.txt",
+                cx,
+            )])
+        });
+        workspace.update(cx, |workspace, cx| {
+            workspace.add_item_to_active_pane(Box::new(item.clone()), None, false, cx);
+        });
+        return item;
+    }
+
+    fn split_pane(cx: &mut VisualTestContext, workspace: &View<Workspace>) -> View<Pane> {
+        return workspace.update(cx, |workspace, cx| {
+            let new_pane =
+                workspace.split_pane(workspace.active_pane().clone(), SplitDirection::Right, cx);
+            new_pane
+        });
+    }
+
+    #[gpui::test]
+    async fn test_join_all_panes(cx: &mut gpui::TestAppContext) {
+        init_test(cx);
+        let fs = FakeFs::new(cx.executor());
+        let project = Project::test(fs, None, cx).await;
+        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project, cx));
+
+        add_an_item_to_active_pane(cx, &workspace, 1);
+        split_pane(cx, &workspace);
+        add_an_item_to_active_pane(cx, &workspace, 2);
+        split_pane(cx, &workspace); // empty pane
+        split_pane(cx, &workspace);
+        let last_item = add_an_item_to_active_pane(cx, &workspace, 3);
+
+        cx.executor().run_until_parked();
+
+        workspace.update(cx, |workspace, cx| {
+            let num_panes = workspace.panes().len();
+            let num_items_in_current_pane = workspace.active_pane().read(cx).items().count();
+            let active_item = workspace
+                .active_pane()
+                .read(cx)
+                .active_item()
+                .expect("item is in focus");
+
+            assert_eq!(num_panes, 4);
+            assert_eq!(num_items_in_current_pane, 1);
+            assert_eq!(active_item.item_id(), last_item.item_id());
+        });
+
+        workspace.update(cx, |workspace, cx| {
+            workspace.join_all_panes(cx);
+        });
+
+        workspace.update(cx, |workspace, cx| {
+            let num_panes = workspace.panes().len();
+            let num_items_in_current_pane = workspace.active_pane().read(cx).items().count();
+            let active_item = workspace
+                .active_pane()
+                .read(cx)
+                .active_item()
+                .expect("item is in focus");
+
+            assert_eq!(num_panes, 1);
+            assert_eq!(num_items_in_current_pane, 3);
+            assert_eq!(active_item.item_id(), last_item.item_id());
+        });
+    }
     struct TestModal(FocusHandle);
 
     impl TestModal {

From 13c553c50f38af721cb51d775b898d4fda20ccb0 Mon Sep 17 00:00:00 2001
From: Nero Song <hucnero@hotmail.com>
Date: Wed, 11 Sep 2024 20:49:12 +0800
Subject: [PATCH 044/762] Doc Fix: Shortcut of "Go forward" in key-bindings.md
 (#17689)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

"Control + _"  =>  "Control + Shift + _"

Doc was edited so quickly using zed that caused a typo 😄


### shot
<img width="729" alt="image"
src="https://github.com/user-attachments/assets/104af7da-1205-43fd-b721-ffab7312487b">


### doc url
https://zed.dev/docs/key-bindings


Release Notes:

- N/A
---
 docs/src/key-bindings.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/src/key-bindings.md b/docs/src/key-bindings.md
index 627e3fc6c4d2cc..2a97bc62a89178 100644
--- a/docs/src/key-bindings.md
+++ b/docs/src/key-bindings.md
@@ -426,7 +426,7 @@ TBD: Add Column with Linux shortcuts
 | Close clean items             | Pane           | `⌘ + K, U`              |
 | Close inactive items          | Pane           | `Alt + ⌘ + T`           |
 | Go back                       | Pane           | `Control + -`           |
-| Go forward                    | Pane           | `Control + _`           |
+| Go forward                    | Pane           | `Control + Shift + _`   |
 | Reopen closed item            | Pane           | `⌘ + Shift + T`         |
 | Split down                    | Pane           | `⌘ + K, Down`           |
 | Split left                    | Pane           | `⌘ + K, Left`           |

From b5c42edf1e0f0a42b6f14d24e8b065ef0959b3dd Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 11 Sep 2024 12:56:39 -0400
Subject: [PATCH 045/762] lsp: Fix noisy logs when starting language servers
 (#17713)

We would log every time we'd lookup a language server for a file and
we'd also log "starting language server" even though we were about to
only download it and not start it.


Release Notes:

- N/A
---
 crates/language/src/language_registry.rs | 2 +-
 crates/lsp/src/lsp.rs                    | 2 +-
 crates/project/src/lsp_store.rs          | 9 ---------
 3 files changed, 2 insertions(+), 11 deletions(-)

diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index a65d20019f3da0..dcce78d6cee371 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -833,7 +833,7 @@ impl LanguageRegistry {
     ) -> Option<PendingLanguageServer> {
         let server_id = self.state.write().next_language_server_id();
         log::info!(
-            "starting language server {:?}, path: {root_path:?}, id: {server_id}",
+            "attempting to start language server {:?}, path: {root_path:?}, id: {server_id}",
             adapter.name.0
         );
 
diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs
index 061291757512bf..21671cd0b13265 100644
--- a/crates/lsp/src/lsp.rs
+++ b/crates/lsp/src/lsp.rs
@@ -272,7 +272,7 @@ impl LanguageServer {
         };
 
         log::info!(
-            "starting language server. binary path: {:?}, working directory: {:?}, args: {:?}",
+            "starting language server process. binary path: {:?}, working directory: {:?}, args: {:?}",
             binary.path,
             working_dir,
             &binary.arguments
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 3b6b9ebb0a636d..dbc75389694d8b 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -26,7 +26,6 @@ use gpui::{
     Task, WeakModel,
 };
 use http_client::{AsyncBody, Error, HttpClient, Request, Response, Uri};
-use itertools::Itertools;
 use language::{
     language_settings::{
         all_language_settings, language_settings, AllLanguageSettings, LanguageSettings,
@@ -4489,14 +4488,6 @@ impl LspStore {
             );
         }
 
-        log::info!(
-            "starting language servers for {language}: {adapters}",
-            adapters = enabled_lsp_adapters
-                .iter()
-                .map(|adapter| adapter.name.0.as_ref())
-                .join(", ")
-        );
-
         for adapter in &enabled_lsp_adapters {
             self.start_language_server(worktree, adapter.clone(), language.clone(), cx);
         }

From 9407d86ce615fd13589f264e4c595a328effa0f1 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 11 Sep 2024 13:33:42 -0400
Subject: [PATCH 046/762] project: Use login shell to get environment per
 project (#17717)

This is a follow-up to #17075 to spawn a login shell when getting the
environment for projects.

The reason why we didn't do it before is that we only used the
environment for certain language servers and not a lot of other things,
like tasks.

But with #17075 we now use the project more often and use it as the
_base_ environment for tasks/terminals.

Before the change, terminals and tasks would inherit the Zed process'
environment, including PATH and so on. After the change, we would set
the environment, overwriting the PATH instead of merging. But the
non-login shell environment is a subset of the login-shell environment.


Release Notes:

- Fixed environment variables used per project in terminals/tasks
overwriting the base environment and not making use of a login-shell
environment.
---
 crates/project/src/environment.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/project/src/environment.rs b/crates/project/src/environment.rs
index b74b577b3992d3..9742b8b6d58e32 100644
--- a/crates/project/src/environment.rs
+++ b/crates/project/src/environment.rs
@@ -219,7 +219,7 @@ async fn load_shell_environment(
     );
 
     let output = smol::process::Command::new(&shell)
-        .args(["-i", "-c", &command])
+        .args(["-l", "-i", "-c", &command])
         .envs(direnv_environment)
         .output()
         .await

From 3a6a29f1173e3cc1059d2220985a53581864388c Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 11 Sep 2024 16:13:17 -0400
Subject: [PATCH 047/762] vim: Fix inline completions showing up in normal mode
 (#17727)

Booleans are hard.

Release Notes:

- Fixed inline completions showing up in Vim normal mode.
---
 crates/editor/src/editor.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index f750abd95c76df..e50bf67ab01a28 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -4975,9 +4975,10 @@ impl Editor {
         let cursor = self.selections.newest_anchor().head();
         let (buffer, cursor_buffer_position) =
             self.buffer.read(cx).text_anchor_for_position(cursor, cx)?;
+
         if !user_requested
-            && self.enable_inline_completions
-            && !self.should_show_inline_completions(&buffer, cursor_buffer_position, cx)
+            && (!self.enable_inline_completions
+                || !self.should_show_inline_completions(&buffer, cursor_buffer_position, cx))
         {
             self.discard_inline_completion(false, cx);
             return None;

From 25b6e43b0f8faf3b24b4ab4ee02456d3933539ce Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 11 Sep 2024 16:22:10 -0400
Subject: [PATCH 048/762] bump eslint memory usage (#17724)

Release Notes:

- Increased memory limit for eslint to reduce crashes
---
 crates/languages/src/typescript.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs
index 185c10be44a70f..9b6d41451f72a1 100644
--- a/crates/languages/src/typescript.rs
+++ b/crates/languages/src/typescript.rs
@@ -58,7 +58,11 @@ fn typescript_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
 }
 
 fn eslint_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
-    vec![server_path.into(), "--stdio".into()]
+    vec![
+        "--max-old-space-size=8192".into(),
+        server_path.into(),
+        "--stdio".into(),
+    ]
 }
 
 pub struct TypeScriptLspAdapter {

From 092f29d3944f969eea6175f6b654c7832ecdeceb Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 12 Sep 2024 09:11:19 -0400
Subject: [PATCH 049/762] Use a bigger prefix for numeric sorting (#17752)

Release Notes:

- Fixed sorting of files with YYYYmmddHHMMSS prefix
---
 crates/util/src/util.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/util/src/util.rs b/crates/util/src/util.rs
index 40a5cf6212e443..a161b8bac2b59f 100644
--- a/crates/util/src/util.rs
+++ b/crates/util/src/util.rs
@@ -644,7 +644,7 @@ impl<T: Ord + Clone> RangeExt<T> for RangeInclusive<T> {
 /// This is useful for turning regular alphanumerically sorted sequences as `1-abc, 10, 11-def, .., 2, 21-abc`
 /// into `1-abc, 2, 10, 11-def, .., 21-abc`
 #[derive(Debug, PartialEq, Eq)]
-pub struct NumericPrefixWithSuffix<'a>(Option<u32>, &'a str);
+pub struct NumericPrefixWithSuffix<'a>(Option<u64>, &'a str);
 
 impl<'a> NumericPrefixWithSuffix<'a> {
     pub fn from_numeric_prefixed_str(str: &'a str) -> Self {

From 9db68ee6ae0a5520ec44b9281a1eb0bd48eab9c9 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 12 Sep 2024 09:47:25 -0400
Subject: [PATCH 050/762] lsp: Use project-local settings if available (#17753)

Release Notes:

- Changed built-in language support (Rust, Go, C, YAML, ...) to lookup
language-server specific settings locally in project directory first
before falling back to global value.

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/languages/src/c.rs          |  8 ++------
 crates/languages/src/go.rs         |  8 ++------
 crates/languages/src/python.rs     | 10 ++++------
 crates/languages/src/rust.rs       |  8 ++------
 crates/languages/src/tailwind.rs   | 15 +++++----------
 crates/languages/src/typescript.rs | 13 ++++---------
 crates/languages/src/vtsls.rs      | 24 ++++++------------------
 crates/languages/src/yaml.rs       | 12 ++++--------
 crates/project/src/lsp_store.rs    | 19 ++++++++++++++++++-
 9 files changed, 47 insertions(+), 70 deletions(-)

diff --git a/crates/languages/src/c.rs b/crates/languages/src/c.rs
index ea11b4e0d0bc34..243f61b084c4e8 100644
--- a/crates/languages/src/c.rs
+++ b/crates/languages/src/c.rs
@@ -5,8 +5,7 @@ use gpui::AsyncAppContext;
 use http_client::github::{latest_github_release, GitHubLspBinaryVersion};
 pub use language::*;
 use lsp::LanguageServerBinary;
-use project::project_settings::{BinarySettings, ProjectSettings};
-use settings::Settings;
+use project::{lsp_store::language_server_settings, project_settings::BinarySettings};
 use smol::fs::{self, File};
 use std::{any::Any, env::consts, path::PathBuf, sync::Arc};
 use util::{fs::remove_matching, maybe, ResultExt};
@@ -29,10 +28,7 @@ impl super::LspAdapter for CLspAdapter {
         cx: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx.update(|cx| {
-            ProjectSettings::get_global(cx)
-                .lsp
-                .get(Self::SERVER_NAME)
-                .and_then(|s| s.binary.clone())
+            language_server_settings(delegate, Self::SERVER_NAME, cx).and_then(|s| s.binary.clone())
         });
 
         match configured_binary {
diff --git a/crates/languages/src/go.rs b/crates/languages/src/go.rs
index a528f4f70cdc44..55850411ca88db 100644
--- a/crates/languages/src/go.rs
+++ b/crates/languages/src/go.rs
@@ -5,10 +5,9 @@ use gpui::{AppContext, AsyncAppContext, Task};
 use http_client::github::latest_github_release;
 pub use language::*;
 use lsp::LanguageServerBinary;
-use project::project_settings::{BinarySettings, ProjectSettings};
+use project::{lsp_store::language_server_settings, project_settings::BinarySettings};
 use regex::Regex;
 use serde_json::json;
-use settings::Settings;
 use smol::{fs, process};
 use std::{
     any::Any,
@@ -71,10 +70,7 @@ impl super::LspAdapter for GoLspAdapter {
         cx: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx.update(|cx| {
-            ProjectSettings::get_global(cx)
-                .lsp
-                .get(Self::SERVER_NAME)
-                .and_then(|s| s.binary.clone())
+            language_server_settings(delegate, Self::SERVER_NAME, cx).and_then(|s| s.binary.clone())
         });
 
         match configured_binary {
diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs
index f9baed63fb66c0..a0005e6f97878c 100644
--- a/crates/languages/src/python.rs
+++ b/crates/languages/src/python.rs
@@ -5,9 +5,9 @@ use gpui::AsyncAppContext;
 use language::{ContextProvider, LanguageServerName, LspAdapter, LspAdapterDelegate};
 use lsp::LanguageServerBinary;
 use node_runtime::NodeRuntime;
-use project::project_settings::ProjectSettings;
+use project::lsp_store::language_server_settings;
 use serde_json::Value;
-use settings::Settings;
+
 use std::{
     any::Any,
     borrow::Cow,
@@ -177,13 +177,11 @@ impl LspAdapter for PythonLspAdapter {
 
     async fn workspace_configuration(
         self: Arc<Self>,
-        _: &Arc<dyn LspAdapterDelegate>,
+        adapter: &Arc<dyn LspAdapterDelegate>,
         cx: &mut AsyncAppContext,
     ) -> Result<Value> {
         cx.update(|cx| {
-            ProjectSettings::get_global(cx)
-                .lsp
-                .get(Self::SERVER_NAME)
+            language_server_settings(adapter.as_ref(), Self::SERVER_NAME, cx)
                 .and_then(|s| s.settings.clone())
                 .unwrap_or_default()
         })
diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs
index 46b6ce475d5283..a32b4f55da1c81 100644
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -7,9 +7,8 @@ use http_client::github::{latest_github_release, GitHubLspBinaryVersion};
 pub use language::*;
 use language_settings::all_language_settings;
 use lsp::LanguageServerBinary;
-use project::project_settings::{BinarySettings, ProjectSettings};
+use project::{lsp_store::language_server_settings, project_settings::BinarySettings};
 use regex::Regex;
-use settings::Settings;
 use smol::fs::{self, File};
 use std::{
     any::Any,
@@ -40,10 +39,7 @@ impl LspAdapter for RustLspAdapter {
         cx: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx.update(|cx| {
-            ProjectSettings::get_global(cx)
-                .lsp
-                .get(Self::SERVER_NAME)
-                .and_then(|s| s.binary.clone())
+            language_server_settings(delegate, Self::SERVER_NAME, cx).and_then(|s| s.binary.clone())
         });
 
         match configured_binary {
diff --git a/crates/languages/src/tailwind.rs b/crates/languages/src/tailwind.rs
index 39ccc8afa10a94..524e4ce84611bc 100644
--- a/crates/languages/src/tailwind.rs
+++ b/crates/languages/src/tailwind.rs
@@ -6,9 +6,8 @@ use gpui::AsyncAppContext;
 use language::{LanguageServerName, LspAdapter, LspAdapterDelegate};
 use lsp::LanguageServerBinary;
 use node_runtime::NodeRuntime;
-use project::project_settings::ProjectSettings;
+use project::lsp_store::language_server_settings;
 use serde_json::{json, Value};
-use settings::Settings;
 use smol::fs;
 use std::{
     any::Any,
@@ -53,14 +52,12 @@ impl LspAdapter for TailwindLspAdapter {
 
     async fn check_if_user_installed(
         &self,
-        _delegate: &dyn LspAdapterDelegate,
+        delegate: &dyn LspAdapterDelegate,
         cx: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx
             .update(|cx| {
-                ProjectSettings::get_global(cx)
-                    .lsp
-                    .get(Self::SERVER_NAME)
+                language_server_settings(delegate, Self::SERVER_NAME, cx)
                     .and_then(|s| s.binary.clone())
             })
             .ok()??;
@@ -171,13 +168,11 @@ impl LspAdapter for TailwindLspAdapter {
 
     async fn workspace_configuration(
         self: Arc<Self>,
-        _: &Arc<dyn LspAdapterDelegate>,
+        delegate: &Arc<dyn LspAdapterDelegate>,
         cx: &mut AsyncAppContext,
     ) -> Result<Value> {
         let tailwind_user_settings = cx.update(|cx| {
-            ProjectSettings::get_global(cx)
-                .lsp
-                .get(Self::SERVER_NAME)
+            language_server_settings(delegate.as_ref(), Self::SERVER_NAME, cx)
                 .and_then(|s| s.settings.clone())
                 .unwrap_or_default()
         })?;
diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs
index 9b6d41451f72a1..14b6303f5cf906 100644
--- a/crates/languages/src/typescript.rs
+++ b/crates/languages/src/typescript.rs
@@ -8,10 +8,9 @@ use http_client::github::{build_asset_url, AssetKind, GitHubLspBinaryVersion};
 use language::{LanguageServerName, LspAdapter, LspAdapterDelegate};
 use lsp::{CodeActionKind, LanguageServerBinary};
 use node_runtime::NodeRuntime;
-use project::project_settings::ProjectSettings;
+use project::lsp_store::language_server_settings;
 use project::ContextProviderWithTasks;
 use serde_json::{json, Value};
-use settings::Settings;
 use smol::{fs, io::BufReader, stream::StreamExt};
 use std::{
     any::Any,
@@ -236,13 +235,11 @@ impl LspAdapter for TypeScriptLspAdapter {
 
     async fn workspace_configuration(
         self: Arc<Self>,
-        _: &Arc<dyn LspAdapterDelegate>,
+        delegate: &Arc<dyn LspAdapterDelegate>,
         cx: &mut AsyncAppContext,
     ) -> Result<Value> {
         let override_options = cx.update(|cx| {
-            ProjectSettings::get_global(cx)
-                .lsp
-                .get(Self::SERVER_NAME)
+            language_server_settings(delegate.as_ref(), Self::SERVER_NAME, cx)
                 .and_then(|s| s.initialization_options.clone())
         })?;
         if let Some(options) = override_options {
@@ -334,9 +331,7 @@ impl LspAdapter for EsLintLspAdapter {
         let workspace_root = delegate.worktree_root_path();
 
         let eslint_user_settings = cx.update(|cx| {
-            ProjectSettings::get_global(cx)
-                .lsp
-                .get(Self::SERVER_NAME)
+            language_server_settings(delegate.as_ref(), Self::SERVER_NAME, cx)
                 .and_then(|s| s.settings.clone())
                 .unwrap_or_default()
         })?;
diff --git a/crates/languages/src/vtsls.rs b/crates/languages/src/vtsls.rs
index 3dca82688cb81d..744405642d59cd 100644
--- a/crates/languages/src/vtsls.rs
+++ b/crates/languages/src/vtsls.rs
@@ -5,9 +5,8 @@ use gpui::AsyncAppContext;
 use language::{LanguageServerName, LspAdapter, LspAdapterDelegate};
 use lsp::{CodeActionKind, LanguageServerBinary};
 use node_runtime::NodeRuntime;
-use project::project_settings::{BinarySettings, ProjectSettings};
+use project::{lsp_store::language_server_settings, project_settings::BinarySettings};
 use serde_json::{json, Value};
-use settings::{Settings, SettingsLocation};
 use std::{
     any::Any,
     ffi::OsString,
@@ -75,10 +74,7 @@ impl LspAdapter for VtslsLspAdapter {
         cx: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx.update(|cx| {
-            ProjectSettings::get_global(cx)
-                .lsp
-                .get(SERVER_NAME)
-                .and_then(|s| s.binary.clone())
+            language_server_settings(delegate, SERVER_NAME, cx).and_then(|s| s.binary.clone())
         });
 
         match configured_binary {
@@ -270,26 +266,18 @@ impl LspAdapter for VtslsLspAdapter {
 
     async fn workspace_configuration(
         self: Arc<Self>,
-        adapter: &Arc<dyn LspAdapterDelegate>,
+        delegate: &Arc<dyn LspAdapterDelegate>,
         cx: &mut AsyncAppContext,
     ) -> Result<Value> {
         let override_options = cx.update(|cx| {
-            ProjectSettings::get(
-                Some(SettingsLocation {
-                    worktree_id: adapter.worktree_id(),
-                    path: adapter.worktree_root_path(),
-                }),
-                cx,
-            )
-            .lsp
-            .get(SERVER_NAME)
-            .and_then(|s| s.initialization_options.clone())
+            language_server_settings(delegate.as_ref(), SERVER_NAME, cx)
+                .and_then(|s| s.initialization_options.clone())
         })?;
         if let Some(options) = override_options {
             return Ok(options);
         }
         let mut initialization_options = self
-            .initialization_options(adapter)
+            .initialization_options(delegate)
             .await
             .map(|o| o.unwrap())?;
 
diff --git a/crates/languages/src/yaml.rs b/crates/languages/src/yaml.rs
index 51a9913b249e9f..b75b3c722667df 100644
--- a/crates/languages/src/yaml.rs
+++ b/crates/languages/src/yaml.rs
@@ -7,7 +7,7 @@ use language::{
 };
 use lsp::LanguageServerBinary;
 use node_runtime::NodeRuntime;
-use project::project_settings::ProjectSettings;
+use project::lsp_store::language_server_settings;
 use serde_json::Value;
 use settings::{Settings, SettingsLocation};
 use smol::fs;
@@ -44,14 +44,12 @@ impl LspAdapter for YamlLspAdapter {
 
     async fn check_if_user_installed(
         &self,
-        _delegate: &dyn LspAdapterDelegate,
+        delegate: &dyn LspAdapterDelegate,
         cx: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx
             .update(|cx| {
-                ProjectSettings::get_global(cx)
-                    .lsp
-                    .get(Self::SERVER_NAME)
+                language_server_settings(delegate, Self::SERVER_NAME, cx)
                     .and_then(|s| s.binary.clone())
             })
             .ok()??;
@@ -147,9 +145,7 @@ impl LspAdapter for YamlLspAdapter {
         let mut options = serde_json::json!({"[yaml]": {"editor.tabSize": tab_size}});
 
         let project_options = cx.update(|cx| {
-            ProjectSettings::get_global(cx)
-                .lsp
-                .get(Self::SERVER_NAME)
+            language_server_settings(delegate.as_ref(), Self::SERVER_NAME, cx)
                 .and_then(|s| s.initialization_options.clone())
         })?;
         if let Some(override_options) = project_options {
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index dbc75389694d8b..307e86de450b7f 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -3,7 +3,7 @@ use crate::{
     environment::ProjectEnvironment,
     lsp_command::{self, *},
     lsp_ext_command,
-    project_settings::ProjectSettings,
+    project_settings::{LspSettings, ProjectSettings},
     relativize_path, resolve_path,
     worktree_store::{WorktreeStore, WorktreeStoreEvent},
     yarn::YarnPathStore,
@@ -7035,6 +7035,23 @@ impl HttpClient for BlockedHttpClient {
         None
     }
 }
+
+pub fn language_server_settings<'a, 'b: 'a>(
+    delegate: &'a dyn LspAdapterDelegate,
+    language: &str,
+    cx: &'b AppContext,
+) -> Option<&'a LspSettings> {
+    ProjectSettings::get(
+        Some(SettingsLocation {
+            worktree_id: delegate.worktree_id(),
+            path: delegate.worktree_root_path(),
+        }),
+        cx,
+    )
+    .lsp
+    .get(language)
+}
+
 #[async_trait]
 impl LspAdapterDelegate for ProjectLspAdapterDelegate {
     fn show_notification(&self, message: &str, cx: &mut AppContext) {

From 02d5f320ad621e92cafaa7075f61e6496e12cd98 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 12 Sep 2024 10:02:45 -0400
Subject: [PATCH 051/762] lsp: Fix initialization_options being used as
 workspace configuration (#17757)

Release Notes:

- Fixed user-configured `initialization_options` being passed as
`workspace/Configuration` for the vtsls, TypeScript, and YAML language
servers.

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/languages/src/typescript.rs |  2 +-
 crates/languages/src/vtsls.rs      | 17 +++--------------
 crates/languages/src/yaml.rs       |  2 +-
 3 files changed, 5 insertions(+), 16 deletions(-)

diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs
index 14b6303f5cf906..cc52df2922a210 100644
--- a/crates/languages/src/typescript.rs
+++ b/crates/languages/src/typescript.rs
@@ -240,7 +240,7 @@ impl LspAdapter for TypeScriptLspAdapter {
     ) -> Result<Value> {
         let override_options = cx.update(|cx| {
             language_server_settings(delegate.as_ref(), Self::SERVER_NAME, cx)
-                .and_then(|s| s.initialization_options.clone())
+                .and_then(|s| s.settings.clone())
         })?;
         if let Some(options) = override_options {
             return Ok(options);
diff --git a/crates/languages/src/vtsls.rs b/crates/languages/src/vtsls.rs
index 744405642d59cd..f3b46d26850ef3 100644
--- a/crates/languages/src/vtsls.rs
+++ b/crates/languages/src/vtsls.rs
@@ -13,7 +13,7 @@ use std::{
     path::{Path, PathBuf},
     sync::Arc,
 };
-use util::{maybe, merge_json_value_into, ResultExt};
+use util::{maybe, ResultExt};
 
 fn typescript_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
     vec![server_path.into(), "--stdio".into()]
@@ -271,20 +271,9 @@ impl LspAdapter for VtslsLspAdapter {
     ) -> Result<Value> {
         let override_options = cx.update(|cx| {
             language_server_settings(delegate.as_ref(), SERVER_NAME, cx)
-                .and_then(|s| s.initialization_options.clone())
+                .and_then(|s| s.settings.clone())
         })?;
-        if let Some(options) = override_options {
-            return Ok(options);
-        }
-        let mut initialization_options = self
-            .initialization_options(delegate)
-            .await
-            .map(|o| o.unwrap())?;
-
-        if let Some(override_options) = override_options {
-            merge_json_value_into(override_options, &mut initialization_options)
-        }
-        Ok(initialization_options)
+        Ok(override_options.unwrap_or_default())
     }
 
     fn language_ids(&self) -> HashMap<String, String> {
diff --git a/crates/languages/src/yaml.rs b/crates/languages/src/yaml.rs
index b75b3c722667df..06360847acc803 100644
--- a/crates/languages/src/yaml.rs
+++ b/crates/languages/src/yaml.rs
@@ -146,7 +146,7 @@ impl LspAdapter for YamlLspAdapter {
 
         let project_options = cx.update(|cx| {
             language_server_settings(delegate.as_ref(), Self::SERVER_NAME, cx)
-                .and_then(|s| s.initialization_options.clone())
+                .and_then(|s| s.settings.clone())
         })?;
         if let Some(override_options) = project_options {
             merge_json_value_into(override_options, &mut options);

From b341079d8a0bd8293f0fb0c479a2af5f47476f6e Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 12 Sep 2024 11:23:37 -0400
Subject: [PATCH 052/762] Fix maxTsServerMemory (#17758)

Release Notes:

- N/A

---------

Co-authored-by: Thorsten Ball <mrnugget@gmail.com>
---
 crates/languages/src/vtsls.rs    | 19 +++++++++++++++----
 docs/src/languages/typescript.md |  2 +-
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/crates/languages/src/vtsls.rs b/crates/languages/src/vtsls.rs
index f3b46d26850ef3..9499b5c54fbeba 100644
--- a/crates/languages/src/vtsls.rs
+++ b/crates/languages/src/vtsls.rs
@@ -222,9 +222,6 @@ impl LspAdapter for VtslsLspAdapter {
             "suggest": {
                 "completeFunctionCalls": true
             },
-            "tsserver": {
-                "maxTsServerMemory": 8092
-            },
             "inlayHints": {
                 "parameterNames": {
                     "enabled": "all",
@@ -273,7 +270,21 @@ impl LspAdapter for VtslsLspAdapter {
             language_server_settings(delegate.as_ref(), SERVER_NAME, cx)
                 .and_then(|s| s.settings.clone())
         })?;
-        Ok(override_options.unwrap_or_default())
+
+        if let Some(options) = override_options {
+            return Ok(options);
+        }
+
+        let config = serde_json::json!({
+            "tsserver": {
+                "maxTsServerMemory": 8092
+            },
+        });
+
+        Ok(serde_json::json!({
+            "typescript": config,
+            "javascript": config
+        }))
     }
 
     fn language_ids(&self) -> HashMap<String, String> {
diff --git a/docs/src/languages/typescript.md b/docs/src/languages/typescript.md
index 12529500d81782..bfe63c5b2c1a6c 100644
--- a/docs/src/languages/typescript.md
+++ b/docs/src/languages/typescript.md
@@ -52,7 +52,7 @@ Prettier will also be used for TypeScript files by default. To disable this:
 {
   "lsp": {
     "vtsls": {
-      "initialization_options": {
+      "settings": {
         // For TypeScript:
         "typescript": { "tsserver": { "maxTsServerMemory": 16184 } },
         // For JavaScript:

From 0043b0d9579fbc17e1362964a4f3922ebe1605eb Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 12 Sep 2024 11:32:24 -0400
Subject: [PATCH 053/762] editor: Render documentation popovers using UI font
 (#17761)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR updates the documentation popovers to render non-code using the
UI font:

<img width="603" alt="Screenshot 2024-09-12 at 11 10 46 AM"
src="https://github.com/user-attachments/assets/c5be0676-0f0f-4ff6-8a96-76b44684e1cf">

<img width="347" alt="Screenshot 2024-09-12 at 11 21 12 AM"
src="https://github.com/user-attachments/assets/842ba922-9837-45c1-9cf2-846fe8362f99">

Requested by @davidbarsky.

Release Notes:

- Changed documentation popovers to render Markdown prose using the UI
font instead of the buffer font. Code blocks still using the buffer
font.
---
 crates/editor/src/hover_popover.rs | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/crates/editor/src/hover_popover.rs b/crates/editor/src/hover_popover.rs
index 0dc2f098394313..adbb5899ff74d0 100644
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -518,19 +518,22 @@ async fn parse_blocks(
     let rendered_block = cx
         .new_view(|cx| {
             let settings = ThemeSettings::get_global(cx);
+            let ui_font_family = settings.ui_font.family.clone();
             let buffer_font_family = settings.buffer_font.family.clone();
-            let mut base_style = cx.text_style();
-            base_style.refine(&TextStyleRefinement {
-                font_family: Some(buffer_font_family.clone()),
+
+            let mut base_text_style = cx.text_style();
+            base_text_style.refine(&TextStyleRefinement {
+                font_family: Some(ui_font_family.clone()),
                 color: Some(cx.theme().colors().editor_foreground),
                 ..Default::default()
             });
 
             let markdown_style = MarkdownStyle {
-                base_text_style: base_style,
-                code_block: StyleRefinement::default().mt(rems(1.)).mb(rems(1.)),
+                base_text_style,
+                code_block: StyleRefinement::default().my(rems(1.)).font_buffer(cx),
                 inline_code: TextStyleRefinement {
                     background_color: Some(cx.theme().colors().background),
+                    font_family: Some(buffer_font_family),
                     ..Default::default()
                 },
                 rule_color: Color::Muted.color(cx),

From f39c175bd3a45a508b370e80492b8539abfa41e2 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 12 Sep 2024 11:52:59 -0400
Subject: [PATCH 054/762] Update Rust crate serde_json_lenient to 0.2 (#17732)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
|
[serde_json_lenient](https://redirect.github.com/google/serde_json_lenient)
| workspace.dependencies | minor | `0.1` -> `0.2` |

---

### Release Notes

<details>
<summary>google/serde_json_lenient (serde_json_lenient)</summary>

###
[`v0.2.1`](https://redirect.github.com/google/serde_json_lenient/releases/tag/v0.2.1)

[Compare
Source](https://redirect.github.com/google/serde_json_lenient/compare/v0.2.0...v0.2.1)

- Fixed newline handling
([#&#8203;20](https://redirect.github.com/google/serde_json_lenient/issues/20))

###
[`v0.2.0`](https://redirect.github.com/google/serde_json_lenient/releases/tag/v0.2.0)

[Compare
Source](https://redirect.github.com/google/serde_json_lenient/compare/v0.1.8...v0.2.0)

-   Merged from upstream `serde_json`
- Introduce cfg!(parse_negative_zero_as_int) to create a build-time
option to parse -0 the same as other JSON parsers.
([#&#8203;16](https://redirect.github.com/google/serde_json_lenient/issues/16))
- Add an option to control escaped newlines separately from other
control
([#&#8203;18](https://redirect.github.com/google/serde_json_lenient/issues/18))

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC43NC4xIiwidXBkYXRlZEluVmVyIjoiMzguNzQuMSIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2027c5421f5dda..36691e72ab772a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9928,9 +9928,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json_lenient"
-version = "0.1.8"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc61c66b53a4035fcce237ef38043f4b2f0ebf918fd0e69541a5166104065581"
+checksum = "a5d0bae483150302560d7cb52e7932f39b69a6fbdd099e48d33ef060a8c9c078"
 dependencies = [
  "indexmap 2.4.0",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index ea8284ccb12b0c..23b17fd2916957 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -393,7 +393,7 @@ semver = "1.0"
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
 serde_json = { version = "1.0", features = ["preserve_order", "raw_value"] }
-serde_json_lenient = { version = "0.1", features = [
+serde_json_lenient = { version = "0.2", features = [
     "preserve_order",
     "raw_value",
 ] }

From 6841f7b9d792f6f89ca1b1bcbfca9dc763b66531 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 12 Sep 2024 11:53:31 -0400
Subject: [PATCH 055/762] Update Python to v3.12.6 (#17728)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [python](https://redirect.github.com/containerbase/python-prebuild) |
dependencies | patch | `3.12.5` -> `3.12.6` |

---

### Release Notes

<details>
<summary>containerbase/python-prebuild (python)</summary>

###
[`v3.12.6`](https://redirect.github.com/containerbase/python-prebuild/releases/tag/3.12.6)

[Compare
Source](https://redirect.github.com/containerbase/python-prebuild/compare/3.12.5...3.12.6)

##### Bug Fixes

-   **deps:** update dependency python to v3.12.6

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC43NC4xIiwidXBkYXRlZEluVmVyIjoiMzguNzQuMSIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 script/update_top_ranking_issues/poetry.lock    | 4 ++--
 script/update_top_ranking_issues/pyproject.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/script/update_top_ranking_issues/poetry.lock b/script/update_top_ranking_issues/poetry.lock
index ae2120c741cd9e..a85844e645f100 100644
--- a/script/update_top_ranking_issues/poetry.lock
+++ b/script/update_top_ranking_issues/poetry.lock
@@ -529,5 +529,5 @@ files = [
 
 [metadata]
 lock-version = "2.0"
-python-versions = "3.12.5"
-content-hash = "3e6aa4dc758eb933f7e2d1a305d1e397b13a960ac4846ef54c5a11b906b77015"
+python-versions = "3.12.6"
+content-hash = "7827704e06a8c195297507e0d05e7a7c3843ed299bd353f31570ee4c435c6896"
diff --git a/script/update_top_ranking_issues/pyproject.toml b/script/update_top_ranking_issues/pyproject.toml
index cb92ce9c536323..15d8346bb99103 100644
--- a/script/update_top_ranking_issues/pyproject.toml
+++ b/script/update_top_ranking_issues/pyproject.toml
@@ -8,7 +8,7 @@ readme = "README.md"
 [tool.poetry.dependencies]
 mypy = "1.6.0"
 PyGithub = "1.55"
-python = "3.12.5"
+python = "3.12.6"
 pytz = "2022.1"
 typer = "0.9.0"
 types-pytz = "2023.3.1.1"

From bba380e41ac9d09b36f63abdaa13477e727c1d3a Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 12 Sep 2024 14:06:38 -0400
Subject: [PATCH 056/762] docs: Add copywriting tweaks to the Vim page (#17766)

Quick writing refinements as we displayed this docs over at RustConf.
Namely:

- Removal of "here" links
- Making link anchors generally bigger
- Adding commas where suitable
- Capitalizing "Vim" (although "vim mode" is still lowercased)

---

Release Notes:

- N/A
---
 docs/src/vim.md | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/docs/src/vim.md b/docs/src/vim.md
index d4e41b58199570..777534813f9657 100644
--- a/docs/src/vim.md
+++ b/docs/src/vim.md
@@ -12,7 +12,7 @@ So, Zed's vim mode does not replicate Vim one-to-one, but it meshes Vim's modal
 
 ## Enabling and disabling vim mode
 
-When you first open Zed, a checkbox will appear on the welcome screen, allowing you to enable vim mode.
+When you first open Zed, you'll see a checkbox on the welcome screen that allows you to enable vim mode.
 
 If you missed this, you can toggle vim mode on or off anytime by opening the command palette and using the workspace command `toggle vim mode`.
 
@@ -83,7 +83,7 @@ ctrl-x ctrl-z  Hides all suggestions
 :Ext[ensions] Open the extensions window
 ```
 
-Vim mode uses Zed to define concepts like "brackets" (for the `%` key) and "words" (for motions like `w` and `e`). This does lead to some differences, but they are mostly positive. For example `%` considers `|` to be a bracket in languages like Rust; and `w` considers `$` to be a word-character in languages like Javascript.
+Vim mode uses Zed to define concepts like "brackets" (for the `%` key) and "words" (for motions like `w` and `e`). This does lead to some differences, but they are mostly positive. For example `%` considers `|` to be a bracket in languages like Rust; and `w` considers `$` to be a word-character in languages like JavaScript.
 
 Vim mode emulates visual block mode using Zed's multiple cursor support. This again leads to some differences, but is much more powerful.
 
@@ -129,11 +129,13 @@ For vim-specific shortcuts, you may find the following template a good place to
 
 If you would like to emulate vim's `map` (`nmap` etc.) commands you can bind to the [`workspace::SendKeystrokes`](./key-bindings.md#remapping-keys) action in the correct context.
 
-You can see the bindings that are enabled by default in vim mode [here](https://github.com/zed-industries/zed/blob/main/assets/keymaps/vim.json).
+Check out the [bindings that are enabled by default in vim mode](https://github.com/zed-industries/zed/blob/main/assets/keymaps/vim.json).
 
 ### Contexts
 
-Zed's keyboard bindings are evaluated only when the `"context"` matches the location you are in on the screen. Locations are nested, so when you're editing you're in the `"Workspace"` location is at the top, containing a `"Pane"` which contains an `"Editor"`. Contexts are matched only on one level at a time. So it is possible to combine `Editor && vim_mode == normal`, but `Workspace && vim_mode == normal` will never match because we set the vim context at the `Editor` level.
+Zed's keyboard bindings are evaluated only when the `"context"` matches the location you are in on the screen. Locations are nested, so when you're editing, you're in the `"Workspace"` location, which is at the top, containing a `"Pane"` that contains an `"Editor"`.
+
+Contexts are matched only on one level at a time. So, it is possible to combine `Editor && vim_mode == normal`, but `Workspace && vim_mode == normal` will never match because we set the vim context at the `Editor` level.
 
 Vim mode adds several contexts to the `Editor`:
 
@@ -164,13 +166,13 @@ If you're using vim mode on Linux or Windows, you may find it overrides keybindi
 
 Vim mode allows you to enable Zed’s command palette with `:`. This means that you can use vim's command palette to run any action that Zed supports.
 
-Additionally, vim mode contains a number of aliases for popular vim commands to ensure that muscle memory works. For example `:w<enter>` will save the file.
+Additionally, vim mode contains a number of aliases for popular Vim commands to ensure that muscle memory works. For example, `:w<enter>` will save the file.
 
-We do not (yet) emulate the full power of vim’s command line, in particular, we do not support arguments to commands yet. Please reach out on [GitHub](https://github.com/zed-industries/zed) as you find things that are missing from the command palette.
+We do not (yet) emulate the full power of Vim’s command line, in particular, we do not support arguments to commands yet. Please [file issues on GitHub](https://github.com/zed-industries/zed) as you find things that are missing from the command palette.
 
 As mentioned above, one thing to be aware of is that the regex engine is slightly different from vim's in `:%s/a/b`.
 
-Currently supported vim-specific commands:
+Currently supported Vim-specific commands:
 
 ```
 # window management
@@ -296,7 +298,7 @@ There are also a few Zed settings that you may also enjoy if you use vim mode:
 }
 ```
 
-If you want to navigate between the editor and docks (terminal, project panel, AI assistant, ...) just like you navigate between splits you can use the following key bindings:
+If you want to navigate between the editor and docks (terminal, project panel, AI assistant panel, etc...), just like you navigate between splits, you can use the following key bindings:
 
 ```json
 {
@@ -366,4 +368,4 @@ Notably:
 
 To help with the transition, the command palette will fix parentheses and replace groups for you when you run `:%s//`. So `%s:/\(a\)(b)/\1/` will be converted into a search for "(a)\(b\)" and a replacement of "$1".
 
-For the full syntax supported by Zed's regex engine see the [regex crate documentation](https://docs.rs/regex/latest/regex/#syntax).
+For the full syntax supported by Zed's regex engine [see the regex crate documentation](https://docs.rs/regex/latest/regex/#syntax).

From 3b37db4140349d4120a4724afa9c41c429efd49b Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 12 Sep 2024 14:17:59 -0400
Subject: [PATCH 057/762] Improve button copy on database load error toast
 (#17767)

Minimal copywriting improvement as that just happened to me while
working on Zed during ReactConf.

Release Notes:

- N/A
---
 crates/workspace/src/workspace.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index e6358cfdb95595..0d774277944c02 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -4644,7 +4644,7 @@ fn notify_if_database_failed(workspace: WindowHandle<Workspace>, cx: &mut AsyncA
                     |cx| {
                         cx.new_view(|_| {
                             MessageNotification::new("Failed to load the database file.")
-                                .with_click_message("Click to let us know about this error")
+                                .with_click_message("File an issue")
                                 .on_click(|cx| cx.open_url(REPORT_ISSUE_URL))
                         })
                     },

From 4d26f83d23165d841ebe95f3c1123616b30709ce Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 12 Sep 2024 14:46:08 -0400
Subject: [PATCH 058/762] Revert "settings: Remove auxiliary Content types
 where possible (#16744)" (#17768)

This breaks setting `{"scrollbar": {"show":"never"}}`
Release Notes:

- N/A
---
 crates/auto_update/src/auto_update.rs         |  23 +-
 crates/call/src/call_settings.rs              |  22 +-
 crates/client/src/client.rs                   |  50 +--
 crates/collab/src/tests/editor_tests.rs       |   8 +-
 crates/collab/src/tests/following_tests.rs    |   2 +-
 crates/collab_ui/src/chat_panel.rs            |   2 +-
 .../src/chat_panel/message_editor.rs          |   8 +-
 crates/collab_ui/src/collab_panel.rs          |   2 +-
 crates/collab_ui/src/notification_panel.rs    |   2 +-
 crates/collab_ui/src/panel_settings.rs        |  74 ++--
 .../src/project_diagnostics_settings.rs       |  20 +-
 crates/editor/src/editor.rs                   |   4 +-
 crates/editor/src/editor_settings.rs          | 318 +++++++++++-------
 crates/editor/src/editor_settings_controls.rs |  22 +-
 crates/editor/src/editor_tests.rs             |  18 +-
 crates/editor/src/element.rs                  |  17 +-
 crates/extension/src/extension_settings.rs    |  13 +-
 crates/extensions_ui/src/extensions_ui.rs     |   2 +-
 crates/go_to_line/src/cursor_position.rs      |  16 +-
 crates/gpui/src/geometry.rs                   |   2 -
 crates/language/src/language_settings.rs      |   8 +-
 crates/languages/src/json.rs                  |  29 +-
 crates/outline_panel/src/outline_panel.rs     |  16 +-
 .../src/outline_panel_settings.rs             |  72 ++--
 crates/performance/src/performance.rs         | 184 ----------
 crates/project/src/project_settings.rs        |  41 ++-
 crates/project_panel/src/project_panel.rs     |  28 +-
 .../src/project_panel_settings.rs             |  92 +++--
 crates/recent_projects/src/dev_servers.rs     |   3 +-
 crates/recent_projects/src/ssh_connections.rs |  25 +-
 crates/repl/src/jupyter_settings.rs           |  28 +-
 crates/tasks_ui/src/settings.rs               |  18 +-
 crates/vim/src/digraph.rs                     |   2 +-
 crates/vim/src/normal.rs                      |   6 +-
 crates/vim/src/normal/paste.rs                |  12 +-
 crates/vim/src/normal/scroll.rs               |   2 +-
 crates/vim/src/normal/search.rs               |   4 +-
 crates/vim/src/test.rs                        |   2 +-
 crates/vim/src/test/vim_test_context.rs       |   6 +-
 crates/vim/src/vim.rs                         |  32 +-
 crates/welcome/src/base_keymap_picker.rs      |   2 +-
 crates/welcome/src/base_keymap_setting.rs     |   6 +-
 crates/welcome/src/welcome.rs                 |   2 +-
 crates/workspace/src/item.rs                  |  70 ++--
 crates/workspace/src/workspace.rs             |   8 +-
 crates/workspace/src/workspace_settings.rs    | 132 ++++----
 crates/worktree/src/worktree_settings.rs      |  43 +--
 crates/worktree/src/worktree_tests.rs         |  11 +-
 crates/zed/src/zed.rs                         |   2 +-
 49 files changed, 682 insertions(+), 829 deletions(-)
 delete mode 100644 crates/performance/src/performance.rs

diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index 499df7fc298594..8063ff4c40fca3 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -116,30 +116,27 @@ impl Drop for MacOsUnmounter {
     }
 }
 
-/// Whether or not to automatically check for updates.
-#[derive(Clone, Copy, JsonSchema, Deserialize, Serialize)]
-#[serde(default)]
-#[serde(transparent)]
 struct AutoUpdateSetting(bool);
 
-impl Default for AutoUpdateSetting {
-    fn default() -> Self {
-        Self(true)
-    }
-}
+/// Whether or not to automatically check for updates.
+///
+/// Default: true
+#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize)]
+#[serde(transparent)]
+struct AutoUpdateSettingContent(bool);
 
 impl Settings for AutoUpdateSetting {
     const KEY: Option<&'static str> = Some("auto_update");
 
-    type FileContent = Self;
+    type FileContent = Option<AutoUpdateSettingContent>;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         let auto_update = [sources.release_channel, sources.user]
             .into_iter()
-            .find_map(|value| value.copied())
-            .unwrap_or(*sources.default);
+            .find_map(|value| value.copied().flatten())
+            .unwrap_or(sources.default.ok_or_else(Self::missing_default)?);
 
-        Ok(auto_update)
+        Ok(Self(auto_update.0))
     }
 }
 
diff --git a/crates/call/src/call_settings.rs b/crates/call/src/call_settings.rs
index e10b711734bb6d..446178ffb982d0 100644
--- a/crates/call/src/call_settings.rs
+++ b/crates/call/src/call_settings.rs
@@ -4,20 +4,30 @@ use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-/// Configuration of voice calls in Zed.
-#[derive(Clone, Debug, Default, Deserialize, Serialize, JsonSchema)]
-#[serde(default)]
+#[derive(Deserialize, Debug)]
 pub struct CallSettings {
-    /// Whether the microphone should be muted when joining a channel or a call.
     pub mute_on_join: bool,
-    /// Whether your current project should be shared when joining an empty channel.
     pub share_on_join: bool,
 }
 
+/// Configuration of voice calls in Zed.
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct CallSettingsContent {
+    /// Whether the microphone should be muted when joining a channel or a call.
+    ///
+    /// Default: false
+    pub mute_on_join: Option<bool>,
+
+    /// Whether your current project should be shared when joining an empty channel.
+    ///
+    /// Default: true
+    pub share_on_join: Option<bool>,
+}
+
 impl Settings for CallSettings {
     const KEY: Option<&'static str> = Some("calls");
 
-    type FileContent = Self;
+    type FileContent = CallSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 83eef45be802bb..8787e2ed9675fe 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -99,26 +99,20 @@ pub const CONNECTION_TIMEOUT: Duration = Duration::from_secs(20);
 
 actions!(client, [SignIn, SignOut, Reconnect]);
 
-#[derive(Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
-pub struct ClientSettings {
-    /// The server to connect to. If the environment variable
-    /// ZED_SERVER_URL is set, it will override this setting.
-    pub server_url: String,
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub struct ClientSettingsContent {
+    server_url: Option<String>,
 }
 
-impl Default for ClientSettings {
-    fn default() -> Self {
-        Self {
-            server_url: "https://zed.dev".to_owned(),
-        }
-    }
+#[derive(Deserialize)]
+pub struct ClientSettings {
+    pub server_url: String,
 }
 
 impl Settings for ClientSettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = Self;
+    type FileContent = ClientSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         let mut result = sources.json_merge::<Self>()?;
@@ -130,37 +124,19 @@ impl Settings for ClientSettings {
 }
 
 #[derive(Default, Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
-pub struct ProxySettings {
-    /// Set a proxy to use. The proxy protocol is specified by the URI scheme.
-    ///
-    /// Supported URI scheme: `http`, `https`, `socks4`, `socks4a`, `socks5`,
-    /// `socks5h`. `http` will be used when no scheme is specified.
-    ///
-    /// By default no proxy will be used, or Zed will try get proxy settings from
-    /// environment variables.
-    ///
-    /// Examples:
-    ///   - "proxy": "socks5://localhost:10808"
-    ///   - "proxy": "http://127.0.0.1:10809"
-    #[schemars(example = "Self::example_1")]
-    #[schemars(example = "Self::example_2")]
-    pub proxy: Option<String>,
+pub struct ProxySettingsContent {
+    proxy: Option<String>,
 }
 
-impl ProxySettings {
-    fn example_1() -> String {
-        "http://127.0.0.1:10809".to_owned()
-    }
-    fn example_2() -> String {
-        "socks5://localhost:10808".to_owned()
-    }
+#[derive(Deserialize, Default)]
+pub struct ProxySettings {
+    pub proxy: Option<String>,
 }
 
 impl Settings for ProxySettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = Self;
+    type FileContent = ProxySettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         Ok(Self {
diff --git a/crates/collab/src/tests/editor_tests.rs b/crates/collab/src/tests/editor_tests.rs
index a214291752a5ef..3f205b7f937c96 100644
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -2261,11 +2261,11 @@ async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestA
     cx_a.update(editor::init);
     cx_b.update(editor::init);
     // Turn inline-blame-off by default so no state is transferred without us explicitly doing so
-    let inline_blame_off_settings = InlineBlameSettings {
+    let inline_blame_off_settings = Some(InlineBlameSettings {
         enabled: false,
-        delay_ms: 0,
-        min_column: 0,
-    };
+        delay_ms: None,
+        min_column: None,
+    });
     cx_a.update(|cx| {
         SettingsStore::update_global(cx, |store, cx| {
             store.update_user_settings::<ProjectSettings>(cx, |settings| {
diff --git a/crates/collab/src/tests/following_tests.rs b/crates/collab/src/tests/following_tests.rs
index 1bc3cd691778d1..e66b66a1b45893 100644
--- a/crates/collab/src/tests/following_tests.rs
+++ b/crates/collab/src/tests/following_tests.rs
@@ -1649,7 +1649,7 @@ async fn test_following_into_excluded_file(
         cx.update(|cx| {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |settings| {
-                    settings.file_scan_exclusions = vec!["**/.git".to_string()];
+                    settings.file_scan_exclusions = Some(vec!["**/.git".to_string()]);
                 });
             });
         });
diff --git a/crates/collab_ui/src/chat_panel.rs b/crates/collab_ui/src/chat_panel.rs
index f6e6c7321ff80d..5a79f364ff571f 100644
--- a/crates/collab_ui/src/chat_panel.rs
+++ b/crates/collab_ui/src/chat_panel.rs
@@ -1108,7 +1108,7 @@ impl Panel for ChatPanel {
         settings::update_settings_file::<ChatPanelSettings>(
             self.fs.clone(),
             cx,
-            move |settings, _| settings.dock = position,
+            move |settings, _| settings.dock = Some(position),
         );
     }
 
diff --git a/crates/collab_ui/src/chat_panel/message_editor.rs b/crates/collab_ui/src/chat_panel/message_editor.rs
index 0b1a2dbe69ec0b..028e148cbac039 100644
--- a/crates/collab_ui/src/chat_panel/message_editor.rs
+++ b/crates/collab_ui/src/chat_panel/message_editor.rs
@@ -113,7 +113,9 @@ impl MessageEditor {
             editor.set_show_indent_guides(false, cx);
             editor.set_completion_provider(Box::new(MessageEditorCompletionProvider(this)));
             editor.set_auto_replace_emoji_shortcode(
-                MessageEditorSettings::get_global(cx).auto_replace_emoji_shortcode,
+                MessageEditorSettings::get_global(cx)
+                    .auto_replace_emoji_shortcode
+                    .unwrap_or_default(),
             );
         });
 
@@ -128,7 +130,9 @@ impl MessageEditor {
         cx.observe_global::<settings::SettingsStore>(|view, cx| {
             view.editor.update(cx, |editor, cx| {
                 editor.set_auto_replace_emoji_shortcode(
-                    MessageEditorSettings::get_global(cx).auto_replace_emoji_shortcode,
+                    MessageEditorSettings::get_global(cx)
+                        .auto_replace_emoji_shortcode
+                        .unwrap_or_default(),
                 )
             })
         })
diff --git a/crates/collab_ui/src/collab_panel.rs b/crates/collab_ui/src/collab_panel.rs
index 3e6483c42dd726..72701101816995 100644
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -2813,7 +2813,7 @@ impl Panel for CollabPanel {
         settings::update_settings_file::<CollaborationPanelSettings>(
             self.fs.clone(),
             cx,
-            move |settings, _| settings.dock = position,
+            move |settings, _| settings.dock = Some(position),
         );
     }
 
diff --git a/crates/collab_ui/src/notification_panel.rs b/crates/collab_ui/src/notification_panel.rs
index 326e1f0f5bdc2b..33ca5a2952180c 100644
--- a/crates/collab_ui/src/notification_panel.rs
+++ b/crates/collab_ui/src/notification_panel.rs
@@ -672,7 +672,7 @@ impl Panel for NotificationPanel {
         settings::update_settings_file::<NotificationPanelSettings>(
             self.fs.clone(),
             cx,
-            move |settings, _| settings.dock = position,
+            move |settings, _| settings.dock = Some(position),
         );
     }
 
diff --git a/crates/collab_ui/src/panel_settings.rs b/crates/collab_ui/src/panel_settings.rs
index a594f023bbcd3e..f9851d5797306c 100644
--- a/crates/collab_ui/src/panel_settings.rs
+++ b/crates/collab_ui/src/panel_settings.rs
@@ -2,84 +2,58 @@ use gpui::Pixels;
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
-use ui::px;
 use workspace::dock::DockPosition;
 
-#[derive(Clone, Deserialize, Debug, JsonSchema, Serialize)]
-#[serde(default)]
+#[derive(Deserialize, Debug)]
 pub struct CollaborationPanelSettings {
-    /// Whether to show the panel button in the status bar.
     pub button: bool,
-    /// Where to dock the panel.
     pub dock: DockPosition,
-    /// Default width of the panel in pixels.
     pub default_width: Pixels,
 }
 
-impl Default for CollaborationPanelSettings {
-    fn default() -> Self {
-        Self {
-            button: true,
-            dock: DockPosition::Left,
-            default_width: px(240.),
-        }
-    }
-}
-
-#[derive(Clone, Deserialize, Debug, JsonSchema, Serialize)]
-#[serde(default)]
+#[derive(Deserialize, Debug)]
 pub struct ChatPanelSettings {
-    /// Whether to show the panel button in the status bar.
     pub button: bool,
-    /// Where to dock the panel.
     pub dock: DockPosition,
-    /// Default width of the panel in pixels.
     pub default_width: Pixels,
 }
 
-impl Default for ChatPanelSettings {
-    fn default() -> Self {
-        Self {
-            button: true,
-            dock: DockPosition::Right,
-            default_width: px(240.),
-        }
-    }
-}
-
-#[derive(Clone, Deserialize, Debug, JsonSchema, Serialize)]
-#[serde(default)]
+#[derive(Deserialize, Debug)]
 pub struct NotificationPanelSettings {
-    /// Whether to show the panel button in the status bar.
     pub button: bool,
-    /// Where to dock the panel.
     pub dock: DockPosition,
-    /// Default width of the panel in pixels.
     pub default_width: Pixels,
 }
 
-impl Default for NotificationPanelSettings {
-    fn default() -> Self {
-        Self {
-            button: true,
-            dock: DockPosition::Right,
-            default_width: px(380.),
-        }
-    }
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct PanelSettingsContent {
+    /// Whether to show the panel button in the status bar.
+    ///
+    /// Default: true
+    pub button: Option<bool>,
+    /// Where to dock the panel.
+    ///
+    /// Default: left
+    pub dock: Option<DockPosition>,
+    /// Default width of the panel in pixels.
+    ///
+    /// Default: 240
+    pub default_width: Option<f32>,
 }
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-#[serde(default)]
 pub struct MessageEditorSettings {
     /// Whether to automatically replace emoji shortcodes with emoji characters.
     /// For example: typing `:wave:` gets replaced with `👋`.
-    pub auto_replace_emoji_shortcode: bool,
+    ///
+    /// Default: false
+    pub auto_replace_emoji_shortcode: Option<bool>,
 }
 
 impl Settings for CollaborationPanelSettings {
     const KEY: Option<&'static str> = Some("collaboration_panel");
 
-    type FileContent = Self;
+    type FileContent = PanelSettingsContent;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
@@ -92,7 +66,7 @@ impl Settings for CollaborationPanelSettings {
 impl Settings for ChatPanelSettings {
     const KEY: Option<&'static str> = Some("chat_panel");
 
-    type FileContent = Self;
+    type FileContent = PanelSettingsContent;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
@@ -105,7 +79,7 @@ impl Settings for ChatPanelSettings {
 impl Settings for NotificationPanelSettings {
     const KEY: Option<&'static str> = Some("notification_panel");
 
-    type FileContent = Self;
+    type FileContent = PanelSettingsContent;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
@@ -118,7 +92,7 @@ impl Settings for NotificationPanelSettings {
 impl Settings for MessageEditorSettings {
     const KEY: Option<&'static str> = Some("message_editor");
 
-    type FileContent = Self;
+    type FileContent = MessageEditorSettings;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
diff --git a/crates/diagnostics/src/project_diagnostics_settings.rs b/crates/diagnostics/src/project_diagnostics_settings.rs
index 34739bcd170adf..55879d0c426e2b 100644
--- a/crates/diagnostics/src/project_diagnostics_settings.rs
+++ b/crates/diagnostics/src/project_diagnostics_settings.rs
@@ -4,25 +4,23 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
-#[serde(default)]
-/// Diagnostics configuration.
+#[derive(Deserialize, Debug)]
 pub struct ProjectDiagnosticsSettings {
-    /// Whether to show warnings or not by default.
     pub include_warnings: bool,
 }
 
-impl Default for ProjectDiagnosticsSettings {
-    fn default() -> Self {
-        Self {
-            include_warnings: true,
-        }
-    }
+/// Diagnostics configuration.
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct ProjectDiagnosticsSettingsContent {
+    /// Whether to show warnings or not by default.
+    ///
+    /// Default: true
+    include_warnings: Option<bool>,
 }
 
 impl Settings for ProjectDiagnosticsSettings {
     const KEY: Option<&'static str> = Some("diagnostics");
-    type FileContent = Self;
+    type FileContent = ProjectDiagnosticsSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index e50bf67ab01a28..4792c6b2cb889d 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -10640,7 +10640,7 @@ impl Editor {
         let fs = workspace.read(cx).app_state().fs.clone();
         let current_show = TabBarSettings::get_global(cx).show;
         update_settings_file::<TabBarSettings>(fs, cx, move |setting, _| {
-            setting.show = !current_show;
+            setting.show = Some(!current_show);
         });
     }
 
@@ -12563,7 +12563,7 @@ impl EditorSnapshot {
         let show_git_gutter = self.show_git_diff_gutter.unwrap_or_else(|| {
             matches!(
                 ProjectSettings::get_global(cx).git.git_gutter,
-                GitGutterSetting::TrackedFiles
+                Some(GitGutterSetting::TrackedFiles)
             )
         });
         let gutter_settings = EditorSettings::get_global(cx).gutter;
diff --git a/crates/editor/src/editor_settings.rs b/crates/editor/src/editor_settings.rs
index 0532fd7bdf880c..2614e4ea303d24 100644
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -3,105 +3,38 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-#[derive(Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
+#[derive(Deserialize, Clone)]
 pub struct EditorSettings {
-    /// Whether the cursor blinks in the editor.
     pub cursor_blink: bool,
-    /// How to highlight the current line in the editor.
     pub current_line_highlight: CurrentLineHighlight,
-    /// Whether to show the informational hover box when moving the mouse
-    /// over symbols in the editor.
     pub hover_popover_enabled: bool,
-    /// Whether to pop the completions menu while typing in an editor without
-    /// explicitly requesting it.
     pub show_completions_on_input: bool,
-    /// Whether to display inline and alongside documentation for items in the
-    /// completions menu.
     pub show_completion_documentation: bool,
-    /// The debounce delay before re-querying the language server for completion
-    /// documentation when not included in original completion list.
     pub completion_documentation_secondary_query_debounce: u64,
-    /// Whether to use additional LSP queries to format (and amend) the code after
-    /// every "trigger" symbol input, defined by LSP server capabilities.
     pub use_on_type_format: bool,
-    /// Toolbar related settings
     pub toolbar: Toolbar,
-    /// Scrollbar related settings
     pub scrollbar: Scrollbar,
-    /// Gutter related settings
     pub gutter: Gutter,
-    /// Whether the editor will scroll beyond the last line.
     pub scroll_beyond_last_line: ScrollBeyondLastLine,
-    /// The number of lines to keep above/below the cursor when auto-scrolling.
     pub vertical_scroll_margin: f32,
-    /// Scroll sensitivity multiplier. This multiplier is applied
-    /// to both the horizontal and vertical delta values while scrolling.
     pub scroll_sensitivity: f32,
-    /// Whether the line numbers on editors gutter are relative or not.
     pub relative_line_numbers: bool,
-    /// When to populate a new search's query based on the text under the cursor.
     pub seed_search_query_from_cursor: SeedQuerySetting,
     pub use_smartcase_search: bool,
-    /// The key to use for adding multiple cursors
     pub multi_cursor_modifier: MultiCursorModifier,
-    /// Hide the values of variables in `private` files, as defined by the
-    /// private_files setting. This only changes the visual representation,
-    /// the values are still present in the file and can be selected / copied / pasted
     pub redact_private_values: bool,
-
-    /// How many lines to expand the multibuffer excerpts by default
     pub expand_excerpt_lines: u32,
     pub middle_click_paste: bool,
-    /// What to do when multibuffer is double clicked in some of its excerpts
-    /// (parts of singleton buffers).
     #[serde(default)]
     pub double_click_in_multibuffer: DoubleClickInMultibuffer,
-    /// Whether the editor search results will loop
     pub search_wrap: bool,
     #[serde(default)]
     pub search: SearchSettings,
-    /// Show method signatures in the editor, when inside parentheses.
     pub auto_signature_help: bool,
-    /// Whether to show the signature help after completion or a bracket pair inserted.
-    /// If `auto_signature_help` is enabled, this setting will be treated as enabled also.
     pub show_signature_help_after_edits: bool,
-    /// Jupyter REPL settings.
     pub jupyter: Jupyter,
 }
 
-impl Default for EditorSettings {
-    fn default() -> Self {
-        Self {
-            cursor_blink: true,
-            current_line_highlight: CurrentLineHighlight::All,
-            hover_popover_enabled: true,
-            show_completions_on_input: true,
-            show_completion_documentation: true,
-            completion_documentation_secondary_query_debounce: 300,
-            use_on_type_format: true,
-            toolbar: Default::default(),
-            scrollbar: Default::default(),
-            gutter: Default::default(),
-            scroll_beyond_last_line: ScrollBeyondLastLine::OnePage,
-            vertical_scroll_margin: 3.,
-            scroll_sensitivity: 1.0,
-            relative_line_numbers: false,
-            seed_search_query_from_cursor: SeedQuerySetting::Always,
-            multi_cursor_modifier: MultiCursorModifier::Alt,
-            redact_private_values: false,
-            expand_excerpt_lines: 3,
-            double_click_in_multibuffer: DoubleClickInMultibuffer::Select,
-            search_wrap: true,
-            auto_signature_help: false,
-            show_signature_help_after_edits: true,
-            jupyter: Default::default(),
-            use_smartcase_search: false,
-            middle_click_paste: true,
-            search: SearchSettings::default(),
-        }
-    }
-}
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum CurrentLineHighlight {
@@ -139,93 +72,48 @@ pub enum DoubleClickInMultibuffer {
     Open,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct Jupyter {
     /// Whether the Jupyter feature is enabled.
+    ///
+    /// Default: true
     pub enabled: bool,
 }
 
-impl Default for Jupyter {
-    fn default() -> Self {
-        Self { enabled: true }
-    }
+#[derive(Default, Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub struct JupyterContent {
+    /// Whether the Jupyter feature is enabled.
+    ///
+    /// Default: true
+    pub enabled: Option<bool>,
 }
 
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
-#[serde(default)]
 pub struct Toolbar {
-    /// Whether to display breadcrumbs in the editor toolbar.
     pub breadcrumbs: bool,
-    /// Whether to display quick action buttons in the editor toolbar.
     pub quick_actions: bool,
-    /// Whether to show the selections menu in the editor toolbar
     pub selections_menu: bool,
 }
 
-impl Default for Toolbar {
-    fn default() -> Self {
-        Self {
-            breadcrumbs: true,
-            quick_actions: true,
-            selections_menu: true,
-        }
-    }
-}
-
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 pub struct Scrollbar {
-    /// When to show the scrollbar in the editor.
     pub show: ShowScrollbar,
-    /// Whether to show git diff indicators in the scrollbar.
     pub git_diff: bool,
-    /// Whether to show buffer search result indicators in the scrollbar.
     pub selected_symbol: bool,
-    /// Whether to show selected symbol occurrences in the scrollbar.
     pub search_results: bool,
-    /// Whether to show diagnostic indicators in the scrollbar.
     pub diagnostics: bool,
-    /// Whether to show cursor positions in the scrollbar.
     pub cursors: bool,
 }
 
-impl Default for Scrollbar {
-    fn default() -> Self {
-        Self {
-            show: ShowScrollbar::Auto,
-            git_diff: true,
-            selected_symbol: true,
-            search_results: true,
-            diagnostics: true,
-            cursors: true,
-        }
-    }
-}
-
-/// Gutter-related settings.
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
-#[serde(default)]
 pub struct Gutter {
-    /// Whether to show line numbers in the gutter.
     pub line_numbers: bool,
-    /// Whether to show code action buttons in the gutter.
     pub code_actions: bool,
-    /// Whether to show runnable buttons in the gutter.
     pub runnables: bool,
-    /// Whether to show fold buttons in the gutter.
     pub folds: bool,
 }
 
-impl Default for Gutter {
-    fn default() -> Self {
-        Self {
-            line_numbers: true,
-            code_actions: true,
-            runnables: true,
-            folds: true,
-        }
-    }
-}
-
 /// When to show the scrollbar in the editor.
 ///
 /// Default: auto
@@ -283,6 +171,188 @@ pub struct SearchSettings {
     pub regex: bool,
 }
 
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub struct EditorSettingsContent {
+    /// Whether the cursor blinks in the editor.
+    ///
+    /// Default: true
+    pub cursor_blink: Option<bool>,
+    /// How to highlight the current line in the editor.
+    ///
+    /// Default: all
+    pub current_line_highlight: Option<CurrentLineHighlight>,
+    /// Whether to show the informational hover box when moving the mouse
+    /// over symbols in the editor.
+    ///
+    /// Default: true
+    pub hover_popover_enabled: Option<bool>,
+
+    /// Whether to pop the completions menu while typing in an editor without
+    /// explicitly requesting it.
+    ///
+    /// Default: true
+    pub show_completions_on_input: Option<bool>,
+    /// Whether to display inline and alongside documentation for items in the
+    /// completions menu.
+    ///
+    /// Default: true
+    pub show_completion_documentation: Option<bool>,
+    /// The debounce delay before re-querying the language server for completion
+    /// documentation when not included in original completion list.
+    ///
+    /// Default: 300 ms
+    pub completion_documentation_secondary_query_debounce: Option<u64>,
+    /// Whether to use additional LSP queries to format (and amend) the code after
+    /// every "trigger" symbol input, defined by LSP server capabilities.
+    ///
+    /// Default: true
+    pub use_on_type_format: Option<bool>,
+    /// Toolbar related settings
+    pub toolbar: Option<ToolbarContent>,
+    /// Scrollbar related settings
+    pub scrollbar: Option<ScrollbarContent>,
+    /// Gutter related settings
+    pub gutter: Option<GutterContent>,
+    /// Whether the editor will scroll beyond the last line.
+    ///
+    /// Default: one_page
+    pub scroll_beyond_last_line: Option<ScrollBeyondLastLine>,
+    /// The number of lines to keep above/below the cursor when auto-scrolling.
+    ///
+    /// Default: 3.
+    pub vertical_scroll_margin: Option<f32>,
+    /// Scroll sensitivity multiplier. This multiplier is applied
+    /// to both the horizontal and vertical delta values while scrolling.
+    ///
+    /// Default: 1.0
+    pub scroll_sensitivity: Option<f32>,
+    /// Whether the line numbers on editors gutter are relative or not.
+    ///
+    /// Default: false
+    pub relative_line_numbers: Option<bool>,
+    /// When to populate a new search's query based on the text under the cursor.
+    ///
+    /// Default: always
+    pub seed_search_query_from_cursor: Option<SeedQuerySetting>,
+    pub use_smartcase_search: Option<bool>,
+    /// The key to use for adding multiple cursors
+    ///
+    /// Default: alt
+    pub multi_cursor_modifier: Option<MultiCursorModifier>,
+    /// Hide the values of variables in `private` files, as defined by the
+    /// private_files setting. This only changes the visual representation,
+    /// the values are still present in the file and can be selected / copied / pasted
+    ///
+    /// Default: false
+    pub redact_private_values: Option<bool>,
+
+    /// How many lines to expand the multibuffer excerpts by default
+    ///
+    /// Default: 3
+    pub expand_excerpt_lines: Option<u32>,
+
+    /// Whether to enable middle-click paste on Linux
+    ///
+    /// Default: true
+    pub middle_click_paste: Option<bool>,
+
+    /// What to do when multibuffer is double clicked in some of its excerpts
+    /// (parts of singleton buffers).
+    ///
+    /// Default: select
+    pub double_click_in_multibuffer: Option<DoubleClickInMultibuffer>,
+    /// Whether the editor search results will loop
+    ///
+    /// Default: true
+    pub search_wrap: Option<bool>,
+
+    /// Defaults to use when opening a new buffer and project search items.
+    ///
+    /// Default: nothing is enabled
+    pub search: Option<SearchSettings>,
+
+    /// Whether to automatically show a signature help pop-up or not.
+    ///
+    /// Default: false
+    pub auto_signature_help: Option<bool>,
+
+    /// Whether to show the signature help pop-up after completions or bracket pairs inserted.
+    ///
+    /// Default: true
+    pub show_signature_help_after_edits: Option<bool>,
+
+    /// Jupyter REPL settings.
+    pub jupyter: Option<JupyterContent>,
+}
+
+// Toolbar related settings
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+pub struct ToolbarContent {
+    /// Whether to display breadcrumbs in the editor toolbar.
+    ///
+    /// Default: true
+    pub breadcrumbs: Option<bool>,
+    /// Whether to display quick action buttons in the editor toolbar.
+    ///
+    /// Default: true
+    pub quick_actions: Option<bool>,
+
+    /// Whether to show the selections menu in the editor toolbar
+    ///
+    /// Default: true
+    pub selections_menu: Option<bool>,
+}
+
+/// Scrollbar related settings
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+pub struct ScrollbarContent {
+    /// When to show the scrollbar in the editor.
+    ///
+    /// Default: auto
+    pub show: Option<ShowScrollbar>,
+    /// Whether to show git diff indicators in the scrollbar.
+    ///
+    /// Default: true
+    pub git_diff: Option<bool>,
+    /// Whether to show buffer search result indicators in the scrollbar.
+    ///
+    /// Default: true
+    pub search_results: Option<bool>,
+    /// Whether to show selected symbol occurrences in the scrollbar.
+    ///
+    /// Default: true
+    pub selected_symbol: Option<bool>,
+    /// Whether to show diagnostic indicators in the scrollbar.
+    ///
+    /// Default: true
+    pub diagnostics: Option<bool>,
+    /// Whether to show cursor positions in the scrollbar.
+    ///
+    /// Default: true
+    pub cursors: Option<bool>,
+}
+
+/// Gutter related settings
+#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+pub struct GutterContent {
+    /// Whether to show line numbers in the gutter.
+    ///
+    /// Default: true
+    pub line_numbers: Option<bool>,
+    /// Whether to show code action buttons in the gutter.
+    ///
+    /// Default: true
+    pub code_actions: Option<bool>,
+    /// Whether to show runnable buttons in the gutter.
+    ///
+    /// Default: true
+    pub runnables: Option<bool>,
+    /// Whether to show fold buttons in the gutter.
+    ///
+    /// Default: true
+    pub folds: Option<bool>,
+}
+
 impl EditorSettings {
     pub fn jupyter_enabled(cx: &AppContext) -> bool {
         EditorSettings::get_global(cx).jupyter.enabled
@@ -292,7 +362,7 @@ impl EditorSettings {
 impl Settings for EditorSettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = Self;
+    type FileContent = EditorSettingsContent;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
diff --git a/crates/editor/src/editor_settings_controls.rs b/crates/editor/src/editor_settings_controls.rs
index 36d471dfa28f4b..bbe1b00324a787 100644
--- a/crates/editor/src/editor_settings_controls.rs
+++ b/crates/editor/src/editor_settings_controls.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use gpui::{AppContext, FontFeatures, FontWeight};
-use project::project_settings::ProjectSettings;
+use project::project_settings::{InlineBlameSettings, ProjectSettings};
 use settings::{EditableSettingControl, Settings};
 use theme::{FontFamilyCache, ThemeSettings};
 use ui::{
@@ -296,7 +296,14 @@ impl EditableSettingControl for InlineGitBlameControl {
         value: Self::Value,
         _cx: &AppContext,
     ) {
-        settings.git.inline_blame.enabled = value;
+        if let Some(inline_blame) = settings.git.inline_blame.as_mut() {
+            inline_blame.enabled = value;
+        } else {
+            settings.git.inline_blame = Some(InlineBlameSettings {
+                enabled: false,
+                ..Default::default()
+            });
+        }
     }
 }
 
@@ -342,7 +349,14 @@ impl EditableSettingControl for LineNumbersControl {
         value: Self::Value,
         _cx: &AppContext,
     ) {
-        settings.gutter.line_numbers = value;
+        if let Some(gutter) = settings.gutter.as_mut() {
+            gutter.line_numbers = Some(value);
+        } else {
+            settings.gutter = Some(crate::editor_settings::GutterContent {
+                line_numbers: Some(value),
+                ..Default::default()
+            });
+        }
     }
 }
 
@@ -388,7 +402,7 @@ impl EditableSettingControl for RelativeLineNumbersControl {
         value: Self::Value,
         _cx: &AppContext,
     ) {
-        settings.relative_line_numbers = value;
+        settings.relative_line_numbers = Some(value);
     }
 }
 
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 7d42dc7a85d06e..0b1e0385ded4ad 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -6964,7 +6964,7 @@ async fn test_handle_input_for_show_signature_help_auto_signature_help_true(
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.auto_signature_help = true;
+                settings.auto_signature_help = Some(true);
             });
         });
     });
@@ -7105,8 +7105,8 @@ async fn test_handle_input_with_different_show_signature_settings(cx: &mut gpui:
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.auto_signature_help = false;
-                settings.show_signature_help_after_edits = false;
+                settings.auto_signature_help = Some(false);
+                settings.show_signature_help_after_edits = Some(false);
             });
         });
     });
@@ -7232,8 +7232,8 @@ async fn test_handle_input_with_different_show_signature_settings(cx: &mut gpui:
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.auto_signature_help = false;
-                settings.show_signature_help_after_edits = true;
+                settings.auto_signature_help = Some(false);
+                settings.show_signature_help_after_edits = Some(true);
             });
         });
     });
@@ -7274,8 +7274,8 @@ async fn test_handle_input_with_different_show_signature_settings(cx: &mut gpui:
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.auto_signature_help = true;
-                settings.show_signature_help_after_edits = false;
+                settings.auto_signature_help = Some(true);
+                settings.show_signature_help_after_edits = Some(false);
             });
         });
     });
@@ -7318,7 +7318,7 @@ async fn test_signature_help(cx: &mut gpui::TestAppContext) {
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.auto_signature_help = true;
+                settings.auto_signature_help = Some(true);
             });
         });
     });
@@ -7759,7 +7759,7 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|settings, cx| {
             settings.update_user_settings::<EditorSettings>(cx, |settings| {
-                settings.show_completions_on_input = false;
+                settings.show_completions_on_input = Some(false);
             });
         })
     });
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 1c0a325b7620e5..d4f5c565c27ef0 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -1283,7 +1283,10 @@ impl EditorElement {
                 .row,
         );
 
-        let git_gutter_setting = ProjectSettings::get_global(cx).git.git_gutter;
+        let git_gutter_setting = ProjectSettings::get_global(cx)
+            .git
+            .git_gutter
+            .unwrap_or_default();
         let display_hunks = buffer_snapshot
             .git_diff_hunks_in_range(buffer_start_row..buffer_end_row)
             .map(|hunk| diff_hunk_to_display(&hunk, snapshot))
@@ -1363,10 +1366,12 @@ impl EditorElement {
             };
             let padded_line_end = line_end + em_width * INLINE_BLAME_PADDING_EM_WIDTHS;
 
-            let min_column_in_pixels = self.column_pixels(
-                ProjectSettings::get_global(cx).git.inline_blame.min_column as usize,
-                cx,
-            );
+            let min_column_in_pixels = ProjectSettings::get_global(cx)
+                .git
+                .inline_blame
+                .and_then(|settings| settings.min_column)
+                .map(|col| self.column_pixels(col as usize, cx))
+                .unwrap_or(px(0.));
             let min_start = content_origin.x - scroll_pixel_position.x + min_column_in_pixels;
 
             cmp::max(padded_line_end, min_start)
@@ -3326,7 +3331,7 @@ impl EditorElement {
             .unwrap_or_else(|| {
                 matches!(
                     ProjectSettings::get_global(cx).git.git_gutter,
-                    GitGutterSetting::TrackedFiles
+                    Some(GitGutterSetting::TrackedFiles)
                 )
             });
         if show_git_gutter {
diff --git a/crates/extension/src/extension_settings.rs b/crates/extension/src/extension_settings.rs
index 715dc3ca827f51..a2ab7ac9cca73b 100644
--- a/crates/extension/src/extension_settings.rs
+++ b/crates/extension/src/extension_settings.rs
@@ -6,25 +6,18 @@ use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 use std::sync::Arc;
 
-#[derive(Deserialize, Serialize, Debug, Clone, JsonSchema)]
-#[serde(default)]
+#[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema)]
 pub struct ExtensionSettings {
     /// The extensions that should be automatically installed by Zed.
     ///
     /// This is used to make functionality provided by extensions (e.g., language support)
     /// available out-of-the-box.
+    #[serde(default)]
     pub auto_install_extensions: HashMap<Arc<str>, bool>,
+    #[serde(default)]
     pub auto_update_extensions: HashMap<Arc<str>, bool>,
 }
 
-impl Default for ExtensionSettings {
-    fn default() -> Self {
-        Self {
-            auto_install_extensions: HashMap::from_iter([("html".into(), true)]),
-            auto_update_extensions: Default::default(),
-        }
-    }
-}
 impl ExtensionSettings {
     /// Returns whether the given extension should be auto-installed.
     pub fn should_auto_install(&self, extension_id: &str) -> bool {
diff --git a/crates/extensions_ui/src/extensions_ui.rs b/crates/extensions_ui/src/extensions_ui.rs
index b2d6d7f2831720..f246e3cf4fb830 100644
--- a/crates/extensions_ui/src/extensions_ui.rs
+++ b/crates/extensions_ui/src/extensions_ui.rs
@@ -1000,7 +1000,7 @@ impl ExtensionsPage {
                             this.update_settings::<VimModeSetting>(
                                 selection,
                                 cx,
-                                |setting, value| *setting = VimModeSetting(value),
+                                |setting, value| *setting = Some(value),
                             );
                         }),
                     )),
diff --git a/crates/go_to_line/src/cursor_position.rs b/crates/go_to_line/src/cursor_position.rs
index de3d1dc74d2774..63e0f2b07915eb 100644
--- a/crates/go_to_line/src/cursor_position.rs
+++ b/crates/go_to_line/src/cursor_position.rs
@@ -180,10 +180,18 @@ pub(crate) enum LineIndicatorFormat {
     Long,
 }
 
+/// Whether or not to automatically check for updates.
+///
+/// Values: short, long
+/// Default: short
+#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize)]
+#[serde(transparent)]
+pub(crate) struct LineIndicatorFormatContent(LineIndicatorFormat);
+
 impl Settings for LineIndicatorFormat {
     const KEY: Option<&'static str> = Some("line_indicator_format");
 
-    type FileContent = Self;
+    type FileContent = Option<LineIndicatorFormatContent>;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
@@ -191,9 +199,9 @@ impl Settings for LineIndicatorFormat {
     ) -> anyhow::Result<Self> {
         let format = [sources.release_channel, sources.user]
             .into_iter()
-            .find_map(|value| value.copied())
-            .unwrap_or(*sources.default);
+            .find_map(|value| value.copied().flatten())
+            .unwrap_or(sources.default.ok_or_else(Self::missing_default)?);
 
-        Ok(format)
+        Ok(format.0)
     }
 }
diff --git a/crates/gpui/src/geometry.rs b/crates/gpui/src/geometry.rs
index b2035923605e0c..8de9e6f009d733 100644
--- a/crates/gpui/src/geometry.rs
+++ b/crates/gpui/src/geometry.rs
@@ -5,7 +5,6 @@
 use core::fmt::Debug;
 use derive_more::{Add, AddAssign, Div, DivAssign, Mul, Neg, Sub, SubAssign};
 use refineable::Refineable;
-use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
 use std::{
     cmp::{self, PartialOrd},
@@ -2202,7 +2201,6 @@ impl From<Percentage> for Radians {
     PartialEq,
     Serialize,
     Deserialize,
-    JsonSchema,
 )]
 #[repr(transparent)]
 pub struct Pixels(pub f32);
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index 7a6b758a2554ec..e1fcaaba28b4f1 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -70,10 +70,10 @@ pub struct LanguageSettings {
     /// The column at which to soft-wrap lines, for buffers where soft-wrap
     /// is enabled.
     pub preferred_line_length: u32,
-    /// Whether to show wrap guides (vertical rulers) in the editor.
-    /// Setting this to true will show a guide at the 'preferred_line_length' value
-    /// if softwrap is set to 'preferred_line_length', and will show any
-    /// additional guides as specified by the 'wrap_guides' setting.
+    // Whether to show wrap guides (vertical rulers) in the editor.
+    // Setting this to true will show a guide at the 'preferred_line_length' value
+    // if softwrap is set to 'preferred_line_length', and will show any
+    // additional guides as specified by the 'wrap_guides' setting.
     pub show_wrap_guides: bool,
     /// Character counts at which to show wrap guides (vertical rulers) in the editor.
     pub wrap_guides: Vec<usize>,
diff --git a/crates/languages/src/json.rs b/crates/languages/src/json.rs
index 102eb1ef2f8563..6b5f74c2634b45 100644
--- a/crates/languages/src/json.rs
+++ b/crates/languages/src/json.rs
@@ -7,13 +7,10 @@ use feature_flags::FeatureFlagAppExt;
 use futures::StreamExt;
 use gpui::{AppContext, AsyncAppContext};
 use http_client::github::{latest_github_release, GitHubLspBinaryVersion};
-use language::{
-    CodeLabel, Language, LanguageRegistry, LanguageServerName, LspAdapter, LspAdapterDelegate,
-};
+use language::{LanguageRegistry, LanguageServerName, LspAdapter, LspAdapterDelegate};
 use lsp::LanguageServerBinary;
 use node_runtime::NodeRuntime;
 use project::ContextProviderWithTasks;
-use rope::Rope;
 use serde_json::{json, Value};
 use settings::{KeymapFile, SettingsJsonSchemaParams, SettingsStore};
 use smol::{
@@ -205,30 +202,6 @@ impl LspAdapter for JsonLspAdapter {
         })))
     }
 
-    async fn label_for_completion(
-        &self,
-        item: &lsp::CompletionItem,
-        language: &Arc<Language>,
-    ) -> Option<CodeLabel> {
-        let text = if let Some(description) = item
-            .label_details
-            .as_ref()
-            .and_then(|label_details| label_details.description.as_ref())
-        {
-            format!("{} {}", item.label, description)
-        } else if let Some(detail) = &item.detail {
-            format!("{} {}", item.label, detail)
-        } else {
-            item.label.clone()
-        };
-        let rope = Rope::from(item.label.as_str());
-        let runs = language.highlight_text(&rope, 0..item.label.len());
-        Some(language::CodeLabel {
-            text,
-            runs,
-            filter_range: 0..item.label.len(),
-        })
-    }
     async fn workspace_configuration(
         self: Arc<Self>,
         _: &Arc<dyn LspAdapterDelegate>,
diff --git a/crates/outline_panel/src/outline_panel.rs b/crates/outline_panel/src/outline_panel.rs
index 361607533b84b0..c5f0187c229fa8 100644
--- a/crates/outline_panel/src/outline_panel.rs
+++ b/crates/outline_panel/src/outline_panel.rs
@@ -24,12 +24,12 @@ use editor::{
 use file_icons::FileIcons;
 use fuzzy::{match_strings, StringMatch, StringMatchCandidate};
 use gpui::{
-    actions, anchored, deferred, div, impl_actions, uniform_list, Action, AnyElement, AppContext,
-    AssetSource, AsyncWindowContext, ClipboardItem, DismissEvent, Div, ElementId, EventEmitter,
-    FocusHandle, FocusableView, HighlightStyle, InteractiveElement, IntoElement, KeyContext, Model,
-    MouseButton, MouseDownEvent, ParentElement, Pixels, Point, Render, SharedString, Stateful,
-    Styled, Subscription, Task, UniformListScrollHandle, View, ViewContext, VisualContext,
-    WeakView, WindowContext,
+    actions, anchored, deferred, div, impl_actions, px, uniform_list, Action, AnyElement,
+    AppContext, AssetSource, AsyncWindowContext, ClipboardItem, DismissEvent, Div, ElementId,
+    EventEmitter, FocusHandle, FocusableView, HighlightStyle, InteractiveElement, IntoElement,
+    KeyContext, Model, MouseButton, MouseDownEvent, ParentElement, Pixels, Point, Render,
+    SharedString, Stateful, Styled, Subscription, Task, UniformListScrollHandle, View, ViewContext,
+    VisualContext, WeakView, WindowContext,
 };
 use itertools::Itertools;
 use language::{BufferId, BufferSnapshot, OffsetRangeExt, OutlineItem};
@@ -1938,7 +1938,7 @@ impl OutlinePanel {
             .child(
                 ListItem::new(item_id)
                     .indent_level(depth)
-                    .indent_step_size(settings.indent_size)
+                    .indent_step_size(px(settings.indent_size))
                     .selected(is_active)
                     .when_some(icon_element, |list_item, icon_element| {
                         list_item.child(h_flex().child(icon_element))
@@ -3801,7 +3801,7 @@ impl Panel for OutlinePanel {
                     DockPosition::Left | DockPosition::Bottom => OutlinePanelDockPosition::Left,
                     DockPosition::Right => OutlinePanelDockPosition::Right,
                 };
-                settings.dock = dock;
+                settings.dock = Some(dock);
             },
         );
     }
diff --git a/crates/outline_panel/src/outline_panel_settings.rs b/crates/outline_panel/src/outline_panel_settings.rs
index a8e51b96c5c3aa..e19fc3c0084947 100644
--- a/crates/outline_panel/src/outline_panel_settings.rs
+++ b/crates/outline_panel/src/outline_panel_settings.rs
@@ -1,5 +1,4 @@
-use anyhow;
-use gpui::{px, Pixels};
+use gpui::Pixels;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
@@ -11,51 +10,66 @@ pub enum OutlinePanelDockPosition {
     Right,
 }
 
-#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq, JsonSchema)]
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq)]
 pub struct OutlinePanelSettings {
-    /// Whether to show the outline panel button in the status bar.
     pub button: bool,
-    /// Customize default width (in pixels) taken by outline panel
     pub default_width: Pixels,
-    /// The position of outline panel
     pub dock: OutlinePanelDockPosition,
-    /// Whether to show file icons in the outline panel.
     pub file_icons: bool,
-    /// Whether to show folder icons or chevrons for directories in the outline panel.
     pub folder_icons: bool,
-    /// Whether to show the git status in the outline panel.
     pub git_status: bool,
+    pub indent_size: f32,
+    pub auto_reveal_entries: bool,
+    pub auto_fold_dirs: bool,
+}
+
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct OutlinePanelSettingsContent {
+    /// Whether to show the outline panel button in the status bar.
+    ///
+    /// Default: true
+    pub button: Option<bool>,
+    /// Customize default width (in pixels) taken by outline panel
+    ///
+    /// Default: 240
+    pub default_width: Option<f32>,
+    /// The position of outline panel
+    ///
+    /// Default: left
+    pub dock: Option<OutlinePanelDockPosition>,
+    /// Whether to show file icons in the outline panel.
+    ///
+    /// Default: true
+    pub file_icons: Option<bool>,
+    /// Whether to show folder icons or chevrons for directories in the outline panel.
+    ///
+    /// Default: true
+    pub folder_icons: Option<bool>,
+    /// Whether to show the git status in the outline panel.
+    ///
+    /// Default: true
+    pub git_status: Option<bool>,
     /// Amount of indentation (in pixels) for nested items.
-    pub indent_size: Pixels,
+    ///
+    /// Default: 20
+    pub indent_size: Option<f32>,
     /// Whether to reveal it in the outline panel automatically,
     /// when a corresponding project entry becomes active.
     /// Gitignored entries are never auto revealed.
-    pub auto_reveal_entries: bool,
+    ///
+    /// Default: true
+    pub auto_reveal_entries: Option<bool>,
     /// Whether to fold directories automatically
     /// when directory has only one directory inside.
-    pub auto_fold_dirs: bool,
-}
-
-impl Default for OutlinePanelSettings {
-    fn default() -> Self {
-        Self {
-            button: true,
-            default_width: px(240.),
-            dock: OutlinePanelDockPosition::Left,
-            file_icons: true,
-            folder_icons: true,
-            auto_fold_dirs: true,
-            auto_reveal_entries: true,
-            indent_size: px(20.),
-            git_status: true,
-        }
-    }
+    ///
+    /// Default: true
+    pub auto_fold_dirs: Option<bool>,
 }
 
 impl Settings for OutlinePanelSettings {
     const KEY: Option<&'static str> = Some("outline_panel");
 
-    type FileContent = Self;
+    type FileContent = OutlinePanelSettingsContent;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
diff --git a/crates/performance/src/performance.rs b/crates/performance/src/performance.rs
deleted file mode 100644
index db2388c59ae1c0..00000000000000
--- a/crates/performance/src/performance.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-use std::time::Instant;
-
-use anyhow::Result;
-use gpui::{
-    div, AppContext, InteractiveElement as _, Render, StatefulInteractiveElement as _,
-    Subscription, ViewContext, VisualContext,
-};
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsStore};
-use workspace::{
-    ui::{Label, LabelCommon, LabelSize, Tooltip},
-    ItemHandle, StatusItemView, Workspace,
-};
-
-const SHOW_STARTUP_TIME_DURATION: std::time::Duration = std::time::Duration::from_secs(5);
-
-pub fn init(cx: &mut AppContext) {
-    PerformanceSettings::register(cx);
-
-    let mut enabled = PerformanceSettings::get_global(cx).show_in_status_bar;
-    let start_time = Instant::now();
-    let mut _observe_workspaces = toggle_status_bar_items(enabled, start_time, cx);
-
-    cx.observe_global::<SettingsStore>(move |cx| {
-        let new_value = PerformanceSettings::get_global(cx).show_in_status_bar;
-        if new_value != enabled {
-            enabled = new_value;
-            _observe_workspaces = toggle_status_bar_items(enabled, start_time, cx);
-        }
-    })
-    .detach();
-}
-
-fn toggle_status_bar_items(
-    enabled: bool,
-    start_time: Instant,
-    cx: &mut AppContext,
-) -> Option<Subscription> {
-    for window in cx.windows() {
-        if let Some(workspace) = window.downcast::<Workspace>() {
-            workspace
-                .update(cx, |workspace, cx| {
-                    toggle_status_bar_item(workspace, enabled, start_time, cx);
-                })
-                .ok();
-        }
-    }
-
-    if enabled {
-        log::info!("performance metrics display enabled");
-        Some(cx.observe_new_views::<Workspace>(move |workspace, cx| {
-            toggle_status_bar_item(workspace, true, start_time, cx);
-        }))
-    } else {
-        log::info!("performance metrics display disabled");
-        None
-    }
-}
-
-struct PerformanceStatusBarItem {
-    display_mode: DisplayMode,
-}
-
-#[derive(Copy, Clone, Debug)]
-enum DisplayMode {
-    StartupTime,
-    Fps,
-}
-
-impl PerformanceStatusBarItem {
-    fn new(start_time: Instant, cx: &mut ViewContext<Self>) -> Self {
-        let now = Instant::now();
-        let display_mode = if now < start_time + SHOW_STARTUP_TIME_DURATION {
-            DisplayMode::StartupTime
-        } else {
-            DisplayMode::Fps
-        };
-
-        let this = Self { display_mode };
-
-        if let DisplayMode::StartupTime = display_mode {
-            cx.spawn(|this, mut cx| async move {
-                let now = Instant::now();
-                let remaining_duration =
-                    (start_time + SHOW_STARTUP_TIME_DURATION).saturating_duration_since(now);
-                cx.background_executor().timer(remaining_duration).await;
-                this.update(&mut cx, |this, cx| {
-                    this.display_mode = DisplayMode::Fps;
-                    cx.notify();
-                })
-                .ok();
-            })
-            .detach();
-        }
-
-        this
-    }
-}
-
-impl Render for PerformanceStatusBarItem {
-    fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> impl gpui::IntoElement {
-        let text = match self.display_mode {
-            DisplayMode::StartupTime => cx
-                .time_to_first_window_draw()
-                .map_or("Pending".to_string(), |duration| {
-                    format!("{}ms", duration.as_millis())
-                }),
-            DisplayMode::Fps => cx.fps().map_or("".to_string(), |fps| {
-                format!("{:3} FPS", fps.round() as u32)
-            }),
-        };
-
-        use gpui::ParentElement;
-        let display_mode = self.display_mode;
-        div()
-            .id("performance status")
-            .child(Label::new(text).size(LabelSize::Small))
-            .tooltip(move |cx| match display_mode {
-                DisplayMode::StartupTime => Tooltip::text("Time to first window draw", cx),
-                DisplayMode::Fps => cx
-                    .new_view(|cx| {
-                        let tooltip = Tooltip::new("Current FPS");
-                        if let Some(time_to_first) = cx.time_to_first_window_draw() {
-                            tooltip.meta(format!(
-                                "Time to first window draw: {}ms",
-                                time_to_first.as_millis()
-                            ))
-                        } else {
-                            tooltip
-                        }
-                    })
-                    .into(),
-            })
-    }
-}
-
-impl StatusItemView for PerformanceStatusBarItem {
-    fn set_active_pane_item(
-        &mut self,
-        _active_pane_item: Option<&dyn ItemHandle>,
-        _cx: &mut gpui::ViewContext<Self>,
-    ) {
-        // This is not currently used.
-    }
-}
-
-fn toggle_status_bar_item(
-    workspace: &mut Workspace,
-    enabled: bool,
-    start_time: Instant,
-    cx: &mut ViewContext<Workspace>,
-) {
-    if enabled {
-        workspace.status_bar().update(cx, |bar, cx| {
-            bar.add_right_item(
-                cx.new_view(|cx| PerformanceStatusBarItem::new(start_time, cx)),
-                cx,
-            )
-        });
-    } else {
-        workspace.status_bar().update(cx, |bar, cx| {
-            bar.remove_items_of_type::<PerformanceStatusBarItem>(cx);
-        });
-    }
-}
-
-/// Configuration of the display of performance details.
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
-#[serde(default)]
-pub struct PerformanceSettings {
-    /// Display the time to first window draw and frame rate in the status bar.
-    pub show_in_status_bar: bool,
-}
-
-impl Settings for PerformanceSettings {
-    const KEY: Option<&'static str> = Some("performance");
-
-    type FileContent = Self;
-
-    fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
-        sources.json_merge()
-    }
-}
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index 3c21b1c5e8caf1..70b2eccf237c62 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -20,7 +20,6 @@ use worktree::{PathChange, UpdatedEntriesSet, Worktree, WorktreeId};
 use crate::worktree_store::{WorktreeStore, WorktreeStoreEvent};
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
 pub struct ProjectSettings {
     /// Configuration for language servers.
     ///
@@ -42,6 +41,7 @@ pub struct ProjectSettings {
     pub load_direnv: DirenvSettings,
 
     /// Configuration for session-related features
+    #[serde(default)]
     pub session: SessionSettings,
 }
 
@@ -59,31 +59,36 @@ pub enum DirenvSettings {
 }
 
 #[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
 pub struct GitSettings {
     /// Whether or not to show the git gutter.
     ///
     /// Default: tracked_files
-    pub git_gutter: GitGutterSetting,
+    pub git_gutter: Option<GitGutterSetting>,
     pub gutter_debounce: Option<u64>,
     /// Whether or not to show git blame data inline in
     /// the currently focused line.
     ///
     /// Default: on
-    pub inline_blame: InlineBlameSettings,
+    pub inline_blame: Option<InlineBlameSettings>,
 }
 
 impl GitSettings {
     pub fn inline_blame_enabled(&self) -> bool {
         #[allow(unknown_lints, clippy::manual_unwrap_or_default)]
-        self.inline_blame.enabled
+        match self.inline_blame {
+            Some(InlineBlameSettings { enabled, .. }) => enabled,
+            _ => false,
+        }
     }
 
     pub fn inline_blame_delay(&self) -> Option<Duration> {
-        self.inline_blame
-            .delay_ms
-            .gt(&0)
-            .then(|| Duration::from_millis(self.inline_blame.delay_ms))
+        match self.inline_blame {
+            Some(InlineBlameSettings {
+                delay_ms: Some(delay_ms),
+                ..
+            }) if delay_ms > 0 => Some(Duration::from_millis(delay_ms)),
+            _ => None,
+        }
     }
 }
 
@@ -97,34 +102,28 @@ pub enum GitGutterSetting {
     Hide,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
-#[serde(default)]
 pub struct InlineBlameSettings {
     /// Whether or not to show git blame data inline in
     /// the currently focused line.
     ///
     /// Default: true
+    #[serde(default = "true_value")]
     pub enabled: bool,
     /// Whether to only show the inline blame information
     /// after a delay once the cursor stops moving.
     ///
     /// Default: 0
-    pub delay_ms: u64,
+    pub delay_ms: Option<u64>,
     /// The minimum column number to show the inline blame information at
     ///
     /// Default: 0
-    pub min_column: u32,
+    pub min_column: Option<u32>,
 }
 
-impl Default for InlineBlameSettings {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            delay_ms: 0,
-            min_column: 0,
-        }
-    }
+const fn true_value() -> bool {
+    true
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 6ca843875b48a5..c77a2170dd01cd 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -2289,7 +2289,7 @@ impl ProjectPanel {
             .child(
                 ListItem::new(entry_id.to_proto() as usize)
                     .indent_level(depth)
-                    .indent_step_size(settings.indent_size)
+                    .indent_step_size(px(settings.indent_size))
                     .selected(is_marked || is_active)
                     .when_some(canonical_path, |this, path| {
                         this.end_slot::<AnyElement>(
@@ -2817,7 +2817,7 @@ impl Render for DraggedProjectEntryView {
                 this.bg(cx.theme().colors().background).w(self.width).child(
                     ListItem::new(self.selection.entry_id.to_proto() as usize)
                         .indent_level(self.details.depth)
-                        .indent_step_size(settings.indent_size)
+                        .indent_step_size(px(settings.indent_size))
                         .child(if let Some(icon) = &self.details.icon {
                             div().child(Icon::from_path(icon.clone()))
                         } else {
@@ -2855,7 +2855,7 @@ impl Panel for ProjectPanel {
                     DockPosition::Left | DockPosition::Bottom => ProjectPanelDockPosition::Left,
                     DockPosition::Right => ProjectPanelDockPosition::Right,
                 };
-                settings.dock = dock;
+                settings.dock = Some(dock);
             },
         );
     }
@@ -3029,7 +3029,7 @@ mod tests {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |worktree_settings| {
                     worktree_settings.file_scan_exclusions =
-                        vec!["**/.git".to_string(), "**/4/**".to_string()];
+                        Some(vec!["**/.git".to_string(), "**/4/**".to_string()]);
                 });
             });
         });
@@ -4818,10 +4818,10 @@ mod tests {
         cx.update(|cx| {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |worktree_settings| {
-                    worktree_settings.file_scan_exclusions = Vec::new();
+                    worktree_settings.file_scan_exclusions = Some(Vec::new());
                 });
                 store.update_user_settings::<ProjectPanelSettings>(cx, |project_panel_settings| {
-                    project_panel_settings.auto_reveal_entries = false
+                    project_panel_settings.auto_reveal_entries = Some(false)
                 });
             })
         });
@@ -4940,7 +4940,7 @@ mod tests {
         cx.update(|cx| {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<ProjectPanelSettings>(cx, |project_panel_settings| {
-                    project_panel_settings.auto_reveal_entries = true
+                    project_panel_settings.auto_reveal_entries = Some(true)
                 });
             })
         });
@@ -5054,10 +5054,10 @@ mod tests {
         cx.update(|cx| {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |worktree_settings| {
-                    worktree_settings.file_scan_exclusions = Vec::new();
+                    worktree_settings.file_scan_exclusions = Some(Vec::new());
                 });
                 store.update_user_settings::<ProjectPanelSettings>(cx, |project_panel_settings| {
-                    project_panel_settings.auto_reveal_entries = false
+                    project_panel_settings.auto_reveal_entries = Some(false)
                 });
             })
         });
@@ -5256,7 +5256,7 @@ mod tests {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
                     project_settings.file_scan_exclusions =
-                        vec!["excluded_dir".to_string(), "**/.git".to_string()];
+                        Some(vec!["excluded_dir".to_string(), "**/.git".to_string()]);
                 });
             });
         });
@@ -5569,10 +5569,10 @@ mod tests {
 
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<ProjectPanelSettings>(cx, |project_panel_settings| {
-                    project_panel_settings.auto_fold_dirs = false;
+                    project_panel_settings.auto_fold_dirs = Some(false);
                 });
                 store.update_user_settings::<WorktreeSettings>(cx, |worktree_settings| {
-                    worktree_settings.file_scan_exclusions = Vec::new();
+                    worktree_settings.file_scan_exclusions = Some(Vec::new());
                 });
             });
         });
@@ -5591,10 +5591,10 @@ mod tests {
 
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<ProjectPanelSettings>(cx, |project_panel_settings| {
-                    project_panel_settings.auto_fold_dirs = false;
+                    project_panel_settings.auto_fold_dirs = Some(false);
                 });
                 store.update_user_settings::<WorktreeSettings>(cx, |worktree_settings| {
-                    worktree_settings.file_scan_exclusions = Vec::new();
+                    worktree_settings.file_scan_exclusions = Some(Vec::new());
                 });
             });
         });
diff --git a/crates/project_panel/src/project_panel_settings.rs b/crates/project_panel/src/project_panel_settings.rs
index 6910b4627a00a0..4d73ae92456da9 100644
--- a/crates/project_panel/src/project_panel_settings.rs
+++ b/crates/project_panel/src/project_panel_settings.rs
@@ -2,7 +2,6 @@ use gpui::Pixels;
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
-use ui::px;
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Copy, PartialEq)]
 #[serde(rename_all = "snake_case")]
@@ -11,50 +10,20 @@ pub enum ProjectPanelDockPosition {
     Right,
 }
 
-#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq, JsonSchema)]
-#[serde(default)]
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq)]
 pub struct ProjectPanelSettings {
-    /// Whether to show the project panel button in the status bar.
     pub button: bool,
-    /// Customize default width (in pixels) taken by project panel
     pub default_width: Pixels,
-    /// The position of project panel
     pub dock: ProjectPanelDockPosition,
-    /// Whether to show file icons in the project panel.
     pub file_icons: bool,
-    /// Whether to show folder icons or chevrons for directories in the project panel.
     pub folder_icons: bool,
-    /// Whether to show the git status in the project panel.
     pub git_status: bool,
-    /// Amount of indentation (in pixels) for nested items.
-    pub indent_size: Pixels,
-    /// Whether to reveal it in the project panel automatically,
-    /// when a corresponding project entry becomes active.
-    /// Gitignored entries are never auto revealed.
+    pub indent_size: f32,
     pub auto_reveal_entries: bool,
-    /// Whether to fold directories automatically
-    /// when directory has only one directory inside.
     pub auto_fold_dirs: bool,
-    /// Scrollbar-related settings
     pub scrollbar: ScrollbarSettings,
 }
 
-impl Default for ProjectPanelSettings {
-    fn default() -> Self {
-        Self {
-            button: true,
-            default_width: px(240.),
-            dock: ProjectPanelDockPosition::Left,
-            file_icons: true,
-            folder_icons: true,
-            git_status: true,
-            indent_size: px(20.),
-            auto_reveal_entries: true,
-            auto_fold_dirs: true,
-            scrollbar: Default::default(),
-        }
-    }
-}
 /// When to show the scrollbar in the project panel.
 ///
 /// Default: always
@@ -68,7 +37,7 @@ pub enum ShowScrollbar {
     Never,
 }
 
-#[derive(Copy, Clone, Default, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 pub struct ScrollbarSettings {
     /// When to show the scrollbar in the project panel.
     ///
@@ -76,10 +45,63 @@ pub struct ScrollbarSettings {
     pub show: ShowScrollbar,
 }
 
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+pub struct ScrollbarSettingsContent {
+    /// When to show the scrollbar in the project panel.
+    ///
+    /// Default: always
+    pub show: Option<ShowScrollbar>,
+}
+
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct ProjectPanelSettingsContent {
+    /// Whether to show the project panel button in the status bar.
+    ///
+    /// Default: true
+    pub button: Option<bool>,
+    /// Customize default width (in pixels) taken by project panel
+    ///
+    /// Default: 240
+    pub default_width: Option<f32>,
+    /// The position of project panel
+    ///
+    /// Default: left
+    pub dock: Option<ProjectPanelDockPosition>,
+    /// Whether to show file icons in the project panel.
+    ///
+    /// Default: true
+    pub file_icons: Option<bool>,
+    /// Whether to show folder icons or chevrons for directories in the project panel.
+    ///
+    /// Default: true
+    pub folder_icons: Option<bool>,
+    /// Whether to show the git status in the project panel.
+    ///
+    /// Default: true
+    pub git_status: Option<bool>,
+    /// Amount of indentation (in pixels) for nested items.
+    ///
+    /// Default: 20
+    pub indent_size: Option<f32>,
+    /// Whether to reveal it in the project panel automatically,
+    /// when a corresponding project entry becomes active.
+    /// Gitignored entries are never auto revealed.
+    ///
+    /// Default: true
+    pub auto_reveal_entries: Option<bool>,
+    /// Whether to fold directories automatically
+    /// when directory has only one directory inside.
+    ///
+    /// Default: false
+    pub auto_fold_dirs: Option<bool>,
+    /// Scrollbar-related settings
+    pub scrollbar: Option<ScrollbarSettingsContent>,
+}
+
 impl Settings for ProjectPanelSettings {
     const KEY: Option<&'static str> = Some("project_panel");
 
-    type FileContent = Self;
+    type FileContent = ProjectPanelSettingsContent;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index b7fa6359459290..d8b10f31f9f55e 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -48,6 +48,7 @@ use workspace::{notifications::DetachAndPromptErr, AppState, ModalView, Workspac
 use crate::open_dev_server_project;
 use crate::ssh_connections::connect_over_ssh;
 use crate::ssh_connections::open_ssh_project;
+use crate::ssh_connections::RemoteSettingsContent;
 use crate::ssh_connections::SshConnection;
 use crate::ssh_connections::SshConnectionModal;
 use crate::ssh_connections::SshProject;
@@ -1023,7 +1024,7 @@ impl DevServerProjects {
     fn update_settings_file(
         &mut self,
         cx: &mut ViewContext<Self>,
-        f: impl FnOnce(&mut SshSettings) + Send + Sync + 'static,
+        f: impl FnOnce(&mut RemoteSettingsContent) + Send + Sync + 'static,
     ) {
         let Some(fs) = self
             .workspace
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index b54196022dbcde..8da4284b7f56a7 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -22,24 +22,8 @@ use ui::{
 use util::paths::PathWithPosition;
 use workspace::{AppState, ModalView, Workspace};
 
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
+#[derive(Deserialize)]
 pub struct SshSettings {
-    /// ssh_connections is an array of ssh connections.
-    /// By default this setting is null, which disables the direct ssh connection support.
-    /// You can configure these from `project: Open Remote` in the command palette.
-    /// Zed's ssh support will pull configuration from your ~/.ssh too.
-    /// Examples:
-    /// [
-    ///   {
-    ///     "host": "example-box",
-    ///     "projects": [
-    ///       {
-    ///         "paths": ["/home/user/code/zed"]
-    ///       }
-    ///     ]
-    ///   }
-    /// ]
     pub ssh_connections: Option<Vec<SshConnection>>,
 }
 
@@ -78,10 +62,15 @@ pub struct SshProject {
     pub paths: Vec<String>,
 }
 
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub struct RemoteSettingsContent {
+    pub ssh_connections: Option<Vec<SshConnection>>,
+}
+
 impl Settings for SshSettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = Self;
+    type FileContent = RemoteSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/repl/src/jupyter_settings.rs b/crates/repl/src/jupyter_settings.rs
index f441da4790b804..aefef6cec5b44d 100644
--- a/crates/repl/src/jupyter_settings.rs
+++ b/crates/repl/src/jupyter_settings.rs
@@ -6,10 +6,8 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
+#[derive(Debug, Default)]
 pub struct JupyterSettings {
-    /// Default kernels to select for each language.
     pub kernel_selections: HashMap<String, String>,
 }
 
@@ -22,10 +20,26 @@ impl JupyterSettings {
     }
 }
 
+#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct JupyterSettingsContent {
+    /// Default kernels to select for each language.
+    ///
+    /// Default: `{}`
+    pub kernel_selections: Option<HashMap<String, String>>,
+}
+
+impl Default for JupyterSettingsContent {
+    fn default() -> Self {
+        JupyterSettingsContent {
+            kernel_selections: Some(HashMap::new()),
+        }
+    }
+}
+
 impl Settings for JupyterSettings {
     const KEY: Option<&'static str> = Some("jupyter");
 
-    type FileContent = Self;
+    type FileContent = JupyterSettingsContent;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
@@ -37,8 +51,10 @@ impl Settings for JupyterSettings {
         let mut settings = JupyterSettings::default();
 
         for value in sources.defaults_and_customizations() {
-            for (k, v) in &value.kernel_selections {
-                settings.kernel_selections.insert(k.clone(), v.clone());
+            if let Some(source) = &value.kernel_selections {
+                for (k, v) in source {
+                    settings.kernel_selections.insert(k.clone(), v.clone());
+                }
             }
         }
 
diff --git a/crates/tasks_ui/src/settings.rs b/crates/tasks_ui/src/settings.rs
index 4ad6f607b76c3a..1bcd4962644232 100644
--- a/crates/tasks_ui/src/settings.rs
+++ b/crates/tasks_ui/src/settings.rs
@@ -2,26 +2,22 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-#[derive(Clone, Serialize, Deserialize, PartialEq, JsonSchema)]
-#[serde(default)]
-/// Task-related settings.
+#[derive(Serialize, Deserialize, PartialEq, Default)]
 pub(crate) struct TaskSettings {
-    /// Whether to show task status indicator in the status bar. Default: true
     pub(crate) show_status_indicator: bool,
 }
 
-impl Default for TaskSettings {
-    fn default() -> Self {
-        Self {
-            show_status_indicator: true,
-        }
-    }
+/// Task-related settings.
+#[derive(Serialize, Deserialize, PartialEq, Default, Clone, JsonSchema)]
+pub(crate) struct TaskSettingsContent {
+    /// Whether to show task status indicator in the status bar. Default: true
+    show_status_indicator: Option<bool>,
 }
 
 impl Settings for TaskSettings {
     const KEY: Option<&'static str> = Some("task");
 
-    type FileContent = Self;
+    type FileContent = TaskSettingsContent;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
diff --git a/crates/vim/src/digraph.rs b/crates/vim/src/digraph.rs
index 282016cfdad277..443b7ff37801eb 100644
--- a/crates/vim/src/digraph.rs
+++ b/crates/vim/src/digraph.rs
@@ -132,7 +132,7 @@ mod test {
                 let mut custom_digraphs = HashMap::default();
                 custom_digraphs.insert("|-".into(), "⊢".into());
                 custom_digraphs.insert(":)".into(), "👨‍💻".into());
-                s.custom_digraphs = custom_digraphs;
+                s.custom_digraphs = Some(custom_digraphs);
             });
         });
 
diff --git a/crates/vim/src/normal.rs b/crates/vim/src/normal.rs
index 815086d0be0470..8198c0da53b4f0 100644
--- a/crates/vim/src/normal.rs
+++ b/crates/vim/src/normal.rs
@@ -1184,7 +1184,7 @@ mod test {
         let mut cx = VimTestContext::new(cx, true).await;
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_multiline_find = true;
+                s.use_multiline_find = Some(true);
             });
         });
 
@@ -1226,7 +1226,7 @@ mod test {
         let mut cx = VimTestContext::new(cx, true).await;
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_multiline_find = true;
+                s.use_multiline_find = Some(true);
             });
         });
 
@@ -1268,7 +1268,7 @@ mod test {
         let mut cx = VimTestContext::new(cx, true).await;
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_smartcase_find = true;
+                s.use_smartcase_find = Some(true);
             });
         });
 
diff --git a/crates/vim/src/normal/paste.rs b/crates/vim/src/normal/paste.rs
index 6465e33e0f3b53..05469dbf9f168f 100644
--- a/crates/vim/src/normal/paste.rs
+++ b/crates/vim/src/normal/paste.rs
@@ -291,7 +291,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = UseSystemClipboard::Never
+                s.use_system_clipboard = Some(UseSystemClipboard::Never)
             });
         });
 
@@ -327,7 +327,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = UseSystemClipboard::OnYank
+                s.use_system_clipboard = Some(UseSystemClipboard::OnYank)
             });
         });
 
@@ -584,7 +584,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = UseSystemClipboard::Never
+                s.use_system_clipboard = Some(UseSystemClipboard::Never)
             });
         });
 
@@ -630,7 +630,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = UseSystemClipboard::Never
+                s.use_system_clipboard = Some(UseSystemClipboard::Never)
             });
         });
 
@@ -659,7 +659,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = UseSystemClipboard::Never
+                s.use_system_clipboard = Some(UseSystemClipboard::Never)
             });
         });
 
@@ -707,7 +707,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<VimSettings>(cx, |s| {
-                s.use_system_clipboard = UseSystemClipboard::Never
+                s.use_system_clipboard = Some(UseSystemClipboard::Never)
             });
         });
 
diff --git a/crates/vim/src/normal/scroll.rs b/crates/vim/src/normal/scroll.rs
index 6a20ea4eb33bb1..f89faa3748372f 100644
--- a/crates/vim/src/normal/scroll.rs
+++ b/crates/vim/src/normal/scroll.rs
@@ -294,7 +294,7 @@ mod test {
 
         cx.update_global(|store: &mut SettingsStore, cx| {
             store.update_user_settings::<EditorSettings>(cx, |s| {
-                s.scroll_beyond_last_line = ScrollBeyondLastLine::Off
+                s.scroll_beyond_last_line = Some(ScrollBeyondLastLine::Off)
             });
         });
 
diff --git a/crates/vim/src/normal/search.rs b/crates/vim/src/normal/search.rs
index 6418475ad2f576..28f33d49d85f20 100644
--- a/crates/vim/src/normal/search.rs
+++ b/crates/vim/src/normal/search.rs
@@ -542,7 +542,7 @@ mod test {
         let mut cx = VimTestContext::new(cx, true).await;
 
         cx.update_global(|store: &mut SettingsStore, cx| {
-            store.update_user_settings::<EditorSettings>(cx, |s| s.search_wrap = false);
+            store.update_user_settings::<EditorSettings>(cx, |s| s.search_wrap = Some(false));
         });
 
         cx.set_state("ˇhi\nhigh\nhi\n", Mode::Normal);
@@ -655,7 +655,7 @@ mod test {
 
         // check that searching with unable search wrap
         cx.update_global(|store: &mut SettingsStore, cx| {
-            store.update_user_settings::<EditorSettings>(cx, |s| s.search_wrap = false);
+            store.update_user_settings::<EditorSettings>(cx, |s| s.search_wrap = Some(false));
         });
         cx.set_state("aa\nbˇb\ncc\ncc\ncc\n", Mode::Normal);
         cx.simulate_keystrokes("/ c c enter");
diff --git a/crates/vim/src/test.rs b/crates/vim/src/test.rs
index be7db47315f22d..9c61e9cd938292 100644
--- a/crates/vim/src/test.rs
+++ b/crates/vim/src/test.rs
@@ -1300,7 +1300,7 @@ async fn test_command_alias(cx: &mut gpui::TestAppContext) {
         store.update_user_settings::<WorkspaceSettings>(cx, |s| {
             let mut aliases = HashMap::default();
             aliases.insert("Q".to_string(), "upper".to_string());
-            s.command_aliases = aliases
+            s.command_aliases = Some(aliases)
         });
     });
 
diff --git a/crates/vim/src/test/vim_test_context.rs b/crates/vim/src/test/vim_test_context.rs
index b68d2ede8b09b7..c985f68e701eb1 100644
--- a/crates/vim/src/test/vim_test_context.rs
+++ b/crates/vim/src/test/vim_test_context.rs
@@ -57,7 +57,7 @@ impl VimTestContext {
     pub fn new_with_lsp(mut cx: EditorLspTestContext, enabled: bool) -> VimTestContext {
         cx.update(|cx| {
             SettingsStore::update_global(cx, |store, cx| {
-                store.update_user_settings::<VimModeSetting>(cx, |s| *s = VimModeSetting(enabled));
+                store.update_user_settings::<VimModeSetting>(cx, |s| *s = Some(enabled));
             });
             settings::KeymapFile::load_asset("keymaps/default-macos.json", cx).unwrap();
             if enabled {
@@ -105,7 +105,7 @@ impl VimTestContext {
     pub fn enable_vim(&mut self) {
         self.cx.update(|cx| {
             SettingsStore::update_global(cx, |store, cx| {
-                store.update_user_settings::<VimModeSetting>(cx, |s| *s = VimModeSetting(true));
+                store.update_user_settings::<VimModeSetting>(cx, |s| *s = Some(true));
             });
         })
     }
@@ -113,7 +113,7 @@ impl VimTestContext {
     pub fn disable_vim(&mut self) {
         self.cx.update(|cx| {
             SettingsStore::update_global(cx, |store, cx| {
-                store.update_user_settings::<VimModeSetting>(cx, |s| *s = VimModeSetting(false));
+                store.update_user_settings::<VimModeSetting>(cx, |s| *s = Some(false));
             });
         })
     }
diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs
index 6baca17948e8ef..6e03374c22595e 100644
--- a/crates/vim/src/vim.rs
+++ b/crates/vim/src/vim.rs
@@ -46,8 +46,6 @@ use crate::state::ReplayableAction;
 /// Whether or not to enable Vim mode.
 ///
 /// Default: false
-#[derive(Copy, Clone, Default, Deserialize, Serialize, JsonSchema)]
-#[serde(default, transparent)]
 pub struct VimModeSetting(pub bool);
 
 /// An Action to Switch between modes
@@ -101,7 +99,7 @@ pub fn init(cx: &mut AppContext) {
             let fs = workspace.app_state().fs.clone();
             let currently_enabled = Vim::enabled(cx);
             update_settings_file::<VimModeSetting>(fs, cx, move |setting, _| {
-                *setting = VimModeSetting(!currently_enabled);
+                *setting = Some(!currently_enabled)
             })
         });
 
@@ -1070,10 +1068,12 @@ impl Vim {
 impl Settings for VimModeSetting {
     const KEY: Option<&'static str> = Some("vim_mode");
 
-    type FileContent = Self;
+    type FileContent = Option<bool>;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
-        Ok(sources.user.copied().unwrap_or(*sources.default))
+        Ok(Self(sources.user.copied().flatten().unwrap_or(
+            sources.default.ok_or_else(Self::missing_default)?,
+        )))
     }
 }
 
@@ -1089,8 +1089,7 @@ pub enum UseSystemClipboard {
     OnYank,
 }
 
-#[derive(Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
+#[derive(Deserialize)]
 struct VimSettings {
     pub toggle_relative_line_numbers: bool,
     pub use_system_clipboard: UseSystemClipboard,
@@ -1099,22 +1098,19 @@ struct VimSettings {
     pub custom_digraphs: HashMap<String, Arc<str>>,
 }
 
-impl Default for VimSettings {
-    fn default() -> Self {
-        Self {
-            toggle_relative_line_numbers: false,
-            use_system_clipboard: UseSystemClipboard::Always,
-            use_multiline_find: false,
-            use_smartcase_find: false,
-            custom_digraphs: Default::default(),
-        }
-    }
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+struct VimSettingsContent {
+    pub toggle_relative_line_numbers: Option<bool>,
+    pub use_system_clipboard: Option<UseSystemClipboard>,
+    pub use_multiline_find: Option<bool>,
+    pub use_smartcase_find: Option<bool>,
+    pub custom_digraphs: Option<HashMap<String, Arc<str>>>,
 }
 
 impl Settings for VimSettings {
     const KEY: Option<&'static str> = Some("vim");
 
-    type FileContent = Self;
+    type FileContent = VimSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/welcome/src/base_keymap_picker.rs b/crates/welcome/src/base_keymap_picker.rs
index fd7361f9b3d002..96a9df9c3c8cca 100644
--- a/crates/welcome/src/base_keymap_picker.rs
+++ b/crates/welcome/src/base_keymap_picker.rs
@@ -177,7 +177,7 @@ impl PickerDelegate for BaseKeymapSelectorDelegate {
                 .report_setting_event("keymap", base_keymap.to_string());
 
             update_settings_file::<BaseKeymap>(self.fs.clone(), cx, move |setting, _| {
-                *setting = base_keymap;
+                *setting = Some(base_keymap)
             });
         }
 
diff --git a/crates/welcome/src/base_keymap_setting.rs b/crates/welcome/src/base_keymap_setting.rs
index 0c1724627cf6d9..1b52bbc9f94fbd 100644
--- a/crates/welcome/src/base_keymap_setting.rs
+++ b/crates/welcome/src/base_keymap_setting.rs
@@ -87,15 +87,15 @@ impl BaseKeymap {
 impl Settings for BaseKeymap {
     const KEY: Option<&'static str> = Some("base_keymap");
 
-    type FileContent = Self;
+    type FileContent = Option<Self>;
 
     fn load(
         sources: SettingsSources<Self::FileContent>,
         _: &mut gpui::AppContext,
     ) -> anyhow::Result<Self> {
-        if let Some(user_value) = sources.user.copied() {
+        if let Some(Some(user_value)) = sources.user.copied() {
             return Ok(user_value);
         }
-        Ok(*sources.default)
+        sources.default.ok_or_else(Self::missing_default)
     }
 }
diff --git a/crates/welcome/src/welcome.rs b/crates/welcome/src/welcome.rs
index 787c2e589bb0fe..fc837c68671a31 100644
--- a/crates/welcome/src/welcome.rs
+++ b/crates/welcome/src/welcome.rs
@@ -188,7 +188,7 @@ impl Render for WelcomePage {
                                     this.update_settings::<VimModeSetting>(
                                         selection,
                                         cx,
-                                        |setting, value| *setting = VimModeSetting(value),
+                                        |setting, value| *setting = Some(value),
                                     );
                                 }),
                             ))
diff --git a/crates/workspace/src/item.rs b/crates/workspace/src/item.rs
index 46b8f3bf7fa90b..935f0268b62ffe 100644
--- a/crates/workspace/src/item.rs
+++ b/crates/workspace/src/item.rs
@@ -36,49 +36,20 @@ use util::ResultExt;
 
 pub const LEADER_UPDATE_THROTTLE: Duration = Duration::from_millis(200);
 
-#[derive(Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
+#[derive(Deserialize)]
 pub struct ItemSettings {
-    /// Whether to show the Git file status on a tab item.
     pub git_status: bool,
-    /// Position of the close button in a tab.
     pub close_position: ClosePosition,
-    /// Whether to show the file icon for a tab.
     pub file_icons: bool,
 }
 
-impl Default for ItemSettings {
-    fn default() -> Self {
-        Self {
-            git_status: false,
-            close_position: ClosePosition::Right,
-            file_icons: false,
-        }
-    }
-}
-
-#[derive(Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
+#[derive(Deserialize)]
 pub struct PreviewTabsSettings {
-    /// Whether to show opened editors as preview tabs.
-    /// Preview tabs do not stay open, are reused until explicitly set to be kept open opened (via double-click or editing) and show file names in italic.
     pub enabled: bool,
-    /// Whether to open tabs in preview mode when selected from the file finder.
     pub enable_preview_from_file_finder: bool,
-    /// Whether a preview tab gets replaced when code navigation is used to navigate away from the tab.
     pub enable_preview_from_code_navigation: bool,
 }
 
-impl Default for PreviewTabsSettings {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            enable_preview_from_file_finder: false,
-            enable_preview_from_code_navigation: false,
-        }
-    }
-}
-
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "lowercase")]
 pub enum ClosePosition {
@@ -96,10 +67,43 @@ impl ClosePosition {
     }
 }
 
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub struct ItemSettingsContent {
+    /// Whether to show the Git file status on a tab item.
+    ///
+    /// Default: false
+    git_status: Option<bool>,
+    /// Position of the close button in a tab.
+    ///
+    /// Default: right
+    close_position: Option<ClosePosition>,
+    /// Whether to show the file icon for a tab.
+    ///
+    /// Default: false
+    file_icons: Option<bool>,
+}
+
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub struct PreviewTabsSettingsContent {
+    /// Whether to show opened editors as preview tabs.
+    /// Preview tabs do not stay open, are reused until explicitly set to be kept open opened (via double-click or editing) and show file names in italic.
+    ///
+    /// Default: true
+    enabled: Option<bool>,
+    /// Whether to open tabs in preview mode when selected from the file finder.
+    ///
+    /// Default: false
+    enable_preview_from_file_finder: Option<bool>,
+    /// Whether a preview tab gets replaced when code navigation is used to navigate away from the tab.
+    ///
+    /// Default: false
+    enable_preview_from_code_navigation: Option<bool>,
+}
+
 impl Settings for ItemSettings {
     const KEY: Option<&'static str> = Some("tabs");
 
-    type FileContent = Self;
+    type FileContent = ItemSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
@@ -109,7 +113,7 @@ impl Settings for ItemSettings {
 impl Settings for PreviewTabsSettings {
     const KEY: Option<&'static str> = Some("preview_tabs");
 
-    type FileContent = Self;
+    type FileContent = PreviewTabsSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 0d774277944c02..a7c63c57f698d4 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -6465,7 +6465,7 @@ mod tests {
         item.update(cx, |item, cx| {
             SettingsStore::update_global(cx, |settings, cx| {
                 settings.update_user_settings::<WorkspaceSettings>(cx, |settings| {
-                    settings.autosave = AutosaveSetting::OnWindowChange;
+                    settings.autosave = Some(AutosaveSetting::OnWindowChange);
                 })
             });
             item.is_dirty = true;
@@ -6485,7 +6485,7 @@ mod tests {
             cx.focus_self();
             SettingsStore::update_global(cx, |settings, cx| {
                 settings.update_user_settings::<WorkspaceSettings>(cx, |settings| {
-                    settings.autosave = AutosaveSetting::OnFocusChange;
+                    settings.autosave = Some(AutosaveSetting::OnFocusChange);
                 })
             });
             item.is_dirty = true;
@@ -6508,7 +6508,7 @@ mod tests {
         item.update(cx, |item, cx| {
             SettingsStore::update_global(cx, |settings, cx| {
                 settings.update_user_settings::<WorkspaceSettings>(cx, |settings| {
-                    settings.autosave = AutosaveSetting::AfterDelay { milliseconds: 500 };
+                    settings.autosave = Some(AutosaveSetting::AfterDelay { milliseconds: 500 });
                 })
             });
             item.is_dirty = true;
@@ -6527,7 +6527,7 @@ mod tests {
         item.update(cx, |item, cx| {
             SettingsStore::update_global(cx, |settings, cx| {
                 settings.update_user_settings::<WorkspaceSettings>(cx, |settings| {
-                    settings.autosave = AutosaveSetting::OnFocusChange;
+                    settings.autosave = Some(AutosaveSetting::OnFocusChange);
                 })
             });
             item.is_dirty = true;
diff --git a/crates/workspace/src/workspace_settings.rs b/crates/workspace/src/workspace_settings.rs
index f87840eb308388..52827c6941ae7d 100644
--- a/crates/workspace/src/workspace_settings.rs
+++ b/crates/workspace/src/workspace_settings.rs
@@ -5,58 +5,22 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 
-#[derive(Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
+#[derive(Deserialize)]
 pub struct WorkspaceSettings {
-    /// Scale by which to zoom the active pane.
-    /// When set to 1.0, the active pane has the same size as others,
-    /// but when set to a larger value, the active pane takes up more space.
     pub active_pane_magnification: f32,
-    /// Direction to split horizontally.
     pub pane_split_direction_horizontal: PaneSplitDirectionHorizontal,
-    /// Direction to split vertically.
     pub pane_split_direction_vertical: PaneSplitDirectionVertical,
-    /// Centered layout related settings.
     pub centered_layout: CenteredLayoutSettings,
-    /// Whether or not to prompt the user to confirm before closing the application.
     pub confirm_quit: bool,
-    /// Whether or not to show the call status icon in the status bar.
     pub show_call_status_icon: bool,
-    /// When to automatically save edited buffers.
     pub autosave: AutosaveSetting,
-    /// Controls previous session restoration in freshly launched Zed instance.
     pub restore_on_startup: RestoreOnStartupBehavior,
-    /// The size of the workspace split drop targets on the outer edges.
-    /// Given as a fraction that will be multiplied by the smaller dimension of the workspace.
     pub drop_target_size: f32,
-    /// Whether to close the window when using 'close active item' on a workspace with no tabs
     pub when_closing_with_no_tabs: CloseWindowWhenNoItems,
-    /// Whether to use the system provided dialogs for Open and Save As.
-    /// When set to false, Zed will use the built-in keyboard-first pickers.
     pub use_system_path_prompts: bool,
-    /// Aliases for the command palette. When you type a key in this map,
-    /// it will be assumed to equal the value.
     pub command_aliases: HashMap<String, String>,
 }
 
-impl Default for WorkspaceSettings {
-    fn default() -> Self {
-        Self {
-            active_pane_magnification: 1.0,
-            pane_split_direction_horizontal: PaneSplitDirectionHorizontal::Up,
-            pane_split_direction_vertical: PaneSplitDirectionVertical::Left,
-            centered_layout: CenteredLayoutSettings::default(),
-            confirm_quit: false,
-            show_call_status_icon: true,
-            autosave: AutosaveSetting::Off,
-            restore_on_startup: RestoreOnStartupBehavior::default(),
-            drop_target_size: 0.2,
-            when_closing_with_no_tabs: CloseWindowWhenNoItems::default(),
-            use_system_path_prompts: true,
-            command_aliases: HashMap::default(),
-        }
-    }
-}
 #[derive(Copy, Clone, Default, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum CloseWindowWhenNoItems {
@@ -91,22 +55,77 @@ pub enum RestoreOnStartupBehavior {
     LastSession,
 }
 
-#[derive(Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub struct WorkspaceSettingsContent {
+    /// Scale by which to zoom the active pane.
+    /// When set to 1.0, the active pane has the same size as others,
+    /// but when set to a larger value, the active pane takes up more space.
+    ///
+    /// Default: `1.0`
+    pub active_pane_magnification: Option<f32>,
+    // Direction to split horizontally.
+    //
+    // Default: "up"
+    pub pane_split_direction_horizontal: Option<PaneSplitDirectionHorizontal>,
+    // Direction to split vertically.
+    //
+    // Default: "left"
+    pub pane_split_direction_vertical: Option<PaneSplitDirectionVertical>,
+    // Centered layout related settings.
+    pub centered_layout: Option<CenteredLayoutSettings>,
+    /// Whether or not to prompt the user to confirm before closing the application.
+    ///
+    /// Default: false
+    pub confirm_quit: Option<bool>,
+    /// Whether or not to show the call status icon in the status bar.
+    ///
+    /// Default: true
+    pub show_call_status_icon: Option<bool>,
+    /// When to automatically save edited buffers.
+    ///
+    /// Default: off
+    pub autosave: Option<AutosaveSetting>,
+    /// Controls previous session restoration in freshly launched Zed instance.
+    /// Values: none, last_workspace, last_session
+    /// Default: last_session
+    pub restore_on_startup: Option<RestoreOnStartupBehavior>,
+    /// The size of the workspace split drop targets on the outer edges.
+    /// Given as a fraction that will be multiplied by the smaller dimension of the workspace.
+    ///
+    /// Default: `0.2` (20% of the smaller dimension of the workspace)
+    pub drop_target_size: Option<f32>,
+    /// Whether to close the window when using 'close active item' on a workspace with no tabs
+    ///
+    /// Default: auto ("on" on macOS, "off" otherwise)
+    pub when_closing_with_no_tabs: Option<CloseWindowWhenNoItems>,
+    /// Whether to use the system provided dialogs for Open and Save As.
+    /// When set to false, Zed will use the built-in keyboard-first pickers.
+    ///
+    /// Default: true
+    pub use_system_path_prompts: Option<bool>,
+    /// Aliases for the command palette. When you type a key in this map,
+    /// it will be assumed to equal the value.
+    ///
+    /// Default: true
+    pub command_aliases: Option<HashMap<String, String>>,
+}
+
+#[derive(Deserialize)]
 pub struct TabBarSettings {
-    /// Whether or not to show the tab bar in the editor.
     pub show: bool,
-    /// Whether or not to show the navigation history buttons in the tab bar.
     pub show_nav_history_buttons: bool,
 }
 
-impl Default for TabBarSettings {
-    fn default() -> Self {
-        Self {
-            show_nav_history_buttons: true,
-            show: true,
-        }
-    }
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub struct TabBarSettingsContent {
+    /// Whether or not to show the tab bar in the editor.
+    ///
+    /// Default: true
+    pub show: Option<bool>,
+    /// Whether or not to show the navigation history buttons in the tab bar.
+    ///
+    /// Default: true
+    pub show_nav_history_buttons: Option<bool>,
 }
 
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
@@ -144,26 +163,17 @@ pub struct CenteredLayoutSettings {
     ///
     /// Default: 0.2
     pub left_padding: Option<f32>,
-    /// The relative width of the right padding of the central pane from the
-    /// workspace when the centered layout is used.
+    // The relative width of the right padding of the central pane from the
+    // workspace when the centered layout is used.
     ///
     /// Default: 0.2
     pub right_padding: Option<f32>,
 }
 
-impl Default for CenteredLayoutSettings {
-    fn default() -> Self {
-        Self {
-            left_padding: Some(0.2),
-            right_padding: Some(0.2),
-        }
-    }
-}
-
 impl Settings for WorkspaceSettings {
     const KEY: Option<&'static str> = None;
 
-    type FileContent = Self;
+    type FileContent = WorkspaceSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
@@ -173,7 +183,7 @@ impl Settings for WorkspaceSettings {
 impl Settings for TabBarSettings {
     const KEY: Option<&'static str> = Some("tab_bar");
 
-    type FileContent = Self;
+    type FileContent = TabBarSettingsContent;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         sources.json_merge()
diff --git a/crates/worktree/src/worktree_settings.rs b/crates/worktree/src/worktree_settings.rs
index 82be3a80287928..32851d963a1321 100644
--- a/crates/worktree/src/worktree_settings.rs
+++ b/crates/worktree/src/worktree_settings.rs
@@ -25,8 +25,7 @@ impl WorktreeSettings {
     }
 }
 
-#[derive(Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(default)]
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
 pub struct WorktreeSettingsContent {
     /// Completely ignore files matching globs from `file_scan_exclusions`
     ///
@@ -40,42 +39,12 @@ pub struct WorktreeSettingsContent {
     ///   "**/.classpath",
     ///   "**/.settings"
     /// ]
-    pub file_scan_exclusions: Vec<String>,
+    #[serde(default)]
+    pub file_scan_exclusions: Option<Vec<String>>,
 
     /// Treat the files matching these globs as `.env` files.
     /// Default: [ "**/.env*" ]
-    pub private_files: Vec<String>,
-}
-
-impl Default for WorktreeSettingsContent {
-    fn default() -> Self {
-        Self {
-            private_files: [
-                "**/.env*",
-                "**/*.pem",
-                "**/*.key",
-                "**/*.cert",
-                "**/*.crt",
-                "**/secrets.yml",
-            ]
-            .into_iter()
-            .map(str::to_owned)
-            .collect(),
-            file_scan_exclusions: [
-                "**/.git",
-                "**/.svn",
-                "**/.hg",
-                "**/CVS",
-                "**/.DS_Store",
-                "**/Thumbs.db",
-                "**/.classpath",
-                "**/.settings",
-            ]
-            .into_iter()
-            .map(str::to_owned)
-            .collect(),
-        }
-    }
+    pub private_files: Option<Vec<String>>,
 }
 
 impl Settings for WorktreeSettings {
@@ -88,8 +57,8 @@ impl Settings for WorktreeSettings {
         _: &mut AppContext,
     ) -> anyhow::Result<Self> {
         let result: WorktreeSettingsContent = sources.json_merge()?;
-        let mut file_scan_exclusions = result.file_scan_exclusions;
-        let mut private_files = result.private_files;
+        let mut file_scan_exclusions = result.file_scan_exclusions.unwrap_or_default();
+        let mut private_files = result.private_files.unwrap_or_default();
         file_scan_exclusions.sort();
         private_files.sort();
         Ok(Self {
diff --git a/crates/worktree/src/worktree_tests.rs b/crates/worktree/src/worktree_tests.rs
index 455bc62a79a874..929dc01c6d17e9 100644
--- a/crates/worktree/src/worktree_tests.rs
+++ b/crates/worktree/src/worktree_tests.rs
@@ -673,7 +673,7 @@ async fn test_rescan_with_gitignore(cx: &mut TestAppContext) {
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|store, cx| {
             store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
-                project_settings.file_scan_exclusions = Vec::new();
+                project_settings.file_scan_exclusions = Some(Vec::new());
             });
         });
     });
@@ -910,7 +910,7 @@ async fn test_file_scan_exclusions(cx: &mut TestAppContext) {
         cx.update_global::<SettingsStore, _>(|store, cx| {
             store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
                 project_settings.file_scan_exclusions =
-                    vec!["**/foo/**".to_string(), "**/.DS_Store".to_string()];
+                    Some(vec!["**/foo/**".to_string(), "**/.DS_Store".to_string()]);
             });
         });
     });
@@ -945,7 +945,8 @@ async fn test_file_scan_exclusions(cx: &mut TestAppContext) {
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|store, cx| {
             store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
-                project_settings.file_scan_exclusions = vec!["**/node_modules/**".to_string()];
+                project_settings.file_scan_exclusions =
+                    Some(vec!["**/node_modules/**".to_string()]);
             });
         });
     });
@@ -1008,11 +1009,11 @@ async fn test_fs_events_in_exclusions(cx: &mut TestAppContext) {
     cx.update(|cx| {
         cx.update_global::<SettingsStore, _>(|store, cx| {
             store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
-                project_settings.file_scan_exclusions = vec![
+                project_settings.file_scan_exclusions = Some(vec![
                     "**/.git".to_string(),
                     "node_modules/".to_string(),
                     "build_output".to_string(),
-                ];
+                ]);
             });
         });
     });
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index 9f670efcd7c5fe..93fee57ecdb654 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -1996,7 +1996,7 @@ mod tests {
             cx.update_global::<SettingsStore, _>(|store, cx| {
                 store.update_user_settings::<WorktreeSettings>(cx, |project_settings| {
                     project_settings.file_scan_exclusions =
-                        vec!["excluded_dir".to_string(), "**/.git".to_string()];
+                        Some(vec!["excluded_dir".to_string(), "**/.git".to_string()]);
                 });
             });
         });

From b9b62842f8e9ccd70dba5fd3fa2f3e4b0f2aaab3 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Thu, 12 Sep 2024 15:23:27 -0400
Subject: [PATCH 059/762] lsp: Treat unrooted paths as relative to the worktree
 root (#17769)

gopls would send us watch patterns like `**/*.mod` and we'd fall back to
watching `/`.

Release Notes:
- Fix file watching for go projects resorting to watching the fs root.

Co-authored-by: Thorsten <thorsten@zed.dev>
---
 crates/project/src/lsp_store.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 307e86de450b7f..cdf1fa4be492dc 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -3499,7 +3499,7 @@ impl LspStore {
                                             .to_owned();
                                         let path = if Path::new(path).components().next().is_none()
                                         {
-                                            Arc::from(Path::new("/"))
+                                            Arc::from(Path::new(worktree_root_path))
                                         } else {
                                             PathBuf::from(path).into()
                                         };

From ee96d69e37790a37603ec0d558f0d3f08b9a6661 Mon Sep 17 00:00:00 2001
From: Jason Lee <huacnlee@gmail.com>
Date: Fri, 13 Sep 2024 03:55:03 +0800
Subject: [PATCH 060/762] gpui: Fix CJK line wrap for GPUI text render (#17737)

Release Notes:

- N/A

This changes is going to let GPUI render correct text wrapping for CJK
characters. We was done this in PR #11296 for Editor, but this is also
need support for other text renders.

| Before | After |
| --- | --- |
| <img width="488" alt="SCR-20240912-jtvo"
src="https://github.com/user-attachments/assets/d061669c-62ab-4a7e-a724-2df84815d1ed">
| <img width="438" alt="image"
src="https://github.com/user-attachments/assets/ec27fd80-69db-48b6-8ade-694cd65d1843">
|
---
 crates/gpui/examples/text_wrapper.rs       |  3 ++-
 crates/gpui/src/text_system/line_layout.rs | 17 ++++++++++++++---
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/crates/gpui/examples/text_wrapper.rs b/crates/gpui/examples/text_wrapper.rs
index 063d60d1983d79..cb064259286ef8 100644
--- a/crates/gpui/examples/text_wrapper.rs
+++ b/crates/gpui/examples/text_wrapper.rs
@@ -4,7 +4,7 @@ struct HelloWorld {}
 
 impl Render for HelloWorld {
     fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
-        let text = "The longest word in any of the major English language 以及中文的测试 dictionaries is pneumonoultramicroscopicsilicovolcanoconiosis, a word that refers to a lung disease contracted from the inhalation of very fine silica particles, specifically from a volcano; medically, it is the same as silicosis.";
+        let text = "The longest word 你好世界这段是中文，こんにちはこの段落は日本語です in any of the major English language dictionaries is pneumonoultramicroscopicsilicovolcanoconiosis, a word that refers to a lung disease contracted from the inhalation of very fine silica particles, specifically from a volcano; medically, it is the same as silicosis.";
         div()
             .id("page")
             .size_full()
@@ -40,6 +40,7 @@ impl Render for HelloWorld {
                             .border_1()
                             .border_color(gpui::red())
                             .text_ellipsis()
+                            .w_full()
                             .child("A short text in normal div"),
                     ),
             )
diff --git a/crates/gpui/src/text_system/line_layout.rs b/crates/gpui/src/text_system/line_layout.rs
index af01eb70ede1c3..7e5a43dee881f4 100644
--- a/crates/gpui/src/text_system/line_layout.rs
+++ b/crates/gpui/src/text_system/line_layout.rs
@@ -9,6 +9,8 @@ use std::{
     sync::Arc,
 };
 
+use super::LineWrapper;
+
 /// A laid out and styled line of text
 #[derive(Default, Debug)]
 pub struct LineLayout {
@@ -152,9 +154,18 @@ impl LineLayout {
                 continue;
             }
 
-            if prev_ch == ' ' && ch != ' ' && first_non_whitespace_ix.is_some() {
-                last_candidate_ix = Some(boundary);
-                last_candidate_x = x;
+            // Here is very similar to `LineWrapper::wrap_line` to determine text wrapping,
+            // but there are some differences, so we have to duplicate the code here.
+            if LineWrapper::is_word_char(ch) {
+                if prev_ch == ' ' && ch != ' ' && first_non_whitespace_ix.is_some() {
+                    last_candidate_ix = Some(boundary);
+                    last_candidate_x = x;
+                }
+            } else {
+                if ch != ' ' && first_non_whitespace_ix.is_some() {
+                    last_candidate_ix = Some(boundary);
+                    last_candidate_x = x;
+                }
             }
 
             if ch != ' ' && first_non_whitespace_ix.is_none() {

From af819bf661242a3e6c6f54782f36b7ac68ab0294 Mon Sep 17 00:00:00 2001
From: Junkui Zhang <364772080@qq.com>
Date: Fri, 13 Sep 2024 04:14:53 +0800
Subject: [PATCH 061/762] windows: Implement `fs::trash_file` and
 `fs::trash_dir` (#17711)

https://github.com/user-attachments/assets/43370cee-26a5-4d27-b86f-656127e03b4a



Release Notes:

- N/A
---
 Cargo.toml          |  1 +
 crates/fs/src/fs.rs | 37 +++++++++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+)

diff --git a/Cargo.toml b/Cargo.toml
index 23b17fd2916957..79f5ce2dcf54d2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -483,6 +483,7 @@ version = "0.58"
 features = [
     "implement",
     "Foundation_Numerics",
+    "Storage",
     "System",
     "System_Threading",
     "UI_ViewManagement",
diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rs
index a463773e7e527d..0ec5a4c601371b 100644
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -342,6 +342,24 @@ impl Fs for RealFs {
         }
     }
 
+    #[cfg(target_os = "windows")]
+    async fn trash_file(&self, path: &Path, _options: RemoveOptions) -> Result<()> {
+        use windows::{
+            core::HSTRING,
+            Storage::{StorageDeleteOption, StorageFile},
+        };
+        // todo(windows)
+        // When new version of `windows-rs` release, make this operation `async`
+        let path = path.canonicalize()?.to_string_lossy().to_string();
+        let path_str = path.trim_start_matches("\\\\?\\");
+        if path_str.is_empty() {
+            anyhow::bail!("File path is empty!");
+        }
+        let file = StorageFile::GetFileFromPathAsync(&HSTRING::from(path_str))?.get()?;
+        file.DeleteAsync(StorageDeleteOption::Default)?.get()?;
+        Ok(())
+    }
+
     #[cfg(target_os = "macos")]
     async fn trash_dir(&self, path: &Path, options: RemoveOptions) -> Result<()> {
         self.trash_file(path, options).await
@@ -352,6 +370,25 @@ impl Fs for RealFs {
         self.trash_file(path, options).await
     }
 
+    #[cfg(target_os = "windows")]
+    async fn trash_dir(&self, path: &Path, _options: RemoveOptions) -> Result<()> {
+        use windows::{
+            core::HSTRING,
+            Storage::{StorageDeleteOption, StorageFolder},
+        };
+
+        let path = path.canonicalize()?.to_string_lossy().to_string();
+        let path_str = path.trim_start_matches("\\\\?\\");
+        if path_str.is_empty() {
+            anyhow::bail!("Folder path is empty!");
+        }
+        // todo(windows)
+        // When new version of `windows-rs` release, make this operation `async`
+        let folder = StorageFolder::GetFolderFromPathAsync(&HSTRING::from(path_str))?.get()?;
+        folder.DeleteAsync(StorageDeleteOption::Default)?.get()?;
+        Ok(())
+    }
+
     async fn open_sync(&self, path: &Path) -> Result<Box<dyn io::Read>> {
         Ok(Box::new(std::fs::File::open(path)?))
     }

From 461812d7b6de0064e2bffd224f82a95351d0f1cb Mon Sep 17 00:00:00 2001
From: Junkui Zhang <364772080@qq.com>
Date: Fri, 13 Sep 2024 04:15:20 +0800
Subject: [PATCH 062/762] windows: Use the existing `open_target` function for
 `platform::open_with_system` (#17705)

Release Notes:

- N/A
---
 crates/gpui/src/platform/windows/platform.rs | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs
index f8b3924e6282b1..934d9336d2f6c2 100644
--- a/crates/gpui/src/platform/windows/platform.rs
+++ b/crates/gpui/src/platform/windows/platform.rs
@@ -401,14 +401,19 @@ impl Platform for WindowsPlatform {
     }
 
     fn open_with_system(&self, path: &Path) {
-        let executor = self.background_executor().clone();
-        let path = path.to_owned();
-        executor
+        let Ok(full_path) = path.canonicalize() else {
+            log::error!("unable to parse file full path: {}", path.display());
+            return;
+        };
+        self.background_executor()
             .spawn(async move {
-                let _ = std::process::Command::new("cmd")
-                    .args(&["/c", "start", "", path.to_str().expect("path to string")])
-                    .spawn()
-                    .expect("Failed to open file");
+                let Some(full_path_str) = full_path.to_str() else {
+                    return;
+                };
+                if full_path_str.is_empty() {
+                    return;
+                };
+                open_target(full_path_str);
             })
             .detach();
     }

From 3613ebd93c137578d947b482fe108e81313a8b47 Mon Sep 17 00:00:00 2001
From: CharlesChen0823 <yongchen0823@gmail.com>
Date: Fri, 13 Sep 2024 04:55:59 +0800
Subject: [PATCH 063/762] editor: Fix an error when cut with vim visual line
 select (#17591)

Becuause in vim visual mode, we will always select next char, hit
[here](https://github.com/zed-industries/zed/blob/66ef31882341852229c74996867916fbd4a2fe2a/crates/vim/src/visual.rs#L174),
when using editor method
for `cut` this selection, will hit this error.

Closes #17585

Release Notes:

- N/A

---------

Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>
---
 crates/editor/src/editor.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 4792c6b2cb889d..515cde1908abb5 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -6671,7 +6671,11 @@ impl Editor {
                 let is_entire_line = selection.is_empty() || self.selections.line_mode;
                 if is_entire_line {
                     selection.start = Point::new(selection.start.row, 0);
-                    selection.end = cmp::min(max_point, Point::new(selection.end.row + 1, 0));
+                    if !selection.is_empty() && selection.end.column == 0 {
+                        selection.end = cmp::min(max_point, selection.end);
+                    } else {
+                        selection.end = cmp::min(max_point, Point::new(selection.end.row + 1, 0));
+                    }
                     selection.goal = SelectionGoal::None;
                 }
                 if is_first {

From 3aeea93847acd4c28f97d2c4de35364a98cb98e4 Mon Sep 17 00:00:00 2001
From: Albert Marashi <albert@lumina.earth>
Date: Fri, 13 Sep 2024 21:41:27 +0930
Subject: [PATCH 064/762] typescript: Highlight `is` predicate keyword & `...`
 spread pattern (#17787)

Release Notes:

- Fixed the `is` and `...` highlights for TypeScript
---
 crates/languages/src/tsx/highlights.scm        | 1 +
 crates/languages/src/typescript/highlights.scm | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/crates/languages/src/tsx/highlights.scm b/crates/languages/src/tsx/highlights.scm
index 296a66c10a6706..bbdd83bb4d4e94 100644
--- a/crates/languages/src/tsx/highlights.scm
+++ b/crates/languages/src/tsx/highlights.scm
@@ -181,6 +181,7 @@
   "import"
   "in"
   "instanceof"
+  "is"
   "let"
   "new"
   "of"
diff --git a/crates/languages/src/typescript/highlights.scm b/crates/languages/src/typescript/highlights.scm
index 19def8d93dd00c..eedcf79aedac77 100644
--- a/crates/languages/src/typescript/highlights.scm
+++ b/crates/languages/src/typescript/highlights.scm
@@ -100,6 +100,7 @@
 ] @punctuation.delimiter
 
 [
+  "..."
   "-"
   "--"
   "-="
@@ -181,6 +182,7 @@
   "import"
   "in"
   "instanceof"
+  "is"
   "let"
   "new"
   "of"

From 93a3e8bc9478572cc07404d9ed3556b6842f00f2 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 13 Sep 2024 10:54:23 -0400
Subject: [PATCH 065/762] zed_extension_api: Fork new version of extension API
 (#17795)

This PR forks a new version of the `zed_extension_api` in preparation
for new changes.

Release Notes:

- N/A

---------

Co-authored-by: Max <max@zed.dev>
---
 Cargo.lock                                    |  66 +--
 crates/extension/build.rs                     |   9 +-
 crates/extension/src/wasm_host/wit.rs         |  85 ++-
 .../src/wasm_host/wit/since_v0_1_0.rs         | 229 +++-----
 .../src/wasm_host/wit/since_v0_2_0.rs         | 551 ++++++++++++++++++
 crates/extension_api/Cargo.toml               |   5 +-
 .../extension_api/wit/since_v0.2.0/common.wit |   9 +
 .../wit/since_v0.2.0/extension.wit            | 147 +++++
 .../extension_api/wit/since_v0.2.0/github.wit |  33 ++
 .../wit/since_v0.2.0/http-client.wit          |  67 +++
 crates/extension_api/wit/since_v0.2.0/lsp.wit |  83 +++
 .../extension_api/wit/since_v0.2.0/nodejs.wit |  13 +
 .../wit/since_v0.2.0/platform.wit             |  24 +
 .../wit/since_v0.2.0/settings.rs              |  29 +
 .../wit/since_v0.2.0/slash-command.wit        |  41 ++
 extensions/test-extension/Cargo.toml          |   2 +-
 16 files changed, 1216 insertions(+), 177 deletions(-)
 create mode 100644 crates/extension/src/wasm_host/wit/since_v0_2_0.rs
 create mode 100644 crates/extension_api/wit/since_v0.2.0/common.wit
 create mode 100644 crates/extension_api/wit/since_v0.2.0/extension.wit
 create mode 100644 crates/extension_api/wit/since_v0.2.0/github.wit
 create mode 100644 crates/extension_api/wit/since_v0.2.0/http-client.wit
 create mode 100644 crates/extension_api/wit/since_v0.2.0/lsp.wit
 create mode 100644 crates/extension_api/wit/since_v0.2.0/nodejs.wit
 create mode 100644 crates/extension_api/wit/since_v0.2.0/platform.wit
 create mode 100644 crates/extension_api/wit/since_v0.2.0/settings.rs
 create mode 100644 crates/extension_api/wit/since_v0.2.0/slash-command.wit

diff --git a/Cargo.lock b/Cargo.lock
index 36691e72ab772a..5eaf3ddde1fda5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7873,7 +7873,7 @@ name = "perplexity"
 version = "0.1.0"
 dependencies = [
  "serde",
- "zed_extension_api 0.1.0",
+ "zed_extension_api 0.2.0",
 ]
 
 [[package]]
@@ -10254,7 +10254,7 @@ dependencies = [
 name = "slash_commands_example"
 version = "0.1.0"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
@@ -14317,68 +14317,70 @@ name = "zed_astro"
 version = "0.1.0"
 dependencies = [
  "serde",
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_clojure"
 version = "0.0.3"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_csharp"
 version = "0.0.2"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_dart"
 version = "0.0.3"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_deno"
 version = "0.0.2"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_elixir"
 version = "0.0.9"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_elm"
 version = "0.0.1"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_emmet"
 version = "0.0.3"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_erlang"
 version = "0.1.0"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_extension_api"
 version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "594fd10dd0f2f853eb243e2425e7c95938cef49adb81d9602921d002c5e6d9d9"
 dependencies = [
  "serde",
  "serde_json",
@@ -14387,9 +14389,7 @@ dependencies = [
 
 [[package]]
 name = "zed_extension_api"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "594fd10dd0f2f853eb243e2425e7c95938cef49adb81d9602921d002c5e6d9d9"
+version = "0.2.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -14401,77 +14401,77 @@ name = "zed_gleam"
 version = "0.2.0"
 dependencies = [
  "html_to_markdown 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_glsl"
 version = "0.1.0"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_haskell"
 version = "0.1.1"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_html"
 version = "0.1.2"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_lua"
 version = "0.0.3"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_ocaml"
 version = "0.0.2"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_php"
 version = "0.2.0"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_prisma"
 version = "0.0.3"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_purescript"
 version = "0.0.1"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_ruby"
 version = "0.2.0"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_ruff"
 version = "0.0.2"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
@@ -14479,42 +14479,42 @@ name = "zed_snippets"
 version = "0.0.5"
 dependencies = [
  "serde_json",
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_svelte"
 version = "0.1.1"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_terraform"
 version = "0.1.0"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_test_extension"
 version = "0.1.0"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.2.0",
 ]
 
 [[package]]
 name = "zed_toml"
 version = "0.1.1"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_uiua"
 version = "0.0.1"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
@@ -14522,14 +14522,14 @@ name = "zed_vue"
 version = "0.1.0"
 dependencies = [
  "serde",
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
 name = "zed_zig"
 version = "0.3.0"
 dependencies = [
- "zed_extension_api 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "zed_extension_api 0.1.0",
 ]
 
 [[package]]
diff --git a/crates/extension/build.rs b/crates/extension/build.rs
index c5f94abaa868bf..f2c2b19998d054 100644
--- a/crates/extension/build.rs
+++ b/crates/extension/build.rs
@@ -6,17 +6,21 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     copy_extension_api_rust_files()
 }
 
-// rust-analyzer doesn't support include! for files from outside the crate.
-// Copy them to the OUT_DIR, so we can include them from there, which is supported.
+/// rust-analyzer doesn't support include! for files from outside the crate.
+/// Copy them to the OUT_DIR, so we can include them from there, which is supported.
 fn copy_extension_api_rust_files() -> Result<(), Box<dyn std::error::Error>> {
     let out_dir = env::var("OUT_DIR")?;
     let input_dir = PathBuf::from("../extension_api/wit");
     let output_dir = PathBuf::from(out_dir);
 
+    println!("cargo:rerun-if-changed={}", input_dir.display());
+
     for entry in fs::read_dir(&input_dir)? {
         let entry = entry?;
         let path = entry.path();
         if path.is_dir() {
+            println!("cargo:rerun-if-changed={}", path.display());
+
             for subentry in fs::read_dir(&path)? {
                 let subentry = subentry?;
                 let subpath = subentry.path();
@@ -26,7 +30,6 @@ fn copy_extension_api_rust_files() -> Result<(), Box<dyn std::error::Error>> {
 
                     fs::create_dir_all(destination.parent().unwrap())?;
                     fs::copy(&subpath, &destination)?;
-                    println!("cargo:rerun-if-changed={}", subpath.display());
                 }
             }
         } else if path.extension() == Some(std::ffi::OsStr::new("rs")) {
diff --git a/crates/extension/src/wasm_host/wit.rs b/crates/extension/src/wasm_host/wit.rs
index 7c7d71be3a0fe5..1c3cdd77f64eea 100644
--- a/crates/extension/src/wasm_host/wit.rs
+++ b/crates/extension/src/wasm_host/wit.rs
@@ -2,9 +2,10 @@ mod since_v0_0_1;
 mod since_v0_0_4;
 mod since_v0_0_6;
 mod since_v0_1_0;
+mod since_v0_2_0;
 use indexed_docs::IndexedDocsDatabase;
 use release_channel::ReleaseChannel;
-use since_v0_1_0 as latest;
+use since_v0_2_0 as latest;
 
 use super::{wasm_engine, WasmState};
 use anyhow::{anyhow, Context, Result};
@@ -52,10 +53,16 @@ pub fn wasm_api_version_range(release_channel: ReleaseChannel) -> RangeInclusive
     // Note: The release channel can be used to stage a new version of the extension API.
     let _ = release_channel;
 
-    since_v0_0_1::MIN_VERSION..=latest::MAX_VERSION
+    let max_version = match release_channel {
+        ReleaseChannel::Dev | ReleaseChannel::Nightly => latest::MAX_VERSION,
+        ReleaseChannel::Stable | ReleaseChannel::Preview => since_v0_1_0::MAX_VERSION,
+    };
+
+    since_v0_0_1::MIN_VERSION..=max_version
 }
 
 pub enum Extension {
+    V020(since_v0_2_0::Extension),
     V010(since_v0_1_0::Extension),
     V006(since_v0_0_6::Extension),
     V004(since_v0_0_4::Extension),
@@ -72,11 +79,25 @@ impl Extension {
         // Note: The release channel can be used to stage a new version of the extension API.
         let _ = release_channel;
 
-        if version >= latest::MIN_VERSION {
+        let allow_latest_version = match release_channel {
+            ReleaseChannel::Dev | ReleaseChannel::Nightly => true,
+            ReleaseChannel::Stable | ReleaseChannel::Preview => false,
+        };
+
+        if allow_latest_version && version >= latest::MIN_VERSION {
             let (extension, instance) =
                 latest::Extension::instantiate_async(store, component, latest::linker())
                     .await
                     .context("failed to instantiate wasm extension")?;
+            Ok((Self::V020(extension), instance))
+        } else if version >= since_v0_1_0::MIN_VERSION {
+            let (extension, instance) = since_v0_1_0::Extension::instantiate_async(
+                store,
+                component,
+                since_v0_1_0::linker(),
+            )
+            .await
+            .context("failed to instantiate wasm extension")?;
             Ok((Self::V010(extension), instance))
         } else if version >= since_v0_0_6::MIN_VERSION {
             let (extension, instance) = since_v0_0_6::Extension::instantiate_async(
@@ -110,6 +131,7 @@ impl Extension {
 
     pub async fn call_init_extension(&self, store: &mut Store<WasmState>) -> Result<()> {
         match self {
+            Extension::V020(ext) => ext.call_init_extension(store).await,
             Extension::V010(ext) => ext.call_init_extension(store).await,
             Extension::V006(ext) => ext.call_init_extension(store).await,
             Extension::V004(ext) => ext.call_init_extension(store).await,
@@ -125,10 +147,14 @@ impl Extension {
         resource: Resource<Arc<dyn LspAdapterDelegate>>,
     ) -> Result<Result<Command, String>> {
         match self {
-            Extension::V010(ext) => {
+            Extension::V020(ext) => {
                 ext.call_language_server_command(store, &language_server_id.0, resource)
                     .await
             }
+            Extension::V010(ext) => Ok(ext
+                .call_language_server_command(store, &language_server_id.0, resource)
+                .await?
+                .map(|command| command.into())),
             Extension::V006(ext) => Ok(ext
                 .call_language_server_command(store, &language_server_id.0, resource)
                 .await?
@@ -152,6 +178,14 @@ impl Extension {
         resource: Resource<Arc<dyn LspAdapterDelegate>>,
     ) -> Result<Result<Option<String>, String>> {
         match self {
+            Extension::V020(ext) => {
+                ext.call_language_server_initialization_options(
+                    store,
+                    &language_server_id.0,
+                    resource,
+                )
+                .await
+            }
             Extension::V010(ext) => {
                 ext.call_language_server_initialization_options(
                     store,
@@ -190,6 +224,14 @@ impl Extension {
         resource: Resource<Arc<dyn LspAdapterDelegate>>,
     ) -> Result<Result<Option<String>, String>> {
         match self {
+            Extension::V020(ext) => {
+                ext.call_language_server_workspace_configuration(
+                    store,
+                    &language_server_id.0,
+                    resource,
+                )
+                .await
+            }
             Extension::V010(ext) => {
                 ext.call_language_server_workspace_configuration(
                     store,
@@ -217,10 +259,19 @@ impl Extension {
         completions: Vec<latest::Completion>,
     ) -> Result<Result<Vec<Option<CodeLabel>>, String>> {
         match self {
-            Extension::V010(ext) => {
+            Extension::V020(ext) => {
                 ext.call_labels_for_completions(store, &language_server_id.0, &completions)
                     .await
             }
+            Extension::V010(ext) => Ok(ext
+                .call_labels_for_completions(store, &language_server_id.0, &completions)
+                .await?
+                .map(|labels| {
+                    labels
+                        .into_iter()
+                        .map(|label| label.map(Into::into))
+                        .collect()
+                })),
             Extension::V006(ext) => Ok(ext
                 .call_labels_for_completions(store, &language_server_id.0, &completions)
                 .await?
@@ -241,10 +292,19 @@ impl Extension {
         symbols: Vec<latest::Symbol>,
     ) -> Result<Result<Vec<Option<CodeLabel>>, String>> {
         match self {
-            Extension::V010(ext) => {
+            Extension::V020(ext) => {
                 ext.call_labels_for_symbols(store, &language_server_id.0, &symbols)
                     .await
             }
+            Extension::V010(ext) => Ok(ext
+                .call_labels_for_symbols(store, &language_server_id.0, &symbols)
+                .await?
+                .map(|labels| {
+                    labels
+                        .into_iter()
+                        .map(|label| label.map(Into::into))
+                        .collect()
+                })),
             Extension::V006(ext) => Ok(ext
                 .call_labels_for_symbols(store, &language_server_id.0, &symbols)
                 .await?
@@ -265,6 +325,10 @@ impl Extension {
         arguments: &[String],
     ) -> Result<Result<Vec<SlashCommandArgumentCompletion>, String>> {
         match self {
+            Extension::V020(ext) => {
+                ext.call_complete_slash_command_argument(store, command, arguments)
+                    .await
+            }
             Extension::V010(ext) => {
                 ext.call_complete_slash_command_argument(store, command, arguments)
                     .await
@@ -281,6 +345,10 @@ impl Extension {
         resource: Option<Resource<Arc<dyn LspAdapterDelegate>>>,
     ) -> Result<Result<SlashCommandOutput, String>> {
         match self {
+            Extension::V020(ext) => {
+                ext.call_run_slash_command(store, command, arguments, resource)
+                    .await
+            }
             Extension::V010(ext) => {
                 ext.call_run_slash_command(store, command, arguments, resource)
                     .await
@@ -297,6 +365,7 @@ impl Extension {
         provider: &str,
     ) -> Result<Result<Vec<String>, String>> {
         match self {
+            Extension::V020(ext) => ext.call_suggest_docs_packages(store, provider).await,
             Extension::V010(ext) => ext.call_suggest_docs_packages(store, provider).await,
             Extension::V001(_) | Extension::V004(_) | Extension::V006(_) => Err(anyhow!(
                 "`suggest_docs_packages` not available prior to v0.1.0"
@@ -312,6 +381,10 @@ impl Extension {
         database: Resource<Arc<IndexedDocsDatabase>>,
     ) -> Result<Result<(), String>> {
         match self {
+            Extension::V020(ext) => {
+                ext.call_index_docs(store, provider, package_name, database)
+                    .await
+            }
             Extension::V010(ext) => {
                 ext.call_index_docs(store, provider, package_name, database)
                     .await
diff --git a/crates/extension/src/wasm_host/wit/since_v0_1_0.rs b/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
index 337bb8afb04a1d..88d860391a477b 100644
--- a/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
+++ b/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
@@ -16,13 +16,14 @@ use language::{
 use project::project_settings::ProjectSettings;
 use semantic_version::SemanticVersion;
 use std::{
-    env,
     path::{Path, PathBuf},
     sync::{Arc, OnceLock},
 };
 use util::maybe;
 use wasmtime::component::{Linker, Resource};
 
+use super::latest;
+
 pub const MIN_VERSION: SemanticVersion = SemanticVersion::new(0, 1, 0);
 pub const MAX_VERSION: SemanticVersion = SemanticVersion::new(0, 1, 0);
 
@@ -33,7 +34,12 @@ wasmtime::component::bindgen!({
     with: {
          "worktree": ExtensionWorktree,
          "key-value-store": ExtensionKeyValueStore,
-         "zed:extension/http-client/http-response-stream": ExtensionHttpResponseStream
+         "zed:extension/http-client/http-response-stream": ExtensionHttpResponseStream,
+         "zed:extension/github": latest::zed::extension::github,
+         "zed:extension/lsp": latest::zed::extension::lsp,
+         "zed:extension/nodejs": latest::zed::extension::nodejs,
+         "zed:extension/platform": latest::zed::extension::platform,
+         "zed:extension/slash-command": latest::zed::extension::slash_command,
     },
 });
 
@@ -49,7 +55,94 @@ pub type ExtensionHttpResponseStream = Arc<Mutex<::http_client::Response<AsyncBo
 
 pub fn linker() -> &'static Linker<WasmState> {
     static LINKER: OnceLock<Linker<WasmState>> = OnceLock::new();
-    LINKER.get_or_init(|| super::new_linker(Extension::add_to_linker))
+    LINKER.get_or_init(|| {
+        super::new_linker(|linker, f| {
+            Extension::add_to_linker(linker, f)?;
+            latest::zed::extension::github::add_to_linker(linker, f)?;
+            latest::zed::extension::nodejs::add_to_linker(linker, f)?;
+            latest::zed::extension::platform::add_to_linker(linker, f)?;
+            latest::zed::extension::slash_command::add_to_linker(linker, f)?;
+            Ok(())
+        })
+    })
+}
+
+impl From<Command> for latest::Command {
+    fn from(value: Command) -> Self {
+        Self {
+            command: value.command,
+            args: value.args,
+            env: value.env,
+        }
+    }
+}
+
+impl From<SettingsLocation> for latest::SettingsLocation {
+    fn from(value: SettingsLocation) -> Self {
+        Self {
+            worktree_id: value.worktree_id,
+            path: value.path,
+        }
+    }
+}
+
+impl From<LanguageServerInstallationStatus> for latest::LanguageServerInstallationStatus {
+    fn from(value: LanguageServerInstallationStatus) -> Self {
+        match value {
+            LanguageServerInstallationStatus::None => Self::None,
+            LanguageServerInstallationStatus::Downloading => Self::Downloading,
+            LanguageServerInstallationStatus::CheckingForUpdate => Self::CheckingForUpdate,
+            LanguageServerInstallationStatus::Failed(message) => Self::Failed(message),
+        }
+    }
+}
+
+impl From<DownloadedFileType> for latest::DownloadedFileType {
+    fn from(value: DownloadedFileType) -> Self {
+        match value {
+            DownloadedFileType::Gzip => Self::Gzip,
+            DownloadedFileType::GzipTar => Self::GzipTar,
+            DownloadedFileType::Zip => Self::Zip,
+            DownloadedFileType::Uncompressed => Self::Uncompressed,
+        }
+    }
+}
+
+impl From<Range> for latest::Range {
+    fn from(value: Range) -> Self {
+        Self {
+            start: value.start,
+            end: value.end,
+        }
+    }
+}
+
+impl From<CodeLabelSpan> for latest::CodeLabelSpan {
+    fn from(value: CodeLabelSpan) -> Self {
+        match value {
+            CodeLabelSpan::CodeRange(range) => Self::CodeRange(range.into()),
+            CodeLabelSpan::Literal(literal) => Self::Literal(literal.into()),
+        }
+    }
+}
+
+impl From<CodeLabelSpanLiteral> for latest::CodeLabelSpanLiteral {
+    fn from(value: CodeLabelSpanLiteral) -> Self {
+        Self {
+            text: value.text,
+            highlight_name: value.highlight_name,
+        }
+    }
+}
+
+impl From<CodeLabel> for latest::CodeLabel {
+    fn from(value: CodeLabel) -> Self {
+        Self {
+            code: value.code,
+            spans: value.spans.into_iter().map(Into::into).collect(),
+            filter_range: value.filter_range.into(),
+        }
+    }
 }
 
 #[async_trait]
@@ -251,136 +344,6 @@ async fn convert_response(
     Ok(extension_response)
 }
 
-#[async_trait]
-impl nodejs::Host for WasmState {
-    async fn node_binary_path(&mut self) -> wasmtime::Result<Result<String, String>> {
-        self.host
-            .node_runtime
-            .binary_path()
-            .await
-            .map(|path| path.to_string_lossy().to_string())
-            .to_wasmtime_result()
-    }
-
-    async fn npm_package_latest_version(
-        &mut self,
-        package_name: String,
-    ) -> wasmtime::Result<Result<String, String>> {
-        self.host
-            .node_runtime
-            .npm_package_latest_version(&package_name)
-            .await
-            .to_wasmtime_result()
-    }
-
-    async fn npm_package_installed_version(
-        &mut self,
-        package_name: String,
-    ) -> wasmtime::Result<Result<Option<String>, String>> {
-        self.host
-            .node_runtime
-            .npm_package_installed_version(&self.work_dir(), &package_name)
-            .await
-            .to_wasmtime_result()
-    }
-
-    async fn npm_install_package(
-        &mut self,
-        package_name: String,
-        version: String,
-    ) -> wasmtime::Result<Result<(), String>> {
-        self.host
-            .node_runtime
-            .npm_install_packages(&self.work_dir(), &[(&package_name, &version)])
-            .await
-            .to_wasmtime_result()
-    }
-}
-
-#[async_trait]
-impl lsp::Host for WasmState {}
-
-impl From<::http_client::github::GithubRelease> for github::GithubRelease {
-    fn from(value: ::http_client::github::GithubRelease) -> Self {
-        Self {
-            version: value.tag_name,
-            assets: value.assets.into_iter().map(Into::into).collect(),
-        }
-    }
-}
-
-impl From<::http_client::github::GithubReleaseAsset> for github::GithubReleaseAsset {
-    fn from(value: ::http_client::github::GithubReleaseAsset) -> Self {
-        Self {
-            name: value.name,
-            download_url: value.browser_download_url,
-        }
-    }
-}
-
-#[async_trait]
-impl github::Host for WasmState {
-    async fn latest_github_release(
-        &mut self,
-        repo: String,
-        options: github::GithubReleaseOptions,
-    ) -> wasmtime::Result<Result<github::GithubRelease, String>> {
-        maybe!(async {
-            let release = ::http_client::github::latest_github_release(
-                &repo,
-                options.require_assets,
-                options.pre_release,
-                self.host.http_client.clone(),
-            )
-            .await?;
-            Ok(release.into())
-        })
-        .await
-        .to_wasmtime_result()
-    }
-
-    async fn github_release_by_tag_name(
-        &mut self,
-        repo: String,
-        tag: String,
-    ) -> wasmtime::Result<Result<github::GithubRelease, String>> {
-        maybe!(async {
-            let release = ::http_client::github::get_release_by_tag_name(
-                &repo,
-                &tag,
-                self.host.http_client.clone(),
-            )
-            .await?;
-            Ok(release.into())
-        })
-        .await
-        .to_wasmtime_result()
-    }
-}
-
-#[async_trait]
-impl platform::Host for WasmState {
-    async fn current_platform(&mut self) -> Result<(platform::Os, platform::Architecture)> {
-        Ok((
-            match env::consts::OS {
-                "macos" => platform::Os::Mac,
-                "linux" => platform::Os::Linux,
-                "windows" => platform::Os::Windows,
-                _ => panic!("unsupported os"),
-            },
-            match env::consts::ARCH {
-                "aarch64" => platform::Architecture::Aarch64,
-                "x86" => platform::Architecture::X86,
-                "x86_64" => platform::Architecture::X8664,
-                _ => panic!("unsupported architecture"),
-            },
-        ))
-    }
-}
-
-#[async_trait]
-impl slash_command::Host for WasmState {}
-
 #[async_trait]
 impl ExtensionImports for WasmState {
     async fn get_settings(
diff --git a/crates/extension/src/wasm_host/wit/since_v0_2_0.rs b/crates/extension/src/wasm_host/wit/since_v0_2_0.rs
new file mode 100644
index 00000000000000..7fa79c2544475b
--- /dev/null
+++ b/crates/extension/src/wasm_host/wit/since_v0_2_0.rs
@@ -0,0 +1,551 @@
+use crate::wasm_host::{wit::ToWasmtimeResult, WasmState};
+use ::http_client::AsyncBody;
+use ::settings::{Settings, WorktreeId};
+use anyhow::{anyhow, bail, Context, Result};
+use async_compression::futures::bufread::GzipDecoder;
+use async_tar::Archive;
+use async_trait::async_trait;
+use futures::{io::BufReader, FutureExt as _};
+use futures::{lock::Mutex, AsyncReadExt};
+use indexed_docs::IndexedDocsDatabase;
+use isahc::config::{Configurable, RedirectPolicy};
+use language::LanguageName;
+use language::{
+    language_settings::AllLanguageSettings, LanguageServerBinaryStatus, LspAdapterDelegate,
+};
+use project::project_settings::ProjectSettings;
+use semantic_version::SemanticVersion;
+use std::{
+    env,
+    path::{Path, PathBuf},
+    sync::{Arc, OnceLock},
+};
+use util::maybe;
+use wasmtime::component::{Linker, Resource};
+
+pub const MIN_VERSION: SemanticVersion = SemanticVersion::new(0, 2, 0);
+pub const MAX_VERSION: SemanticVersion = SemanticVersion::new(0, 2, 0);
+
+wasmtime::component::bindgen!({
+    async: true,
+    trappable_imports: true,
+    path: "../extension_api/wit/since_v0.2.0",
+    with: {
+         "worktree": ExtensionWorktree,
+         "key-value-store": ExtensionKeyValueStore,
+         "zed:extension/http-client/http-response-stream": ExtensionHttpResponseStream
+    },
+});
+
+pub use self::zed::extension::*;
+
+mod settings {
+    include!(concat!(env!("OUT_DIR"), "/since_v0.2.0/settings.rs"));
+}
+
+pub type ExtensionWorktree = Arc<dyn LspAdapterDelegate>;
+pub type ExtensionKeyValueStore = Arc<IndexedDocsDatabase>;
+pub type ExtensionHttpResponseStream = Arc<Mutex<::http_client::Response<AsyncBody>>>;
+
+pub fn linker() -> &'static Linker<WasmState> {
+    static LINKER: OnceLock<Linker<WasmState>> = OnceLock::new();
+    LINKER.get_or_init(|| super::new_linker(Extension::add_to_linker))
+}
+
+#[async_trait]
+impl HostKeyValueStore for WasmState {
+    async fn insert(
+        &mut self,
+        kv_store: Resource<ExtensionKeyValueStore>,
+        key: String,
+        value: String,
+    ) -> wasmtime::Result<Result<(), String>> {
+        let kv_store = self.table.get(&kv_store)?;
+        kv_store.insert(key, value).await.to_wasmtime_result()
+    }
+
+    fn drop(&mut self, _worktree: Resource<ExtensionKeyValueStore>) -> Result<()> {
+        // We only ever hand out borrows of key-value stores.
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl HostWorktree for WasmState {
+    async fn id(
+        &mut self,
+        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+    ) -> wasmtime::Result<u64> {
+        let delegate = self.table.get(&delegate)?;
+        Ok(delegate.worktree_id().to_proto())
+    }
+
+    async fn root_path(
+        &mut self,
+        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+    ) -> wasmtime::Result<String> {
+        let delegate = self.table.get(&delegate)?;
+        Ok(delegate.worktree_root_path().to_string_lossy().to_string())
+    }
+
+    async fn read_text_file(
+        &mut self,
+        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        path: String,
+    ) -> wasmtime::Result<Result<String, String>> {
+        let delegate = self.table.get(&delegate)?;
+        Ok(delegate
+            .read_text_file(path.into())
+            .await
+            .map_err(|error| error.to_string()))
+    }
+
+    async fn shell_env(
+        &mut self,
+        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+    ) -> wasmtime::Result<EnvVars> {
+        let delegate = self.table.get(&delegate)?;
+        Ok(delegate.shell_env().await.into_iter().collect())
+    }
+
+    async fn which(
+        &mut self,
+        delegate: Resource<Arc<dyn LspAdapterDelegate>>,
+        binary_name: String,
+    ) -> wasmtime::Result<Option<String>> {
+        let delegate = self.table.get(&delegate)?;
+        Ok(delegate
+            .which(binary_name.as_ref())
+            .await
+            .map(|path| path.to_string_lossy().to_string()))
+    }
+
+    fn drop(&mut self, _worktree: Resource<Worktree>) -> Result<()> {
+        // We only ever hand out borrows of worktrees.
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl common::Host for WasmState {}
+
+#[async_trait]
+impl http_client::Host for WasmState {
+    async fn fetch(
+        &mut self,
+        request: http_client::HttpRequest,
+    ) -> wasmtime::Result<Result<http_client::HttpResponse, String>> {
+        maybe!(async {
+            let url = &request.url;
+            let request = convert_request(&request)?;
+            let mut response = self.host.http_client.send(request).await?;
+
+            if response.status().is_client_error() || response.status().is_server_error() {
+                bail!("failed to fetch '{url}': status code {}", response.status())
+            }
+            convert_response(&mut response).await
+        })
+        .await
+        .to_wasmtime_result()
+    }
+
+    async fn fetch_stream(
+        &mut self,
+        request: http_client::HttpRequest,
+    ) -> wasmtime::Result<Result<Resource<ExtensionHttpResponseStream>, String>> {
+        let request = convert_request(&request)?;
+        let response = self.host.http_client.send(request);
+        maybe!(async {
+            let response = response.await?;
+            let stream = Arc::new(Mutex::new(response));
+            let resource = self.table.push(stream)?;
+            Ok(resource)
+        })
+        .await
+        .to_wasmtime_result()
+    }
+}
+
+#[async_trait]
+impl http_client::HostHttpResponseStream for WasmState {
+    async fn next_chunk(
+        &mut self,
+        resource: Resource<ExtensionHttpResponseStream>,
+    ) -> wasmtime::Result<Result<Option<Vec<u8>>, String>> {
+        let stream = self.table.get(&resource)?.clone();
+        maybe!(async move {
+            let mut response = stream.lock().await;
+            let mut buffer = vec![0; 8192]; // 8KB buffer
+            let bytes_read = response.body_mut().read(&mut buffer).await?;
+            if bytes_read == 0 {
+                Ok(None)
+            } else {
+                buffer.truncate(bytes_read);
+                Ok(Some(buffer))
+            }
+        })
+        .await
+        .to_wasmtime_result()
+    }
+
+    fn drop(&mut self, _resource: Resource<ExtensionHttpResponseStream>) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl From<http_client::HttpMethod> for ::http_client::Method {
+    fn from(value: http_client::HttpMethod) -> Self {
+        match value {
+            http_client::HttpMethod::Get => Self::GET,
+            http_client::HttpMethod::Post => Self::POST,
+            http_client::HttpMethod::Put => Self::PUT,
+            http_client::HttpMethod::Delete => Self::DELETE,
+            http_client::HttpMethod::Head => Self::HEAD,
+            http_client::HttpMethod::Options => Self::OPTIONS,
+            http_client::HttpMethod::Patch => Self::PATCH,
+        }
+    }
+}
+
+fn convert_request(
+    extension_request: &http_client::HttpRequest,
+) -> Result<::http_client::Request<AsyncBody>, anyhow::Error> {
+    let mut request = ::http_client::Request::builder()
+        .method(::http_client::Method::from(extension_request.method))
+        .uri(&extension_request.url)
+        .redirect_policy(match extension_request.redirect_policy {
+            http_client::RedirectPolicy::NoFollow => RedirectPolicy::None,
+            http_client::RedirectPolicy::FollowLimit(limit) => RedirectPolicy::Limit(limit),
+            http_client::RedirectPolicy::FollowAll => RedirectPolicy::Follow,
+        });
+    for (key, value) in &extension_request.headers {
+        request = request.header(key, value);
+    }
+    let body = extension_request
+        .body
+        .clone()
+        .map(AsyncBody::from)
+        .unwrap_or_default();
+    request.body(body).map_err(anyhow::Error::from)
+}
+
+async fn convert_response(
+    response: &mut ::http_client::Response<AsyncBody>,
+) -> Result<http_client::HttpResponse, anyhow::Error> {
+    let mut extension_response = http_client::HttpResponse {
+        body: Vec::new(),
+        headers: Vec::new(),
+    };
+
+    for (key, value) in response.headers() {
+        extension_response
+            .headers
+            .push((key.to_string(), value.to_str().unwrap_or("").to_string()));
+    }
+
+    response
+        .body_mut()
+        .read_to_end(&mut extension_response.body)
+        .await?;
+
+    Ok(extension_response)
+}
+
+#[async_trait]
+impl nodejs::Host for WasmState {
+    async fn node_binary_path(&mut self) -> wasmtime::Result<Result<String, String>> {
+        self.host
+            .node_runtime
+            .binary_path()
+            .await
+            .map(|path| path.to_string_lossy().to_string())
+            .to_wasmtime_result()
+    }
+
+    async fn npm_package_latest_version(
+        &mut self,
+        package_name: String,
+    ) -> wasmtime::Result<Result<String, String>> {
+        self.host
+            .node_runtime
+            .npm_package_latest_version(&package_name)
+            .await
+            .to_wasmtime_result()
+    }
+
+    async fn npm_package_installed_version(
+        &mut self,
+        package_name: String,
+    ) -> wasmtime::Result<Result<Option<String>, String>> {
+        self.host
+            .node_runtime
+            .npm_package_installed_version(&self.work_dir(), &package_name)
+            .await
+            .to_wasmtime_result()
+    }
+
+    async fn npm_install_package(
+        &mut self,
+        package_name: String,
+        version: String,
+    ) -> wasmtime::Result<Result<(), String>> {
+        self.host
+            .node_runtime
+            .npm_install_packages(&self.work_dir(), &[(&package_name, &version)])
+            .await
+            .to_wasmtime_result()
+    }
+}
+
+#[async_trait]
+impl lsp::Host for WasmState {}
+
+impl From<::http_client::github::GithubRelease> for github::GithubRelease {
+    fn from(value: ::http_client::github::GithubRelease) -> Self {
+        Self {
+            version: value.tag_name,
+            assets: value.assets.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<::http_client::github::GithubReleaseAsset> for github::GithubReleaseAsset {
+    fn from(value: ::http_client::github::GithubReleaseAsset) -> Self {
+        Self {
+            name: value.name,
+            download_url: value.browser_download_url,
+        }
+    }
+}
+
+#[async_trait]
+impl github::Host for WasmState {
+    async fn latest_github_release(
+        &mut self,
+        repo: String,
+        options: github::GithubReleaseOptions,
+    ) -> wasmtime::Result<Result<github::GithubRelease, String>> {
+        maybe!(async {
+            let release = ::http_client::github::latest_github_release(
+                &repo,
+                options.require_assets,
+                options.pre_release,
+                self.host.http_client.clone(),
+            )
+            .await?;
+            Ok(release.into())
+        })
+        .await
+        .to_wasmtime_result()
+    }
+
+    async fn github_release_by_tag_name(
+        &mut self,
+        repo: String,
+        tag: String,
+    ) -> wasmtime::Result<Result<github::GithubRelease, String>> {
+        maybe!(async {
+            let release = ::http_client::github::get_release_by_tag_name(
+                &repo,
+                &tag,
+                self.host.http_client.clone(),
+            )
+            .await?;
+            Ok(release.into())
+        })
+        .await
+        .to_wasmtime_result()
+    }
+}
+
+#[async_trait]
+impl platform::Host for WasmState {
+    async fn current_platform(&mut self) -> Result<(platform::Os, platform::Architecture)> {
+        Ok((
+            match env::consts::OS {
+                "macos" => platform::Os::Mac,
+                "linux" => platform::Os::Linux,
+                "windows" => platform::Os::Windows,
+                _ => panic!("unsupported os"),
+            },
+            match env::consts::ARCH {
+                "aarch64" => platform::Architecture::Aarch64,
+                "x86" => platform::Architecture::X86,
+                "x86_64" => platform::Architecture::X8664,
+                _ => panic!("unsupported architecture"),
+            },
+        ))
+    }
+}
+
+#[async_trait]
+impl slash_command::Host for WasmState {}
+
+#[async_trait]
+impl ExtensionImports for WasmState {
+    async fn get_settings(
+        &mut self,
+        location: Option<self::SettingsLocation>,
+        category: String,
+        key: Option<String>,
+    ) -> wasmtime::Result<Result<String, String>> {
+        self.on_main_thread(|cx| {
+            async move {
+                let location = location
+                    .as_ref()
+                    .map(|location| ::settings::SettingsLocation {
+                        worktree_id: WorktreeId::from_proto(location.worktree_id),
+                        path: Path::new(&location.path),
+                    });
+
+                cx.update(|cx| match category.as_str() {
+                    "language" => {
+                        let key = key.map(|k| LanguageName::new(&k));
+                        let settings =
+                            AllLanguageSettings::get(location, cx).language(key.as_ref());
+                        Ok(serde_json::to_string(&settings::LanguageSettings {
+                            tab_size: settings.tab_size,
+                        })?)
+                    }
+                    "lsp" => {
+                        let settings = key
+                            .and_then(|key| {
+                                ProjectSettings::get(location, cx)
+                                    .lsp
+                                    .get(&Arc::<str>::from(key))
+                            })
+                            .cloned()
+                            .unwrap_or_default();
+                        Ok(serde_json::to_string(&settings::LspSettings {
+                            binary: settings.binary.map(|binary| settings::BinarySettings {
+                                path: binary.path,
+                                arguments: binary.arguments,
+                            }),
+                            settings: settings.settings,
+                            initialization_options: settings.initialization_options,
+                        })?)
+                    }
+                    _ => {
+                        bail!("Unknown settings category: {}", category);
+                    }
+                })
+            }
+            .boxed_local()
+        })
+        .await?
+        .to_wasmtime_result()
+    }
+
+    async fn set_language_server_installation_status(
+        &mut self,
+        server_name: String,
+        status: LanguageServerInstallationStatus,
+    ) -> wasmtime::Result<()> {
+        let status = match status {
+            LanguageServerInstallationStatus::CheckingForUpdate => {
+                LanguageServerBinaryStatus::CheckingForUpdate
+            }
+            LanguageServerInstallationStatus::Downloading => {
+                LanguageServerBinaryStatus::Downloading
+            }
+            LanguageServerInstallationStatus::None => LanguageServerBinaryStatus::None,
+            LanguageServerInstallationStatus::Failed(error) => {
+                LanguageServerBinaryStatus::Failed { error }
+            }
+        };
+
+        self.host
+            .language_registry
+            .update_lsp_status(language::LanguageServerName(server_name.into()), status);
+        Ok(())
+    }
+
+    async fn download_file(
+        &mut self,
+        url: String,
+        path: String,
+        file_type: DownloadedFileType,
+    ) -> wasmtime::Result<Result<(), String>> {
+        maybe!(async {
+            let path = PathBuf::from(path);
+            let extension_work_dir = self.host.work_dir.join(self.manifest.id.as_ref());
+
+            self.host.fs.create_dir(&extension_work_dir).await?;
+
+            let destination_path = self
+                .host
+                .writeable_path_from_extension(&self.manifest.id, &path)?;
+
+            let mut response = self
+                .host
+                .http_client
+                .get(&url, Default::default(), true)
+                .await
+                .map_err(|err| anyhow!("error downloading release: {}", err))?;
+
+            if !response.status().is_success() {
+                Err(anyhow!(
+                    "download failed with status {}",
+                    response.status().to_string()
+                ))?;
+            }
+            let body = BufReader::new(response.body_mut());
+
+            match file_type {
+                DownloadedFileType::Uncompressed => {
+                    futures::pin_mut!(body);
+                    self.host
+                        .fs
+                        .create_file_with(&destination_path, body)
+                        .await?;
+                }
+                DownloadedFileType::Gzip => {
+                    let body = GzipDecoder::new(body);
+                    futures::pin_mut!(body);
+                    self.host
+                        .fs
+                        .create_file_with(&destination_path, body)
+                        .await?;
+                }
+                DownloadedFileType::GzipTar => {
+                    let body = GzipDecoder::new(body);
+                    futures::pin_mut!(body);
+                    self.host
+                        .fs
+                        .extract_tar_file(&destination_path, Archive::new(body))
+                        .await?;
+                }
+                DownloadedFileType::Zip => {
+                    futures::pin_mut!(body);
+                    node_runtime::extract_zip(&destination_path, body)
+                        .await
+                        .with_context(|| format!("failed to unzip {} archive", path.display()))?;
+                }
+            }
+
+            Ok(())
+        })
+        .await
+        .to_wasmtime_result()
+    }
+
+    async fn make_file_executable(&mut self, path: String) -> wasmtime::Result<Result<(), String>> {
+        #[allow(unused)]
+        let path = self
+            .host
+            .writeable_path_from_extension(&self.manifest.id, Path::new(&path))?;
+
+        #[cfg(unix)]
+        {
+            use std::fs::{self, Permissions};
+            use std::os::unix::fs::PermissionsExt;
+
+            return fs::set_permissions(&path, Permissions::from_mode(0o755))
+                .map_err(|error| anyhow!("failed to set permissions for path {path:?}: {error}"))
+                .to_wasmtime_result();
+        }
+
+        #[cfg(not(unix))]
+        Ok(Ok(()))
+    }
+}
diff --git a/crates/extension_api/Cargo.toml b/crates/extension_api/Cargo.toml
index 89d7ed947be34f..1a2b25b0f6a1d8 100644
--- a/crates/extension_api/Cargo.toml
+++ b/crates/extension_api/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_extension_api"
-version = "0.1.0"
+version = "0.2.0"
 description = "APIs for creating Zed extensions in Rust"
 repository = "https://github.com/zed-industries/zed"
 documentation = "https://docs.rs/zed_extension_api"
@@ -8,6 +8,9 @@ keywords = ["zed", "extension"]
 edition = "2021"
 license = "Apache-2.0"
 
+# Remove when we're ready to publish v0.2.0.
+publish = false
+
 [lints]
 workspace = true
 
diff --git a/crates/extension_api/wit/since_v0.2.0/common.wit b/crates/extension_api/wit/since_v0.2.0/common.wit
new file mode 100644
index 00000000000000..c4f321f4c70a11
--- /dev/null
+++ b/crates/extension_api/wit/since_v0.2.0/common.wit
@@ -0,0 +1,9 @@
+interface common {
+    /// A (half-open) range (`[start, end)`).
+    record range {
+        /// The start of the range (inclusive).
+        start: u32,
+        /// The end of the range (exclusive).
+        end: u32,
+    }
+}
diff --git a/crates/extension_api/wit/since_v0.2.0/extension.wit b/crates/extension_api/wit/since_v0.2.0/extension.wit
new file mode 100644
index 00000000000000..c7599f93ffd55d
--- /dev/null
+++ b/crates/extension_api/wit/since_v0.2.0/extension.wit
@@ -0,0 +1,147 @@
+package zed:extension;
+
+world extension {
+    import github;
+    import http-client;
+    import platform;
+    import nodejs;
+
+    use common.{range};
+    use lsp.{completion, symbol};
+    use slash-command.{slash-command, slash-command-argument-completion, slash-command-output};
+
+    /// Initializes the extension.
+    export init-extension: func();
+
+    /// The type of a downloaded file.
+    enum downloaded-file-type {
+        /// A gzipped file (`.gz`).
+        gzip,
+        /// A gzipped tar archive (`.tar.gz`).
+        gzip-tar,
+        /// A ZIP file (`.zip`).
+        zip,
+        /// An uncompressed file.
+        uncompressed,
+    }
+
+    /// The installation status for a language server.
+    variant language-server-installation-status {
+        /// The language server has no installation status.
+        none,
+        /// The language server is being downloaded.
+        downloading,
+        /// The language server is checking for updates.
+        checking-for-update,
+        /// The language server installation failed for specified reason.
+        failed(string),
+    }
+
+    record settings-location {
+        worktree-id: u64,
+        path: string,
+    }
+
+    import get-settings: func(path: option<settings-location>, category: string, key: option<string>) -> result<string, string>;
+
+    /// Downloads a file from the given URL and saves it to the given path within the extension's
+    /// working directory.
+    ///
+    /// The file will be extracted according to the given file type.
+    import download-file: func(url: string, file-path: string, file-type: downloaded-file-type) -> result<_, string>;
+
+    /// Makes the file at the given path executable.
+    import make-file-executable: func(filepath: string) -> result<_, string>;
+
+    /// Updates the installation status for the given language server.
+    import set-language-server-installation-status: func(language-server-name: string, status: language-server-installation-status);
+
+    /// A list of environment variables.
+    type env-vars = list<tuple<string, string>>;
+
+    /// A command.
+    record command {
+        /// The command to execute.
+        command: string,
+        /// The arguments to pass to the command.
+        args: list<string>,
+        /// The environment variables to set for the command.
+        env: env-vars,
+    }
+
+    /// A Zed worktree.
+    resource worktree {
+        /// Returns the ID of the worktree.
+        id: func() -> u64;
+        /// Returns the root path of the worktree.
+        root-path: func() -> string;
+        /// Returns the textual contents of the specified file in the worktree.
+        read-text-file: func(path: string) -> result<string, string>;
+        /// Returns the path to the given binary name, if one is present on the `$PATH`.
+        which: func(binary-name: string) -> option<string>;
+        /// Returns the current shell environment.
+        shell-env: func() -> env-vars;
+    }
+
+    /// A key-value store.
+    resource key-value-store {
+        /// Inserts an entry under the specified key.
+        insert: func(key: string, value: string) -> result<_, string>;
+    }
+
+    /// Returns the command used to start up the language server.
+    export language-server-command: func(language-server-id: string, worktree: borrow<worktree>) -> result<command, string>;
+
+    /// Returns the initialization options to pass to the language server on startup.
+    ///
+    /// The initialization options are represented as a JSON string.
+    export language-server-initialization-options: func(language-server-id: string, worktree: borrow<worktree>) -> result<option<string>, string>;
+
+    /// Returns the workspace configuration options to pass to the language server.
+    export language-server-workspace-configuration: func(language-server-id: string, worktree: borrow<worktree>) -> result<option<string>, string>;
+
+    /// A label containing some code.
+    record code-label {
+        /// The source code to parse with Tree-sitter.
+        code: string,
+        /// The spans to display in the label.
+        spans: list<code-label-span>,
+        /// The range of the displayed label to include when filtering.
+        filter-range: range,
+    }
+
+    /// A span within a code label.
+    variant code-label-span {
+        /// A range into the parsed code.
+        code-range(range),
+        /// A span containing a code literal.
+        literal(code-label-span-literal),
+    }
+
+    /// A span containing a code literal.
+    record code-label-span-literal {
+        /// The literal text.
+        text: string,
+        /// The name of the highlight to use for this literal.
+        highlight-name: option<string>,
+    }
+
+    export labels-for-completions: func(language-server-id: string, completions: list<completion>) -> result<list<option<code-label>>, string>;
+    export labels-for-symbols: func(language-server-id: string, symbols: list<symbol>) -> result<list<option<code-label>>, string>;
+
+    /// Returns the completions that should be shown when completing the provided slash command with the given query.
+    export complete-slash-command-argument: func(command: slash-command, args: list<string>) -> result<list<slash-command-argument-completion>, string>;
+
+    /// Returns the output from running the provided slash command.
+    export run-slash-command: func(command: slash-command, args: list<string>, worktree: option<borrow<worktree>>) -> result<slash-command-output, string>;
+
+    /// Returns a list of packages as suggestions to be included in the `/docs`
+    /// search results.
+    ///
+    /// This can be used to provide completions for known packages (e.g., from the
+    /// local project or a registry) before a package has been indexed.
+    export suggest-docs-packages: func(provider-name: string) -> result<list<string>, string>;
+
+    /// Indexes the docs for the specified package.
+    export index-docs: func(provider-name: string, package-name: string, database: borrow<key-value-store>) -> result<_, string>;
+}
diff --git a/crates/extension_api/wit/since_v0.2.0/github.wit b/crates/extension_api/wit/since_v0.2.0/github.wit
new file mode 100644
index 00000000000000..bb138f5d31bf8e
--- /dev/null
+++ b/crates/extension_api/wit/since_v0.2.0/github.wit
@@ -0,0 +1,33 @@
+interface github {
+    /// A GitHub release.
+    record github-release {
+        /// The version of the release.
+        version: string,
+        /// The list of assets attached to the release.
+        assets: list<github-release-asset>,
+    }
+
+    /// An asset from a GitHub release.
+    record github-release-asset {
+        /// The name of the asset.
+        name: string,
+        /// The download URL for the asset.
+        download-url: string,
+    }
+
+    /// The options used to filter down GitHub releases.
+    record github-release-options {
+        /// Whether releases without assets should be included.
+        require-assets: bool,
+        /// Whether pre-releases should be included.
+        pre-release: bool,
+    }
+
+    /// Returns the latest release for the given GitHub repository.
+    latest-github-release: func(repo: string, options: github-release-options) -> result<github-release, string>;
+
+    /// Returns the GitHub release with the specified tag name for the given GitHub repository.
+    ///
+    /// Returns an error if a release with the given tag name does not exist.
+    github-release-by-tag-name: func(repo: string, tag: string) -> result<github-release, string>;
+}
diff --git a/crates/extension_api/wit/since_v0.2.0/http-client.wit b/crates/extension_api/wit/since_v0.2.0/http-client.wit
new file mode 100644
index 00000000000000..bb0206c17a52d4
--- /dev/null
+++ b/crates/extension_api/wit/since_v0.2.0/http-client.wit
@@ -0,0 +1,67 @@
+interface http-client {
+    /// An HTTP request.
+    record http-request {
+        /// The HTTP method for the request.
+        method: http-method,
+        /// The URL to which the request should be made.
+        url: string,
+        /// The headers for the request.
+        headers: list<tuple<string, string>>,
+        /// The request body.
+        body: option<list<u8>>,
+        /// The policy to use for redirects.
+        redirect-policy: redirect-policy,
+    }
+
+    /// HTTP methods.
+    enum http-method {
+        /// `GET`
+        get,
+        /// `HEAD`
+        head,
+        /// `POST`
+        post,
+        /// `PUT`
+        put,
+        /// `DELETE`
+        delete,
+        /// `OPTIONS`
+        options,
+        /// `PATCH`
+        patch,
+    }
+
+    /// The policy for dealing with redirects received from the server.
+    variant redirect-policy {
+        /// Redirects from the server will not be followed.
+        ///
+        /// This is the default behavior.
+        no-follow,
+        /// Redirects from the server will be followed up to the specified limit.
+        follow-limit(u32),
+        /// All redirects from the server will be followed.
+        follow-all,
+    }
+
+    /// An HTTP response.
+    record http-response {
+        /// The response headers.
+        headers: list<tuple<string, string>>,
+        /// The response body.
+        body: list<u8>,
+    }
+
+    /// Performs an HTTP request and returns the response.
+    fetch: func(req: http-request) -> result<http-response, string>;
+
+    /// An HTTP response stream.
+    resource http-response-stream {
+        /// Retrieves the next chunk of data from the response stream.
+        ///
+        /// Returns `Ok(None)` if the stream has ended.
+        next-chunk: func() -> result<option<list<u8>>, string>;
+    }
+
+    /// Performs an HTTP request and returns a response stream.
+    fetch-stream: func(req: http-request) -> result<http-response-stream, string>;
+}
diff --git a/crates/extension_api/wit/since_v0.2.0/lsp.wit b/crates/extension_api/wit/since_v0.2.0/lsp.wit
new file mode 100644
index 00000000000000..19e81b6b145fe2
--- /dev/null
+++ b/crates/extension_api/wit/since_v0.2.0/lsp.wit
@@ -0,0 +1,83 @@
+interface lsp {
+    /// An LSP completion.
+    record completion {
+        label: string,
+        detail: option<string>,
+        kind: option<completion-kind>,
+        insert-text-format: option<insert-text-format>,
+    }
+
+    /// The kind of an LSP completion.
+    variant completion-kind {
+        text,
+        method,
+        function,
+        %constructor,
+        field,
+        variable,
+        class,
+        %interface,
+        module,
+        property,
+        unit,
+        value,
+        %enum,
+        keyword,
+        snippet,
+        color,
+        file,
+        reference,
+        folder,
+        enum-member,
+        constant,
+        struct,
+        event,
+        operator,
+        type-parameter,
+        other(s32),
+    }
+
+    /// Defines how to interpret the insert text in a completion item.
+    variant insert-text-format {
+        plain-text,
+        snippet,
+        other(s32),
+    }
+
+    /// An LSP symbol.
+    record symbol {
+        kind: symbol-kind,
+        name: string,
+    }
+
+    /// The kind of an LSP symbol.
+    variant symbol-kind {
+        file,
+        module,
+        namespace,
+        %package,
+        class,
+        method,
+        property,
+        field,
+        %constructor,
+        %enum,
+        %interface,
+        function,
+        variable,
+        constant,
+        %string,
+        number,
+        boolean,
+        array,
+        object,
+        key,
+        null,
+        enum-member,
+        struct,
+        event,
+        operator,
+        type-parameter,
+        other(s32),
+    }
+}
diff --git a/crates/extension_api/wit/since_v0.2.0/nodejs.wit b/crates/extension_api/wit/since_v0.2.0/nodejs.wit
new file mode 100644
index 00000000000000..c814548314162c
--- /dev/null
+++ b/crates/extension_api/wit/since_v0.2.0/nodejs.wit
@@ -0,0 +1,13 @@
+interface nodejs {
+    /// Returns the path to the Node binary used by Zed.
+    node-binary-path: func() -> result<string, string>;
+
+    /// Returns the latest version of the given NPM package.
+    npm-package-latest-version: func(package-name: string) -> result<string, string>;
+
+    /// Returns the installed version of the given NPM package, if it exists.
+    npm-package-installed-version: func(package-name: string) -> result<option<string>, string>;
+
+    /// Installs the specified NPM package.
+    npm-install-package: func(package-name: string, version: string) -> result<_, string>;
+}
diff --git a/crates/extension_api/wit/since_v0.2.0/platform.wit b/crates/extension_api/wit/since_v0.2.0/platform.wit
new file mode 100644
index 00000000000000..48472a99bc175f
--- /dev/null
+++ b/crates/extension_api/wit/since_v0.2.0/platform.wit
@@ -0,0 +1,24 @@
+interface platform {
+    /// An operating system.
+    enum os {
+        /// macOS.
+        mac,
+        /// Linux.
+        linux,
+        /// Windows.
+        windows,
+    }
+
+    /// A platform architecture.
+    enum architecture {
+        /// AArch64 (e.g., Apple Silicon).
+        aarch64,
+        /// x86.
+        x86,
+        /// x86-64.
+        x8664,
+    }
+
+    /// Gets the current operating system and architecture.
+    current-platform: func() -> tuple<os, architecture>;
+}
diff --git a/crates/extension_api/wit/since_v0.2.0/settings.rs b/crates/extension_api/wit/since_v0.2.0/settings.rs
new file mode 100644
index 00000000000000..5c6cae70649840
--- /dev/null
+++ b/crates/extension_api/wit/since_v0.2.0/settings.rs
@@ -0,0 +1,29 @@
+use serde::{Deserialize, Serialize};
+use std::num::NonZeroU32;
+
+/// The settings for a particular language.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct LanguageSettings {
+    /// How many columns a tab should occupy.
+    pub tab_size: NonZeroU32,
+}
+
+/// The settings for a particular language server.
+#[derive(Default, Debug, Serialize, Deserialize)]
+pub struct LspSettings {
+    /// The settings for the language server binary.
+    pub binary: Option<BinarySettings>,
+    /// The initialization options to pass to the language server.
+    pub initialization_options: Option<serde_json::Value>,
+    /// The settings to pass to language server.
+    pub settings: Option<serde_json::Value>,
+}
+
+/// The settings for a language server binary.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BinarySettings {
+    /// The path to the binary.
+    pub path: Option<String>,
+    /// The arguments to pass to the binary.
+    pub arguments: Option<Vec<String>>,
+}
diff --git a/crates/extension_api/wit/since_v0.2.0/slash-command.wit b/crates/extension_api/wit/since_v0.2.0/slash-command.wit
new file mode 100644
index 00000000000000..f52561c2ef412b
--- /dev/null
+++ b/crates/extension_api/wit/since_v0.2.0/slash-command.wit
@@ -0,0 +1,41 @@
+interface slash-command {
+    use common.{range};
+
+    /// A slash command for use in the Assistant.
+    record slash-command {
+        /// The name of the slash command.
+        name: string,
+        /// The description of the slash command.
+        description: string,
+        /// The tooltip text to display for the run button.
+        tooltip-text: string,
+        /// Whether this slash command requires an argument.
+        requires-argument: bool,
+    }
+
+    /// The output of a slash command.
+    record slash-command-output {
+        /// The text produced by the slash command.
+        text: string,
+        /// The list of sections to show in the slash command placeholder.
+        sections: list<slash-command-output-section>,
+    }
+
+    /// A section in the slash command output.
+    record slash-command-output-section {
+        /// The range this section occupies.
+        range: range,
+        /// The label to display in the placeholder for this section.
+        label: string,
+    }
+
+    /// A completion for a slash command argument.
+    record slash-command-argument-completion {
+        /// The label to display for this completion.
+        label: string,
+        /// The new text that should be inserted into the command when this completion is accepted.
+        new-text: string,
+        /// Whether the command should be run when accepting this completion.
+        run-command: bool,
+    }
+}
diff --git a/extensions/test-extension/Cargo.toml b/extensions/test-extension/Cargo.toml
index 094302e89f47a1..5e17a9a6a3c549 100644
--- a/extensions/test-extension/Cargo.toml
+++ b/extensions/test-extension/Cargo.toml
@@ -13,4 +13,4 @@ path = "src/test_extension.rs"
 crate-type = ["cdylib"]
 
 [dependencies]
-zed_extension_api = "0.1.0"
+zed_extension_api = { path = "../../crates/extension_api" }

From 91ffa02e2c7ee30b9a172ce5944ad96a747a453e Mon Sep 17 00:00:00 2001
From: Richard Feldman <oss@rtfeldman.com>
Date: Fri, 13 Sep 2024 13:17:49 -0400
Subject: [PATCH 066/762] /auto (#16696)

Add `/auto` behind a feature flag that's disabled for now, even for
staff.

We've decided on a different design for context inference, but there are
parts of /auto that will be useful for that, so we want them in the code
base even if they're unused for now.

Release Notes:

- N/A

---------

Co-authored-by: Antonio Scandurra <me@as-cii.com>
Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 Cargo.lock                                    |   27 +
 Cargo.toml                                    |    2 +
 crates/assistant/src/assistant.rs             |   23 +-
 crates/assistant/src/assistant_panel.rs       |   14 +
 crates/assistant/src/assistant_settings.rs    |    1 +
 crates/assistant/src/slash_command.rs         |    1 +
 .../src/slash_command/auto_command.rs         |  360 ++++++
 .../slash_command/prompt_after_summary.txt    |   24 +
 .../slash_command/prompt_before_summary.txt   |   31 +
 .../src/slash_command/search_command.rs       |    9 +-
 crates/collab/k8s/collab.template.yml         |   10 +-
 crates/collab/src/db/queries/projects.rs      |    5 +
 crates/collab/src/db/queries/rooms.rs         |    5 +
 crates/collab/src/lib.rs                      |    8 +-
 crates/collab/src/llm.rs                      |    4 +-
 crates/collab/src/llm/db/queries/providers.rs |   13 +-
 crates/collab/src/llm/db/seed.rs              |    9 +
 crates/collab/src/tests/test_server.rs        |    4 +-
 crates/feature_flags/Cargo.toml               |    1 +
 crates/feature_flags/src/feature_flags.rs     |   58 +-
 crates/fs/src/fs.rs                           |   20 +-
 crates/git/src/status.rs                      |    1 -
 crates/http_client/src/http_client.rs         |    4 +
 .../language_model/src/model/cloud_model.rs   |    4 +-
 .../language_model/src/provider/anthropic.rs  |    2 +-
 crates/language_model/src/provider/google.rs  |    4 +-
 crates/language_model/src/provider/open_ai.rs |    2 +-
 crates/language_model/src/registry.rs         |    6 +-
 crates/project_panel/src/project_panel.rs     |    1 +
 crates/proto/proto/zed.proto                  |    1 +
 crates/semantic_index/Cargo.toml              |    4 +
 crates/semantic_index/examples/index.rs       |    5 +-
 crates/semantic_index/src/embedding.rs        |   12 +-
 crates/semantic_index/src/embedding_index.rs  |  469 +++++++
 crates/semantic_index/src/indexing.rs         |   49 +
 crates/semantic_index/src/project_index.rs    |  523 ++++++++
 .../src/project_index_debug_view.rs           |   16 +-
 crates/semantic_index/src/semantic_index.rs   | 1129 ++---------------
 crates/semantic_index/src/summary_backlog.rs  |   48 +
 crates/semantic_index/src/summary_index.rs    |  693 ++++++++++
 crates/semantic_index/src/worktree_index.rs   |  217 ++++
 crates/worktree/src/worktree.rs               |    5 +
 42 files changed, 2773 insertions(+), 1051 deletions(-)
 create mode 100644 crates/assistant/src/slash_command/auto_command.rs
 create mode 100644 crates/assistant/src/slash_command/prompt_after_summary.txt
 create mode 100644 crates/assistant/src/slash_command/prompt_before_summary.txt
 create mode 100644 crates/semantic_index/src/embedding_index.rs
 create mode 100644 crates/semantic_index/src/indexing.rs
 create mode 100644 crates/semantic_index/src/project_index.rs
 create mode 100644 crates/semantic_index/src/summary_backlog.rs
 create mode 100644 crates/semantic_index/src/summary_index.rs
 create mode 100644 crates/semantic_index/src/worktree_index.rs

diff --git a/Cargo.lock b/Cargo.lock
index 5eaf3ddde1fda5..793cb66ad77b07 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -304,6 +304,9 @@ name = "arrayvec"
 version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "as-raw-xcb-connection"
@@ -1709,6 +1712,19 @@ dependencies = [
  "profiling",
 ]
 
+[[package]]
+name = "blake3"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d82033247fd8e890df8f740e407ad4d038debb9eb1f40533fffb32e7d17dc6f7"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+]
+
 [[package]]
 name = "block"
 version = "0.1.6"
@@ -2752,6 +2768,12 @@ dependencies = [
  "tiny-keccak",
 ]
 
+[[package]]
+name = "constant_time_eq"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
+
 [[package]]
 name = "context_servers"
 version = "0.1.0"
@@ -4187,6 +4209,7 @@ dependencies = [
 name = "feature_flags"
 version = "0.1.0"
 dependencies = [
+ "futures 0.3.30",
  "gpui",
 ]
 
@@ -9814,10 +9837,13 @@ name = "semantic_index"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "arrayvec",
+ "blake3",
  "client",
  "clock",
  "collections",
  "env_logger",
+ "feature_flags",
  "fs",
  "futures 0.3.30",
  "futures-batch",
@@ -9825,6 +9851,7 @@ dependencies = [
  "heed",
  "http_client",
  "language",
+ "language_model",
  "languages",
  "log",
  "open_ai",
diff --git a/Cargo.toml b/Cargo.toml
index 79f5ce2dcf54d2..53109002fa1139 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -309,6 +309,7 @@ aho-corasick = "1.1"
 alacritty_terminal = { git = "https://github.com/alacritty/alacritty", rev = "91d034ff8b53867143c005acfaa14609147c9a2c" }
 any_vec = "0.14"
 anyhow = "1.0.86"
+arrayvec = { version = "0.7.4", features = ["serde"] }
 ashpd = "0.9.1"
 async-compression = { version = "0.4", features = ["gzip", "futures-io"] }
 async-dispatcher = "0.1"
@@ -325,6 +326,7 @@ bitflags = "2.6.0"
 blade-graphics = { git = "https://github.com/kvark/blade", rev = "e142a3a5e678eb6a13e642ad8401b1f3aa38e969" }
 blade-macros = { git = "https://github.com/kvark/blade", rev = "e142a3a5e678eb6a13e642ad8401b1f3aa38e969" }
 blade-util = { git = "https://github.com/kvark/blade", rev = "e142a3a5e678eb6a13e642ad8401b1f3aa38e969" }
+blake3 = "1.5.3"
 cargo_metadata = "0.18"
 cargo_toml = "0.20"
 chrono = { version = "0.4", features = ["serde"] }
diff --git a/crates/assistant/src/assistant.rs b/crates/assistant/src/assistant.rs
index 70e37ba239eed6..7a73c188ec9dc1 100644
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -37,13 +37,13 @@ use language_model::{
 pub(crate) use model_selector::*;
 pub use prompts::PromptBuilder;
 use prompts::PromptLoadingParams;
-use semantic_index::{CloudEmbeddingProvider, SemanticIndex};
+use semantic_index::{CloudEmbeddingProvider, SemanticDb};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings, SettingsStore};
 use slash_command::{
-    context_server_command, default_command, diagnostics_command, docs_command, fetch_command,
-    file_command, now_command, project_command, prompt_command, search_command, symbols_command,
-    tab_command, terminal_command, workflow_command,
+    auto_command, context_server_command, default_command, diagnostics_command, docs_command,
+    fetch_command, file_command, now_command, project_command, prompt_command, search_command,
+    symbols_command, tab_command, terminal_command, workflow_command,
 };
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -210,12 +210,13 @@ pub fn init(
         let client = client.clone();
         async move {
             let embedding_provider = CloudEmbeddingProvider::new(client.clone());
-            let semantic_index = SemanticIndex::new(
+            let semantic_index = SemanticDb::new(
                 paths::embeddings_dir().join("semantic-index-db.0.mdb"),
                 Arc::new(embedding_provider),
                 &mut cx,
             )
             .await?;
+
             cx.update(|cx| cx.set_global(semantic_index))
         }
     })
@@ -364,6 +365,7 @@ fn update_active_language_model_from_settings(cx: &mut AppContext) {
 
 fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut AppContext) {
     let slash_command_registry = SlashCommandRegistry::global(cx);
+
     slash_command_registry.register_command(file_command::FileSlashCommand, true);
     slash_command_registry.register_command(symbols_command::OutlineSlashCommand, true);
     slash_command_registry.register_command(tab_command::TabSlashCommand, true);
@@ -382,6 +384,17 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
     }
     slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
 
+    cx.observe_flag::<auto_command::AutoSlashCommandFeatureFlag, _>({
+        let slash_command_registry = slash_command_registry.clone();
+        move |is_enabled, _cx| {
+            if is_enabled {
+                // [#auto-staff-ship] TODO remove this when /auto is no longer staff-shipped
+                slash_command_registry.register_command(auto_command::AutoCommand, true);
+            }
+        }
+    })
+    .detach();
+
     update_slash_commands_from_settings(cx);
     cx.observe_global::<SettingsStore>(update_slash_commands_from_settings)
         .detach();
diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 634f2231cd4f51..51c9aa9b4ea901 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -4723,6 +4723,20 @@ impl Render for ContextEditorToolbarItem {
         let weak_self = cx.view().downgrade();
         let right_side = h_flex()
             .gap_2()
+            // TODO display this in a nicer way, once we have a design for it.
+            // .children({
+            //     let project = self
+            //         .workspace
+            //         .upgrade()
+            //         .map(|workspace| workspace.read(cx).project().downgrade());
+            //
+            //     let scan_items_remaining = cx.update_global(|db: &mut SemanticDb, cx| {
+            //         project.and_then(|project| db.remaining_summaries(&project, cx))
+            //     });
+
+            //     scan_items_remaining
+            //         .map(|remaining_items| format!("Files to scan: {}", remaining_items))
+            // })
             .child(
                 ModelSelector::new(
                     self.fs.clone(),
diff --git a/crates/assistant/src/assistant_settings.rs b/crates/assistant/src/assistant_settings.rs
index 3e326886d50d71..7939eacd9344a3 100644
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -519,6 +519,7 @@ impl Settings for AssistantSettings {
                 &mut settings.default_model,
                 value.default_model.map(Into::into),
             );
+            // merge(&mut settings.infer_context, value.infer_context); TODO re-enable this once we ship context inference
         }
 
         Ok(settings)
diff --git a/crates/assistant/src/slash_command.rs b/crates/assistant/src/slash_command.rs
index b1a97688b2b46a..387e8231e47842 100644
--- a/crates/assistant/src/slash_command.rs
+++ b/crates/assistant/src/slash_command.rs
@@ -19,6 +19,7 @@ use std::{
 use ui::ActiveTheme;
 use workspace::Workspace;
 
+pub mod auto_command;
 pub mod context_server_command;
 pub mod default_command;
 pub mod diagnostics_command;
diff --git a/crates/assistant/src/slash_command/auto_command.rs b/crates/assistant/src/slash_command/auto_command.rs
new file mode 100644
index 00000000000000..cedfc63702b9aa
--- /dev/null
+++ b/crates/assistant/src/slash_command/auto_command.rs
@@ -0,0 +1,360 @@
+use super::create_label_for_command;
+use super::{SlashCommand, SlashCommandOutput};
+use anyhow::{anyhow, Result};
+use assistant_slash_command::ArgumentCompletion;
+use feature_flags::FeatureFlag;
+use futures::StreamExt;
+use gpui::{AppContext, AsyncAppContext, Task, WeakView};
+use language::{CodeLabel, LspAdapterDelegate};
+use language_model::{
+    LanguageModelCompletionEvent, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, Role,
+};
+use semantic_index::{FileSummary, SemanticDb};
+use smol::channel;
+use std::sync::{atomic::AtomicBool, Arc};
+use ui::{BorrowAppContext, WindowContext};
+use util::ResultExt;
+use workspace::Workspace;
+
+pub struct AutoSlashCommandFeatureFlag;
+
+impl FeatureFlag for AutoSlashCommandFeatureFlag {
+    const NAME: &'static str = "auto-slash-command";
+}
+
+pub(crate) struct AutoCommand;
+
+impl SlashCommand for AutoCommand {
+    fn name(&self) -> String {
+        "auto".into()
+    }
+
+    fn description(&self) -> String {
+        "Automatically infer what context to add, based on your prompt".into()
+    }
+
+    fn menu_text(&self) -> String {
+        "Automatically Infer Context".into()
+    }
+
+    fn label(&self, cx: &AppContext) -> CodeLabel {
+        create_label_for_command("auto", &["--prompt"], cx)
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        _arguments: &[String],
+        _cancel: Arc<AtomicBool>,
+        workspace: Option<WeakView<Workspace>>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        // There's no autocomplete for a prompt, since it's arbitrary text.
+        // However, we can use this opportunity to kick off a drain of the backlog.
+        // That way, it can hopefully be done resummarizing by the time we've actually
+        // typed out our prompt. This re-runs on every keystroke during autocomplete,
+        // but in the future, we could instead do it only once, when /auto is first entered.
+        let Some(workspace) = workspace.and_then(|ws| ws.upgrade()) else {
+            log::warn!("workspace was dropped or unavailable during /auto autocomplete");
+
+            return Task::ready(Ok(Vec::new()));
+        };
+
+        let project = workspace.read(cx).project().clone();
+        let Some(project_index) =
+            cx.update_global(|index: &mut SemanticDb, cx| index.project_index(project, cx))
+        else {
+            return Task::ready(Err(anyhow!("No project indexer, cannot use /auto")));
+        };
+
+        let cx: &mut AppContext = cx;
+
+        cx.spawn(|cx: gpui::AsyncAppContext| async move {
+            let task = project_index.read_with(&cx, |project_index, cx| {
+                project_index.flush_summary_backlogs(cx)
+            })?;
+
+            cx.background_executor().spawn(task).await;
+
+            anyhow::Ok(Vec::new())
+        })
+    }
+
+    fn requires_argument(&self) -> bool {
+        true
+    }
+
+    fn run(
+        self: Arc<Self>,
+        arguments: &[String],
+        workspace: WeakView<Workspace>,
+        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let Some(workspace) = workspace.upgrade() else {
+            return Task::ready(Err(anyhow::anyhow!("workspace was dropped")));
+        };
+        if arguments.is_empty() {
+            return Task::ready(Err(anyhow!("missing prompt")));
+        };
+        let argument = arguments.join(" ");
+        let original_prompt = argument.to_string();
+        let project = workspace.read(cx).project().clone();
+        let Some(project_index) =
+            cx.update_global(|index: &mut SemanticDb, cx| index.project_index(project, cx))
+        else {
+            return Task::ready(Err(anyhow!("no project indexer")));
+        };
+
+        let task = cx.spawn(|cx: gpui::AsyncWindowContext| async move {
+            let summaries = project_index
+                .read_with(&cx, |project_index, cx| project_index.all_summaries(cx))?
+                .await?;
+
+            commands_for_summaries(&summaries, &original_prompt, &cx).await
+        });
+
+        // As a convenience, append /auto's argument to the end of the prompt
+        // so you don't have to write it again.
+        let original_prompt = argument.to_string();
+
+        cx.background_executor().spawn(async move {
+            let commands = task.await?;
+            let mut prompt = String::new();
+
+            log::info!(
+                "Translating this response into slash-commands: {:?}",
+                commands
+            );
+
+            for command in commands {
+                prompt.push('/');
+                prompt.push_str(&command.name);
+                prompt.push(' ');
+                prompt.push_str(&command.arg);
+                prompt.push('\n');
+            }
+
+            prompt.push('\n');
+            prompt.push_str(&original_prompt);
+
+            Ok(SlashCommandOutput {
+                text: prompt,
+                sections: Vec::new(),
+                run_commands_in_text: true,
+            })
+        })
+    }
+}
+
+const PROMPT_INSTRUCTIONS_BEFORE_SUMMARY: &str = include_str!("prompt_before_summary.txt");
+const PROMPT_INSTRUCTIONS_AFTER_SUMMARY: &str = include_str!("prompt_after_summary.txt");
+
+fn summaries_prompt(summaries: &[FileSummary], original_prompt: &str) -> String {
+    let json_summaries = serde_json::to_string(summaries).unwrap();
+
+    format!("{PROMPT_INSTRUCTIONS_BEFORE_SUMMARY}\n{json_summaries}\n{PROMPT_INSTRUCTIONS_AFTER_SUMMARY}\n{original_prompt}")
+}
+
+/// The slash commands that the model is told about, and which we look for in the inference response.
+const SUPPORTED_SLASH_COMMANDS: &[&str] = &["search", "file"];
+
+#[derive(Debug, Clone)]
+struct CommandToRun {
+    name: String,
+    arg: String,
+}
+
+/// Given the pre-indexed file summaries for this project, as well as the original prompt
+/// string passed to `/auto`, get a list of slash commands to run, along with their arguments.
+///
+/// The prompt's output does not include the slashes (to reduce the chance that it makes a mistake),
+/// so taking one of these returned Strings and turning it into a real slash-command-with-argument
+/// involves prepending a slash to it.
+///
+/// This function will validate that each of the returned lines begins with one of SUPPORTED_SLASH_COMMANDS.
+/// Any other lines it encounters will be discarded, with a warning logged.
+async fn commands_for_summaries(
+    summaries: &[FileSummary],
+    original_prompt: &str,
+    cx: &AsyncAppContext,
+) -> Result<Vec<CommandToRun>> {
+    if summaries.is_empty() {
+        log::warn!("Inferring no context because there were no summaries available.");
+        return Ok(Vec::new());
+    }
+
+    // Use the globally configured model to translate the summaries into slash-commands,
+    // because Qwen2-7B-Instruct has not done a good job at that task.
+    let Some(model) = cx.update(|cx| LanguageModelRegistry::read_global(cx).active_model())? else {
+        log::warn!("Can't infer context because there's no active model.");
+        return Ok(Vec::new());
+    };
+    // Only go up to 90% of the actual max token count, to reduce chances of
+    // exceeding the token count due to inaccuracies in the token counting heuristic.
+    let max_token_count = (model.max_token_count() * 9) / 10;
+
+    // Rather than recursing (which would require this async function use a pinned box),
+    // we use an explicit stack of arguments and answers for when we need to "recurse."
+    let mut stack = vec![summaries];
+    let mut final_response = Vec::new();
+    let mut prompts = Vec::new();
+
+    // TODO We only need to create multiple Requests because we currently
+    // don't have the ability to tell if a CompletionProvider::complete response
+    // was a "too many tokens in this request" error. If we had that, then
+    // we could try the request once, instead of having to make separate requests
+    // to check the token count and then afterwards to run the actual prompt.
+    let make_request = |prompt: String| LanguageModelRequest {
+        messages: vec![LanguageModelRequestMessage {
+            role: Role::User,
+            content: vec![prompt.into()],
+            // Nothing in here will benefit from caching
+            cache: false,
+        }],
+        tools: Vec::new(),
+        stop: Vec::new(),
+        temperature: 1.0,
+    };
+
+    while let Some(current_summaries) = stack.pop() {
+        // The split can result in one slice being empty and the other having one element.
+        // Whenever that happens, skip the empty one.
+        if current_summaries.is_empty() {
+            continue;
+        }
+
+        log::info!(
+            "Inferring prompt context using {} file summaries",
+            current_summaries.len()
+        );
+
+        let prompt = summaries_prompt(&current_summaries, original_prompt);
+        let start = std::time::Instant::now();
+        // Per OpenAI, 1 token ~= 4 chars in English (we go with 4.5 to overestimate a bit, because failed API requests cost a lot of perf)
+        // Verifying this against an actual model.count_tokens() confirms that it's usually within ~5% of the correct answer, whereas
+        // getting the correct answer from tiktoken takes hundreds of milliseconds (compared to this arithmetic being ~free).
+        // source: https://help.openai.com/en/articles/4936856-what-are-tokens-and-how-to-count-them
+        let token_estimate = prompt.len() * 2 / 9;
+        let duration = start.elapsed();
+        log::info!(
+            "Time taken to count tokens for prompt of length {:?}B: {:?}",
+            prompt.len(),
+            duration
+        );
+
+        if token_estimate < max_token_count {
+            prompts.push(prompt);
+        } else if current_summaries.len() == 1 {
+            log::warn!("Inferring context for a single file's summary failed because the prompt's token length exceeded the model's token limit.");
+        } else {
+            log::info!(
+                "Context inference using file summaries resulted in a prompt containing {token_estimate} tokens, which exceeded the model's max of {max_token_count}. Retrying as two separate prompts, each including half the number of summaries.",
+            );
+            let (left, right) = current_summaries.split_at(current_summaries.len() / 2);
+            stack.push(right);
+            stack.push(left);
+        }
+    }
+
+    let all_start = std::time::Instant::now();
+
+    let (tx, rx) = channel::bounded(1024);
+
+    let completion_streams = prompts
+        .into_iter()
+        .map(|prompt| {
+            let request = make_request(prompt.clone());
+            let model = model.clone();
+            let tx = tx.clone();
+            let stream = model.stream_completion(request, &cx);
+
+            (stream, tx)
+        })
+        .collect::<Vec<_>>();
+
+    cx.background_executor()
+        .spawn(async move {
+            let futures = completion_streams
+                .into_iter()
+                .enumerate()
+                .map(|(ix, (stream, tx))| async move {
+                    let start = std::time::Instant::now();
+                    let events = stream.await?;
+                    log::info!("Time taken for awaiting /await chunk stream #{ix}: {:?}", start.elapsed());
+
+                    let completion: String = events
+                        .filter_map(|event| async {
+                            if let Ok(LanguageModelCompletionEvent::Text(text)) = event {
+                                Some(text)
+                            } else {
+                                None
+                            }
+                        })
+                        .collect()
+                        .await;
+
+                    log::info!("Time taken for all /auto chunks to come back for #{ix}: {:?}", start.elapsed());
+
+                    for line in completion.split('\n') {
+                        if let Some(first_space) = line.find(' ') {
+                            let command = &line[..first_space].trim();
+                            let arg = &line[first_space..].trim();
+
+                            tx.send(CommandToRun {
+                                name: command.to_string(),
+                                arg: arg.to_string(),
+                            })
+                            .await?;
+                        } else if !line.trim().is_empty() {
+                            // All slash-commands currently supported in context inference need a space for the argument.
+                            log::warn!(
+                                "Context inference returned a non-blank line that contained no spaces (meaning no argument for the slash command): {:?}",
+                                line
+                            );
+                        }
+                    }
+
+                    anyhow::Ok(())
+                })
+                .collect::<Vec<_>>();
+
+            let _ = futures::future::try_join_all(futures).await.log_err();
+
+            let duration = all_start.elapsed();
+            eprintln!("All futures completed in {:?}", duration);
+        })
+        .await;
+
+    drop(tx); // Close the channel so that rx.collect() won't hang. This is safe because all futures have completed.
+    let results = rx.collect::<Vec<_>>().await;
+    eprintln!(
+        "Finished collecting from the channel with {} results",
+        results.len()
+    );
+    for command in results {
+        // Don't return empty or duplicate commands
+        if !command.name.is_empty()
+            && !final_response
+                .iter()
+                .any(|cmd: &CommandToRun| cmd.name == command.name && cmd.arg == command.arg)
+        {
+            if SUPPORTED_SLASH_COMMANDS
+                .iter()
+                .any(|supported| &command.name == supported)
+            {
+                final_response.push(command);
+            } else {
+                log::warn!(
+                    "Context inference returned an unrecognized slash command: {:?}",
+                    command
+                );
+            }
+        }
+    }
+
+    // Sort the commands by name (reversed just so that /search appears before /file)
+    final_response.sort_by(|cmd1, cmd2| cmd1.name.cmp(&cmd2.name).reverse());
+
+    Ok(final_response)
+}
diff --git a/crates/assistant/src/slash_command/prompt_after_summary.txt b/crates/assistant/src/slash_command/prompt_after_summary.txt
new file mode 100644
index 00000000000000..fc139a1fcb0c15
--- /dev/null
+++ b/crates/assistant/src/slash_command/prompt_after_summary.txt
@@ -0,0 +1,24 @@
+Actions have a cost, so only include actions that you think
+will be helpful to you in doing a great job answering the
+prompt in the future.
+
+You must respond ONLY with a list of actions you would like to
+perform. Each action should be on its own line, and followed by a space and then its parameter.
+
+Actions can be performed more than once with different parameters.
+Here is an example valid response:
+
+```
+file path/to/my/file.txt
+file path/to/another/file.txt
+search something to search for
+search something else to search for
+```
+
+Once again, do not forget: you must respond ONLY in the format of
+one action per line, and the action name should be followed by
+its parameter. Your response must not include anything other
+than a list of actions, with one action per line, in this format.
+It is extremely important that you do not deviate from this format even slightly!
+
+This is the end of my instructions for how to respond. The rest is the prompt:
diff --git a/crates/assistant/src/slash_command/prompt_before_summary.txt b/crates/assistant/src/slash_command/prompt_before_summary.txt
new file mode 100644
index 00000000000000..5d8db1b8f7903f
--- /dev/null
+++ b/crates/assistant/src/slash_command/prompt_before_summary.txt
@@ -0,0 +1,31 @@
+I'm going to give you a prompt. I don't want you to respond
+to the prompt itself. I want you to figure out which of the following
+actions on my project, if any, would help you answer the prompt.
+
+Here are the actions:
+
+## file
+
+This action's parameter is a file path to one of the files
+in the project. If you ask for this action, I will tell you
+the full contents of the file, so you  can learn all the
+details of the file.
+
+## search
+
+This action's parameter is a string to do a semantic search for
+across the files in the project. (You will have a JSON summary
+of all the files in the project.) It will tell you which files this string
+(or similar strings; it is a semantic search) appear in,
+as well as some context of the lines surrounding each result.
+It's very important that you only use this action when you think
+that searching across the specific files in this project for the query
+in question will be useful. For example, don't use this command to search
+for queries you might put into a general Web search engine, because those
+will be too general to give useful results in this project-specific search.
+
+---
+
+That was the end of the list of actions.
+
+Here is a JSON summary of each of the files in my project:
diff --git a/crates/assistant/src/slash_command/search_command.rs b/crates/assistant/src/slash_command/search_command.rs
index 4da8a5585f3824..3a513ed9ad3784 100644
--- a/crates/assistant/src/slash_command/search_command.rs
+++ b/crates/assistant/src/slash_command/search_command.rs
@@ -8,7 +8,7 @@ use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use feature_flags::FeatureFlag;
 use gpui::{AppContext, Task, WeakView};
 use language::{CodeLabel, LineEnding, LspAdapterDelegate};
-use semantic_index::SemanticIndex;
+use semantic_index::SemanticDb;
 use std::{
     fmt::Write,
     path::PathBuf,
@@ -92,8 +92,11 @@ impl SlashCommand for SearchSlashCommand {
 
         let project = workspace.read(cx).project().clone();
         let fs = project.read(cx).fs().clone();
-        let project_index =
-            cx.update_global(|index: &mut SemanticIndex, cx| index.project_index(project, cx));
+        let Some(project_index) =
+            cx.update_global(|index: &mut SemanticDb, cx| index.project_index(project, cx))
+        else {
+            return Task::ready(Err(anyhow::anyhow!("no project indexer")));
+        };
 
         cx.spawn(|cx| async move {
             let results = project_index
diff --git a/crates/collab/k8s/collab.template.yml b/crates/collab/k8s/collab.template.yml
index dcd935166a7de7..f5e454c3fcf04d 100644
--- a/crates/collab/k8s/collab.template.yml
+++ b/crates/collab/k8s/collab.template.yml
@@ -149,16 +149,16 @@ spec:
                 secretKeyRef:
                   name: google-ai
                   key: api_key
-            - name: QWEN2_7B_API_KEY
+            - name: RUNPOD_API_KEY
               valueFrom:
                 secretKeyRef:
-                  name: hugging-face
+                  name: runpod
                   key: api_key
-            - name: QWEN2_7B_API_URL
+            - name: RUNPOD_API_SUMMARY_URL
               valueFrom:
                 secretKeyRef:
-                  name: hugging-face
-                  key: qwen2_api_url
+                  name: runpod
+                  key: summary
             - name: BLOB_STORE_ACCESS_KEY
               valueFrom:
                 secretKeyRef:
diff --git a/crates/collab/src/db/queries/projects.rs b/crates/collab/src/db/queries/projects.rs
index a6956c84966ea3..c6db54b5729f4f 100644
--- a/crates/collab/src/db/queries/projects.rs
+++ b/crates/collab/src/db/queries/projects.rs
@@ -728,6 +728,11 @@ impl Database {
                         is_ignored: db_entry.is_ignored,
                         is_external: db_entry.is_external,
                         git_status: db_entry.git_status.map(|status| status as i32),
+                        // This is only used in the summarization backlog, so if it's None,
+                        // that just means we won't be able to detect when to resummarize
+                        // based on total number of backlogged bytes - instead, we'd go
+                        // on number of files only. That shouldn't be a huge deal in practice.
+                        size: None,
                         is_fifo: db_entry.is_fifo,
                     });
                 }
diff --git a/crates/collab/src/db/queries/rooms.rs b/crates/collab/src/db/queries/rooms.rs
index 1669ddbb3b7477..635e2d232f087f 100644
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@@ -663,6 +663,11 @@ impl Database {
                             is_ignored: db_entry.is_ignored,
                             is_external: db_entry.is_external,
                             git_status: db_entry.git_status.map(|status| status as i32),
+                            // This is only used in the summarization backlog, so if it's None,
+                            // that just means we won't be able to detect when to resummarize
+                            // based on total number of backlogged bytes - instead, we'd go
+                            // on number of files only. That shouldn't be a huge deal in practice.
+                            size: None,
                             is_fifo: db_entry.is_fifo,
                         });
                     }
diff --git a/crates/collab/src/lib.rs b/crates/collab/src/lib.rs
index 461adc3575badf..81ff3ff21f6926 100644
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -170,8 +170,8 @@ pub struct Config {
     pub anthropic_api_key: Option<Arc<str>>,
     pub anthropic_staff_api_key: Option<Arc<str>>,
     pub llm_closed_beta_model_name: Option<Arc<str>>,
-    pub qwen2_7b_api_key: Option<Arc<str>>,
-    pub qwen2_7b_api_url: Option<Arc<str>>,
+    pub runpod_api_key: Option<Arc<str>>,
+    pub runpod_api_summary_url: Option<Arc<str>>,
     pub zed_client_checksum_seed: Option<String>,
     pub slack_panics_webhook: Option<String>,
     pub auto_join_channel_id: Option<ChannelId>,
@@ -235,8 +235,8 @@ impl Config {
             stripe_api_key: None,
             stripe_price_id: None,
             supermaven_admin_api_key: None,
-            qwen2_7b_api_key: None,
-            qwen2_7b_api_url: None,
+            runpod_api_key: None,
+            runpod_api_summary_url: None,
             user_backfiller_github_access_token: None,
         }
     }
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index e1a345436810ea..def4499ae41bac 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -402,12 +402,12 @@ async fn perform_completion(
         LanguageModelProvider::Zed => {
             let api_key = state
                 .config
-                .qwen2_7b_api_key
+                .runpod_api_key
                 .as_ref()
                 .context("no Qwen2-7B API key configured on the server")?;
             let api_url = state
                 .config
-                .qwen2_7b_api_url
+                .runpod_api_summary_url
                 .as_ref()
                 .context("no Qwen2-7B URL configured on the server")?;
             let chunks = open_ai::stream_completion(
diff --git a/crates/collab/src/llm/db/queries/providers.rs b/crates/collab/src/llm/db/queries/providers.rs
index 8a73b399c67ade..7e51061ceef2ee 100644
--- a/crates/collab/src/llm/db/queries/providers.rs
+++ b/crates/collab/src/llm/db/queries/providers.rs
@@ -1,5 +1,5 @@
 use super::*;
-use sea_orm::QueryOrder;
+use sea_orm::{sea_query::OnConflict, QueryOrder};
 use std::str::FromStr;
 use strum::IntoEnumIterator as _;
 
@@ -99,6 +99,17 @@ impl LlmDatabase {
                     ..Default::default()
                 }
             }))
+            .on_conflict(
+                OnConflict::columns([model::Column::ProviderId, model::Column::Name])
+                    .update_columns([
+                        model::Column::MaxRequestsPerMinute,
+                        model::Column::MaxTokensPerMinute,
+                        model::Column::MaxTokensPerDay,
+                        model::Column::PricePerMillionInputTokens,
+                        model::Column::PricePerMillionOutputTokens,
+                    ])
+                    .to_owned(),
+            )
             .exec_without_returning(&*tx)
             .await?;
             Ok(())
diff --git a/crates/collab/src/llm/db/seed.rs b/crates/collab/src/llm/db/seed.rs
index 55c6c30cd5d8bf..24bc224227c8d2 100644
--- a/crates/collab/src/llm/db/seed.rs
+++ b/crates/collab/src/llm/db/seed.rs
@@ -40,6 +40,15 @@ pub async fn seed_database(_config: &Config, db: &mut LlmDatabase, _force: bool)
             price_per_million_input_tokens: 25,   // $0.25/MTok
             price_per_million_output_tokens: 125, // $1.25/MTok
         },
+        ModelParams {
+            provider: LanguageModelProvider::Zed,
+            name: "Qwen/Qwen2-7B-Instruct".into(),
+            max_requests_per_minute: 5,
+            max_tokens_per_minute: 25_000, // These are arbitrary limits we've set to cap costs; we control this number
+            max_tokens_per_day: 300_000,
+            price_per_million_input_tokens: 25,
+            price_per_million_output_tokens: 125,
+        },
     ])
     .await
 }
diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs
index e691afceda7e08..1421e4c7f7aed7 100644
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -679,8 +679,8 @@ impl TestServer {
                 stripe_api_key: None,
                 stripe_price_id: None,
                 supermaven_admin_api_key: None,
-                qwen2_7b_api_key: None,
-                qwen2_7b_api_url: None,
+                runpod_api_key: None,
+                runpod_api_summary_url: None,
                 user_backfiller_github_access_token: None,
             },
         })
diff --git a/crates/feature_flags/Cargo.toml b/crates/feature_flags/Cargo.toml
index 101e90c6460c98..834e315af37d97 100644
--- a/crates/feature_flags/Cargo.toml
+++ b/crates/feature_flags/Cargo.toml
@@ -13,3 +13,4 @@ path = "src/feature_flags.rs"
 
 [dependencies]
 gpui.workspace = true
+futures.workspace = true
diff --git a/crates/feature_flags/src/feature_flags.rs b/crates/feature_flags/src/feature_flags.rs
index 29768138afe1e1..fb4e192023d914 100644
--- a/crates/feature_flags/src/feature_flags.rs
+++ b/crates/feature_flags/src/feature_flags.rs
@@ -1,4 +1,10 @@
+use futures::{channel::oneshot, FutureExt as _};
 use gpui::{AppContext, Global, Subscription, ViewContext};
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 #[derive(Default)]
 struct FeatureFlags {
@@ -53,6 +59,15 @@ impl FeatureFlag for ZedPro {
     const NAME: &'static str = "zed-pro";
 }
 
+pub struct AutoCommand {}
+impl FeatureFlag for AutoCommand {
+    const NAME: &'static str = "auto-command";
+
+    fn enabled_for_staff() -> bool {
+        false
+    }
+}
+
 pub trait FeatureFlagViewExt<V: 'static> {
     fn observe_flag<T: FeatureFlag, F>(&mut self, callback: F) -> Subscription
     where
@@ -75,6 +90,7 @@ where
 }
 
 pub trait FeatureFlagAppExt {
+    fn wait_for_flag<T: FeatureFlag>(&mut self) -> WaitForFlag;
     fn update_flags(&mut self, staff: bool, flags: Vec<String>);
     fn set_staff(&mut self, staff: bool);
     fn has_flag<T: FeatureFlag>(&self) -> bool;
@@ -82,7 +98,7 @@ pub trait FeatureFlagAppExt {
 
     fn observe_flag<T: FeatureFlag, F>(&mut self, callback: F) -> Subscription
     where
-        F: Fn(bool, &mut AppContext) + 'static;
+        F: FnMut(bool, &mut AppContext) + 'static;
 }
 
 impl FeatureFlagAppExt for AppContext {
@@ -109,13 +125,49 @@ impl FeatureFlagAppExt for AppContext {
             .unwrap_or(false)
     }
 
-    fn observe_flag<T: FeatureFlag, F>(&mut self, callback: F) -> Subscription
+    fn observe_flag<T: FeatureFlag, F>(&mut self, mut callback: F) -> Subscription
     where
-        F: Fn(bool, &mut AppContext) + 'static,
+        F: FnMut(bool, &mut AppContext) + 'static,
     {
         self.observe_global::<FeatureFlags>(move |cx| {
             let feature_flags = cx.global::<FeatureFlags>();
             callback(feature_flags.has_flag::<T>(), cx);
         })
     }
+
+    fn wait_for_flag<T: FeatureFlag>(&mut self) -> WaitForFlag {
+        let (tx, rx) = oneshot::channel::<bool>();
+        let mut tx = Some(tx);
+        let subscription: Option<Subscription>;
+
+        match self.try_global::<FeatureFlags>() {
+            Some(feature_flags) => {
+                subscription = None;
+                tx.take().unwrap().send(feature_flags.has_flag::<T>()).ok();
+            }
+            None => {
+                subscription = Some(self.observe_global::<FeatureFlags>(move |cx| {
+                    let feature_flags = cx.global::<FeatureFlags>();
+                    if let Some(tx) = tx.take() {
+                        tx.send(feature_flags.has_flag::<T>()).ok();
+                    }
+                }));
+            }
+        }
+
+        WaitForFlag(rx, subscription)
+    }
+}
+
+pub struct WaitForFlag(oneshot::Receiver<bool>, Option<Subscription>);
+
+impl Future for WaitForFlag {
+    type Output = bool;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        self.0.poll_unpin(cx).map(|result| {
+            self.1.take();
+            result.unwrap_or(false)
+        })
+    }
 }
diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rs
index 0ec5a4c601371b..b649831fd2de69 100644
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -171,6 +171,7 @@ pub struct Metadata {
     pub mtime: SystemTime,
     pub is_symlink: bool,
     pub is_dir: bool,
+    pub len: u64,
     pub is_fifo: bool,
 }
 
@@ -497,6 +498,7 @@ impl Fs for RealFs {
         Ok(Some(Metadata {
             inode,
             mtime: metadata.modified().unwrap(),
+            len: metadata.len(),
             is_symlink,
             is_dir: metadata.file_type().is_dir(),
             is_fifo,
@@ -800,11 +802,13 @@ enum FakeFsEntry {
     File {
         inode: u64,
         mtime: SystemTime,
+        len: u64,
         content: Vec<u8>,
     },
     Dir {
         inode: u64,
         mtime: SystemTime,
+        len: u64,
         entries: BTreeMap<String, Arc<Mutex<FakeFsEntry>>>,
         git_repo_state: Option<Arc<Mutex<git::repository::FakeGitRepositoryState>>>,
     },
@@ -935,6 +939,7 @@ impl FakeFs {
                 root: Arc::new(Mutex::new(FakeFsEntry::Dir {
                     inode: 0,
                     mtime: SystemTime::UNIX_EPOCH,
+                    len: 0,
                     entries: Default::default(),
                     git_repo_state: None,
                 })),
@@ -969,6 +974,7 @@ impl FakeFs {
                             inode: new_inode,
                             mtime: new_mtime,
                             content: Vec::new(),
+                            len: 0,
                         })));
                     }
                     btree_map::Entry::Occupied(mut e) => match &mut *e.get_mut().lock() {
@@ -1016,6 +1022,7 @@ impl FakeFs {
         let file = Arc::new(Mutex::new(FakeFsEntry::File {
             inode,
             mtime,
+            len: content.len() as u64,
             content,
         }));
         let mut kind = None;
@@ -1369,6 +1376,7 @@ impl Fs for FakeFs {
                     Arc::new(Mutex::new(FakeFsEntry::Dir {
                         inode,
                         mtime,
+                        len: 0,
                         entries: Default::default(),
                         git_repo_state: None,
                     }))
@@ -1391,6 +1399,7 @@ impl Fs for FakeFs {
         let file = Arc::new(Mutex::new(FakeFsEntry::File {
             inode,
             mtime,
+            len: 0,
             content: Vec::new(),
         }));
         let mut kind = Some(PathEventKind::Created);
@@ -1539,6 +1548,7 @@ impl Fs for FakeFs {
                 e.insert(Arc::new(Mutex::new(FakeFsEntry::File {
                     inode,
                     mtime,
+                    len: content.len() as u64,
                     content: Vec::new(),
                 })))
                 .clone(),
@@ -1694,16 +1704,22 @@ impl Fs for FakeFs {
 
             let entry = entry.lock();
             Ok(Some(match &*entry {
-                FakeFsEntry::File { inode, mtime, .. } => Metadata {
+                FakeFsEntry::File {
+                    inode, mtime, len, ..
+                } => Metadata {
                     inode: *inode,
                     mtime: *mtime,
+                    len: *len,
                     is_dir: false,
                     is_symlink,
                     is_fifo: false,
                 },
-                FakeFsEntry::Dir { inode, mtime, .. } => Metadata {
+                FakeFsEntry::Dir {
+                    inode, mtime, len, ..
+                } => Metadata {
                     inode: *inode,
                     mtime: *mtime,
+                    len: *len,
                     is_dir: true,
                     is_symlink,
                     is_fifo: false,
diff --git a/crates/git/src/status.rs b/crates/git/src/status.rs
index e6098ffd3c47bf..6eb98ecefe70d2 100644
--- a/crates/git/src/status.rs
+++ b/crates/git/src/status.rs
@@ -57,7 +57,6 @@ impl GitStatus {
             let stderr = String::from_utf8_lossy(&output.stderr);
             return Err(anyhow!("git status process failed: {}", stderr));
         }
-
         let stdout = String::from_utf8_lossy(&output.stdout);
         let mut entries = stdout
             .split('\0')
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index 452be0a2430dad..1841a1f394627d 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -221,6 +221,10 @@ impl HttpClient for HttpClientWithUrl {
 
 pub fn client(user_agent: Option<String>, proxy: Option<Uri>) -> Arc<dyn HttpClient> {
     let mut builder = isahc::HttpClient::builder()
+        // Some requests to Qwen2 models on Runpod can take 32+ seconds,
+        // especially if there's a cold boot involved. We may need to have
+        // those requests use a different http client, because global timeouts
+        // of 50 and 60 seconds, respectively, would be very high!
         .connect_timeout(Duration::from_secs(5))
         .low_speed_timeout(100, Duration::from_secs(5))
         .proxy(proxy.clone());
diff --git a/crates/language_model/src/model/cloud_model.rs b/crates/language_model/src/model/cloud_model.rs
index f36b6b2788ae05..be0812eab90e70 100644
--- a/crates/language_model/src/model/cloud_model.rs
+++ b/crates/language_model/src/model/cloud_model.rs
@@ -17,14 +17,14 @@ pub enum CloudModel {
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema, EnumIter)]
 pub enum ZedModel {
-    #[serde(rename = "qwen2-7b-instruct")]
+    #[serde(rename = "Qwen/Qwen2-7B-Instruct")]
     Qwen2_7bInstruct,
 }
 
 impl ZedModel {
     pub fn id(&self) -> &str {
         match self {
-            ZedModel::Qwen2_7bInstruct => "qwen2-7b-instruct",
+            ZedModel::Qwen2_7bInstruct => "Qwen/Qwen2-7B-Instruct",
         }
     }
 
diff --git a/crates/language_model/src/provider/anthropic.rs b/crates/language_model/src/provider/anthropic.rs
index eac4ad3021ee1d..9f7135aef7d73f 100644
--- a/crates/language_model/src/provider/anthropic.rs
+++ b/crates/language_model/src/provider/anthropic.rs
@@ -319,7 +319,7 @@ impl AnthropicModel {
         };
 
         async move {
-            let api_key = api_key.ok_or_else(|| anyhow!("missing api key"))?;
+            let api_key = api_key.ok_or_else(|| anyhow!("Missing Anthropic API Key"))?;
             let request = anthropic::stream_completion(
                 http_client.as_ref(),
                 &api_url,
diff --git a/crates/language_model/src/provider/google.rs b/crates/language_model/src/provider/google.rs
index fc4a7a7a3405a0..005f35ff8b1bfe 100644
--- a/crates/language_model/src/provider/google.rs
+++ b/crates/language_model/src/provider/google.rs
@@ -265,7 +265,7 @@ impl LanguageModel for GoogleLanguageModel {
         let low_speed_timeout = settings.low_speed_timeout;
 
         async move {
-            let api_key = api_key.ok_or_else(|| anyhow!("missing api key"))?;
+            let api_key = api_key.ok_or_else(|| anyhow!("Missing Google API key"))?;
             let response = google_ai::count_tokens(
                 http_client.as_ref(),
                 &api_url,
@@ -304,7 +304,7 @@ impl LanguageModel for GoogleLanguageModel {
         };
 
         let future = self.rate_limiter.stream(async move {
-            let api_key = api_key.ok_or_else(|| anyhow!("missing api key"))?;
+            let api_key = api_key.ok_or_else(|| anyhow!("Missing Google API Key"))?;
             let response = stream_generate_content(
                 http_client.as_ref(),
                 &api_url,
diff --git a/crates/language_model/src/provider/open_ai.rs b/crates/language_model/src/provider/open_ai.rs
index 3a371499eb44db..fe5e60caec8a95 100644
--- a/crates/language_model/src/provider/open_ai.rs
+++ b/crates/language_model/src/provider/open_ai.rs
@@ -239,7 +239,7 @@ impl OpenAiLanguageModel {
         };
 
         let future = self.request_limiter.stream(async move {
-            let api_key = api_key.ok_or_else(|| anyhow!("missing api key"))?;
+            let api_key = api_key.ok_or_else(|| anyhow!("Missing OpenAI API Key"))?;
             let request = stream_completion(
                 http_client.as_ref(),
                 &api_url,
diff --git a/crates/language_model/src/registry.rs b/crates/language_model/src/registry.rs
index 589dfe776a8d8c..b3c8ef5f57cc6b 100644
--- a/crates/language_model/src/registry.rs
+++ b/crates/language_model/src/registry.rs
@@ -159,11 +159,13 @@ impl LanguageModelRegistry {
         providers
     }
 
-    pub fn available_models(&self, cx: &AppContext) -> Vec<Arc<dyn LanguageModel>> {
+    pub fn available_models<'a>(
+        &'a self,
+        cx: &'a AppContext,
+    ) -> impl Iterator<Item = Arc<dyn LanguageModel>> + 'a {
         self.providers
             .values()
             .flat_map(|provider| provider.provided_models(cx))
-            .collect()
     }
 
     pub fn provider(&self, id: &LanguageModelProviderId) -> Option<Arc<dyn LanguageModelProvider>> {
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index c77a2170dd01cd..c8e1ce28eb5938 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -1823,6 +1823,7 @@ impl ProjectPanel {
                         path: entry.path.join("\0").into(),
                         inode: 0,
                         mtime: entry.mtime,
+                        size: entry.size,
                         is_ignored: entry.is_ignored,
                         is_external: false,
                         is_private: false,
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index e5d767fffb3fae..f59e8146b6f18c 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -1855,6 +1855,7 @@ message Entry {
     bool is_external = 8;
     optional GitStatus git_status = 9;
     bool is_fifo = 10;
+    optional uint64 size = 11;
 }
 
 message RepositoryEntry {
diff --git a/crates/semantic_index/Cargo.toml b/crates/semantic_index/Cargo.toml
index 4fd3a86b29f702..c8dbb6a9f53dd2 100644
--- a/crates/semantic_index/Cargo.toml
+++ b/crates/semantic_index/Cargo.toml
@@ -19,14 +19,18 @@ crate-type = ["bin"]
 
 [dependencies]
 anyhow.workspace = true
+arrayvec.workspace = true
+blake3.workspace = true
 client.workspace = true
 clock.workspace = true
 collections.workspace = true
+feature_flags.workspace = true
 fs.workspace = true
 futures.workspace = true
 futures-batch.workspace = true
 gpui.workspace = true
 language.workspace = true
+language_model.workspace = true
 log.workspace = true
 heed.workspace = true
 http_client.workspace = true
diff --git a/crates/semantic_index/examples/index.rs b/crates/semantic_index/examples/index.rs
index e536ea1db606d1..977473d1dc38ba 100644
--- a/crates/semantic_index/examples/index.rs
+++ b/crates/semantic_index/examples/index.rs
@@ -4,7 +4,7 @@ use gpui::App;
 use http_client::HttpClientWithUrl;
 use language::language_settings::AllLanguageSettings;
 use project::Project;
-use semantic_index::{OpenAiEmbeddingModel, OpenAiEmbeddingProvider, SemanticIndex};
+use semantic_index::{OpenAiEmbeddingModel, OpenAiEmbeddingProvider, SemanticDb};
 use settings::SettingsStore;
 use std::{
     path::{Path, PathBuf},
@@ -50,7 +50,7 @@ fn main() {
         ));
 
         cx.spawn(|mut cx| async move {
-            let semantic_index = SemanticIndex::new(
+            let semantic_index = SemanticDb::new(
                 PathBuf::from("/tmp/semantic-index-db.mdb"),
                 embedding_provider,
                 &mut cx,
@@ -71,6 +71,7 @@ fn main() {
 
             let project_index = cx
                 .update(|cx| semantic_index.project_index(project.clone(), cx))
+                .unwrap()
                 .unwrap();
 
             let (tx, rx) = oneshot::channel();
diff --git a/crates/semantic_index/src/embedding.rs b/crates/semantic_index/src/embedding.rs
index b5195c891177d4..b05c4ac9da0ef2 100644
--- a/crates/semantic_index/src/embedding.rs
+++ b/crates/semantic_index/src/embedding.rs
@@ -12,6 +12,12 @@ use futures::{future::BoxFuture, FutureExt};
 use serde::{Deserialize, Serialize};
 use std::{fmt, future};
 
+/// Trait for embedding providers. Texts in, vectors out.
+pub trait EmbeddingProvider: Sync + Send {
+    fn embed<'a>(&'a self, texts: &'a [TextToEmbed<'a>]) -> BoxFuture<'a, Result<Vec<Embedding>>>;
+    fn batch_size(&self) -> usize;
+}
+
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Embedding(Vec<f32>);
 
@@ -68,12 +74,6 @@ impl fmt::Display for Embedding {
     }
 }
 
-/// Trait for embedding providers. Texts in, vectors out.
-pub trait EmbeddingProvider: Sync + Send {
-    fn embed<'a>(&'a self, texts: &'a [TextToEmbed<'a>]) -> BoxFuture<'a, Result<Vec<Embedding>>>;
-    fn batch_size(&self) -> usize;
-}
-
 #[derive(Debug)]
 pub struct TextToEmbed<'a> {
     pub text: &'a str,
diff --git a/crates/semantic_index/src/embedding_index.rs b/crates/semantic_index/src/embedding_index.rs
new file mode 100644
index 00000000000000..dd7c58dc11a760
--- /dev/null
+++ b/crates/semantic_index/src/embedding_index.rs
@@ -0,0 +1,469 @@
+use crate::{
+    chunking::{self, Chunk},
+    embedding::{Embedding, EmbeddingProvider, TextToEmbed},
+    indexing::{IndexingEntryHandle, IndexingEntrySet},
+};
+use anyhow::{anyhow, Context as _, Result};
+use collections::Bound;
+use fs::Fs;
+use futures::stream::StreamExt;
+use futures_batch::ChunksTimeoutStreamExt;
+use gpui::{AppContext, Model, Task};
+use heed::types::{SerdeBincode, Str};
+use language::LanguageRegistry;
+use log;
+use project::{Entry, UpdatedEntriesSet, Worktree};
+use serde::{Deserialize, Serialize};
+use smol::channel;
+use std::{
+    cmp::Ordering,
+    future::Future,
+    iter,
+    path::Path,
+    sync::Arc,
+    time::{Duration, SystemTime},
+};
+use util::ResultExt;
+use worktree::Snapshot;
+
+pub struct EmbeddingIndex {
+    worktree: Model<Worktree>,
+    db_connection: heed::Env,
+    db: heed::Database<Str, SerdeBincode<EmbeddedFile>>,
+    fs: Arc<dyn Fs>,
+    language_registry: Arc<LanguageRegistry>,
+    embedding_provider: Arc<dyn EmbeddingProvider>,
+    entry_ids_being_indexed: Arc<IndexingEntrySet>,
+}
+
+impl EmbeddingIndex {
+    pub fn new(
+        worktree: Model<Worktree>,
+        fs: Arc<dyn Fs>,
+        db_connection: heed::Env,
+        embedding_db: heed::Database<Str, SerdeBincode<EmbeddedFile>>,
+        language_registry: Arc<LanguageRegistry>,
+        embedding_provider: Arc<dyn EmbeddingProvider>,
+        entry_ids_being_indexed: Arc<IndexingEntrySet>,
+    ) -> Self {
+        Self {
+            worktree,
+            fs,
+            db_connection,
+            db: embedding_db,
+            language_registry,
+            embedding_provider,
+            entry_ids_being_indexed,
+        }
+    }
+
+    pub fn db(&self) -> &heed::Database<Str, SerdeBincode<EmbeddedFile>> {
+        &self.db
+    }
+
+    pub fn index_entries_changed_on_disk(
+        &self,
+        cx: &AppContext,
+    ) -> impl Future<Output = Result<()>> {
+        let worktree = self.worktree.read(cx).snapshot();
+        let worktree_abs_path = worktree.abs_path().clone();
+        let scan = self.scan_entries(worktree, cx);
+        let chunk = self.chunk_files(worktree_abs_path, scan.updated_entries, cx);
+        let embed = Self::embed_files(self.embedding_provider.clone(), chunk.files, cx);
+        let persist = self.persist_embeddings(scan.deleted_entry_ranges, embed.files, cx);
+        async move {
+            futures::try_join!(scan.task, chunk.task, embed.task, persist)?;
+            Ok(())
+        }
+    }
+
+    pub fn index_updated_entries(
+        &self,
+        updated_entries: UpdatedEntriesSet,
+        cx: &AppContext,
+    ) -> impl Future<Output = Result<()>> {
+        let worktree = self.worktree.read(cx).snapshot();
+        let worktree_abs_path = worktree.abs_path().clone();
+        let scan = self.scan_updated_entries(worktree, updated_entries.clone(), cx);
+        let chunk = self.chunk_files(worktree_abs_path, scan.updated_entries, cx);
+        let embed = Self::embed_files(self.embedding_provider.clone(), chunk.files, cx);
+        let persist = self.persist_embeddings(scan.deleted_entry_ranges, embed.files, cx);
+        async move {
+            futures::try_join!(scan.task, chunk.task, embed.task, persist)?;
+            Ok(())
+        }
+    }
+
+    fn scan_entries(&self, worktree: Snapshot, cx: &AppContext) -> ScanEntries {
+        let (updated_entries_tx, updated_entries_rx) = channel::bounded(512);
+        let (deleted_entry_ranges_tx, deleted_entry_ranges_rx) = channel::bounded(128);
+        let db_connection = self.db_connection.clone();
+        let db = self.db;
+        let entries_being_indexed = self.entry_ids_being_indexed.clone();
+        let task = cx.background_executor().spawn(async move {
+            let txn = db_connection
+                .read_txn()
+                .context("failed to create read transaction")?;
+            let mut db_entries = db
+                .iter(&txn)
+                .context("failed to create iterator")?
+                .move_between_keys()
+                .peekable();
+
+            let mut deletion_range: Option<(Bound<&str>, Bound<&str>)> = None;
+            for entry in worktree.files(false, 0) {
+                log::trace!("scanning for embedding index: {:?}", &entry.path);
+
+                let entry_db_key = db_key_for_path(&entry.path);
+
+                let mut saved_mtime = None;
+                while let Some(db_entry) = db_entries.peek() {
+                    match db_entry {
+                        Ok((db_path, db_embedded_file)) => match (*db_path).cmp(&entry_db_key) {
+                            Ordering::Less => {
+                                if let Some(deletion_range) = deletion_range.as_mut() {
+                                    deletion_range.1 = Bound::Included(db_path);
+                                } else {
+                                    deletion_range =
+                                        Some((Bound::Included(db_path), Bound::Included(db_path)));
+                                }
+
+                                db_entries.next();
+                            }
+                            Ordering::Equal => {
+                                if let Some(deletion_range) = deletion_range.take() {
+                                    deleted_entry_ranges_tx
+                                        .send((
+                                            deletion_range.0.map(ToString::to_string),
+                                            deletion_range.1.map(ToString::to_string),
+                                        ))
+                                        .await?;
+                                }
+                                saved_mtime = db_embedded_file.mtime;
+                                db_entries.next();
+                                break;
+                            }
+                            Ordering::Greater => {
+                                break;
+                            }
+                        },
+                        Err(_) => return Err(db_entries.next().unwrap().unwrap_err())?,
+                    }
+                }
+
+                if entry.mtime != saved_mtime {
+                    let handle = entries_being_indexed.insert(entry.id);
+                    updated_entries_tx.send((entry.clone(), handle)).await?;
+                }
+            }
+
+            if let Some(db_entry) = db_entries.next() {
+                let (db_path, _) = db_entry?;
+                deleted_entry_ranges_tx
+                    .send((Bound::Included(db_path.to_string()), Bound::Unbounded))
+                    .await?;
+            }
+
+            Ok(())
+        });
+
+        ScanEntries {
+            updated_entries: updated_entries_rx,
+            deleted_entry_ranges: deleted_entry_ranges_rx,
+            task,
+        }
+    }
+
+    fn scan_updated_entries(
+        &self,
+        worktree: Snapshot,
+        updated_entries: UpdatedEntriesSet,
+        cx: &AppContext,
+    ) -> ScanEntries {
+        let (updated_entries_tx, updated_entries_rx) = channel::bounded(512);
+        let (deleted_entry_ranges_tx, deleted_entry_ranges_rx) = channel::bounded(128);
+        let entries_being_indexed = self.entry_ids_being_indexed.clone();
+        let task = cx.background_executor().spawn(async move {
+            for (path, entry_id, status) in updated_entries.iter() {
+                match status {
+                    project::PathChange::Added
+                    | project::PathChange::Updated
+                    | project::PathChange::AddedOrUpdated => {
+                        if let Some(entry) = worktree.entry_for_id(*entry_id) {
+                            if entry.is_file() {
+                                let handle = entries_being_indexed.insert(entry.id);
+                                updated_entries_tx.send((entry.clone(), handle)).await?;
+                            }
+                        }
+                    }
+                    project::PathChange::Removed => {
+                        let db_path = db_key_for_path(path);
+                        deleted_entry_ranges_tx
+                            .send((Bound::Included(db_path.clone()), Bound::Included(db_path)))
+                            .await?;
+                    }
+                    project::PathChange::Loaded => {
+                        // Do nothing.
+                    }
+                }
+            }
+
+            Ok(())
+        });
+
+        ScanEntries {
+            updated_entries: updated_entries_rx,
+            deleted_entry_ranges: deleted_entry_ranges_rx,
+            task,
+        }
+    }
+
+    fn chunk_files(
+        &self,
+        worktree_abs_path: Arc<Path>,
+        entries: channel::Receiver<(Entry, IndexingEntryHandle)>,
+        cx: &AppContext,
+    ) -> ChunkFiles {
+        let language_registry = self.language_registry.clone();
+        let fs = self.fs.clone();
+        let (chunked_files_tx, chunked_files_rx) = channel::bounded(2048);
+        let task = cx.spawn(|cx| async move {
+            cx.background_executor()
+                .scoped(|cx| {
+                    for _ in 0..cx.num_cpus() {
+                        cx.spawn(async {
+                            while let Ok((entry, handle)) = entries.recv().await {
+                                let entry_abs_path = worktree_abs_path.join(&entry.path);
+                                match fs.load(&entry_abs_path).await {
+                                    Ok(text) => {
+                                        let language = language_registry
+                                            .language_for_file_path(&entry.path)
+                                            .await
+                                            .ok();
+                                        let chunked_file = ChunkedFile {
+                                            chunks: chunking::chunk_text(
+                                                &text,
+                                                language.as_ref(),
+                                                &entry.path,
+                                            ),
+                                            handle,
+                                            path: entry.path,
+                                            mtime: entry.mtime,
+                                            text,
+                                        };
+
+                                        if chunked_files_tx.send(chunked_file).await.is_err() {
+                                            return;
+                                        }
+                                    }
+                                    Err(_)=> {
+                                        log::error!("Failed to read contents into a UTF-8 string: {entry_abs_path:?}");
+                                    }
+                                }
+                            }
+                        });
+                    }
+                })
+                .await;
+            Ok(())
+        });
+
+        ChunkFiles {
+            files: chunked_files_rx,
+            task,
+        }
+    }
+
+    pub fn embed_files(
+        embedding_provider: Arc<dyn EmbeddingProvider>,
+        chunked_files: channel::Receiver<ChunkedFile>,
+        cx: &AppContext,
+    ) -> EmbedFiles {
+        let embedding_provider = embedding_provider.clone();
+        let (embedded_files_tx, embedded_files_rx) = channel::bounded(512);
+        let task = cx.background_executor().spawn(async move {
+            let mut chunked_file_batches =
+                chunked_files.chunks_timeout(512, Duration::from_secs(2));
+            while let Some(chunked_files) = chunked_file_batches.next().await {
+                // View the batch of files as a vec of chunks
+                // Flatten out to a vec of chunks that we can subdivide into batch sized pieces
+                // Once those are done, reassemble them back into the files in which they belong
+                // If any embeddings fail for a file, the entire file is discarded
+
+                let chunks: Vec<TextToEmbed> = chunked_files
+                    .iter()
+                    .flat_map(|file| {
+                        file.chunks.iter().map(|chunk| TextToEmbed {
+                            text: &file.text[chunk.range.clone()],
+                            digest: chunk.digest,
+                        })
+                    })
+                    .collect::<Vec<_>>();
+
+                let mut embeddings: Vec<Option<Embedding>> = Vec::new();
+                for embedding_batch in chunks.chunks(embedding_provider.batch_size()) {
+                    if let Some(batch_embeddings) =
+                        embedding_provider.embed(embedding_batch).await.log_err()
+                    {
+                        if batch_embeddings.len() == embedding_batch.len() {
+                            embeddings.extend(batch_embeddings.into_iter().map(Some));
+                            continue;
+                        }
+                        log::error!(
+                            "embedding provider returned unexpected embedding count {}, expected {}",
+                            batch_embeddings.len(), embedding_batch.len()
+                        );
+                    }
+
+                    embeddings.extend(iter::repeat(None).take(embedding_batch.len()));
+                }
+
+                let mut embeddings = embeddings.into_iter();
+                for chunked_file in chunked_files {
+                    let mut embedded_file = EmbeddedFile {
+                        path: chunked_file.path,
+                        mtime: chunked_file.mtime,
+                        chunks: Vec::new(),
+                    };
+
+                    let mut embedded_all_chunks = true;
+                    for (chunk, embedding) in
+                        chunked_file.chunks.into_iter().zip(embeddings.by_ref())
+                    {
+                        if let Some(embedding) = embedding {
+                            embedded_file
+                                .chunks
+                                .push(EmbeddedChunk { chunk, embedding });
+                        } else {
+                            embedded_all_chunks = false;
+                        }
+                    }
+
+                    if embedded_all_chunks {
+                        embedded_files_tx
+                            .send((embedded_file, chunked_file.handle))
+                            .await?;
+                    }
+                }
+            }
+            Ok(())
+        });
+
+        EmbedFiles {
+            files: embedded_files_rx,
+            task,
+        }
+    }
+
+    fn persist_embeddings(
+        &self,
+        mut deleted_entry_ranges: channel::Receiver<(Bound<String>, Bound<String>)>,
+        embedded_files: channel::Receiver<(EmbeddedFile, IndexingEntryHandle)>,
+        cx: &AppContext,
+    ) -> Task<Result<()>> {
+        let db_connection = self.db_connection.clone();
+        let db = self.db;
+        cx.background_executor().spawn(async move {
+            while let Some(deletion_range) = deleted_entry_ranges.next().await {
+                let mut txn = db_connection.write_txn()?;
+                let start = deletion_range.0.as_ref().map(|start| start.as_str());
+                let end = deletion_range.1.as_ref().map(|end| end.as_str());
+                log::debug!("deleting embeddings in range {:?}", &(start, end));
+                db.delete_range(&mut txn, &(start, end))?;
+                txn.commit()?;
+            }
+
+            let mut embedded_files = embedded_files.chunks_timeout(4096, Duration::from_secs(2));
+            while let Some(embedded_files) = embedded_files.next().await {
+                let mut txn = db_connection.write_txn()?;
+                for (file, _) in &embedded_files {
+                    log::debug!("saving embedding for file {:?}", file.path);
+                    let key = db_key_for_path(&file.path);
+                    db.put(&mut txn, &key, file)?;
+                }
+                txn.commit()?;
+
+                drop(embedded_files);
+                log::debug!("committed");
+            }
+
+            Ok(())
+        })
+    }
+
+    pub fn paths(&self, cx: &AppContext) -> Task<Result<Vec<Arc<Path>>>> {
+        let connection = self.db_connection.clone();
+        let db = self.db;
+        cx.background_executor().spawn(async move {
+            let tx = connection
+                .read_txn()
+                .context("failed to create read transaction")?;
+            let result = db
+                .iter(&tx)?
+                .map(|entry| Ok(entry?.1.path.clone()))
+                .collect::<Result<Vec<Arc<Path>>>>();
+            drop(tx);
+            result
+        })
+    }
+
+    pub fn chunks_for_path(
+        &self,
+        path: Arc<Path>,
+        cx: &AppContext,
+    ) -> Task<Result<Vec<EmbeddedChunk>>> {
+        let connection = self.db_connection.clone();
+        let db = self.db;
+        cx.background_executor().spawn(async move {
+            let tx = connection
+                .read_txn()
+                .context("failed to create read transaction")?;
+            Ok(db
+                .get(&tx, &db_key_for_path(&path))?
+                .ok_or_else(|| anyhow!("no such path"))?
+                .chunks
+                .clone())
+        })
+    }
+}
+
+struct ScanEntries {
+    updated_entries: channel::Receiver<(Entry, IndexingEntryHandle)>,
+    deleted_entry_ranges: channel::Receiver<(Bound<String>, Bound<String>)>,
+    task: Task<Result<()>>,
+}
+
+struct ChunkFiles {
+    files: channel::Receiver<ChunkedFile>,
+    task: Task<Result<()>>,
+}
+
+pub struct ChunkedFile {
+    pub path: Arc<Path>,
+    pub mtime: Option<SystemTime>,
+    pub handle: IndexingEntryHandle,
+    pub text: String,
+    pub chunks: Vec<Chunk>,
+}
+
+pub struct EmbedFiles {
+    pub files: channel::Receiver<(EmbeddedFile, IndexingEntryHandle)>,
+    pub task: Task<Result<()>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct EmbeddedFile {
+    pub path: Arc<Path>,
+    pub mtime: Option<SystemTime>,
+    pub chunks: Vec<EmbeddedChunk>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct EmbeddedChunk {
+    pub chunk: Chunk,
+    pub embedding: Embedding,
+}
+
+fn db_key_for_path(path: &Arc<Path>) -> String {
+    path.to_string_lossy().replace('/', "\0")
+}
diff --git a/crates/semantic_index/src/indexing.rs b/crates/semantic_index/src/indexing.rs
new file mode 100644
index 00000000000000..aca9504891d0f7
--- /dev/null
+++ b/crates/semantic_index/src/indexing.rs
@@ -0,0 +1,49 @@
+use collections::HashSet;
+use parking_lot::Mutex;
+use project::ProjectEntryId;
+use smol::channel;
+use std::sync::{Arc, Weak};
+
+/// The set of entries that are currently being indexed.
+pub struct IndexingEntrySet {
+    entry_ids: Mutex<HashSet<ProjectEntryId>>,
+    tx: channel::Sender<()>,
+}
+
+/// When dropped, removes the entry from the set of entries that are being indexed.
+#[derive(Clone)]
+pub(crate) struct IndexingEntryHandle {
+    entry_id: ProjectEntryId,
+    set: Weak<IndexingEntrySet>,
+}
+
+impl IndexingEntrySet {
+    pub fn new(tx: channel::Sender<()>) -> Self {
+        Self {
+            entry_ids: Default::default(),
+            tx,
+        }
+    }
+
+    pub fn insert(self: &Arc<Self>, entry_id: ProjectEntryId) -> IndexingEntryHandle {
+        self.entry_ids.lock().insert(entry_id);
+        self.tx.send_blocking(()).ok();
+        IndexingEntryHandle {
+            entry_id,
+            set: Arc::downgrade(self),
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.entry_ids.lock().len()
+    }
+}
+
+impl Drop for IndexingEntryHandle {
+    fn drop(&mut self) {
+        if let Some(set) = self.set.upgrade() {
+            set.tx.send_blocking(()).ok();
+            set.entry_ids.lock().remove(&self.entry_id);
+        }
+    }
+}
diff --git a/crates/semantic_index/src/project_index.rs b/crates/semantic_index/src/project_index.rs
new file mode 100644
index 00000000000000..84a72c1a3d8c61
--- /dev/null
+++ b/crates/semantic_index/src/project_index.rs
@@ -0,0 +1,523 @@
+use crate::{
+    embedding::{EmbeddingProvider, TextToEmbed},
+    summary_index::FileSummary,
+    worktree_index::{WorktreeIndex, WorktreeIndexHandle},
+};
+use anyhow::{anyhow, Context, Result};
+use collections::HashMap;
+use fs::Fs;
+use futures::{stream::StreamExt, FutureExt};
+use gpui::{
+    AppContext, Entity, EntityId, EventEmitter, Model, ModelContext, Subscription, Task, WeakModel,
+};
+use language::LanguageRegistry;
+use log;
+use project::{Project, Worktree, WorktreeId};
+use serde::{Deserialize, Serialize};
+use smol::channel;
+use std::{cmp::Ordering, future::Future, num::NonZeroUsize, ops::Range, path::Path, sync::Arc};
+use util::ResultExt;
+
+#[derive(Debug)]
+pub struct SearchResult {
+    pub worktree: Model<Worktree>,
+    pub path: Arc<Path>,
+    pub range: Range<usize>,
+    pub score: f32,
+}
+
+pub struct WorktreeSearchResult {
+    pub worktree_id: WorktreeId,
+    pub path: Arc<Path>,
+    pub range: Range<usize>,
+    pub score: f32,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+pub enum Status {
+    Idle,
+    Loading,
+    Scanning { remaining_count: NonZeroUsize },
+}
+
+pub struct ProjectIndex {
+    db_connection: heed::Env,
+    project: WeakModel<Project>,
+    worktree_indices: HashMap<EntityId, WorktreeIndexHandle>,
+    language_registry: Arc<LanguageRegistry>,
+    fs: Arc<dyn Fs>,
+    last_status: Status,
+    status_tx: channel::Sender<()>,
+    embedding_provider: Arc<dyn EmbeddingProvider>,
+    _maintain_status: Task<()>,
+    _subscription: Subscription,
+}
+
+impl ProjectIndex {
+    pub fn new(
+        project: Model<Project>,
+        db_connection: heed::Env,
+        embedding_provider: Arc<dyn EmbeddingProvider>,
+        cx: &mut ModelContext<Self>,
+    ) -> Self {
+        let language_registry = project.read(cx).languages().clone();
+        let fs = project.read(cx).fs().clone();
+        let (status_tx, mut status_rx) = channel::unbounded();
+        let mut this = ProjectIndex {
+            db_connection,
+            project: project.downgrade(),
+            worktree_indices: HashMap::default(),
+            language_registry,
+            fs,
+            status_tx,
+            last_status: Status::Idle,
+            embedding_provider,
+            _subscription: cx.subscribe(&project, Self::handle_project_event),
+            _maintain_status: cx.spawn(|this, mut cx| async move {
+                while status_rx.next().await.is_some() {
+                    if this
+                        .update(&mut cx, |this, cx| this.update_status(cx))
+                        .is_err()
+                    {
+                        break;
+                    }
+                }
+            }),
+        };
+        this.update_worktree_indices(cx);
+        this
+    }
+
+    pub fn status(&self) -> Status {
+        self.last_status
+    }
+
+    pub fn project(&self) -> WeakModel<Project> {
+        self.project.clone()
+    }
+
+    pub fn fs(&self) -> Arc<dyn Fs> {
+        self.fs.clone()
+    }
+
+    fn handle_project_event(
+        &mut self,
+        _: Model<Project>,
+        event: &project::Event,
+        cx: &mut ModelContext<Self>,
+    ) {
+        match event {
+            project::Event::WorktreeAdded | project::Event::WorktreeRemoved(_) => {
+                self.update_worktree_indices(cx);
+            }
+            _ => {}
+        }
+    }
+
+    fn update_worktree_indices(&mut self, cx: &mut ModelContext<Self>) {
+        let Some(project) = self.project.upgrade() else {
+            return;
+        };
+
+        let worktrees = project
+            .read(cx)
+            .visible_worktrees(cx)
+            .filter_map(|worktree| {
+                if worktree.read(cx).is_local() {
+                    Some((worktree.entity_id(), worktree))
+                } else {
+                    None
+                }
+            })
+            .collect::<HashMap<_, _>>();
+
+        self.worktree_indices
+            .retain(|worktree_id, _| worktrees.contains_key(worktree_id));
+        for (worktree_id, worktree) in worktrees {
+            self.worktree_indices.entry(worktree_id).or_insert_with(|| {
+                let worktree_index = WorktreeIndex::load(
+                    worktree.clone(),
+                    self.db_connection.clone(),
+                    self.language_registry.clone(),
+                    self.fs.clone(),
+                    self.status_tx.clone(),
+                    self.embedding_provider.clone(),
+                    cx,
+                );
+
+                let load_worktree = cx.spawn(|this, mut cx| async move {
+                    let result = match worktree_index.await {
+                        Ok(worktree_index) => {
+                            this.update(&mut cx, |this, _| {
+                                this.worktree_indices.insert(
+                                    worktree_id,
+                                    WorktreeIndexHandle::Loaded {
+                                        index: worktree_index.clone(),
+                                    },
+                                );
+                            })?;
+                            Ok(worktree_index)
+                        }
+                        Err(error) => {
+                            this.update(&mut cx, |this, _cx| {
+                                this.worktree_indices.remove(&worktree_id)
+                            })?;
+                            Err(Arc::new(error))
+                        }
+                    };
+
+                    this.update(&mut cx, |this, cx| this.update_status(cx))?;
+
+                    result
+                });
+
+                WorktreeIndexHandle::Loading {
+                    index: load_worktree.shared(),
+                }
+            });
+        }
+
+        self.update_status(cx);
+    }
+
+    fn update_status(&mut self, cx: &mut ModelContext<Self>) {
+        let mut indexing_count = 0;
+        let mut any_loading = false;
+
+        for index in self.worktree_indices.values_mut() {
+            match index {
+                WorktreeIndexHandle::Loading { .. } => {
+                    any_loading = true;
+                    break;
+                }
+                WorktreeIndexHandle::Loaded { index, .. } => {
+                    indexing_count += index.read(cx).entry_ids_being_indexed().len();
+                }
+            }
+        }
+
+        let status = if any_loading {
+            Status::Loading
+        } else if let Some(remaining_count) = NonZeroUsize::new(indexing_count) {
+            Status::Scanning { remaining_count }
+        } else {
+            Status::Idle
+        };
+
+        if status != self.last_status {
+            self.last_status = status;
+            cx.emit(status);
+        }
+    }
+
+    pub fn search(
+        &self,
+        query: String,
+        limit: usize,
+        cx: &AppContext,
+    ) -> Task<Result<Vec<SearchResult>>> {
+        let (chunks_tx, chunks_rx) = channel::bounded(1024);
+        let mut worktree_scan_tasks = Vec::new();
+        for worktree_index in self.worktree_indices.values() {
+            let worktree_index = worktree_index.clone();
+            let chunks_tx = chunks_tx.clone();
+            worktree_scan_tasks.push(cx.spawn(|cx| async move {
+                let index = match worktree_index {
+                    WorktreeIndexHandle::Loading { index } => {
+                        index.clone().await.map_err(|error| anyhow!(error))?
+                    }
+                    WorktreeIndexHandle::Loaded { index } => index.clone(),
+                };
+
+                index
+                    .read_with(&cx, |index, cx| {
+                        let worktree_id = index.worktree().read(cx).id();
+                        let db_connection = index.db_connection().clone();
+                        let db = *index.embedding_index().db();
+                        cx.background_executor().spawn(async move {
+                            let txn = db_connection
+                                .read_txn()
+                                .context("failed to create read transaction")?;
+                            let db_entries = db.iter(&txn).context("failed to iterate database")?;
+                            for db_entry in db_entries {
+                                let (_key, db_embedded_file) = db_entry?;
+                                for chunk in db_embedded_file.chunks {
+                                    chunks_tx
+                                        .send((worktree_id, db_embedded_file.path.clone(), chunk))
+                                        .await?;
+                                }
+                            }
+                            anyhow::Ok(())
+                        })
+                    })?
+                    .await
+            }));
+        }
+        drop(chunks_tx);
+
+        let project = self.project.clone();
+        let embedding_provider = self.embedding_provider.clone();
+        cx.spawn(|cx| async move {
+            #[cfg(debug_assertions)]
+            let embedding_query_start = std::time::Instant::now();
+            log::info!("Searching for {query}");
+
+            let query_embeddings = embedding_provider
+                .embed(&[TextToEmbed::new(&query)])
+                .await?;
+            let query_embedding = query_embeddings
+                .into_iter()
+                .next()
+                .ok_or_else(|| anyhow!("no embedding for query"))?;
+
+            let mut results_by_worker = Vec::new();
+            for _ in 0..cx.background_executor().num_cpus() {
+                results_by_worker.push(Vec::<WorktreeSearchResult>::new());
+            }
+
+            #[cfg(debug_assertions)]
+            let search_start = std::time::Instant::now();
+
+            cx.background_executor()
+                .scoped(|cx| {
+                    for results in results_by_worker.iter_mut() {
+                        cx.spawn(async {
+                            while let Ok((worktree_id, path, chunk)) = chunks_rx.recv().await {
+                                let score = chunk.embedding.similarity(&query_embedding);
+                                let ix = match results.binary_search_by(|probe| {
+                                    score.partial_cmp(&probe.score).unwrap_or(Ordering::Equal)
+                                }) {
+                                    Ok(ix) | Err(ix) => ix,
+                                };
+                                results.insert(
+                                    ix,
+                                    WorktreeSearchResult {
+                                        worktree_id,
+                                        path: path.clone(),
+                                        range: chunk.chunk.range.clone(),
+                                        score,
+                                    },
+                                );
+                                results.truncate(limit);
+                            }
+                        });
+                    }
+                })
+                .await;
+
+            for scan_task in futures::future::join_all(worktree_scan_tasks).await {
+                scan_task.log_err();
+            }
+
+            project.read_with(&cx, |project, cx| {
+                let mut search_results = Vec::with_capacity(results_by_worker.len() * limit);
+                for worker_results in results_by_worker {
+                    search_results.extend(worker_results.into_iter().filter_map(|result| {
+                        Some(SearchResult {
+                            worktree: project.worktree_for_id(result.worktree_id, cx)?,
+                            path: result.path,
+                            range: result.range,
+                            score: result.score,
+                        })
+                    }));
+                }
+                search_results.sort_unstable_by(|a, b| {
+                    b.score.partial_cmp(&a.score).unwrap_or(Ordering::Equal)
+                });
+                search_results.truncate(limit);
+
+                #[cfg(debug_assertions)]
+                {
+                    let search_elapsed = search_start.elapsed();
+                    log::debug!(
+                        "searched {} entries in {:?}",
+                        search_results.len(),
+                        search_elapsed
+                    );
+                    let embedding_query_elapsed = embedding_query_start.elapsed();
+                    log::debug!("embedding query took {:?}", embedding_query_elapsed);
+                }
+
+                search_results
+            })
+        })
+    }
+
+    #[cfg(test)]
+    pub fn path_count(&self, cx: &AppContext) -> Result<u64> {
+        let mut result = 0;
+        for worktree_index in self.worktree_indices.values() {
+            if let WorktreeIndexHandle::Loaded { index, .. } = worktree_index {
+                result += index.read(cx).path_count()?;
+            }
+        }
+        Ok(result)
+    }
+
+    pub(crate) fn worktree_index(
+        &self,
+        worktree_id: WorktreeId,
+        cx: &AppContext,
+    ) -> Option<Model<WorktreeIndex>> {
+        for index in self.worktree_indices.values() {
+            if let WorktreeIndexHandle::Loaded { index, .. } = index {
+                if index.read(cx).worktree().read(cx).id() == worktree_id {
+                    return Some(index.clone());
+                }
+            }
+        }
+        None
+    }
+
+    pub(crate) fn worktree_indices(&self, cx: &AppContext) -> Vec<Model<WorktreeIndex>> {
+        let mut result = self
+            .worktree_indices
+            .values()
+            .filter_map(|index| {
+                if let WorktreeIndexHandle::Loaded { index, .. } = index {
+                    Some(index.clone())
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+        result.sort_by_key(|index| index.read(cx).worktree().read(cx).id());
+        result
+    }
+
+    pub fn all_summaries(&self, cx: &AppContext) -> Task<Result<Vec<FileSummary>>> {
+        let (summaries_tx, summaries_rx) = channel::bounded(1024);
+        let mut worktree_scan_tasks = Vec::new();
+        for worktree_index in self.worktree_indices.values() {
+            let worktree_index = worktree_index.clone();
+            let summaries_tx: channel::Sender<(String, String)> = summaries_tx.clone();
+            worktree_scan_tasks.push(cx.spawn(|cx| async move {
+                let index = match worktree_index {
+                    WorktreeIndexHandle::Loading { index } => {
+                        index.clone().await.map_err(|error| anyhow!(error))?
+                    }
+                    WorktreeIndexHandle::Loaded { index } => index.clone(),
+                };
+
+                index
+                    .read_with(&cx, |index, cx| {
+                        let db_connection = index.db_connection().clone();
+                        let summary_index = index.summary_index();
+                        let file_digest_db = summary_index.file_digest_db();
+                        let summary_db = summary_index.summary_db();
+
+                        cx.background_executor().spawn(async move {
+                            let txn = db_connection
+                                .read_txn()
+                                .context("failed to create db read transaction")?;
+                            let db_entries = file_digest_db
+                                .iter(&txn)
+                                .context("failed to iterate database")?;
+                            for db_entry in db_entries {
+                                let (file_path, db_file) = db_entry?;
+
+                                match summary_db.get(&txn, &db_file.digest) {
+                                    Ok(opt_summary) => {
+                                        // Currently, we only use summaries we already have. If the file hasn't been
+                                        // summarized yet, then we skip it and don't include it in the inferred context.
+                                        // If we want to do just-in-time summarization, this would be the place to do it!
+                                        if let Some(summary) = opt_summary {
+                                            summaries_tx
+                                                .send((file_path.to_string(), summary.to_string()))
+                                                .await?;
+                                        } else {
+                                            log::warn!("No summary found for {:?}", &db_file);
+                                        }
+                                    }
+                                    Err(err) => {
+                                        log::error!(
+                                            "Error reading from summary database: {:?}",
+                                            err
+                                        );
+                                    }
+                                }
+                            }
+                            anyhow::Ok(())
+                        })
+                    })?
+                    .await
+            }));
+        }
+        drop(summaries_tx);
+
+        let project = self.project.clone();
+        cx.spawn(|cx| async move {
+            let mut results_by_worker = Vec::new();
+            for _ in 0..cx.background_executor().num_cpus() {
+                results_by_worker.push(Vec::<FileSummary>::new());
+            }
+
+            cx.background_executor()
+                .scoped(|cx| {
+                    for results in results_by_worker.iter_mut() {
+                        cx.spawn(async {
+                            while let Ok((filename, summary)) = summaries_rx.recv().await {
+                                results.push(FileSummary { filename, summary });
+                            }
+                        });
+                    }
+                })
+                .await;
+
+            for scan_task in futures::future::join_all(worktree_scan_tasks).await {
+                scan_task.log_err();
+            }
+
+            project.read_with(&cx, |_project, _cx| {
+                results_by_worker.into_iter().flatten().collect()
+            })
+        })
+    }
+
+    /// Empty out the backlogs of all the worktrees in the project
+    pub fn flush_summary_backlogs(&self, cx: &AppContext) -> impl Future<Output = ()> {
+        let flush_start = std::time::Instant::now();
+
+        futures::future::join_all(self.worktree_indices.values().map(|worktree_index| {
+            let worktree_index = worktree_index.clone();
+
+            cx.spawn(|cx| async move {
+                let index = match worktree_index {
+                    WorktreeIndexHandle::Loading { index } => {
+                        index.clone().await.map_err(|error| anyhow!(error))?
+                    }
+                    WorktreeIndexHandle::Loaded { index } => index.clone(),
+                };
+                let worktree_abs_path =
+                    cx.update(|cx| index.read(cx).worktree().read(cx).abs_path())?;
+
+                index
+                    .read_with(&cx, |index, cx| {
+                        cx.background_executor()
+                            .spawn(index.summary_index().flush_backlog(worktree_abs_path, cx))
+                    })?
+                    .await
+            })
+        }))
+        .map(move |results| {
+            // Log any errors, but don't block the user. These summaries are supposed to
+            // improve quality by providing extra context, but they aren't hard requirements!
+            for result in results {
+                if let Err(err) = result {
+                    log::error!("Error flushing summary backlog: {:?}", err);
+                }
+            }
+
+            log::info!("Summary backlog flushed in {:?}", flush_start.elapsed());
+        })
+    }
+
+    pub fn remaining_summaries(&self, cx: &mut ModelContext<Self>) -> usize {
+        self.worktree_indices(cx)
+            .iter()
+            .map(|index| index.read(cx).summary_index().backlog_len())
+            .sum()
+    }
+}
+
+impl EventEmitter<Status> for ProjectIndex {}
diff --git a/crates/semantic_index/src/project_index_debug_view.rs b/crates/semantic_index/src/project_index_debug_view.rs
index e5881a24e71e61..d6628064ac0aee 100644
--- a/crates/semantic_index/src/project_index_debug_view.rs
+++ b/crates/semantic_index/src/project_index_debug_view.rs
@@ -55,8 +55,12 @@ impl ProjectIndexDebugView {
             for index in worktree_indices {
                 let (root_path, worktree_id, worktree_paths) =
                     index.read_with(&cx, |index, cx| {
-                        let worktree = index.worktree.read(cx);
-                        (worktree.abs_path(), worktree.id(), index.paths(cx))
+                        let worktree = index.worktree().read(cx);
+                        (
+                            worktree.abs_path(),
+                            worktree.id(),
+                            index.embedding_index().paths(cx),
+                        )
                     })?;
                 rows.push(Row::Worktree(root_path));
                 rows.extend(
@@ -82,10 +86,12 @@ impl ProjectIndexDebugView {
         cx: &mut ViewContext<Self>,
     ) -> Option<()> {
         let project_index = self.index.read(cx);
-        let fs = project_index.fs.clone();
+        let fs = project_index.fs().clone();
         let worktree_index = project_index.worktree_index(worktree_id, cx)?.read(cx);
-        let root_path = worktree_index.worktree.read(cx).abs_path();
-        let chunks = worktree_index.chunks_for_path(file_path.clone(), cx);
+        let root_path = worktree_index.worktree().read(cx).abs_path();
+        let chunks = worktree_index
+            .embedding_index()
+            .chunks_for_path(file_path.clone(), cx);
 
         cx.spawn(|this, mut cx| async move {
             let chunks = chunks.await?;
diff --git a/crates/semantic_index/src/semantic_index.rs b/crates/semantic_index/src/semantic_index.rs
index fad3a5d3e8554b..f2b325ead690b3 100644
--- a/crates/semantic_index/src/semantic_index.rs
+++ b/crates/semantic_index/src/semantic_index.rs
@@ -1,48 +1,35 @@
 mod chunking;
 mod embedding;
+mod embedding_index;
+mod indexing;
+mod project_index;
 mod project_index_debug_view;
+mod summary_backlog;
+mod summary_index;
+mod worktree_index;
+
+use anyhow::{Context as _, Result};
+use collections::HashMap;
+use gpui::{AppContext, AsyncAppContext, BorrowAppContext, Context, Global, Model, WeakModel};
+use project::Project;
+use project_index::ProjectIndex;
+use std::{path::PathBuf, sync::Arc};
+use ui::ViewContext;
+use workspace::Workspace;
 
-use anyhow::{anyhow, Context as _, Result};
-use chunking::{chunk_text, Chunk};
-use collections::{Bound, HashMap, HashSet};
 pub use embedding::*;
-use fs::Fs;
-use futures::{future::Shared, stream::StreamExt, FutureExt};
-use futures_batch::ChunksTimeoutStreamExt;
-use gpui::{
-    AppContext, AsyncAppContext, BorrowAppContext, Context, Entity, EntityId, EventEmitter, Global,
-    Model, ModelContext, Subscription, Task, WeakModel,
-};
-use heed::types::{SerdeBincode, Str};
-use language::LanguageRegistry;
-use parking_lot::Mutex;
-use project::{Entry, Project, ProjectEntryId, UpdatedEntriesSet, Worktree, WorktreeId};
-use serde::{Deserialize, Serialize};
-use smol::channel;
-use std::{
-    cmp::Ordering,
-    future::Future,
-    iter,
-    num::NonZeroUsize,
-    ops::Range,
-    path::{Path, PathBuf},
-    sync::{Arc, Weak},
-    time::{Duration, SystemTime},
-};
-use util::ResultExt;
-use worktree::Snapshot;
-
 pub use project_index_debug_view::ProjectIndexDebugView;
+pub use summary_index::FileSummary;
 
-pub struct SemanticIndex {
+pub struct SemanticDb {
     embedding_provider: Arc<dyn EmbeddingProvider>,
     db_connection: heed::Env,
     project_indices: HashMap<WeakModel<Project>, Model<ProjectIndex>>,
 }
 
-impl Global for SemanticIndex {}
+impl Global for SemanticDb {}
 
-impl SemanticIndex {
+impl SemanticDb {
     pub async fn new(
         db_path: PathBuf,
         embedding_provider: Arc<dyn EmbeddingProvider>,
@@ -62,7 +49,45 @@ impl SemanticIndex {
             .await
             .context("opening database connection")?;
 
-        Ok(SemanticIndex {
+        cx.update(|cx| {
+            cx.observe_new_views(
+                |workspace: &mut Workspace, cx: &mut ViewContext<Workspace>| {
+                    let project = workspace.project().clone();
+
+                    if cx.has_global::<SemanticDb>() {
+                        cx.update_global::<SemanticDb, _>(|this, cx| {
+                            let project_index = cx.new_model(|cx| {
+                                ProjectIndex::new(
+                                    project.clone(),
+                                    this.db_connection.clone(),
+                                    this.embedding_provider.clone(),
+                                    cx,
+                                )
+                            });
+
+                            let project_weak = project.downgrade();
+                            this.project_indices
+                                .insert(project_weak.clone(), project_index);
+
+                            cx.on_release(move |_, _, cx| {
+                                if cx.has_global::<SemanticDb>() {
+                                    cx.update_global::<SemanticDb, _>(|this, _| {
+                                        this.project_indices.remove(&project_weak);
+                                    })
+                                }
+                            })
+                            .detach();
+                        })
+                    } else {
+                        log::info!("No SemanticDb, skipping project index")
+                    }
+                },
+            )
+            .detach();
+        })
+        .ok();
+
+        Ok(SemanticDb {
             db_connection,
             embedding_provider,
             project_indices: HashMap::default(),
@@ -72,985 +97,50 @@ impl SemanticIndex {
     pub fn project_index(
         &mut self,
         project: Model<Project>,
-        cx: &mut AppContext,
-    ) -> Model<ProjectIndex> {
-        let project_weak = project.downgrade();
-        project.update(cx, move |_, cx| {
-            cx.on_release(move |_, cx| {
-                if cx.has_global::<SemanticIndex>() {
-                    cx.update_global::<SemanticIndex, _>(|this, _| {
-                        this.project_indices.remove(&project_weak);
-                    })
-                }
-            })
-            .detach();
-        });
-
-        self.project_indices
-            .entry(project.downgrade())
-            .or_insert_with(|| {
-                cx.new_model(|cx| {
-                    ProjectIndex::new(
-                        project,
-                        self.db_connection.clone(),
-                        self.embedding_provider.clone(),
-                        cx,
-                    )
-                })
-            })
-            .clone()
-    }
-}
-
-pub struct ProjectIndex {
-    db_connection: heed::Env,
-    project: WeakModel<Project>,
-    worktree_indices: HashMap<EntityId, WorktreeIndexHandle>,
-    language_registry: Arc<LanguageRegistry>,
-    fs: Arc<dyn Fs>,
-    last_status: Status,
-    status_tx: channel::Sender<()>,
-    embedding_provider: Arc<dyn EmbeddingProvider>,
-    _maintain_status: Task<()>,
-    _subscription: Subscription,
-}
-
-#[derive(Clone)]
-enum WorktreeIndexHandle {
-    Loading {
-        index: Shared<Task<Result<Model<WorktreeIndex>, Arc<anyhow::Error>>>>,
-    },
-    Loaded {
-        index: Model<WorktreeIndex>,
-    },
-}
-
-impl ProjectIndex {
-    fn new(
-        project: Model<Project>,
-        db_connection: heed::Env,
-        embedding_provider: Arc<dyn EmbeddingProvider>,
-        cx: &mut ModelContext<Self>,
-    ) -> Self {
-        let language_registry = project.read(cx).languages().clone();
-        let fs = project.read(cx).fs().clone();
-        let (status_tx, mut status_rx) = channel::unbounded();
-        let mut this = ProjectIndex {
-            db_connection,
-            project: project.downgrade(),
-            worktree_indices: HashMap::default(),
-            language_registry,
-            fs,
-            status_tx,
-            last_status: Status::Idle,
-            embedding_provider,
-            _subscription: cx.subscribe(&project, Self::handle_project_event),
-            _maintain_status: cx.spawn(|this, mut cx| async move {
-                while status_rx.next().await.is_some() {
-                    if this
-                        .update(&mut cx, |this, cx| this.update_status(cx))
-                        .is_err()
-                    {
-                        break;
-                    }
-                }
-            }),
-        };
-        this.update_worktree_indices(cx);
-        this
-    }
-
-    pub fn status(&self) -> Status {
-        self.last_status
-    }
-
-    pub fn project(&self) -> WeakModel<Project> {
-        self.project.clone()
-    }
-
-    pub fn fs(&self) -> Arc<dyn Fs> {
-        self.fs.clone()
-    }
-
-    fn handle_project_event(
-        &mut self,
-        _: Model<Project>,
-        event: &project::Event,
-        cx: &mut ModelContext<Self>,
-    ) {
-        match event {
-            project::Event::WorktreeAdded | project::Event::WorktreeRemoved(_) => {
-                self.update_worktree_indices(cx);
-            }
-            _ => {}
-        }
-    }
-
-    fn update_worktree_indices(&mut self, cx: &mut ModelContext<Self>) {
-        let Some(project) = self.project.upgrade() else {
-            return;
-        };
-
-        let worktrees = project
-            .read(cx)
-            .visible_worktrees(cx)
-            .filter_map(|worktree| {
-                if worktree.read(cx).is_local() {
-                    Some((worktree.entity_id(), worktree))
-                } else {
-                    None
-                }
-            })
-            .collect::<HashMap<_, _>>();
-
-        self.worktree_indices
-            .retain(|worktree_id, _| worktrees.contains_key(worktree_id));
-        for (worktree_id, worktree) in worktrees {
-            self.worktree_indices.entry(worktree_id).or_insert_with(|| {
-                let worktree_index = WorktreeIndex::load(
-                    worktree.clone(),
-                    self.db_connection.clone(),
-                    self.language_registry.clone(),
-                    self.fs.clone(),
-                    self.status_tx.clone(),
-                    self.embedding_provider.clone(),
-                    cx,
-                );
-
-                let load_worktree = cx.spawn(|this, mut cx| async move {
-                    let result = match worktree_index.await {
-                        Ok(worktree_index) => {
-                            this.update(&mut cx, |this, _| {
-                                this.worktree_indices.insert(
-                                    worktree_id,
-                                    WorktreeIndexHandle::Loaded {
-                                        index: worktree_index.clone(),
-                                    },
-                                );
-                            })?;
-                            Ok(worktree_index)
-                        }
-                        Err(error) => {
-                            this.update(&mut cx, |this, _cx| {
-                                this.worktree_indices.remove(&worktree_id)
-                            })?;
-                            Err(Arc::new(error))
-                        }
-                    };
-
-                    this.update(&mut cx, |this, cx| this.update_status(cx))?;
-
-                    result
-                });
-
-                WorktreeIndexHandle::Loading {
-                    index: load_worktree.shared(),
-                }
-            });
-        }
-
-        self.update_status(cx);
+        _cx: &mut AppContext,
+    ) -> Option<Model<ProjectIndex>> {
+        self.project_indices.get(&project.downgrade()).cloned()
     }
 
-    fn update_status(&mut self, cx: &mut ModelContext<Self>) {
-        let mut indexing_count = 0;
-        let mut any_loading = false;
-
-        for index in self.worktree_indices.values_mut() {
-            match index {
-                WorktreeIndexHandle::Loading { .. } => {
-                    any_loading = true;
-                    break;
-                }
-                WorktreeIndexHandle::Loaded { index, .. } => {
-                    indexing_count += index.read(cx).entry_ids_being_indexed.len();
-                }
-            }
-        }
-
-        let status = if any_loading {
-            Status::Loading
-        } else if let Some(remaining_count) = NonZeroUsize::new(indexing_count) {
-            Status::Scanning { remaining_count }
-        } else {
-            Status::Idle
-        };
-
-        if status != self.last_status {
-            self.last_status = status;
-            cx.emit(status);
-        }
-    }
-
-    pub fn search(
-        &self,
-        query: String,
-        limit: usize,
-        cx: &AppContext,
-    ) -> Task<Result<Vec<SearchResult>>> {
-        let (chunks_tx, chunks_rx) = channel::bounded(1024);
-        let mut worktree_scan_tasks = Vec::new();
-        for worktree_index in self.worktree_indices.values() {
-            let worktree_index = worktree_index.clone();
-            let chunks_tx = chunks_tx.clone();
-            worktree_scan_tasks.push(cx.spawn(|cx| async move {
-                let index = match worktree_index {
-                    WorktreeIndexHandle::Loading { index } => {
-                        index.clone().await.map_err(|error| anyhow!(error))?
-                    }
-                    WorktreeIndexHandle::Loaded { index } => index.clone(),
-                };
-
-                index
-                    .read_with(&cx, |index, cx| {
-                        let worktree_id = index.worktree.read(cx).id();
-                        let db_connection = index.db_connection.clone();
-                        let db = index.db;
-                        cx.background_executor().spawn(async move {
-                            let txn = db_connection
-                                .read_txn()
-                                .context("failed to create read transaction")?;
-                            let db_entries = db.iter(&txn).context("failed to iterate database")?;
-                            for db_entry in db_entries {
-                                let (_key, db_embedded_file) = db_entry?;
-                                for chunk in db_embedded_file.chunks {
-                                    chunks_tx
-                                        .send((worktree_id, db_embedded_file.path.clone(), chunk))
-                                        .await?;
-                                }
-                            }
-                            anyhow::Ok(())
-                        })
-                    })?
-                    .await
-            }));
-        }
-        drop(chunks_tx);
-
-        let project = self.project.clone();
-        let embedding_provider = self.embedding_provider.clone();
-        cx.spawn(|cx| async move {
-            #[cfg(debug_assertions)]
-            let embedding_query_start = std::time::Instant::now();
-            log::info!("Searching for {query}");
-
-            let query_embeddings = embedding_provider
-                .embed(&[TextToEmbed::new(&query)])
-                .await?;
-            let query_embedding = query_embeddings
-                .into_iter()
-                .next()
-                .ok_or_else(|| anyhow!("no embedding for query"))?;
-
-            let mut results_by_worker = Vec::new();
-            for _ in 0..cx.background_executor().num_cpus() {
-                results_by_worker.push(Vec::<WorktreeSearchResult>::new());
-            }
-
-            #[cfg(debug_assertions)]
-            let search_start = std::time::Instant::now();
-
-            cx.background_executor()
-                .scoped(|cx| {
-                    for results in results_by_worker.iter_mut() {
-                        cx.spawn(async {
-                            while let Ok((worktree_id, path, chunk)) = chunks_rx.recv().await {
-                                let score = chunk.embedding.similarity(&query_embedding);
-                                let ix = match results.binary_search_by(|probe| {
-                                    score.partial_cmp(&probe.score).unwrap_or(Ordering::Equal)
-                                }) {
-                                    Ok(ix) | Err(ix) => ix,
-                                };
-                                results.insert(
-                                    ix,
-                                    WorktreeSearchResult {
-                                        worktree_id,
-                                        path: path.clone(),
-                                        range: chunk.chunk.range.clone(),
-                                        score,
-                                    },
-                                );
-                                results.truncate(limit);
-                            }
-                        });
-                    }
-                })
-                .await;
-
-            for scan_task in futures::future::join_all(worktree_scan_tasks).await {
-                scan_task.log_err();
-            }
-
-            project.read_with(&cx, |project, cx| {
-                let mut search_results = Vec::with_capacity(results_by_worker.len() * limit);
-                for worker_results in results_by_worker {
-                    search_results.extend(worker_results.into_iter().filter_map(|result| {
-                        Some(SearchResult {
-                            worktree: project.worktree_for_id(result.worktree_id, cx)?,
-                            path: result.path,
-                            range: result.range,
-                            score: result.score,
-                        })
-                    }));
-                }
-                search_results.sort_unstable_by(|a, b| {
-                    b.score.partial_cmp(&a.score).unwrap_or(Ordering::Equal)
-                });
-                search_results.truncate(limit);
-
-                #[cfg(debug_assertions)]
-                {
-                    let search_elapsed = search_start.elapsed();
-                    log::debug!(
-                        "searched {} entries in {:?}",
-                        search_results.len(),
-                        search_elapsed
-                    );
-                    let embedding_query_elapsed = embedding_query_start.elapsed();
-                    log::debug!("embedding query took {:?}", embedding_query_elapsed);
-                }
-
-                search_results
-            })
-        })
-    }
-
-    #[cfg(test)]
-    pub fn path_count(&self, cx: &AppContext) -> Result<u64> {
-        let mut result = 0;
-        for worktree_index in self.worktree_indices.values() {
-            if let WorktreeIndexHandle::Loaded { index, .. } = worktree_index {
-                result += index.read(cx).path_count()?;
-            }
-        }
-        Ok(result)
-    }
-
-    pub(crate) fn worktree_index(
+    pub fn remaining_summaries(
         &self,
-        worktree_id: WorktreeId,
-        cx: &AppContext,
-    ) -> Option<Model<WorktreeIndex>> {
-        for index in self.worktree_indices.values() {
-            if let WorktreeIndexHandle::Loaded { index, .. } = index {
-                if index.read(cx).worktree.read(cx).id() == worktree_id {
-                    return Some(index.clone());
-                }
-            }
-        }
-        None
-    }
-
-    pub(crate) fn worktree_indices(&self, cx: &AppContext) -> Vec<Model<WorktreeIndex>> {
-        let mut result = self
-            .worktree_indices
-            .values()
-            .filter_map(|index| {
-                if let WorktreeIndexHandle::Loaded { index, .. } = index {
-                    Some(index.clone())
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<_>>();
-        result.sort_by_key(|index| index.read(cx).worktree.read(cx).id());
-        result
-    }
-}
-
-pub struct SearchResult {
-    pub worktree: Model<Worktree>,
-    pub path: Arc<Path>,
-    pub range: Range<usize>,
-    pub score: f32,
-}
-
-pub struct WorktreeSearchResult {
-    pub worktree_id: WorktreeId,
-    pub path: Arc<Path>,
-    pub range: Range<usize>,
-    pub score: f32,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-pub enum Status {
-    Idle,
-    Loading,
-    Scanning { remaining_count: NonZeroUsize },
-}
-
-impl EventEmitter<Status> for ProjectIndex {}
-
-struct WorktreeIndex {
-    worktree: Model<Worktree>,
-    db_connection: heed::Env,
-    db: heed::Database<Str, SerdeBincode<EmbeddedFile>>,
-    language_registry: Arc<LanguageRegistry>,
-    fs: Arc<dyn Fs>,
-    embedding_provider: Arc<dyn EmbeddingProvider>,
-    entry_ids_being_indexed: Arc<IndexingEntrySet>,
-    _index_entries: Task<Result<()>>,
-    _subscription: Subscription,
-}
-
-impl WorktreeIndex {
-    pub fn load(
-        worktree: Model<Worktree>,
-        db_connection: heed::Env,
-        language_registry: Arc<LanguageRegistry>,
-        fs: Arc<dyn Fs>,
-        status_tx: channel::Sender<()>,
-        embedding_provider: Arc<dyn EmbeddingProvider>,
+        project: &WeakModel<Project>,
         cx: &mut AppContext,
-    ) -> Task<Result<Model<Self>>> {
-        let worktree_abs_path = worktree.read(cx).abs_path();
-        cx.spawn(|mut cx| async move {
-            let db = cx
-                .background_executor()
-                .spawn({
-                    let db_connection = db_connection.clone();
-                    async move {
-                        let mut txn = db_connection.write_txn()?;
-                        let db_name = worktree_abs_path.to_string_lossy();
-                        let db = db_connection.create_database(&mut txn, Some(&db_name))?;
-                        txn.commit()?;
-                        anyhow::Ok(db)
-                    }
-                })
-                .await?;
-            cx.new_model(|cx| {
-                Self::new(
-                    worktree,
-                    db_connection,
-                    db,
-                    status_tx,
-                    language_registry,
-                    fs,
-                    embedding_provider,
-                    cx,
-                )
+    ) -> Option<usize> {
+        self.project_indices.get(project).map(|project_index| {
+            project_index.update(cx, |project_index, cx| {
+                project_index.remaining_summaries(cx)
             })
         })
     }
-
-    #[allow(clippy::too_many_arguments)]
-    fn new(
-        worktree: Model<Worktree>,
-        db_connection: heed::Env,
-        db: heed::Database<Str, SerdeBincode<EmbeddedFile>>,
-        status: channel::Sender<()>,
-        language_registry: Arc<LanguageRegistry>,
-        fs: Arc<dyn Fs>,
-        embedding_provider: Arc<dyn EmbeddingProvider>,
-        cx: &mut ModelContext<Self>,
-    ) -> Self {
-        let (updated_entries_tx, updated_entries_rx) = channel::unbounded();
-        let _subscription = cx.subscribe(&worktree, move |_this, _worktree, event, _cx| {
-            if let worktree::Event::UpdatedEntries(update) = event {
-                _ = updated_entries_tx.try_send(update.clone());
-            }
-        });
-
-        Self {
-            db_connection,
-            db,
-            worktree,
-            language_registry,
-            fs,
-            embedding_provider,
-            entry_ids_being_indexed: Arc::new(IndexingEntrySet::new(status)),
-            _index_entries: cx.spawn(|this, cx| Self::index_entries(this, updated_entries_rx, cx)),
-            _subscription,
-        }
-    }
-
-    async fn index_entries(
-        this: WeakModel<Self>,
-        updated_entries: channel::Receiver<UpdatedEntriesSet>,
-        mut cx: AsyncAppContext,
-    ) -> Result<()> {
-        let index = this.update(&mut cx, |this, cx| this.index_entries_changed_on_disk(cx))?;
-        index.await.log_err();
-
-        while let Ok(updated_entries) = updated_entries.recv().await {
-            let index = this.update(&mut cx, |this, cx| {
-                this.index_updated_entries(updated_entries, cx)
-            })?;
-            index.await.log_err();
-        }
-
-        Ok(())
-    }
-
-    fn index_entries_changed_on_disk(&self, cx: &AppContext) -> impl Future<Output = Result<()>> {
-        let worktree = self.worktree.read(cx).snapshot();
-        let worktree_abs_path = worktree.abs_path().clone();
-        let scan = self.scan_entries(worktree, cx);
-        let chunk = self.chunk_files(worktree_abs_path, scan.updated_entries, cx);
-        let embed = Self::embed_files(self.embedding_provider.clone(), chunk.files, cx);
-        let persist = self.persist_embeddings(scan.deleted_entry_ranges, embed.files, cx);
-        async move {
-            futures::try_join!(scan.task, chunk.task, embed.task, persist)?;
-            Ok(())
-        }
-    }
-
-    fn index_updated_entries(
-        &self,
-        updated_entries: UpdatedEntriesSet,
-        cx: &AppContext,
-    ) -> impl Future<Output = Result<()>> {
-        let worktree = self.worktree.read(cx).snapshot();
-        let worktree_abs_path = worktree.abs_path().clone();
-        let scan = self.scan_updated_entries(worktree, updated_entries.clone(), cx);
-        let chunk = self.chunk_files(worktree_abs_path, scan.updated_entries, cx);
-        let embed = Self::embed_files(self.embedding_provider.clone(), chunk.files, cx);
-        let persist = self.persist_embeddings(scan.deleted_entry_ranges, embed.files, cx);
-        async move {
-            futures::try_join!(scan.task, chunk.task, embed.task, persist)?;
-            Ok(())
-        }
-    }
-
-    fn scan_entries(&self, worktree: Snapshot, cx: &AppContext) -> ScanEntries {
-        let (updated_entries_tx, updated_entries_rx) = channel::bounded(512);
-        let (deleted_entry_ranges_tx, deleted_entry_ranges_rx) = channel::bounded(128);
-        let db_connection = self.db_connection.clone();
-        let db = self.db;
-        let entries_being_indexed = self.entry_ids_being_indexed.clone();
-        let task = cx.background_executor().spawn(async move {
-            let txn = db_connection
-                .read_txn()
-                .context("failed to create read transaction")?;
-            let mut db_entries = db
-                .iter(&txn)
-                .context("failed to create iterator")?
-                .move_between_keys()
-                .peekable();
-
-            let mut deletion_range: Option<(Bound<&str>, Bound<&str>)> = None;
-            for entry in worktree.files(false, 0) {
-                let entry_db_key = db_key_for_path(&entry.path);
-
-                let mut saved_mtime = None;
-                while let Some(db_entry) = db_entries.peek() {
-                    match db_entry {
-                        Ok((db_path, db_embedded_file)) => match (*db_path).cmp(&entry_db_key) {
-                            Ordering::Less => {
-                                if let Some(deletion_range) = deletion_range.as_mut() {
-                                    deletion_range.1 = Bound::Included(db_path);
-                                } else {
-                                    deletion_range =
-                                        Some((Bound::Included(db_path), Bound::Included(db_path)));
-                                }
-
-                                db_entries.next();
-                            }
-                            Ordering::Equal => {
-                                if let Some(deletion_range) = deletion_range.take() {
-                                    deleted_entry_ranges_tx
-                                        .send((
-                                            deletion_range.0.map(ToString::to_string),
-                                            deletion_range.1.map(ToString::to_string),
-                                        ))
-                                        .await?;
-                                }
-                                saved_mtime = db_embedded_file.mtime;
-                                db_entries.next();
-                                break;
-                            }
-                            Ordering::Greater => {
-                                break;
-                            }
-                        },
-                        Err(_) => return Err(db_entries.next().unwrap().unwrap_err())?,
-                    }
-                }
-
-                if entry.mtime != saved_mtime {
-                    let handle = entries_being_indexed.insert(entry.id);
-                    updated_entries_tx.send((entry.clone(), handle)).await?;
-                }
-            }
-
-            if let Some(db_entry) = db_entries.next() {
-                let (db_path, _) = db_entry?;
-                deleted_entry_ranges_tx
-                    .send((Bound::Included(db_path.to_string()), Bound::Unbounded))
-                    .await?;
-            }
-
-            Ok(())
-        });
-
-        ScanEntries {
-            updated_entries: updated_entries_rx,
-            deleted_entry_ranges: deleted_entry_ranges_rx,
-            task,
-        }
-    }
-
-    fn scan_updated_entries(
-        &self,
-        worktree: Snapshot,
-        updated_entries: UpdatedEntriesSet,
-        cx: &AppContext,
-    ) -> ScanEntries {
-        let (updated_entries_tx, updated_entries_rx) = channel::bounded(512);
-        let (deleted_entry_ranges_tx, deleted_entry_ranges_rx) = channel::bounded(128);
-        let entries_being_indexed = self.entry_ids_being_indexed.clone();
-        let task = cx.background_executor().spawn(async move {
-            for (path, entry_id, status) in updated_entries.iter() {
-                match status {
-                    project::PathChange::Added
-                    | project::PathChange::Updated
-                    | project::PathChange::AddedOrUpdated => {
-                        if let Some(entry) = worktree.entry_for_id(*entry_id) {
-                            if entry.is_file() {
-                                let handle = entries_being_indexed.insert(entry.id);
-                                updated_entries_tx.send((entry.clone(), handle)).await?;
-                            }
-                        }
-                    }
-                    project::PathChange::Removed => {
-                        let db_path = db_key_for_path(path);
-                        deleted_entry_ranges_tx
-                            .send((Bound::Included(db_path.clone()), Bound::Included(db_path)))
-                            .await?;
-                    }
-                    project::PathChange::Loaded => {
-                        // Do nothing.
-                    }
-                }
-            }
-
-            Ok(())
-        });
-
-        ScanEntries {
-            updated_entries: updated_entries_rx,
-            deleted_entry_ranges: deleted_entry_ranges_rx,
-            task,
-        }
-    }
-
-    fn chunk_files(
-        &self,
-        worktree_abs_path: Arc<Path>,
-        entries: channel::Receiver<(Entry, IndexingEntryHandle)>,
-        cx: &AppContext,
-    ) -> ChunkFiles {
-        let language_registry = self.language_registry.clone();
-        let fs = self.fs.clone();
-        let (chunked_files_tx, chunked_files_rx) = channel::bounded(2048);
-        let task = cx.spawn(|cx| async move {
-            cx.background_executor()
-                .scoped(|cx| {
-                    for _ in 0..cx.num_cpus() {
-                        cx.spawn(async {
-                            while let Ok((entry, handle)) = entries.recv().await {
-                                let entry_abs_path = worktree_abs_path.join(&entry.path);
-                                let Some(text) = fs
-                                    .load(&entry_abs_path)
-                                    .await
-                                    .with_context(|| {
-                                        format!("failed to read path {entry_abs_path:?}")
-                                    })
-                                    .log_err()
-                                else {
-                                    continue;
-                                };
-                                let language = language_registry
-                                    .language_for_file_path(&entry.path)
-                                    .await
-                                    .ok();
-                                let chunked_file = ChunkedFile {
-                                    chunks: chunk_text(&text, language.as_ref(), &entry.path),
-                                    handle,
-                                    path: entry.path,
-                                    mtime: entry.mtime,
-                                    text,
-                                };
-
-                                if chunked_files_tx.send(chunked_file).await.is_err() {
-                                    return;
-                                }
-                            }
-                        });
-                    }
-                })
-                .await;
-            Ok(())
-        });
-
-        ChunkFiles {
-            files: chunked_files_rx,
-            task,
-        }
-    }
-
-    fn embed_files(
-        embedding_provider: Arc<dyn EmbeddingProvider>,
-        chunked_files: channel::Receiver<ChunkedFile>,
-        cx: &AppContext,
-    ) -> EmbedFiles {
-        let embedding_provider = embedding_provider.clone();
-        let (embedded_files_tx, embedded_files_rx) = channel::bounded(512);
-        let task = cx.background_executor().spawn(async move {
-            let mut chunked_file_batches =
-                chunked_files.chunks_timeout(512, Duration::from_secs(2));
-            while let Some(chunked_files) = chunked_file_batches.next().await {
-                // View the batch of files as a vec of chunks
-                // Flatten out to a vec of chunks that we can subdivide into batch sized pieces
-                // Once those are done, reassemble them back into the files in which they belong
-                // If any embeddings fail for a file, the entire file is discarded
-
-                let chunks: Vec<TextToEmbed> = chunked_files
-                    .iter()
-                    .flat_map(|file| {
-                        file.chunks.iter().map(|chunk| TextToEmbed {
-                            text: &file.text[chunk.range.clone()],
-                            digest: chunk.digest,
-                        })
-                    })
-                    .collect::<Vec<_>>();
-
-                let mut embeddings: Vec<Option<Embedding>> = Vec::new();
-                for embedding_batch in chunks.chunks(embedding_provider.batch_size()) {
-                    if let Some(batch_embeddings) =
-                        embedding_provider.embed(embedding_batch).await.log_err()
-                    {
-                        if batch_embeddings.len() == embedding_batch.len() {
-                            embeddings.extend(batch_embeddings.into_iter().map(Some));
-                            continue;
-                        }
-                        log::error!(
-                            "embedding provider returned unexpected embedding count {}, expected {}",
-                            batch_embeddings.len(), embedding_batch.len()
-                        );
-                    }
-
-                    embeddings.extend(iter::repeat(None).take(embedding_batch.len()));
-                }
-
-                let mut embeddings = embeddings.into_iter();
-                for chunked_file in chunked_files {
-                    let mut embedded_file = EmbeddedFile {
-                        path: chunked_file.path,
-                        mtime: chunked_file.mtime,
-                        chunks: Vec::new(),
-                    };
-
-                    let mut embedded_all_chunks = true;
-                    for (chunk, embedding) in
-                        chunked_file.chunks.into_iter().zip(embeddings.by_ref())
-                    {
-                        if let Some(embedding) = embedding {
-                            embedded_file
-                                .chunks
-                                .push(EmbeddedChunk { chunk, embedding });
-                        } else {
-                            embedded_all_chunks = false;
-                        }
-                    }
-
-                    if embedded_all_chunks {
-                        embedded_files_tx
-                            .send((embedded_file, chunked_file.handle))
-                            .await?;
-                    }
-                }
-            }
-            Ok(())
-        });
-
-        EmbedFiles {
-            files: embedded_files_rx,
-            task,
-        }
-    }
-
-    fn persist_embeddings(
-        &self,
-        mut deleted_entry_ranges: channel::Receiver<(Bound<String>, Bound<String>)>,
-        embedded_files: channel::Receiver<(EmbeddedFile, IndexingEntryHandle)>,
-        cx: &AppContext,
-    ) -> Task<Result<()>> {
-        let db_connection = self.db_connection.clone();
-        let db = self.db;
-        cx.background_executor().spawn(async move {
-            while let Some(deletion_range) = deleted_entry_ranges.next().await {
-                let mut txn = db_connection.write_txn()?;
-                let start = deletion_range.0.as_ref().map(|start| start.as_str());
-                let end = deletion_range.1.as_ref().map(|end| end.as_str());
-                log::debug!("deleting embeddings in range {:?}", &(start, end));
-                db.delete_range(&mut txn, &(start, end))?;
-                txn.commit()?;
-            }
-
-            let mut embedded_files = embedded_files.chunks_timeout(4096, Duration::from_secs(2));
-            while let Some(embedded_files) = embedded_files.next().await {
-                let mut txn = db_connection.write_txn()?;
-                for (file, _) in &embedded_files {
-                    log::debug!("saving embedding for file {:?}", file.path);
-                    let key = db_key_for_path(&file.path);
-                    db.put(&mut txn, &key, file)?;
-                }
-                txn.commit()?;
-
-                drop(embedded_files);
-                log::debug!("committed");
-            }
-
-            Ok(())
-        })
-    }
-
-    fn paths(&self, cx: &AppContext) -> Task<Result<Vec<Arc<Path>>>> {
-        let connection = self.db_connection.clone();
-        let db = self.db;
-        cx.background_executor().spawn(async move {
-            let tx = connection
-                .read_txn()
-                .context("failed to create read transaction")?;
-            let result = db
-                .iter(&tx)?
-                .map(|entry| Ok(entry?.1.path.clone()))
-                .collect::<Result<Vec<Arc<Path>>>>();
-            drop(tx);
-            result
-        })
-    }
-
-    fn chunks_for_path(
-        &self,
-        path: Arc<Path>,
-        cx: &AppContext,
-    ) -> Task<Result<Vec<EmbeddedChunk>>> {
-        let connection = self.db_connection.clone();
-        let db = self.db;
-        cx.background_executor().spawn(async move {
-            let tx = connection
-                .read_txn()
-                .context("failed to create read transaction")?;
-            Ok(db
-                .get(&tx, &db_key_for_path(&path))?
-                .ok_or_else(|| anyhow!("no such path"))?
-                .chunks
-                .clone())
-        })
-    }
-
-    #[cfg(test)]
-    fn path_count(&self) -> Result<u64> {
-        let txn = self
-            .db_connection
-            .read_txn()
-            .context("failed to create read transaction")?;
-        Ok(self.db.len(&txn)?)
-    }
-}
-
-struct ScanEntries {
-    updated_entries: channel::Receiver<(Entry, IndexingEntryHandle)>,
-    deleted_entry_ranges: channel::Receiver<(Bound<String>, Bound<String>)>,
-    task: Task<Result<()>>,
-}
-
-struct ChunkFiles {
-    files: channel::Receiver<ChunkedFile>,
-    task: Task<Result<()>>,
-}
-
-struct ChunkedFile {
-    pub path: Arc<Path>,
-    pub mtime: Option<SystemTime>,
-    pub handle: IndexingEntryHandle,
-    pub text: String,
-    pub chunks: Vec<Chunk>,
-}
-
-struct EmbedFiles {
-    files: channel::Receiver<(EmbeddedFile, IndexingEntryHandle)>,
-    task: Task<Result<()>>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct EmbeddedFile {
-    path: Arc<Path>,
-    mtime: Option<SystemTime>,
-    chunks: Vec<EmbeddedChunk>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-struct EmbeddedChunk {
-    chunk: Chunk,
-    embedding: Embedding,
-}
-
-/// The set of entries that are currently being indexed.
-struct IndexingEntrySet {
-    entry_ids: Mutex<HashSet<ProjectEntryId>>,
-    tx: channel::Sender<()>,
-}
-
-/// When dropped, removes the entry from the set of entries that are being indexed.
-#[derive(Clone)]
-struct IndexingEntryHandle {
-    entry_id: ProjectEntryId,
-    set: Weak<IndexingEntrySet>,
-}
-
-impl IndexingEntrySet {
-    fn new(tx: channel::Sender<()>) -> Self {
-        Self {
-            entry_ids: Default::default(),
-            tx,
-        }
-    }
-
-    fn insert(self: &Arc<Self>, entry_id: ProjectEntryId) -> IndexingEntryHandle {
-        self.entry_ids.lock().insert(entry_id);
-        self.tx.send_blocking(()).ok();
-        IndexingEntryHandle {
-            entry_id,
-            set: Arc::downgrade(self),
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.entry_ids.lock().len()
-    }
-}
-
-impl Drop for IndexingEntryHandle {
-    fn drop(&mut self) {
-        if let Some(set) = self.set.upgrade() {
-            set.tx.send_blocking(()).ok();
-            set.entry_ids.lock().remove(&self.entry_id);
-        }
-    }
-}
-
-fn db_key_for_path(path: &Arc<Path>) -> String {
-    path.to_string_lossy().replace('/', "\0")
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use anyhow::anyhow;
+    use chunking::Chunk;
+    use embedding_index::{ChunkedFile, EmbeddingIndex};
+    use feature_flags::FeatureFlagAppExt;
+    use fs::FakeFs;
     use futures::{future::BoxFuture, FutureExt};
     use gpui::TestAppContext;
+    use indexing::IndexingEntrySet;
     use language::language_settings::AllLanguageSettings;
-    use project::Project;
+    use project::{Project, ProjectEntryId};
+    use serde_json::json;
     use settings::SettingsStore;
+    use smol::{channel, stream::StreamExt};
     use std::{future, path::Path, sync::Arc};
 
     fn init_test(cx: &mut TestAppContext) {
+        env_logger::try_init().ok();
+
         cx.update(|cx| {
             let store = SettingsStore::test(cx);
             cx.set_global(store);
             language::init(cx);
+            cx.update_flags(false, vec![]);
             Project::init_settings(cx);
             SettingsStore::update(cx, |store, cx| {
                 store.update_user_settings::<AllLanguageSettings>(cx, |_| {});
@@ -1100,7 +190,7 @@ mod tests {
 
         let temp_dir = tempfile::tempdir().unwrap();
 
-        let mut semantic_index = SemanticIndex::new(
+        let mut semantic_index = SemanticDb::new(
             temp_dir.path().into(),
             Arc::new(TestEmbeddingProvider::new(16, |text| {
                 let mut embedding = vec![0f32; 2];
@@ -1124,26 +214,57 @@ mod tests {
         .await
         .unwrap();
 
-        let project_path = Path::new("./fixture");
+        let fs = FakeFs::new(cx.executor());
+        let project_path = Path::new("/fake_project");
 
-        let project = cx
-            .spawn(|mut cx| async move { Project::example([project_path], &mut cx).await })
-            .await;
+        fs.insert_tree(
+            project_path,
+            json!({
+                "fixture": {
+                    "main.rs": include_str!("../fixture/main.rs"),
+                    "needle.md": include_str!("../fixture/needle.md"),
+                }
+            }),
+        )
+        .await;
+
+        let project = Project::test(fs, [project_path], cx).await;
 
         cx.update(|cx| {
             let language_registry = project.read(cx).languages().clone();
             let node_runtime = project.read(cx).node_runtime().unwrap().clone();
             languages::init(language_registry, node_runtime, cx);
+
+            // Manually create and insert the ProjectIndex
+            let project_index = cx.new_model(|cx| {
+                ProjectIndex::new(
+                    project.clone(),
+                    semantic_index.db_connection.clone(),
+                    semantic_index.embedding_provider.clone(),
+                    cx,
+                )
+            });
+            semantic_index
+                .project_indices
+                .insert(project.downgrade(), project_index);
         });
 
-        let project_index = cx.update(|cx| semantic_index.project_index(project.clone(), cx));
+        let project_index = cx
+            .update(|_cx| {
+                semantic_index
+                    .project_indices
+                    .get(&project.downgrade())
+                    .cloned()
+            })
+            .unwrap();
 
-        while project_index
-            .read_with(cx, |index, cx| index.path_count(cx))
+        cx.run_until_parked();
+        while cx
+            .update(|cx| semantic_index.remaining_summaries(&project.downgrade(), cx))
             .unwrap()
-            == 0
+            > 0
         {
-            project_index.next_event(cx).await;
+            cx.run_until_parked();
         }
 
         let results = cx
@@ -1155,7 +276,11 @@ mod tests {
             .await
             .unwrap();
 
-        assert!(results.len() > 1, "should have found some results");
+        assert!(
+            results.len() > 1,
+            "should have found some results, but only found {:?}",
+            results
+        );
 
         for result in &results {
             println!("result: {:?}", result.path);
@@ -1165,7 +290,7 @@ mod tests {
         // Find result that is greater than 0.5
         let search_result = results.iter().find(|result| result.score > 0.9).unwrap();
 
-        assert_eq!(search_result.path.to_string_lossy(), "needle.md");
+        assert_eq!(search_result.path.to_string_lossy(), "fixture/needle.md");
 
         let content = cx
             .update(|cx| {
@@ -1236,7 +361,7 @@ mod tests {
         chunked_files_tx.close();
 
         let embed_files_task =
-            cx.update(|cx| WorktreeIndex::embed_files(provider.clone(), chunked_files_rx, cx));
+            cx.update(|cx| EmbeddingIndex::embed_files(provider.clone(), chunked_files_rx, cx));
         embed_files_task.task.await.unwrap();
 
         let mut embedded_files_rx = embed_files_task.files;
diff --git a/crates/semantic_index/src/summary_backlog.rs b/crates/semantic_index/src/summary_backlog.rs
new file mode 100644
index 00000000000000..c6d8e33a45df83
--- /dev/null
+++ b/crates/semantic_index/src/summary_backlog.rs
@@ -0,0 +1,48 @@
+use collections::HashMap;
+use std::{path::Path, sync::Arc, time::SystemTime};
+
+const MAX_FILES_BEFORE_RESUMMARIZE: usize = 4;
+const MAX_BYTES_BEFORE_RESUMMARIZE: u64 = 1_000_000; // 1 MB
+
+#[derive(Default, Debug)]
+pub struct SummaryBacklog {
+    /// Key: path to a file that needs summarization, but that we haven't summarized yet. Value: that file's size on disk, in bytes, and its mtime.
+    files: HashMap<Arc<Path>, (u64, Option<SystemTime>)>,
+    /// Cache of the sum of all values in `files`, so we don't have to traverse the whole map to check if we're over the byte limit.
+    total_bytes: u64,
+}
+
+impl SummaryBacklog {
+    /// Store the given path in the backlog, along with how many bytes are in it.
+    pub fn insert(&mut self, path: Arc<Path>, bytes_on_disk: u64, mtime: Option<SystemTime>) {
+        let (prev_bytes, _) = self
+            .files
+            .insert(path, (bytes_on_disk, mtime))
+            .unwrap_or_default(); // Default to 0 prev_bytes
+
+        // Update the cached total by subtracting out the old amount and adding the new one.
+        self.total_bytes = self.total_bytes - prev_bytes + bytes_on_disk;
+    }
+
+    /// Returns true if the total number of bytes in the backlog exceeds a predefined threshold.
+    pub fn needs_drain(&self) -> bool {
+        self.files.len() > MAX_FILES_BEFORE_RESUMMARIZE ||
+        // The whole purpose of the cached total_bytes is to make this comparison cheap.
+        // Otherwise we'd have to traverse the entire dictionary every time we wanted this answer.
+        self.total_bytes > MAX_BYTES_BEFORE_RESUMMARIZE
+    }
+
+    /// Remove all the entries in the backlog and return the file paths as an iterator.
+    #[allow(clippy::needless_lifetimes)] // Clippy thinks this 'a can be elided, but eliding it gives a compile error
+    pub fn drain<'a>(&'a mut self) -> impl Iterator<Item = (Arc<Path>, Option<SystemTime>)> + 'a {
+        self.total_bytes = 0;
+
+        self.files
+            .drain()
+            .map(|(path, (_size, mtime))| (path, mtime))
+    }
+
+    pub fn len(&self) -> usize {
+        self.files.len()
+    }
+}
diff --git a/crates/semantic_index/src/summary_index.rs b/crates/semantic_index/src/summary_index.rs
new file mode 100644
index 00000000000000..08f25ae0287fa2
--- /dev/null
+++ b/crates/semantic_index/src/summary_index.rs
@@ -0,0 +1,693 @@
+use anyhow::{anyhow, Context as _, Result};
+use arrayvec::ArrayString;
+use fs::Fs;
+use futures::{stream::StreamExt, TryFutureExt};
+use futures_batch::ChunksTimeoutStreamExt;
+use gpui::{AppContext, Model, Task};
+use heed::{
+    types::{SerdeBincode, Str},
+    RoTxn,
+};
+use language_model::{
+    LanguageModelCompletionEvent, LanguageModelId, LanguageModelRegistry, LanguageModelRequest,
+    LanguageModelRequestMessage, Role,
+};
+use log;
+use parking_lot::Mutex;
+use project::{Entry, UpdatedEntriesSet, Worktree};
+use serde::{Deserialize, Serialize};
+use smol::channel;
+use std::{
+    future::Future,
+    path::Path,
+    sync::Arc,
+    time::{Duration, Instant, SystemTime},
+};
+use util::ResultExt;
+use worktree::Snapshot;
+
+use crate::{indexing::IndexingEntrySet, summary_backlog::SummaryBacklog};
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct FileSummary {
+    pub filename: String,
+    pub summary: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct UnsummarizedFile {
+    // Path to the file on disk
+    path: Arc<Path>,
+    // The mtime of the file on disk
+    mtime: Option<SystemTime>,
+    // BLAKE3 hash of the source file's contents
+    digest: Blake3Digest,
+    // The source file's contents
+    contents: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct SummarizedFile {
+    // Path to the file on disk
+    path: String,
+    // The mtime of the file on disk
+    mtime: Option<SystemTime>,
+    // BLAKE3 hash of the source file's contents
+    digest: Blake3Digest,
+    // The LLM's summary of the file's contents
+    summary: String,
+}
+
+/// This is what blake3's to_hex() method returns - see https://docs.rs/blake3/1.5.3/src/blake3/lib.rs.html#246
+pub type Blake3Digest = ArrayString<{ blake3::OUT_LEN * 2 }>;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct FileDigest {
+    pub mtime: Option<SystemTime>,
+    pub digest: Blake3Digest,
+}
+
+struct NeedsSummary {
+    files: channel::Receiver<UnsummarizedFile>,
+    task: Task<Result<()>>,
+}
+
+struct SummarizeFiles {
+    files: channel::Receiver<SummarizedFile>,
+    task: Task<Result<()>>,
+}
+
+pub struct SummaryIndex {
+    worktree: Model<Worktree>,
+    fs: Arc<dyn Fs>,
+    db_connection: heed::Env,
+    file_digest_db: heed::Database<Str, SerdeBincode<FileDigest>>, // Key: file path. Val: BLAKE3 digest of its contents.
+    summary_db: heed::Database<SerdeBincode<Blake3Digest>, Str>, // Key: BLAKE3 digest of a file's contents. Val: LLM summary of those contents.
+    backlog: Arc<Mutex<SummaryBacklog>>,
+    _entry_ids_being_indexed: Arc<IndexingEntrySet>, // TODO can this be removed?
+}
+
+struct Backlogged {
+    paths_to_digest: channel::Receiver<Vec<(Arc<Path>, Option<SystemTime>)>>,
+    task: Task<Result<()>>,
+}
+
+struct MightNeedSummaryFiles {
+    files: channel::Receiver<UnsummarizedFile>,
+    task: Task<Result<()>>,
+}
+
+impl SummaryIndex {
+    pub fn new(
+        worktree: Model<Worktree>,
+        fs: Arc<dyn Fs>,
+        db_connection: heed::Env,
+        file_digest_db: heed::Database<Str, SerdeBincode<FileDigest>>,
+        summary_db: heed::Database<SerdeBincode<Blake3Digest>, Str>,
+        _entry_ids_being_indexed: Arc<IndexingEntrySet>,
+    ) -> Self {
+        Self {
+            worktree,
+            fs,
+            db_connection,
+            file_digest_db,
+            summary_db,
+            _entry_ids_being_indexed,
+            backlog: Default::default(),
+        }
+    }
+
+    pub fn file_digest_db(&self) -> heed::Database<Str, SerdeBincode<FileDigest>> {
+        self.file_digest_db
+    }
+
+    pub fn summary_db(&self) -> heed::Database<SerdeBincode<Blake3Digest>, Str> {
+        self.summary_db
+    }
+
+    pub fn index_entries_changed_on_disk(
+        &self,
+        is_auto_available: bool,
+        cx: &AppContext,
+    ) -> impl Future<Output = Result<()>> {
+        let start = Instant::now();
+        let backlogged;
+        let digest;
+        let needs_summary;
+        let summaries;
+        let persist;
+
+        if is_auto_available {
+            let worktree = self.worktree.read(cx).snapshot();
+            let worktree_abs_path = worktree.abs_path().clone();
+
+            backlogged = self.scan_entries(worktree, cx);
+            digest = self.digest_files(backlogged.paths_to_digest, worktree_abs_path, cx);
+            needs_summary = self.check_summary_cache(digest.files, cx);
+            summaries = self.summarize_files(needs_summary.files, cx);
+            persist = self.persist_summaries(summaries.files, cx);
+        } else {
+            // This feature is only staff-shipped, so make the rest of these no-ops.
+            backlogged = Backlogged {
+                paths_to_digest: channel::unbounded().1,
+                task: Task::ready(Ok(())),
+            };
+            digest = MightNeedSummaryFiles {
+                files: channel::unbounded().1,
+                task: Task::ready(Ok(())),
+            };
+            needs_summary = NeedsSummary {
+                files: channel::unbounded().1,
+                task: Task::ready(Ok(())),
+            };
+            summaries = SummarizeFiles {
+                files: channel::unbounded().1,
+                task: Task::ready(Ok(())),
+            };
+            persist = Task::ready(Ok(()));
+        }
+
+        async move {
+            futures::try_join!(
+                backlogged.task,
+                digest.task,
+                needs_summary.task,
+                summaries.task,
+                persist
+            )?;
+
+            if is_auto_available {
+                log::info!(
+                    "Summarizing everything that changed on disk took {:?}",
+                    start.elapsed()
+                );
+            }
+
+            Ok(())
+        }
+    }
+
+    pub fn index_updated_entries(
+        &mut self,
+        updated_entries: UpdatedEntriesSet,
+        is_auto_available: bool,
+        cx: &AppContext,
+    ) -> impl Future<Output = Result<()>> {
+        let start = Instant::now();
+        let backlogged;
+        let digest;
+        let needs_summary;
+        let summaries;
+        let persist;
+
+        if is_auto_available {
+            let worktree = self.worktree.read(cx).snapshot();
+            let worktree_abs_path = worktree.abs_path().clone();
+
+            backlogged = self.scan_updated_entries(worktree, updated_entries.clone(), cx);
+            digest = self.digest_files(backlogged.paths_to_digest, worktree_abs_path, cx);
+            needs_summary = self.check_summary_cache(digest.files, cx);
+            summaries = self.summarize_files(needs_summary.files, cx);
+            persist = self.persist_summaries(summaries.files, cx);
+        } else {
+            // This feature is only staff-shipped, so make the rest of these no-ops.
+            backlogged = Backlogged {
+                paths_to_digest: channel::unbounded().1,
+                task: Task::ready(Ok(())),
+            };
+            digest = MightNeedSummaryFiles {
+                files: channel::unbounded().1,
+                task: Task::ready(Ok(())),
+            };
+            needs_summary = NeedsSummary {
+                files: channel::unbounded().1,
+                task: Task::ready(Ok(())),
+            };
+            summaries = SummarizeFiles {
+                files: channel::unbounded().1,
+                task: Task::ready(Ok(())),
+            };
+            persist = Task::ready(Ok(()));
+        }
+
+        async move {
+            futures::try_join!(
+                backlogged.task,
+                digest.task,
+                needs_summary.task,
+                summaries.task,
+                persist
+            )?;
+
+            log::info!("Summarizing updated entries took {:?}", start.elapsed());
+
+            Ok(())
+        }
+    }
+
+    fn check_summary_cache(
+        &self,
+        mut might_need_summary: channel::Receiver<UnsummarizedFile>,
+        cx: &AppContext,
+    ) -> NeedsSummary {
+        let db_connection = self.db_connection.clone();
+        let db = self.summary_db;
+        let (needs_summary_tx, needs_summary_rx) = channel::bounded(512);
+        let task = cx.background_executor().spawn(async move {
+            while let Some(file) = might_need_summary.next().await {
+                let tx = db_connection
+                    .read_txn()
+                    .context("Failed to create read transaction for checking which hashes are in summary cache")?;
+
+                match db.get(&tx, &file.digest) {
+                    Ok(opt_answer) => {
+                        if opt_answer.is_none() {
+                            // It's not in the summary cache db, so we need to summarize it.
+                            log::debug!("File {:?} (digest {:?}) was NOT in the db cache and needs to be resummarized.", file.path.display(), &file.digest);
+                            needs_summary_tx.send(file).await?;
+                        } else {
+                            log::debug!("File {:?} (digest {:?}) was in the db cache and does not need to be resummarized.", file.path.display(), &file.digest);
+                        }
+                    }
+                    Err(err) => {
+                        log::error!("Reading from the summaries database failed: {:?}", err);
+                    }
+                }
+            }
+
+            Ok(())
+        });
+
+        NeedsSummary {
+            files: needs_summary_rx,
+            task,
+        }
+    }
+
+    fn scan_entries(&self, worktree: Snapshot, cx: &AppContext) -> Backlogged {
+        let (tx, rx) = channel::bounded(512);
+        let db_connection = self.db_connection.clone();
+        let digest_db = self.file_digest_db;
+        let backlog = Arc::clone(&self.backlog);
+        let task = cx.background_executor().spawn(async move {
+            let txn = db_connection
+                .read_txn()
+                .context("failed to create read transaction")?;
+
+            for entry in worktree.files(false, 0) {
+                let needs_summary =
+                    Self::add_to_backlog(Arc::clone(&backlog), digest_db, &txn, entry);
+
+                if !needs_summary.is_empty() {
+                    tx.send(needs_summary).await?;
+                }
+            }
+
+            // TODO delete db entries for deleted files
+
+            Ok(())
+        });
+
+        Backlogged {
+            paths_to_digest: rx,
+            task,
+        }
+    }
+
+    fn add_to_backlog(
+        backlog: Arc<Mutex<SummaryBacklog>>,
+        digest_db: heed::Database<Str, SerdeBincode<FileDigest>>,
+        txn: &RoTxn<'_>,
+        entry: &Entry,
+    ) -> Vec<(Arc<Path>, Option<SystemTime>)> {
+        let entry_db_key = db_key_for_path(&entry.path);
+
+        match digest_db.get(&txn, &entry_db_key) {
+            Ok(opt_saved_digest) => {
+                // The file path is the same, but the mtime is different. (Or there was no mtime.)
+                // It needs updating, so add it to the backlog! Then, if the backlog is full, drain it and summarize its contents.
+                if entry.mtime != opt_saved_digest.and_then(|digest| digest.mtime) {
+                    let mut backlog = backlog.lock();
+
+                    log::info!(
+                        "Inserting {:?} ({:?} bytes) into backlog",
+                        &entry.path,
+                        entry.size,
+                    );
+                    backlog.insert(Arc::clone(&entry.path), entry.size, entry.mtime);
+
+                    if backlog.needs_drain() {
+                        log::info!("Draining summary backlog...");
+                        return backlog.drain().collect();
+                    }
+                }
+            }
+            Err(err) => {
+                log::error!(
+                    "Error trying to get file digest db entry {:?}: {:?}",
+                    &entry_db_key,
+                    err
+                );
+            }
+        }
+
+        Vec::new()
+    }
+
+    fn scan_updated_entries(
+        &self,
+        worktree: Snapshot,
+        updated_entries: UpdatedEntriesSet,
+        cx: &AppContext,
+    ) -> Backlogged {
+        log::info!("Scanning for updated entries that might need summarization...");
+        let (tx, rx) = channel::bounded(512);
+        // let (deleted_entry_ranges_tx, deleted_entry_ranges_rx) = channel::bounded(128);
+        let db_connection = self.db_connection.clone();
+        let digest_db = self.file_digest_db;
+        let backlog = Arc::clone(&self.backlog);
+        let task = cx.background_executor().spawn(async move {
+            let txn = db_connection
+                .read_txn()
+                .context("failed to create read transaction")?;
+
+            for (path, entry_id, status) in updated_entries.iter() {
+                match status {
+                    project::PathChange::Loaded
+                    | project::PathChange::Added
+                    | project::PathChange::Updated
+                    | project::PathChange::AddedOrUpdated => {
+                        if let Some(entry) = worktree.entry_for_id(*entry_id) {
+                            if entry.is_file() {
+                                let needs_summary = Self::add_to_backlog(
+                                    Arc::clone(&backlog),
+                                    digest_db,
+                                    &txn,
+                                    entry,
+                                );
+
+                                if !needs_summary.is_empty() {
+                                    tx.send(needs_summary).await?;
+                                }
+                            }
+                        }
+                    }
+                    project::PathChange::Removed => {
+                        let _db_path = db_key_for_path(path);
+                        // TODO delete db entries for deleted files
+                        // deleted_entry_ranges_tx
+                        //     .send((Bound::Included(db_path.clone()), Bound::Included(db_path)))
+                        //     .await?;
+                    }
+                }
+            }
+
+            Ok(())
+        });
+
+        Backlogged {
+            paths_to_digest: rx,
+            // deleted_entry_ranges: deleted_entry_ranges_rx,
+            task,
+        }
+    }
+
+    fn digest_files(
+        &self,
+        paths: channel::Receiver<Vec<(Arc<Path>, Option<SystemTime>)>>,
+        worktree_abs_path: Arc<Path>,
+        cx: &AppContext,
+    ) -> MightNeedSummaryFiles {
+        let fs = self.fs.clone();
+        let (rx, tx) = channel::bounded(2048);
+        let task = cx.spawn(|cx| async move {
+            cx.background_executor()
+                .scoped(|cx| {
+                    for _ in 0..cx.num_cpus() {
+                        cx.spawn(async {
+                            while let Ok(pairs) = paths.recv().await {
+                                // Note: we could process all these files concurrently if desired. Might or might not speed things up.
+                                for (path, mtime) in pairs {
+                                    let entry_abs_path = worktree_abs_path.join(&path);
+
+                                    // Load the file's contents and compute its hash digest.
+                                    let unsummarized_file = {
+                                        let Some(contents) = fs
+                                            .load(&entry_abs_path)
+                                            .await
+                                            .with_context(|| {
+                                                format!("failed to read path {entry_abs_path:?}")
+                                            })
+                                            .log_err()
+                                        else {
+                                            continue;
+                                        };
+
+                                        let digest = {
+                                            let mut hasher = blake3::Hasher::new();
+                                            // Incorporate both the (relative) file path as well as the contents of the file into the hash.
+                                            // This is because in some languages and frameworks, identical files can do different things
+                                            // depending on their paths (e.g. Rails controllers). It's also why we send the path to the model.
+                                            hasher.update(path.display().to_string().as_bytes());
+                                            hasher.update(contents.as_bytes());
+                                            hasher.finalize().to_hex()
+                                        };
+
+                                        UnsummarizedFile {
+                                            digest,
+                                            contents,
+                                            path,
+                                            mtime,
+                                        }
+                                    };
+
+                                    if let Err(err) = rx
+                                        .send(unsummarized_file)
+                                        .map_err(|error| anyhow!(error))
+                                        .await
+                                    {
+                                        log::error!("Error: {:?}", err);
+
+                                        return;
+                                    }
+                                }
+                            }
+                        });
+                    }
+                })
+                .await;
+            Ok(())
+        });
+
+        MightNeedSummaryFiles { files: tx, task }
+    }
+
+    fn summarize_files(
+        &self,
+        mut unsummarized_files: channel::Receiver<UnsummarizedFile>,
+        cx: &AppContext,
+    ) -> SummarizeFiles {
+        let (summarized_tx, summarized_rx) = channel::bounded(512);
+        let task = cx.spawn(|cx| async move {
+            while let Some(file) = unsummarized_files.next().await {
+                log::debug!("Summarizing {:?}", file);
+                let summary = cx
+                    .update(|cx| Self::summarize_code(&file.contents, &file.path, cx))?
+                    .await
+                    .unwrap_or_else(|err| {
+                        // Log a warning because we'll continue anyway.
+                        // In the future, we may want to try splitting it up into multiple requests and concatenating the summaries,
+                        // but this might give bad summaries due to cutting off source code files in the middle.
+                        log::warn!("Failed to summarize {} - {:?}", file.path.display(), err);
+
+                        String::new()
+                    });
+
+                // Note that the summary could be empty because of an error talking to a cloud provider,
+                // e.g. because the context limit was exceeded. In that case, we return Ok(String::new()).
+                if !summary.is_empty() {
+                    summarized_tx
+                        .send(SummarizedFile {
+                            path: file.path.display().to_string(),
+                            digest: file.digest,
+                            summary,
+                            mtime: file.mtime,
+                        })
+                        .await?
+                }
+            }
+
+            Ok(())
+        });
+
+        SummarizeFiles {
+            files: summarized_rx,
+            task,
+        }
+    }
+
+    fn summarize_code(
+        code: &str,
+        path: &Path,
+        cx: &AppContext,
+    ) -> impl Future<Output = Result<String>> {
+        let start = Instant::now();
+        let (summary_model_id, use_cache): (LanguageModelId, bool) = (
+            "Qwen/Qwen2-7B-Instruct".to_string().into(), // TODO read this from the user's settings.
+            false, // qwen2 doesn't have a cache, but we should probably infer this from the model
+        );
+        let Some(model) = LanguageModelRegistry::read_global(cx)
+            .available_models(cx)
+            .find(|model| &model.id() == &summary_model_id)
+        else {
+            return cx.background_executor().spawn(async move {
+                Err(anyhow!("Couldn't find the preferred summarization model ({:?}) in the language registry's available models", summary_model_id))
+            });
+        };
+        let utf8_path = path.to_string_lossy();
+        const PROMPT_BEFORE_CODE: &str = "Summarize what the code in this file does in 3 sentences, using no newlines or bullet points in the summary:";
+        let prompt = format!("{PROMPT_BEFORE_CODE}\n{utf8_path}:\n{code}");
+
+        log::debug!(
+            "Summarizing code by sending this prompt to {:?}: {:?}",
+            model.name(),
+            &prompt
+        );
+
+        let request = LanguageModelRequest {
+            messages: vec![LanguageModelRequestMessage {
+                role: Role::User,
+                content: vec![prompt.into()],
+                cache: use_cache,
+            }],
+            tools: Vec::new(),
+            stop: Vec::new(),
+            temperature: 1.0,
+        };
+
+        let code_len = code.len();
+        cx.spawn(|cx| async move {
+            let stream = model.stream_completion(request, &cx);
+            cx.background_executor()
+                .spawn(async move {
+                    let answer: String = stream
+                        .await?
+                        .filter_map(|event| async {
+                            if let Ok(LanguageModelCompletionEvent::Text(text)) = event {
+                                Some(text)
+                            } else {
+                                None
+                            }
+                        })
+                        .collect()
+                        .await;
+
+                    log::info!(
+                        "It took {:?} to summarize {:?} bytes of code.",
+                        start.elapsed(),
+                        code_len
+                    );
+
+                    log::debug!("Summary was: {:?}", &answer);
+
+                    Ok(answer)
+                })
+                .await
+
+            // TODO if summarization failed, put it back in the backlog!
+        })
+    }
+
+    fn persist_summaries(
+        &self,
+        summaries: channel::Receiver<SummarizedFile>,
+        cx: &AppContext,
+    ) -> Task<Result<()>> {
+        let db_connection = self.db_connection.clone();
+        let digest_db = self.file_digest_db;
+        let summary_db = self.summary_db;
+        cx.background_executor().spawn(async move {
+            let mut summaries = summaries.chunks_timeout(4096, Duration::from_secs(2));
+            while let Some(summaries) = summaries.next().await {
+                let mut txn = db_connection.write_txn()?;
+                for file in &summaries {
+                    log::debug!(
+                        "Saving summary of {:?} - which is {} bytes of summary for content digest {:?}",
+                        &file.path,
+                        file.summary.len(),
+                        file.digest
+                    );
+                    digest_db.put(
+                        &mut txn,
+                        &file.path,
+                        &FileDigest {
+                            mtime: file.mtime,
+                            digest: file.digest,
+                        },
+                    )?;
+                    summary_db.put(&mut txn, &file.digest, &file.summary)?;
+                }
+                txn.commit()?;
+
+                drop(summaries);
+                log::debug!("committed summaries");
+            }
+
+            Ok(())
+        })
+    }
+
+    /// Empty out the backlog of files that haven't been resummarized, and resummarize them immediately.
+    pub(crate) fn flush_backlog(
+        &self,
+        worktree_abs_path: Arc<Path>,
+        cx: &AppContext,
+    ) -> impl Future<Output = Result<()>> {
+        let start = Instant::now();
+        let backlogged = {
+            let (tx, rx) = channel::bounded(512);
+            let needs_summary: Vec<(Arc<Path>, Option<SystemTime>)> = {
+                let mut backlog = self.backlog.lock();
+
+                backlog.drain().collect()
+            };
+
+            let task = cx.background_executor().spawn(async move {
+                tx.send(needs_summary).await?;
+                Ok(())
+            });
+
+            Backlogged {
+                paths_to_digest: rx,
+                task,
+            }
+        };
+
+        let digest = self.digest_files(backlogged.paths_to_digest, worktree_abs_path, cx);
+        let needs_summary = self.check_summary_cache(digest.files, cx);
+        let summaries = self.summarize_files(needs_summary.files, cx);
+        let persist = self.persist_summaries(summaries.files, cx);
+
+        async move {
+            futures::try_join!(
+                backlogged.task,
+                digest.task,
+                needs_summary.task,
+                summaries.task,
+                persist
+            )?;
+
+            log::info!("Summarizing backlogged entries took {:?}", start.elapsed());
+
+            Ok(())
+        }
+    }
+
+    pub(crate) fn backlog_len(&self) -> usize {
+        self.backlog.lock().len()
+    }
+}
+
+fn db_key_for_path(path: &Arc<Path>) -> String {
+    path.to_string_lossy().replace('/', "\0")
+}
diff --git a/crates/semantic_index/src/worktree_index.rs b/crates/semantic_index/src/worktree_index.rs
new file mode 100644
index 00000000000000..7ca5a496196bd7
--- /dev/null
+++ b/crates/semantic_index/src/worktree_index.rs
@@ -0,0 +1,217 @@
+use crate::embedding::EmbeddingProvider;
+use crate::embedding_index::EmbeddingIndex;
+use crate::indexing::IndexingEntrySet;
+use crate::summary_index::SummaryIndex;
+use anyhow::Result;
+use feature_flags::{AutoCommand, FeatureFlagAppExt};
+use fs::Fs;
+use futures::future::Shared;
+use gpui::{
+    AppContext, AsyncAppContext, Context, Model, ModelContext, Subscription, Task, WeakModel,
+};
+use language::LanguageRegistry;
+use log;
+use project::{UpdatedEntriesSet, Worktree};
+use smol::channel;
+use std::sync::Arc;
+use util::ResultExt;
+
+#[derive(Clone)]
+pub enum WorktreeIndexHandle {
+    Loading {
+        index: Shared<Task<Result<Model<WorktreeIndex>, Arc<anyhow::Error>>>>,
+    },
+    Loaded {
+        index: Model<WorktreeIndex>,
+    },
+}
+
+pub struct WorktreeIndex {
+    worktree: Model<Worktree>,
+    db_connection: heed::Env,
+    embedding_index: EmbeddingIndex,
+    summary_index: SummaryIndex,
+    entry_ids_being_indexed: Arc<IndexingEntrySet>,
+    _index_entries: Task<Result<()>>,
+    _subscription: Subscription,
+}
+
+impl WorktreeIndex {
+    pub fn load(
+        worktree: Model<Worktree>,
+        db_connection: heed::Env,
+        language_registry: Arc<LanguageRegistry>,
+        fs: Arc<dyn Fs>,
+        status_tx: channel::Sender<()>,
+        embedding_provider: Arc<dyn EmbeddingProvider>,
+        cx: &mut AppContext,
+    ) -> Task<Result<Model<Self>>> {
+        let worktree_for_index = worktree.clone();
+        let worktree_for_summary = worktree.clone();
+        let worktree_abs_path = worktree.read(cx).abs_path();
+        let embedding_fs = Arc::clone(&fs);
+        let summary_fs = fs;
+        cx.spawn(|mut cx| async move {
+            let entries_being_indexed = Arc::new(IndexingEntrySet::new(status_tx));
+            let (embedding_index, summary_index) = cx
+                .background_executor()
+                .spawn({
+                    let entries_being_indexed = Arc::clone(&entries_being_indexed);
+                    let db_connection = db_connection.clone();
+                    async move {
+                        let mut txn = db_connection.write_txn()?;
+                        let embedding_index = {
+                            let db_name = worktree_abs_path.to_string_lossy();
+                            let db = db_connection.create_database(&mut txn, Some(&db_name))?;
+
+                            EmbeddingIndex::new(
+                                worktree_for_index,
+                                embedding_fs,
+                                db_connection.clone(),
+                                db,
+                                language_registry,
+                                embedding_provider,
+                                Arc::clone(&entries_being_indexed),
+                            )
+                        };
+                        let summary_index = {
+                            let file_digest_db = {
+                                let db_name =
+                                // Prepend something that wouldn't be found at the beginning of an
+                                // absolute path, so we don't get db key namespace conflicts with
+                                // embeddings, which use the abs path as a key.
+                                format!("digests-{}", worktree_abs_path.to_string_lossy());
+                                db_connection.create_database(&mut txn, Some(&db_name))?
+                            };
+                            let summary_db = {
+                                let db_name =
+                                // Prepend something that wouldn't be found at the beginning of an
+                                // absolute path, so we don't get db key namespace conflicts with
+                                // embeddings, which use the abs path as a key.
+                                format!("summaries-{}", worktree_abs_path.to_string_lossy());
+                                db_connection.create_database(&mut txn, Some(&db_name))?
+                            };
+                            SummaryIndex::new(
+                                worktree_for_summary,
+                                summary_fs,
+                                db_connection.clone(),
+                                file_digest_db,
+                                summary_db,
+                                Arc::clone(&entries_being_indexed),
+                            )
+                        };
+                        txn.commit()?;
+                        anyhow::Ok((embedding_index, summary_index))
+                    }
+                })
+                .await?;
+
+            cx.new_model(|cx| {
+                Self::new(
+                    worktree,
+                    db_connection,
+                    embedding_index,
+                    summary_index,
+                    entries_being_indexed,
+                    cx,
+                )
+            })
+        })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        worktree: Model<Worktree>,
+        db_connection: heed::Env,
+        embedding_index: EmbeddingIndex,
+        summary_index: SummaryIndex,
+        entry_ids_being_indexed: Arc<IndexingEntrySet>,
+        cx: &mut ModelContext<Self>,
+    ) -> Self {
+        let (updated_entries_tx, updated_entries_rx) = channel::unbounded();
+        let _subscription = cx.subscribe(&worktree, move |_this, _worktree, event, _cx| {
+            if let worktree::Event::UpdatedEntries(update) = event {
+                log::debug!("Updating entries...");
+                _ = updated_entries_tx.try_send(update.clone());
+            }
+        });
+
+        Self {
+            db_connection,
+            embedding_index,
+            summary_index,
+            worktree,
+            entry_ids_being_indexed,
+            _index_entries: cx.spawn(|this, cx| Self::index_entries(this, updated_entries_rx, cx)),
+            _subscription,
+        }
+    }
+
+    pub fn entry_ids_being_indexed(&self) -> &IndexingEntrySet {
+        self.entry_ids_being_indexed.as_ref()
+    }
+
+    pub fn worktree(&self) -> &Model<Worktree> {
+        &self.worktree
+    }
+
+    pub fn db_connection(&self) -> &heed::Env {
+        &self.db_connection
+    }
+
+    pub fn embedding_index(&self) -> &EmbeddingIndex {
+        &self.embedding_index
+    }
+
+    pub fn summary_index(&self) -> &SummaryIndex {
+        &self.summary_index
+    }
+
+    async fn index_entries(
+        this: WeakModel<Self>,
+        updated_entries: channel::Receiver<UpdatedEntriesSet>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        let is_auto_available = cx.update(|cx| cx.wait_for_flag::<AutoCommand>())?.await;
+        let index = this.update(&mut cx, |this, cx| {
+            futures::future::try_join(
+                this.embedding_index.index_entries_changed_on_disk(cx),
+                this.summary_index
+                    .index_entries_changed_on_disk(is_auto_available, cx),
+            )
+        })?;
+        index.await.log_err();
+
+        while let Ok(updated_entries) = updated_entries.recv().await {
+            let is_auto_available = cx
+                .update(|cx| cx.has_flag::<AutoCommand>())
+                .unwrap_or(false);
+
+            let index = this.update(&mut cx, |this, cx| {
+                futures::future::try_join(
+                    this.embedding_index
+                        .index_updated_entries(updated_entries.clone(), cx),
+                    this.summary_index.index_updated_entries(
+                        updated_entries,
+                        is_auto_available,
+                        cx,
+                    ),
+                )
+            })?;
+            index.await.log_err();
+        }
+
+        Ok(())
+    }
+
+    #[cfg(test)]
+    pub fn path_count(&self) -> Result<u64> {
+        use anyhow::Context;
+
+        let txn = self
+            .db_connection
+            .read_txn()
+            .context("failed to create read transaction")?;
+        Ok(self.embedding_index().db().len(&txn)?)
+    }
+}
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index c6e64deb59d1b1..584524a1d7b6fe 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -3227,6 +3227,8 @@ pub struct Entry {
     pub git_status: Option<GitFileStatus>,
     /// Whether this entry is considered to be a `.env` file.
     pub is_private: bool,
+    /// The entry's size on disk, in bytes.
+    pub size: u64,
     pub char_bag: CharBag,
     pub is_fifo: bool,
 }
@@ -3282,6 +3284,7 @@ impl Entry {
             path,
             inode: metadata.inode,
             mtime: Some(metadata.mtime),
+            size: metadata.len,
             canonical_path,
             is_symlink: metadata.is_symlink,
             is_ignored: false,
@@ -5210,6 +5213,7 @@ impl<'a> From<&'a Entry> for proto::Entry {
             is_external: entry.is_external,
             git_status: entry.git_status.map(git_status_to_proto),
             is_fifo: entry.is_fifo,
+            size: Some(entry.size),
         }
     }
 }
@@ -5231,6 +5235,7 @@ impl<'a> TryFrom<(&'a CharBag, proto::Entry)> for Entry {
             path,
             inode: entry.inode,
             mtime: entry.mtime.map(|time| time.into()),
+            size: entry.size.unwrap_or(0),
             canonical_path: None,
             is_ignored: entry.is_ignored,
             is_external: entry.is_external,

From de344c833bf5b61641eb0057127d17ac830f74b4 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 13 Sep 2024 14:49:50 -0400
Subject: [PATCH 067/762] zed_extension_api: Use v0.2.0 WIT types (#17802)

This PR makes `zed_extension_api` use the WIT types from v0.2.0 of
extension API.

A follow-up from #17795, since I had forgotten to do it there.

Release Notes:

- N/A
---
 crates/extension_api/src/extension_api.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/extension_api/src/extension_api.rs b/crates/extension_api/src/extension_api.rs
index f66c6ef59f5f8c..f0b5baab9ab128 100644
--- a/crates/extension_api/src/extension_api.rs
+++ b/crates/extension_api/src/extension_api.rs
@@ -186,7 +186,7 @@ mod wit {
 
     wit_bindgen::generate!({
         skip: ["init-extension"],
-        path: "./wit/since_v0.1.0",
+        path: "./wit/since_v0.2.0",
     });
 }
 

From 8f833ea0294448c8b7e9e6a09541fa9537867e65 Mon Sep 17 00:00:00 2001
From: Barry Penner <34104395+skytwosea@users.noreply.github.com>
Date: Fri, 13 Sep 2024 14:51:14 -0400
Subject: [PATCH 068/762] Fix missing on-mouseup when dragging the window on
 Linux (#17801)

Zed Hackathon entry :D

Release Notes:

- Fixed a bug where Zed would initiate a window move and then refuse to
release the mouse.

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 crates/title_bar/src/title_bar.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index fd3f01e5f78bae..e2d45a923b7d06 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -182,6 +182,12 @@ impl Render for TitleBar {
                             .on_mouse_down_out(cx.listener(move |this, _ev, _cx| {
                                 this.should_move = false;
                             }))
+                            .on_mouse_up(
+                                gpui::MouseButton::Left,
+                                cx.listener(move |this, _ev, _cx| {
+                                    this.should_move = false;
+                                }),
+                            )
                             .on_mouse_down(
                                 gpui::MouseButton::Left,
                                 cx.listener(move |this, _ev, _cx| {

From adbe973f02b2e4cfe0645657ca10681a58f333a0 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Fri, 13 Sep 2024 15:11:10 -0400
Subject: [PATCH 069/762] editor: In OpenFile check if file with path_suffix
 exists (#17805)

Demo:


https://github.com/user-attachments/assets/6acb6c1e-bb15-4205-9dcb-2aa4bb99dcf9



Release Notes:

- When using `OpenFile` (`gf` in Vim mode) and the word under the cursor
is not an existing file path, we now fall back and additionally check
whether a file called
`<word-under-cursor>.<language-specific-path-suffixes>` exists. That's
similar to Vim's `suffixesadd` option.

---------

Co-authored-by: Abdelhakim Qbaich <abdelhakim@qbaich.com>
Co-authored-by: Pete LeVasseur <plevasseur@gmail.com>
---
 crates/editor/src/hover_links.rs | 69 +++++++++++++++++++++++++++-----
 crates/language/src/language.rs  |  4 ++
 crates/vim/src/command.rs        | 19 +++++++++
 3 files changed, 83 insertions(+), 9 deletions(-)

diff --git a/crates/editor/src/hover_links.rs b/crates/editor/src/hover_links.rs
index 86c17625e1ef92..3f590273df8e88 100644
--- a/crates/editor/src/hover_links.rs
+++ b/crates/editor/src/hover_links.rs
@@ -713,17 +713,42 @@ pub(crate) async fn find_file(
     cx: &mut AsyncWindowContext,
 ) -> Option<(Range<text::Anchor>, ResolvedPath)> {
     let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot()).ok()?;
-
+    let scope = snapshot.language_scope_at(position);
     let (range, candidate_file_path) = surrounding_filename(snapshot, position)?;
 
-    let existing_path = project
-        .update(cx, |project, cx| {
-            project.resolve_existing_file_path(&candidate_file_path, buffer, cx)
-        })
-        .ok()?
-        .await?;
+    async fn check_path(
+        candidate_file_path: &str,
+        project: &Model<Project>,
+        buffer: &Model<language::Buffer>,
+        cx: &mut AsyncWindowContext,
+    ) -> Option<ResolvedPath> {
+        project
+            .update(cx, |project, cx| {
+                project.resolve_existing_file_path(&candidate_file_path, buffer, cx)
+            })
+            .ok()?
+            .await
+    }
 
-    Some((range, existing_path))
+    if let Some(existing_path) = check_path(&candidate_file_path, &project, buffer, cx).await {
+        return Some((range, existing_path));
+    }
+
+    if let Some(scope) = scope {
+        for suffix in scope.path_suffixes() {
+            if candidate_file_path.ends_with(format!(".{suffix}").as_str()) {
+                continue;
+            }
+
+            let suffixed_candidate = format!("{candidate_file_path}.{suffix}");
+            if let Some(existing_path) = check_path(&suffixed_candidate, &project, buffer, cx).await
+            {
+                return Some((range, existing_path));
+            }
+        }
+    }
+
+    None
 }
 
 fn surrounding_filename(
@@ -1490,7 +1515,8 @@ mod tests {
             You can't go to a file that does_not_exist.txt.
             Go to file2.rs if you want.
             Or go to ../dir/file2.rs if you want.
-            Or go to /root/dir/file2.rs if project is local.ˇ
+            Or go to /root/dir/file2.rs if project is local.
+            Or go to /root/dir/file2 if this is a Rust file.ˇ
         "});
 
         // File does not exist
@@ -1499,6 +1525,7 @@ mod tests {
             Go to file2.rs if you want.
             Or go to ../dir/file2.rs if you want.
             Or go to /root/dir/file2.rs if project is local.
+            Or go to /root/dir/file2 if this is a Rust file.
         "});
         cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
         // No highlight
@@ -1517,6 +1544,7 @@ mod tests {
             Go to fˇile2.rs if you want.
             Or go to ../dir/file2.rs if you want.
             Or go to /root/dir/file2.rs if project is local.
+            Or go to /root/dir/file2 if this is a Rust file.
         "});
 
         cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
@@ -1525,6 +1553,7 @@ mod tests {
             Go to «file2.rsˇ» if you want.
             Or go to ../dir/file2.rs if you want.
             Or go to /root/dir/file2.rs if project is local.
+            Or go to /root/dir/file2 if this is a Rust file.
         "});
 
         // Moving the mouse over a relative path that does exist should highlight it
@@ -1533,6 +1562,7 @@ mod tests {
             Go to file2.rs if you want.
             Or go to ../dir/fˇile2.rs if you want.
             Or go to /root/dir/file2.rs if project is local.
+            Or go to /root/dir/file2 if this is a Rust file.
         "});
 
         cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
@@ -1541,6 +1571,7 @@ mod tests {
             Go to file2.rs if you want.
             Or go to «../dir/file2.rsˇ» if you want.
             Or go to /root/dir/file2.rs if project is local.
+            Or go to /root/dir/file2 if this is a Rust file.
         "});
 
         // Moving the mouse over an absolute path that does exist should highlight it
@@ -1549,6 +1580,7 @@ mod tests {
             Go to file2.rs if you want.
             Or go to ../dir/file2.rs if you want.
             Or go to /root/diˇr/file2.rs if project is local.
+            Or go to /root/dir/file2 if this is a Rust file.
         "});
 
         cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
@@ -1557,6 +1589,25 @@ mod tests {
             Go to file2.rs if you want.
             Or go to ../dir/file2.rs if you want.
             Or go to «/root/dir/file2.rsˇ» if project is local.
+            Or go to /root/dir/file2 if this is a Rust file.
+        "});
+
+        // Moving the mouse over a path that exists, if we add the language-specific suffix, it should highlight it
+        let screen_coord = cx.pixel_position(indoc! {"
+            You can't go to a file that does_not_exist.txt.
+            Go to file2.rs if you want.
+            Or go to ../dir/file2.rs if you want.
+            Or go to /root/dir/file2.rs if project is local.
+            Or go to /root/diˇr/file2 if this is a Rust file.
+        "});
+
+        cx.simulate_mouse_move(screen_coord, None, Modifiers::secondary_key());
+        cx.assert_editor_text_highlights::<HoveredLinkState>(indoc! {"
+            You can't go to a file that does_not_exist.txt.
+            Go to file2.rs if you want.
+            Or go to ../dir/file2.rs if you want.
+            Or go to /root/dir/file2.rs if project is local.
+            Or go to «/root/dir/file2ˇ» if this is a Rust file.
         "});
 
         cx.simulate_click(screen_coord, Modifiers::secondary_key());
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index cd39490d0bbdf4..3112d88aa5543c 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -1410,6 +1410,10 @@ impl Language {
 }
 
 impl LanguageScope {
+    pub fn path_suffixes(&self) -> &[String] {
+        &self.language.path_suffixes()
+    }
+
     pub fn language_name(&self) -> LanguageName {
         self.language.config.name.clone()
     }
diff --git a/crates/vim/src/command.rs b/crates/vim/src/command.rs
index 06c5f0bd3fc1ba..67a674afa6f127 100644
--- a/crates/vim/src/command.rs
+++ b/crates/vim/src/command.rs
@@ -969,6 +969,9 @@ mod test {
         fs.as_fake()
             .insert_file("/root/dir/file2.rs", "This is file2.rs".as_bytes().to_vec())
             .await;
+        fs.as_fake()
+            .insert_file("/root/dir/file3.rs", "go to file3".as_bytes().to_vec())
+            .await;
 
         // Put the path to the second file into the currently open buffer
         cx.set_state(indoc! {"go to fiˇle2.rs"}, Mode::Normal);
@@ -981,5 +984,21 @@ mod test {
         cx.workspace(|workspace, cx| {
             assert_active_item(workspace, "/root/dir/file2.rs", "This is file2.rs", cx);
         });
+
+        // Update editor to point to `file2.rs`
+        cx.editor = cx.workspace(|workspace, cx| workspace.active_item_as::<Editor>(cx).unwrap());
+
+        // Put the path to the third file into the currently open buffer,
+        // but remove its suffix, because we want that lookup to happen automatically.
+        cx.set_state(indoc! {"go to fiˇle3"}, Mode::Normal);
+
+        // Go to file3.rs
+        cx.simulate_keystrokes("g f");
+
+        // We now have three items
+        cx.workspace(|workspace, cx| assert_eq!(workspace.items(cx).count(), 3));
+        cx.workspace(|workspace, cx| {
+            assert_active_item(workspace, "/root/dir/file3.rs", "go to file3", cx);
+        });
     }
 }

From 1b36c62188884ae5fe5d5d3b07d36cb2ee730469 Mon Sep 17 00:00:00 2001
From: tepek2 <stepanjosef2@gmail.com>
Date: Fri, 13 Sep 2024 21:17:01 +0200
Subject: [PATCH 070/762] Add keybinding to swap pane items (#15583)

- Rearrange tabs (left: `ctrl-shift-pageup`, right: `ctrl-shift-pagedown`) like Chrome

Co-authored-by: Peter Tripp <peter@zed.dev>
---
 assets/keymaps/default-linux.json |  2 +
 assets/keymaps/default-macos.json |  2 +
 crates/workspace/src/pane.rs      | 24 +++++++++
 docs/src/key-bindings.md          | 82 ++++++++++++++++---------------
 4 files changed, 70 insertions(+), 40 deletions(-)

diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index 3c627d7803e1d5..bb5673dde6c178 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -245,6 +245,8 @@
     "bindings": {
       "ctrl-pageup": "pane::ActivatePrevItem",
       "ctrl-pagedown": "pane::ActivateNextItem",
+      "ctrl-shift-pageup": "pane::SwapItemLeft",
+      "ctrl-shift-pagedown": "pane::SwapItemRight",
       "ctrl-w": "pane::CloseActiveItem",
       "ctrl-f4": "pane::CloseActiveItem",
       "alt-ctrl-t": "pane::CloseInactiveItems",
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index ed6ece0556e038..9a0c08c3dcaddc 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -285,6 +285,8 @@
       "cmd-}": "pane::ActivateNextItem",
       "alt-cmd-left": "pane::ActivatePrevItem",
       "alt-cmd-right": "pane::ActivateNextItem",
+      "ctrl-shift-pageup": "pane::SwapItemLeft",
+      "ctrl-shift-pagedown": "pane::SwapItemRight",
       "cmd-w": "pane::CloseActiveItem",
       "alt-cmd-t": "pane::CloseInactiveItems",
       "ctrl-alt-cmd-w": "workspace::CloseInactiveTabsAndPanes",
diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index d0fa411381a6d6..09b4683c0c5552 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -158,6 +158,8 @@ actions!(
         SplitDown,
         SplitHorizontal,
         SplitVertical,
+        SwapItemLeft,
+        SwapItemRight,
         TogglePreviewTab,
         TogglePinTab,
     ]
@@ -1054,6 +1056,26 @@ impl Pane {
         self.activate_item(index, activate_pane, activate_pane, cx);
     }
 
+    pub fn swap_item_left(&mut self, cx: &mut ViewContext<Self>) {
+        let index = self.active_item_index;
+        if index == 0 {
+            return;
+        }
+
+        self.items.swap(index, index - 1);
+        self.activate_item(index - 1, true, true, cx);
+    }
+
+    pub fn swap_item_right(&mut self, cx: &mut ViewContext<Self>) {
+        let index = self.active_item_index;
+        if index + 1 == self.items.len() {
+            return;
+        }
+
+        self.items.swap(index, index + 1);
+        self.activate_item(index + 1, true, true, cx);
+    }
+
     pub fn close_active_item(
         &mut self,
         action: &CloseActiveItem,
@@ -2574,6 +2596,8 @@ impl Render for Pane {
             .on_action(cx.listener(|pane: &mut Pane, _: &ActivateNextItem, cx| {
                 pane.activate_next_item(true, cx);
             }))
+            .on_action(cx.listener(|pane, _: &SwapItemLeft, cx| pane.swap_item_left(cx)))
+            .on_action(cx.listener(|pane, _: &SwapItemRight, cx| pane.swap_item_right(cx)))
             .on_action(cx.listener(|pane, action, cx| {
                 pane.toggle_pin_tab(action, cx);
             }))
diff --git a/docs/src/key-bindings.md b/docs/src/key-bindings.md
index 2a97bc62a89178..989e101e7d9fbd 100644
--- a/docs/src/key-bindings.md
+++ b/docs/src/key-bindings.md
@@ -405,46 +405,48 @@ TBD: Add Column with Linux shortcuts
 
 #### Pane
 
-| **Command**                   | **Target**     | **Default Shortcut**    |
-| ----------------------------- | -------------- | ----------------------- |
-| Activate item 1               | Pane           | `Control + 1`           |
-| Activate item 2               | Pane           | `Control + 2`           |
-| Activate item 3               | Pane           | `Control + 3`           |
-| Activate item 4               | Pane           | `Control + 4`           |
-| Activate item 5               | Pane           | `Control + 5`           |
-| Activate item 6               | Pane           | `Control + 6`           |
-| Activate item 7               | Pane           | `Control + 7`           |
-| Activate item 8               | Pane           | `Control + 8`           |
-| Activate item 9               | Pane           | `Control + 9`           |
-| Activate last item            | Pane           | `Control + 0`           |
-| Activate next item            | Pane           | `Alt + ⌘ + Right`       |
-| Activate next item            | Pane           | `⌘ + }`                 |
-| Activate prev item            | Pane           | `Alt + ⌘ + Left`        |
-| Activate prev item            | Pane           | `⌘ + {`                 |
-| Close active item             | Pane           | `⌘ + W`                 |
-| Close all items               | Pane           | `⌘ + K, ⌘ + W`          |
-| Close clean items             | Pane           | `⌘ + K, U`              |
-| Close inactive items          | Pane           | `Alt + ⌘ + T`           |
-| Go back                       | Pane           | `Control + -`           |
-| Go forward                    | Pane           | `Control + Shift + _`   |
-| Reopen closed item            | Pane           | `⌘ + Shift + T`         |
-| Split down                    | Pane           | `⌘ + K, Down`           |
-| Split left                    | Pane           | `⌘ + K, Left`           |
-| Split right                   | Pane           | `⌘ + K, Right`          |
-| Split up                      | Pane           | `⌘ + K, Up`             |
-| Toggle filters                | Project Search | `Alt + ⌘ + F`           |
-| Toggle focus                  | Project Search | `⌘ + F`                 |
-| Toggle focus                  | Project Search | `⌘ + Shift + F`         |
-| Activate regex mode           | Search         | `Alt + ⌘ + G`           |
-| Activate text mode            | Search         | `Alt + ⌘ + X`           |
-| Cycle mode                    | Search         | `Alt + Tab`             |
-| Select all matches            | Search         | `Alt + Enter`           |
-| Select next match             | Search         | `⌘ + G`                 |
-| Select prev match             | Search         | `⌘ + Shift + G`         |
-| Toggle case sensitive         | Search         | `Alt + ⌘ + C`           |
-| Toggle replace                | Search         | `⌘ + Shift + H`         |
-| Toggle whole word             | Search         | `Alt + ⌘ + W`           |
-| Close inactive tabs and panes | Workspace      | `Control + Alt + ⌘ + W` |
+| **Command**                   | **Target**     | **Default Shortcut**          |
+| ----------------------------- | -------------- | ----------------------------- |
+| Activate item 1               | Pane           | `Control + 1`                 |
+| Activate item 2               | Pane           | `Control + 2`                 |
+| Activate item 3               | Pane           | `Control + 3`                 |
+| Activate item 4               | Pane           | `Control + 4`                 |
+| Activate item 5               | Pane           | `Control + 5`                 |
+| Activate item 6               | Pane           | `Control + 6`                 |
+| Activate item 7               | Pane           | `Control + 7`                 |
+| Activate item 8               | Pane           | `Control + 8`                 |
+| Activate item 9               | Pane           | `Control + 9`                 |
+| Activate last item            | Pane           | `Control + 0`                 |
+| Activate next item            | Pane           | `Alt + ⌘ + Right`             |
+| Activate next item            | Pane           | `⌘ + }`                       |
+| Activate prev item            | Pane           | `Alt + ⌘ + Left`              |
+| Activate prev item            | Pane           | `⌘ + {`                       |
+| Swap item to left             | Pane           | `Control + Shift + Page Up`   |
+| Swap item to right            | Pane           | `Control + Shift + Page Down` |
+| Close active item             | Pane           | `⌘ + W`                       |
+| Close all items               | Pane           | `⌘ + K, ⌘ + W`                |
+| Close clean items             | Pane           | `⌘ + K, U`                    |
+| Close inactive items          | Pane           | `Alt + ⌘ + T`                 |
+| Go back                       | Pane           | `Control + -`                 |
+| Go forward                    | Pane           | `Control + Shift + _`         |
+| Reopen closed item            | Pane           | `⌘ + Shift + T`               |
+| Split down                    | Pane           | `⌘ + K, Down`                 |
+| Split left                    | Pane           | `⌘ + K, Left`                 |
+| Split right                   | Pane           | `⌘ + K, Right`                |
+| Split up                      | Pane           | `⌘ + K, Up`                   |
+| Toggle filters                | Project Search | `Alt + ⌘ + F`                 |
+| Toggle focus                  | Project Search | `⌘ + F`                       |
+| Toggle focus                  | Project Search | `⌘ + Shift + F`               |
+| Activate regex mode           | Search         | `Alt + ⌘ + G`                 |
+| Activate text mode            | Search         | `Alt + ⌘ + X`                 |
+| Cycle mode                    | Search         | `Alt + Tab`                   |
+| Select all matches            | Search         | `Alt + Enter`                 |
+| Select next match             | Search         | `⌘ + G`                       |
+| Select prev match             | Search         | `⌘ + Shift + G`               |
+| Toggle case sensitive         | Search         | `Alt + ⌘ + C`                 |
+| Toggle replace                | Search         | `⌘ + Shift + H`               |
+| Toggle whole word             | Search         | `Alt + ⌘ + W`                 |
+| Close inactive tabs and panes | Workspace      | `Control + Alt + ⌘ + W`       |
 
 #### Buffer Search Bar
 

From c71f052276d57c93358b700d8022b5c8f1338289 Mon Sep 17 00:00:00 2001
From: jvmncs <7891333+jvmncs@users.noreply.github.com>
Date: Fri, 13 Sep 2024 15:42:15 -0400
Subject: [PATCH 071/762] Add ability to use o1-preview and o1-mini as custom
 models (#17804)

This is a barebones modification of the OpenAI provider code to
accommodate non-streaming completions. This is specifically for the o1
models, which do not support streaming. Tested that this is working by
running a `/workflow` with the following (arbitrarily chosen) settings:

```json
{
  "language_models": {
    "openai": {
      "version": "1",
      "available_models": [
        {
          "name": "o1-preview",
          "display_name": "o1-preview",
          "max_tokens": 128000,
          "max_completion_tokens": 30000
        },
        {
          "name": "o1-mini",
          "display_name": "o1-mini",
          "max_tokens": 128000,
          "max_completion_tokens": 20000
        }
      ]
    }
  },
}
```

Release Notes:

- Changed  `low_speed_timeout_in_seconds` option to `600` for OpenAI
provider to accommodate recent o1 model release.

---------

Co-authored-by: Peter <peter@zed.dev>
Co-authored-by: Bennet <bennet@zed.dev>
Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 assets/settings/default.json                  |   3 +-
 crates/assistant/src/assistant_settings.rs    |   2 +
 crates/assistant/src/inline_assistant.rs      |   2 +-
 crates/language_model/src/provider/cloud.rs   |   3 +
 crates/language_model/src/provider/open_ai.rs |   2 +
 crates/language_model/src/settings.rs         |   2 +
 crates/open_ai/src/open_ai.rs                 | 126 +++++++++++++++++-
 7 files changed, 136 insertions(+), 4 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 65254afb7cf72c..22dafb2890fb5a 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -916,7 +916,8 @@
     },
     "openai": {
       "version": "1",
-      "api_url": "https://api.openai.com/v1"
+      "api_url": "https://api.openai.com/v1",
+      "low_speed_timeout_in_seconds": 600
     }
   },
   // Zed's Prettier integration settings.
diff --git a/crates/assistant/src/assistant_settings.rs b/crates/assistant/src/assistant_settings.rs
index 7939eacd9344a3..e2c6a8eb24f088 100644
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -163,11 +163,13 @@ impl AssistantSettingsContent {
                                                     display_name,
                                                     max_tokens,
                                                     max_output_tokens,
+                                                    max_completion_tokens: None,
                                                 } => Some(open_ai::AvailableModel {
                                                     name,
                                                     display_name,
                                                     max_tokens,
                                                     max_output_tokens,
+                                                    max_completion_tokens: None,
                                                 }),
                                                 _ => None,
                                             })
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index 246a408477bb6e..b01a712a7e4e40 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -2407,7 +2407,7 @@ impl Codegen {
         Ok(LanguageModelRequest {
             messages,
             tools: Vec::new(),
-            stop: vec!["|END|>".to_string()],
+            stop: Vec::new(),
             temperature: 1.,
         })
     }
diff --git a/crates/language_model/src/provider/cloud.rs b/crates/language_model/src/provider/cloud.rs
index 0de7fb3feb49e2..f8f64ff3b84988 100644
--- a/crates/language_model/src/provider/cloud.rs
+++ b/crates/language_model/src/provider/cloud.rs
@@ -78,6 +78,8 @@ pub struct AvailableModel {
     pub max_tokens: usize,
     /// The maximum number of output tokens allowed by the model.
     pub max_output_tokens: Option<u32>,
+    /// The maximum number of completion tokens allowed by the model (o1-* only)
+    pub max_completion_tokens: Option<u32>,
     /// Override this model with a different Anthropic model for tool calls.
     pub tool_override: Option<String>,
     /// Indicates whether this custom model supports caching.
@@ -257,6 +259,7 @@ impl LanguageModelProvider for CloudLanguageModelProvider {
                     display_name: model.display_name.clone(),
                     max_tokens: model.max_tokens,
                     max_output_tokens: model.max_output_tokens,
+                    max_completion_tokens: model.max_completion_tokens,
                 }),
                 AvailableProvider::Google => CloudModel::Google(google_ai::Model::Custom {
                     name: model.name.clone(),
diff --git a/crates/language_model/src/provider/open_ai.rs b/crates/language_model/src/provider/open_ai.rs
index fe5e60caec8a95..98424a23aad8fe 100644
--- a/crates/language_model/src/provider/open_ai.rs
+++ b/crates/language_model/src/provider/open_ai.rs
@@ -43,6 +43,7 @@ pub struct AvailableModel {
     pub display_name: Option<String>,
     pub max_tokens: usize,
     pub max_output_tokens: Option<u32>,
+    pub max_completion_tokens: Option<u32>,
 }
 
 pub struct OpenAiLanguageModelProvider {
@@ -175,6 +176,7 @@ impl LanguageModelProvider for OpenAiLanguageModelProvider {
                     display_name: model.display_name.clone(),
                     max_tokens: model.max_tokens,
                     max_output_tokens: model.max_output_tokens,
+                    max_completion_tokens: model.max_completion_tokens,
                 },
             );
         }
diff --git a/crates/language_model/src/settings.rs b/crates/language_model/src/settings.rs
index 0059ed56c4c63b..80749c0bdb3736 100644
--- a/crates/language_model/src/settings.rs
+++ b/crates/language_model/src/settings.rs
@@ -178,11 +178,13 @@ impl OpenAiSettingsContent {
                                     display_name,
                                     max_tokens,
                                     max_output_tokens,
+                                    max_completion_tokens,
                                 } => Some(provider::open_ai::AvailableModel {
                                     name,
                                     max_tokens,
                                     max_output_tokens,
                                     display_name,
+                                    max_completion_tokens,
                                 }),
                                 _ => None,
                             })
diff --git a/crates/open_ai/src/open_ai.rs b/crates/open_ai/src/open_ai.rs
index 5b621d6bb844c3..7b0294bd9c0835 100644
--- a/crates/open_ai/src/open_ai.rs
+++ b/crates/open_ai/src/open_ai.rs
@@ -1,12 +1,21 @@
 mod supported_countries;
 
 use anyhow::{anyhow, Context, Result};
-use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, Stream, StreamExt};
+use futures::{
+    io::BufReader,
+    stream::{self, BoxStream},
+    AsyncBufReadExt, AsyncReadExt, Stream, StreamExt,
+};
 use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use isahc::config::Configurable;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use std::{convert::TryFrom, future::Future, pin::Pin, time::Duration};
+use std::{
+    convert::TryFrom,
+    future::{self, Future},
+    pin::Pin,
+    time::Duration,
+};
 use strum::EnumIter;
 
 pub use supported_countries::*;
@@ -72,6 +81,7 @@ pub enum Model {
         display_name: Option<String>,
         max_tokens: usize,
         max_output_tokens: Option<u32>,
+        max_completion_tokens: Option<u32>,
     },
 }
 
@@ -139,6 +149,7 @@ pub struct Request {
     pub stream: bool,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub max_tokens: Option<u32>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub stop: Vec<String>,
     pub temperature: f32,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -263,6 +274,111 @@ pub struct ResponseStreamEvent {
     pub usage: Option<Usage>,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Response {
+    pub id: String,
+    pub object: String,
+    pub created: u64,
+    pub model: String,
+    pub choices: Vec<Choice>,
+    pub usage: Usage,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Choice {
+    pub index: u32,
+    pub message: RequestMessage,
+    pub finish_reason: Option<String>,
+}
+
+pub async fn complete(
+    client: &dyn HttpClient,
+    api_url: &str,
+    api_key: &str,
+    request: Request,
+    low_speed_timeout: Option<Duration>,
+) -> Result<Response> {
+    let uri = format!("{api_url}/chat/completions");
+    let mut request_builder = HttpRequest::builder()
+        .method(Method::POST)
+        .uri(uri)
+        .header("Content-Type", "application/json")
+        .header("Authorization", format!("Bearer {}", api_key));
+    if let Some(low_speed_timeout) = low_speed_timeout {
+        request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
+    };
+
+    let mut request_body = request;
+    request_body.stream = false;
+
+    let request = request_builder.body(AsyncBody::from(serde_json::to_string(&request_body)?))?;
+    let mut response = client.send(request).await?;
+
+    if response.status().is_success() {
+        let mut body = String::new();
+        response.body_mut().read_to_string(&mut body).await?;
+        let response: Response = serde_json::from_str(&body)?;
+        Ok(response)
+    } else {
+        let mut body = String::new();
+        response.body_mut().read_to_string(&mut body).await?;
+
+        #[derive(Deserialize)]
+        struct OpenAiResponse {
+            error: OpenAiError,
+        }
+
+        #[derive(Deserialize)]
+        struct OpenAiError {
+            message: String,
+        }
+
+        match serde_json::from_str::<OpenAiResponse>(&body) {
+            Ok(response) if !response.error.message.is_empty() => Err(anyhow!(
+                "Failed to connect to OpenAI API: {}",
+                response.error.message,
+            )),
+
+            _ => Err(anyhow!(
+                "Failed to connect to OpenAI API: {} {}",
+                response.status(),
+                body,
+            )),
+        }
+    }
+}
+
+fn adapt_response_to_stream(response: Response) -> ResponseStreamEvent {
+    ResponseStreamEvent {
+        created: response.created as u32,
+        model: response.model,
+        choices: response
+            .choices
+            .into_iter()
+            .map(|choice| ChoiceDelta {
+                index: choice.index,
+                delta: ResponseMessageDelta {
+                    role: Some(match choice.message {
+                        RequestMessage::Assistant { .. } => Role::Assistant,
+                        RequestMessage::User { .. } => Role::User,
+                        RequestMessage::System { .. } => Role::System,
+                        RequestMessage::Tool { .. } => Role::Tool,
+                    }),
+                    content: match choice.message {
+                        RequestMessage::Assistant { content, .. } => content,
+                        RequestMessage::User { content } => Some(content),
+                        RequestMessage::System { content } => Some(content),
+                        RequestMessage::Tool { content, .. } => Some(content),
+                    },
+                    tool_calls: None,
+                },
+                finish_reason: choice.finish_reason,
+            })
+            .collect(),
+        usage: Some(response.usage),
+    }
+}
+
 pub async fn stream_completion(
     client: &dyn HttpClient,
     api_url: &str,
@@ -270,6 +386,12 @@ pub async fn stream_completion(
     request: Request,
     low_speed_timeout: Option<Duration>,
 ) -> Result<BoxStream<'static, Result<ResponseStreamEvent>>> {
+    if request.model == "o1-preview" || request.model == "o1-mini" {
+        let response = complete(client, api_url, api_key, request, low_speed_timeout).await;
+        let response_stream_event = response.map(adapt_response_to_stream);
+        return Ok(stream::once(future::ready(response_stream_event)).boxed());
+    }
+
     let uri = format!("{api_url}/chat/completions");
     let mut request_builder = HttpRequest::builder()
         .method(Method::POST)

From e145c13f731269bd361dc64602bc9fddf61684bf Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Fri, 13 Sep 2024 16:05:34 -0400
Subject: [PATCH 072/762] Add stray UI polish to the SSH flow (#17798)

Some super subtle refinement opportunities I spotted while playing
around with this flow. There are mostly copywriting tweaks and some UI
tweaks here and there (including editing the modal horizontal padding).

---

Release Notes:

- N/A
---
 crates/recent_projects/src/dev_servers.rs | 32 +++++++++++------------
 crates/ui/src/components/modal.rs         |  9 +++----
 2 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index d8b10f31f9f55e..491f378f30ce64 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -929,7 +929,7 @@ impl DevServerProjects {
                                 .on_click(
                                     cx.listener(move |this, _, cx| this.delete_ssh_server(ix, cx)),
                                 )
-                                .tooltip(|cx| Tooltip::text("Remove dev server", cx))
+                                .tooltip(|cx| Tooltip::text("Remove Dev Server", cx))
                         })),
                 ),
             )
@@ -1162,9 +1162,10 @@ impl DevServerProjects {
             })
         });
 
-        const MANUAL_SETUP_MESSAGE: &str = "Click create to generate a token for this server. The next step will provide instructions for setting zed up on that machine.";
+        const MANUAL_SETUP_MESSAGE: &str =
+            "Generate a token for this server and follow the steps to set Zed up on that machine.";
         const SSH_SETUP_MESSAGE: &str =
-            "Enter the command you use to ssh into this server.\nFor example: `ssh me@my.server` or `ssh me@secret-box:2222`.";
+            "Enter the command you use to SSH into this server.\nFor example: `ssh me@my.server` or `ssh me@secret-box:2222`.";
 
         Modal::new("create-dev-server", Some(self.scroll_handle.clone()))
             .header(
@@ -1191,6 +1192,7 @@ impl DevServerProjects {
                     .child(
                         v_flex()
                             .w_full()
+                            .px_2()
                             .gap_y(Spacing::Large.rems(cx))
                             .when(ssh_prompt.is_none(), |el| {
                                 el.child(
@@ -1346,9 +1348,9 @@ impl DevServerProjects {
     ) -> Div {
         self.markdown.update(cx, |markdown, cx| {
             if kind == NewServerKind::Manual {
-                markdown.reset(format!("Please log into '{}'. If you don't yet have zed installed, run:\n```\ncurl https://zed.dev/install.sh | bash\n```\nThen to start zed in headless mode:\n```\nzed --dev-server-token {}\n```", dev_server_name, access_token), cx);
+                markdown.reset(format!("Please log into '{}'. If you don't yet have Zed installed, run:\n```\ncurl https://zed.dev/install.sh | bash\n```\nThen, to start Zed in headless mode:\n```\nzed --dev-server-token {}\n```", dev_server_name, access_token), cx);
             } else {
-                markdown.reset("Please wait while we connect over SSH.\n\nIf you run into problems, please [file a bug](https://github.com/zed-industries/zed), and in the meantime try using manual setup.".to_string(), cx);
+                markdown.reset("Please wait while we connect over SSH.\n\nIf you run into problems, please [file a bug](https://github.com/zed-industries/zed), and in the meantime try using the manual setup.".to_string(), cx);
             }
         });
 
@@ -1420,15 +1422,14 @@ impl DevServerProjects {
             )
             .when(is_signed_out, |modal| {
                 modal
-                    .section(Section::new().child(v_flex().mb_4().child(Label::new(
-                        "You are not currently signed in to Zed. Currently the remote development features are only available to signed in users. Please sign in to continue.",
+                    .section(Section::new().child(div().child(Label::new(
+                        "To continue with the remote development features, you need to sign in to Zed.",
                     ))))
                     .footer(
                         ModalFooter::new().end_slot(
-                            Button::new("sign_in", "Sign in")
+                            Button::new("sign_in", "Sign in with GitHub")
                                 .icon(IconName::Github)
                                 .icon_position(IconPosition::Start)
-                                .style(ButtonStyle::Filled)
                                 .full_width()
                                 .on_click(cx.listener(|_, _, cx| {
                                     let client = Client::global(cx).clone();
@@ -1447,17 +1448,15 @@ impl DevServerProjects {
             .when(!is_signed_out, |modal| {
                 modal.section(
                     Section::new().child(
-                        div().mb_4().child(
+                        div().child(
                             List::new()
-                                .empty_message("No dev servers registered.")
+                                .empty_message("No dev servers registered yet.")
                                 .header(Some(
                                     ListHeader::new("Connections").end_slot(
-                                        Button::new("register-dev-server-button", "Connect")
+                                        Button::new("register-dev-server-button", "Connect New Server")
                                             .icon(IconName::Plus)
                                             .icon_position(IconPosition::Start)
-                                            .tooltip(|cx| {
-                                                Tooltip::text("Connect to a new server", cx)
-                                            })
+                                            .icon_color(Color::Muted)
                                             .on_click(cx.listener(|this, _, cx| {
                                                 this.mode = Mode::CreateDevServer(
                                                     CreateDevServer {
@@ -1524,6 +1523,7 @@ impl Render for DevServerProjects {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         div()
             .track_focus(&self.focus_handle)
+            .p_2()
             .elevation_3(cx)
             .key_context("DevServerModal")
             .on_action(cx.listener(Self::cancel))
@@ -1590,7 +1590,7 @@ pub fn reconnect_to_dev_server(
     cx: &mut WindowContext,
 ) -> Task<Result<()>> {
     let Some(ssh_connection_string) = dev_server.ssh_connection_string else {
-        return Task::ready(Err(anyhow!("can't reconnect, no ssh_connection_string")));
+        return Task::ready(Err(anyhow!("Can't reconnect, no ssh_connection_string")));
     };
     let dev_server_store = dev_server_projects::Store::global(cx);
     let get_access_token = dev_server_store.update(cx, |store, cx| {
diff --git a/crates/ui/src/components/modal.rs b/crates/ui/src/components/modal.rs
index de85ee9dafa3ee..dec7a14a52fe5e 100644
--- a/crates/ui/src/components/modal.rs
+++ b/crates/ui/src/components/modal.rs
@@ -1,6 +1,6 @@
 use crate::{
-    h_flex, rems_from_px, v_flex, Clickable, Color, Headline, HeadlineSize, IconButton,
-    IconButtonShape, IconName, Label, LabelCommon, LabelSize, Spacing,
+    h_flex, v_flex, Clickable, Color, Headline, HeadlineSize, IconButton, IconButtonShape,
+    IconName, Label, LabelCommon, LabelSize, Spacing,
 };
 use gpui::{prelude::FluentBuilder, *};
 use smallvec::SmallVec;
@@ -210,7 +210,7 @@ impl ParentElement for ModalRow {
 
 impl RenderOnce for ModalRow {
     fn render(self, _cx: &mut WindowContext) -> impl IntoElement {
-        h_flex().w_full().px_2().py_1().children(self.children)
+        h_flex().w_full().py_1().children(self.children)
     }
 }
 
@@ -326,7 +326,6 @@ impl RenderOnce for Section {
                     .border_color(cx.theme().colors().border)
                     .bg(section_bg)
                     .py(Spacing::Medium.rems(cx))
-                    .px(Spacing::Large.rems(cx) - rems_from_px(1.0))
                     .gap_y(Spacing::Small.rems(cx))
                     .child(div().flex().flex_1().size_full().children(self.children)),
             )
@@ -334,7 +333,7 @@ impl RenderOnce for Section {
             v_flex()
                 .w_full()
                 .gap_y(Spacing::Small.rems(cx))
-                .px(Spacing::Large.rems(cx) + Spacing::Large.rems(cx))
+                .px(Spacing::Medium.rems(cx) + Spacing::Medium.rems(cx))
                 .children(self.children)
         };
 

From d245f5e75cb095444cbe582ee7d4765e551faa99 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 13 Sep 2024 16:23:55 -0400
Subject: [PATCH 073/762] OpenAI o1-preview and o1-mini support (#17796)

Release Notes:

- Added support for OpenAI o1-mini and o1-preview models.

---------

Co-authored-by: Jason Mancuso <7891333+jvmncs@users.noreply.github.com>
Co-authored-by: Bennet <bennet@zed.dev>
---
 .../language_model/src/model/cloud_model.rs   |  2 ++
 crates/language_model/src/provider/open_ai.rs | 11 +++++---
 crates/language_model/src/request.rs          |  3 ++-
 crates/open_ai/src/open_ai.rs                 | 27 ++++++++++++++-----
 docs/src/assistant/configuration.md           | 10 +++++--
 5 files changed, 39 insertions(+), 14 deletions(-)

diff --git a/crates/language_model/src/model/cloud_model.rs b/crates/language_model/src/model/cloud_model.rs
index be0812eab90e70..2ce48931f6d4db 100644
--- a/crates/language_model/src/model/cloud_model.rs
+++ b/crates/language_model/src/model/cloud_model.rs
@@ -102,6 +102,8 @@ impl CloudModel {
                 | open_ai::Model::FourTurbo
                 | open_ai::Model::FourOmni
                 | open_ai::Model::FourOmniMini
+                | open_ai::Model::O1Mini
+                | open_ai::Model::O1Preview
                 | open_ai::Model::Custom { .. } => {
                     LanguageModelAvailability::RequiresPlan(Plan::ZedPro)
                 }
diff --git a/crates/language_model/src/provider/open_ai.rs b/crates/language_model/src/provider/open_ai.rs
index 98424a23aad8fe..222c1530412aab 100644
--- a/crates/language_model/src/provider/open_ai.rs
+++ b/crates/language_model/src/provider/open_ai.rs
@@ -372,10 +372,13 @@ pub fn count_open_ai_tokens(
                 })
                 .collect::<Vec<_>>();
 
-            if let open_ai::Model::Custom { .. } = model {
-                tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)
-            } else {
-                tiktoken_rs::num_tokens_from_messages(model.id(), &messages)
+            match model {
+                open_ai::Model::Custom { .. }
+                | open_ai::Model::O1Mini
+                | open_ai::Model::O1Preview => {
+                    tiktoken_rs::num_tokens_from_messages("gpt-4", &messages)
+                }
+                _ => tiktoken_rs::num_tokens_from_messages(model.id(), &messages),
             }
         })
         .boxed()
diff --git a/crates/language_model/src/request.rs b/crates/language_model/src/request.rs
index 4162e9df87037a..dd480b8aaf38c2 100644
--- a/crates/language_model/src/request.rs
+++ b/crates/language_model/src/request.rs
@@ -241,6 +241,7 @@ pub struct LanguageModelRequest {
 
 impl LanguageModelRequest {
     pub fn into_open_ai(self, model: String, max_output_tokens: Option<u32>) -> open_ai::Request {
+        let stream = !model.starts_with("o1-");
         open_ai::Request {
             model,
             messages: self
@@ -259,7 +260,7 @@ impl LanguageModelRequest {
                     },
                 })
                 .collect(),
-            stream: true,
+            stream,
             stop: self.stop,
             temperature: self.temperature,
             max_tokens: max_output_tokens,
diff --git a/crates/open_ai/src/open_ai.rs b/crates/open_ai/src/open_ai.rs
index 7b0294bd9c0835..e67fe1af27cdb8 100644
--- a/crates/open_ai/src/open_ai.rs
+++ b/crates/open_ai/src/open_ai.rs
@@ -63,17 +63,22 @@ impl From<Role> for String {
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
 pub enum Model {
-    #[serde(rename = "gpt-3.5-turbo", alias = "gpt-3.5-turbo-0613")]
+    #[serde(rename = "gpt-3.5-turbo", alias = "gpt-3.5-turbo")]
     ThreePointFiveTurbo,
-    #[serde(rename = "gpt-4", alias = "gpt-4-0613")]
+    #[serde(rename = "gpt-4", alias = "gpt-4")]
     Four,
-    #[serde(rename = "gpt-4-turbo-preview", alias = "gpt-4-1106-preview")]
+    #[serde(rename = "gpt-4-turbo", alias = "gpt-4-turbo")]
     FourTurbo,
-    #[serde(rename = "gpt-4o", alias = "gpt-4o-2024-05-13")]
+    #[serde(rename = "gpt-4o", alias = "gpt-4o")]
     #[default]
     FourOmni,
-    #[serde(rename = "gpt-4o-mini", alias = "gpt-4o-mini-2024-07-18")]
+    #[serde(rename = "gpt-4o-mini", alias = "gpt-4o-mini")]
     FourOmniMini,
+    #[serde(rename = "o1-preview", alias = "o1-preview")]
+    O1Preview,
+    #[serde(rename = "o1-mini", alias = "o1-mini")]
+    O1Mini,
+
     #[serde(rename = "custom")]
     Custom {
         name: String,
@@ -93,6 +98,8 @@ impl Model {
             "gpt-4-turbo-preview" => Ok(Self::FourTurbo),
             "gpt-4o" => Ok(Self::FourOmni),
             "gpt-4o-mini" => Ok(Self::FourOmniMini),
+            "o1-preview" => Ok(Self::O1Preview),
+            "o1-mini" => Ok(Self::O1Mini),
             _ => Err(anyhow!("invalid model id")),
         }
     }
@@ -101,9 +108,11 @@ impl Model {
         match self {
             Self::ThreePointFiveTurbo => "gpt-3.5-turbo",
             Self::Four => "gpt-4",
-            Self::FourTurbo => "gpt-4-turbo-preview",
+            Self::FourTurbo => "gpt-4-turbo",
             Self::FourOmni => "gpt-4o",
             Self::FourOmniMini => "gpt-4o-mini",
+            Self::O1Preview => "o1-preview",
+            Self::O1Mini => "o1-mini",
             Self::Custom { name, .. } => name,
         }
     }
@@ -115,6 +124,8 @@ impl Model {
             Self::FourTurbo => "gpt-4-turbo",
             Self::FourOmni => "gpt-4o",
             Self::FourOmniMini => "gpt-4o-mini",
+            Self::O1Preview => "o1-preview",
+            Self::O1Mini => "o1-mini",
             Self::Custom {
                 name, display_name, ..
             } => display_name.as_ref().unwrap_or(name),
@@ -123,11 +134,13 @@ impl Model {
 
     pub fn max_token_count(&self) -> usize {
         match self {
-            Self::ThreePointFiveTurbo => 4096,
+            Self::ThreePointFiveTurbo => 16385,
             Self::Four => 8192,
             Self::FourTurbo => 128000,
             Self::FourOmni => 128000,
             Self::FourOmniMini => 128000,
+            Self::O1Preview => 128000,
+            Self::O1Mini => 128000,
             Self::Custom { max_tokens, .. } => *max_tokens,
         }
     }
diff --git a/docs/src/assistant/configuration.md b/docs/src/assistant/configuration.md
index 0fd242c6191b4d..4d9870e8960a0a 100644
--- a/docs/src/assistant/configuration.md
+++ b/docs/src/assistant/configuration.md
@@ -165,7 +165,7 @@ Zed will also use the `OPENAI_API_KEY` environment variable if it's defined.
 
 #### OpenAI Custom Models {#openai-custom-models}
 
-The Zed Assistant comes pre-configured to use the latest version for common models (GPT-3.5 Turbo, GPT-4, GPT-4 Turbo, GPT-4o, GPT-4o mini). If you wish to use alternate models, perhaps a preview release or a dated model release, you can do so by adding the following to your Zed `settings.json`:
+The Zed Assistant comes pre-configured to use the latest version for common models (GPT-3.5 Turbo, GPT-4, GPT-4 Turbo, GPT-4o, GPT-4o mini). If you wish to use alternate models, perhaps a preview release or a dated model release or you wish to control the request parameters you can do so by adding the following to your Zed `settings.json`:
 
 ```json
 {
@@ -176,6 +176,12 @@ The Zed Assistant comes pre-configured to use the latest version for common mode
           "provider": "openai",
           "name": "gpt-4o-2024-08-06",
           "max_tokens": 128000
+        },
+        {
+          "name": "o1-mini",
+          "display_name": "o1-mini",
+          "max_tokens": 128000,
+          "max_completion_tokens": 20000
         }
       ]
     }
@@ -183,7 +189,7 @@ The Zed Assistant comes pre-configured to use the latest version for common mode
 }
 ```
 
-You must provide the model's Context Window in the `max_tokens` parameter, this can be found [OpenAI Model Docs](https://platform.openai.com/docs/models). Custom models will be listed in the model dropdown in the assistant panel.
+You must provide the model's Context Window in the `max_tokens` parameter, this can be found [OpenAI Model Docs](https://platform.openai.com/docs/models). OpenAI `o1` models should set `max_completion_tokens` as well to avoid incurring high reasoning token costs. Custom models will be listed in the model dropdown in the assistant panel.
 
 ### Advanced configuration {#advanced-configuration}
 

From fac9ee5f861b501b4ca79ab04d410eeb49d9ec5e Mon Sep 17 00:00:00 2001
From: Nate Butler <iamnbutler@gmail.com>
Date: Fri, 13 Sep 2024 16:45:16 -0400
Subject: [PATCH 074/762] Add `ui_macros` crate & `DerivePathStr` derive macro
 (#17811)

This PR adds the `ui_macros` crate to allow building supporting macros
for the `ui` crate.

Additionally, it implements the `DerivePathStr` derive macro and the
`path_str` attribute macro. These macros work together to generate a
`path` method for enum variants, which is useful for creating
standardized string representations of enum variants.

The `DerivePathStr` macro provides the following functionality:
- Generates a `path` method for each enum variant.
- Allows specifying a prefix (required) and suffix (optional) for all
paths.
- Supports `strum` attributes for case conversion (e.g., snake_case,
lowercase).

Usage example:

```rust
#[derive(DerivePathStr)]
#[path_str(prefix = "my_prefix", suffix = ".txt")]
#[strum(serialize_all = "snake_case")]
enum MyEnum {
    VariantOne,
    VariantTwo,
}

// Generated paths:
// MyEnum::VariantOne.path() -> "my_prefix/variant_one.txt"
// MyEnum::VariantTwo.path() -> "my_prefix/variant_two.txt"
```

In a later PR this will be used to automate the creation of icon & image
paths in the `ui` crate.

This gives the following benefits:

1. Ensures standard naming of assets as paths are not manually
specified.
2. Makes adding new enum variants less tedious and error-prone.
3. Quickly catches missing or incorrect paths during compilation.
3. Adds a building block towards being able to lint for unused assets in
the future.

Release Notes:

- N/A
---
 Cargo.lock                              |  11 +++
 Cargo.toml                              |   3 +
 crates/editor/Cargo.toml                |   2 +-
 crates/ui/Cargo.toml                    |   1 +
 crates/ui/src/path_str.rs               |  33 ++++++++
 crates/ui/src/ui.rs                     |   1 +
 crates/ui_macros/Cargo.toml             |  19 +++++
 crates/ui_macros/LICENSE-GPL            |   1 +
 crates/ui_macros/src/derive_path_str.rs | 105 ++++++++++++++++++++++++
 crates/ui_macros/src/ui_macros.rs       |  53 ++++++++++++
 10 files changed, 228 insertions(+), 1 deletion(-)
 create mode 100644 crates/ui/src/path_str.rs
 create mode 100644 crates/ui_macros/Cargo.toml
 create mode 120000 crates/ui_macros/LICENSE-GPL
 create mode 100644 crates/ui_macros/src/derive_path_str.rs
 create mode 100644 crates/ui_macros/src/ui_macros.rs

diff --git a/Cargo.lock b/Cargo.lock
index 793cb66ad77b07..79f4e803a8461a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12273,6 +12273,7 @@ dependencies = [
  "story",
  "strum 0.25.0",
  "theme",
+ "ui_macros",
  "windows 0.58.0",
 ]
 
@@ -12287,6 +12288,16 @@ dependencies = [
  "ui",
 ]
 
+[[package]]
+name = "ui_macros"
+version = "0.1.0"
+dependencies = [
+ "convert_case 0.6.0",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "unicase"
 version = "2.7.0"
diff --git a/Cargo.toml b/Cargo.toml
index 53109002fa1139..726ffe0cca3782 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -118,6 +118,7 @@ members = [
     "crates/title_bar",
     "crates/ui",
     "crates/ui_input",
+    "crates/ui_macros",
     "crates/util",
     "crates/vcs_menu",
     "crates/vim",
@@ -292,6 +293,7 @@ time_format = { path = "crates/time_format" }
 title_bar = { path = "crates/title_bar" }
 ui = { path = "crates/ui" }
 ui_input = { path = "crates/ui_input" }
+ui_macros = { path = "crates/ui_macros" }
 util = { path = "crates/util" }
 vcs_menu = { path = "crates/vcs_menu" }
 vim = { path = "crates/vim" }
@@ -333,6 +335,7 @@ chrono = { version = "0.4", features = ["serde"] }
 clap = { version = "4.4", features = ["derive"] }
 clickhouse = "0.11.6"
 cocoa = "0.26"
+convert_case = "0.6.0"
 core-foundation = "0.9.3"
 core-foundation-sys = "0.8.6"
 ctor = "0.2.6"
diff --git a/crates/editor/Cargo.toml b/crates/editor/Cargo.toml
index 324201b41ebaa0..b1cc59ace60322 100644
--- a/crates/editor/Cargo.toml
+++ b/crates/editor/Cargo.toml
@@ -35,7 +35,7 @@ chrono.workspace = true
 client.workspace = true
 clock.workspace = true
 collections.workspace = true
-convert_case = "0.6.0"
+convert_case.workspace = true
 db.workspace = true
 emojis.workspace = true
 file_icons.workspace = true
diff --git a/crates/ui/Cargo.toml b/crates/ui/Cargo.toml
index 71e67cb1842a43..594814ae2a4b27 100644
--- a/crates/ui/Cargo.toml
+++ b/crates/ui/Cargo.toml
@@ -23,6 +23,7 @@ smallvec.workspace = true
 story = { workspace = true, optional = true }
 strum = { workspace = true, features = ["derive"] }
 theme.workspace = true
+ui_macros.workspace = true
 
 [target.'cfg(windows)'.dependencies]
 windows.workspace = true
diff --git a/crates/ui/src/path_str.rs b/crates/ui/src/path_str.rs
new file mode 100644
index 00000000000000..2ebb3fedb36266
--- /dev/null
+++ b/crates/ui/src/path_str.rs
@@ -0,0 +1,33 @@
+#[cfg(test)]
+mod tests {
+    use strum::EnumString;
+    use ui_macros::{path_str, DerivePathStr};
+
+    #[test]
+    fn test_derive_path_str_with_prefix() {
+        #[derive(Debug, EnumString, DerivePathStr)]
+        #[strum(serialize_all = "snake_case")]
+        #[path_str(prefix = "test_prefix")]
+        enum MyEnum {
+            FooBar,
+            Baz,
+        }
+
+        assert_eq!(MyEnum::FooBar.path(), "test_prefix/foo_bar");
+        assert_eq!(MyEnum::Baz.path(), "test_prefix/baz");
+    }
+
+    #[test]
+    fn test_derive_path_str_with_prefix_and_suffix() {
+        #[derive(Debug, EnumString, DerivePathStr)]
+        #[strum(serialize_all = "snake_case")]
+        #[path_str(prefix = "test_prefix", suffix = ".txt")]
+        enum MyEnum {
+            FooBar,
+            Baz,
+        }
+
+        assert_eq!(MyEnum::FooBar.path(), "test_prefix/foo_bar.txt");
+        assert_eq!(MyEnum::Baz.path(), "test_prefix/baz.txt");
+    }
+}
diff --git a/crates/ui/src/ui.rs b/crates/ui/src/ui.rs
index a0146c69fac7c0..4f5d6314bea6a6 100644
--- a/crates/ui/src/ui.rs
+++ b/crates/ui/src/ui.rs
@@ -8,6 +8,7 @@ mod components;
 mod disableable;
 mod fixed;
 mod key_bindings;
+mod path_str;
 pub mod prelude;
 mod selectable;
 mod styled_ext;
diff --git a/crates/ui_macros/Cargo.toml b/crates/ui_macros/Cargo.toml
new file mode 100644
index 00000000000000..72009f1162cc8d
--- /dev/null
+++ b/crates/ui_macros/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "ui_macros"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/ui_macros.rs"
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0.66"
+quote = "1.0.9"
+syn = { version = "1.0.72", features = ["full", "extra-traits"] }
+convert_case.workspace = true
diff --git a/crates/ui_macros/LICENSE-GPL b/crates/ui_macros/LICENSE-GPL
new file mode 120000
index 00000000000000..89e542f750cd38
--- /dev/null
+++ b/crates/ui_macros/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
\ No newline at end of file
diff --git a/crates/ui_macros/src/derive_path_str.rs b/crates/ui_macros/src/derive_path_str.rs
new file mode 100644
index 00000000000000..3988bc0c5c2e08
--- /dev/null
+++ b/crates/ui_macros/src/derive_path_str.rs
@@ -0,0 +1,105 @@
+use convert_case::{Case, Casing};
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, Attribute, Data, DeriveInput, Lit, Meta, NestedMeta};
+
+pub fn derive_path_str(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+
+    let prefix = get_attr_value(&input.attrs, "prefix").expect("prefix attribute is required");
+    let suffix = get_attr_value(&input.attrs, "suffix").unwrap_or_else(|| "".to_string());
+
+    let serialize_all = get_strum_serialize_all(&input.attrs);
+    let path_str_impl = impl_path_str(name, &input.data, &prefix, &suffix, serialize_all);
+
+    let expanded = quote! {
+        impl #name {
+            pub fn path(&self) -> &'static str {
+                #path_str_impl
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}
+
+fn impl_path_str(
+    name: &syn::Ident,
+    data: &Data,
+    prefix: &str,
+    suffix: &str,
+    serialize_all: Option<String>,
+) -> proc_macro2::TokenStream {
+    match *data {
+        Data::Enum(ref data) => {
+            let match_arms = data.variants.iter().map(|variant| {
+                let ident = &variant.ident;
+                let variant_name = if let Some(ref case) = serialize_all {
+                    match case.as_str() {
+                        "snake_case" => ident.to_string().to_case(Case::Snake),
+                        "lowercase" => ident.to_string().to_lowercase(),
+                        _ => ident.to_string(),
+                    }
+                } else {
+                    ident.to_string()
+                };
+                let path = format!("{}/{}{}", prefix, variant_name, suffix);
+                quote! {
+                    #name::#ident => #path,
+                }
+            });
+
+            quote! {
+                match self {
+                    #(#match_arms)*
+                }
+            }
+        }
+        _ => panic!("DerivePathStr only supports enums"),
+    }
+}
+
+fn get_strum_serialize_all(attrs: &[Attribute]) -> Option<String> {
+    attrs
+        .iter()
+        .filter(|attr| attr.path.is_ident("strum"))
+        .find_map(|attr| {
+            if let Ok(Meta::List(meta_list)) = attr.parse_meta() {
+                meta_list.nested.iter().find_map(|nested_meta| {
+                    if let NestedMeta::Meta(Meta::NameValue(name_value)) = nested_meta {
+                        if name_value.path.is_ident("serialize_all") {
+                            if let Lit::Str(lit_str) = &name_value.lit {
+                                return Some(lit_str.value());
+                            }
+                        }
+                    }
+                    None
+                })
+            } else {
+                None
+            }
+        })
+}
+
+fn get_attr_value(attrs: &[Attribute], key: &str) -> Option<String> {
+    attrs
+        .iter()
+        .filter(|attr| attr.path.is_ident("path_str"))
+        .find_map(|attr| {
+            if let Ok(Meta::List(meta_list)) = attr.parse_meta() {
+                meta_list.nested.iter().find_map(|nested_meta| {
+                    if let NestedMeta::Meta(Meta::NameValue(name_value)) = nested_meta {
+                        if name_value.path.is_ident(key) {
+                            if let Lit::Str(lit_str) = &name_value.lit {
+                                return Some(lit_str.value());
+                            }
+                        }
+                    }
+                    None
+                })
+            } else {
+                None
+            }
+        })
+}
diff --git a/crates/ui_macros/src/ui_macros.rs b/crates/ui_macros/src/ui_macros.rs
new file mode 100644
index 00000000000000..a625caefd5111b
--- /dev/null
+++ b/crates/ui_macros/src/ui_macros.rs
@@ -0,0 +1,53 @@
+mod derive_path_str;
+
+use proc_macro::TokenStream;
+
+/// Derives the `path` method for an enum.
+///
+/// This macro generates a `path` method for each variant of the enum, which returns a string
+/// representation of the enum variant's path. The path is constructed using a prefix and
+/// optionally a suffix, which are specified using attributes.
+///
+/// # Attributes
+///
+/// - `#[path_str(prefix = "...")]`: Required. Specifies the prefix for all paths.
+/// - `#[path_str(suffix = "...")]`: Optional. Specifies a suffix for all paths.
+/// - `#[strum(serialize_all = "...")]`: Optional. Specifies the case conversion for variant names.
+///
+/// # Example
+///
+/// ```
+/// use strum::EnumString;
+/// use ui_macros::{path_str, DerivePathStr};
+///
+/// #[derive(EnumString, DerivePathStr)]
+/// #[path_str(prefix = "my_prefix", suffix = ".txt")]
+/// #[strum(serialize_all = "snake_case")]
+/// enum MyEnum {
+///     VariantOne,
+///     VariantTwo,
+/// }
+///
+/// // These assertions would work if we could instantiate the enum
+/// // assert_eq!(MyEnum::VariantOne.path(), "my_prefix/variant_one.txt");
+/// // assert_eq!(MyEnum::VariantTwo.path(), "my_prefix/variant_two.txt");
+/// ```
+///
+/// # Panics
+///
+/// This macro will panic if used on anything other than an enum.
+#[proc_macro_derive(DerivePathStr, attributes(path_str))]
+pub fn derive_path_str(input: TokenStream) -> TokenStream {
+    derive_path_str::derive_path_str(input)
+}
+
+/// A marker attribute for use with `DerivePathStr`.
+///
+/// This attribute is used to specify the prefix and suffix for the `path` method
+/// generated by `DerivePathStr`. It doesn't modify the input and is only used as a
+/// marker for the derive macro.
+#[proc_macro_attribute]
+pub fn path_str(_args: TokenStream, input: TokenStream) -> TokenStream {
+    // This attribute doesn't modify the input, it's just a marker
+    input
+}

From ce848375fe6511c2e167a9d002af8af4772bf08c Mon Sep 17 00:00:00 2001
From: Nate Butler <iamnbutler@gmail.com>
Date: Fri, 13 Sep 2024 17:44:16 -0400
Subject: [PATCH 075/762] add `ui::Vector` and separate images from icons
 (#17815)

This PR pulls non-icon assets out of `ui::components::icon` in
preparation for icon standardization.

In the future icons will have standard names and sizes, and these image
assets won't conform to those constraints.

We can also add a `ui::components::image::Image` wrapper around the
`gpui::img` element in the future for any Zed-specific image styling we
want to enforce.

Of note:

```rust
#[derive(Debug, PartialEq, Eq, Copy, Clone, EnumIter, EnumString, IntoStaticStr, Serialize, Deserialize, DerivePathStr)]
#[strum(serialize_all = "snake_case")]
#[path_str(prefix = "images", suffix = ".svg")]
pub enum VectorName {
    ZedLogo,
    ZedXCopilot,
}
```

You can see in the above code we no longer need to manually specify
paths for image/icon enums like we currently do in
`ui::components::icon`.

The icon component will get this same treatment in the future, once we:

- do the design work needed to standardize the icons
- remove unused icons
- update icon names

Release Notes:

- N/A
---
 assets/images/zed_logo.svg                    |  10 ++
 assets/images/zed_x_copilot.svg               |  14 +++
 crates/assets/src/assets.rs                   |   1 +
 crates/copilot/src/sign_in.rs                 |  12 +-
 .../gpui_macros/src/derive_path_static_str.rs |  73 +++++++++++
 crates/gpui_macros/src/gpui_macros.rs         |   7 ++
 crates/storybook/src/assets.rs                |   1 +
 crates/storybook/src/story_selector.rs        |   2 +
 crates/ui/src/components.rs                   |   4 +
 crates/ui/src/components/icon.rs              |   2 -
 crates/ui/src/components/image.rs             | 115 ++++++++++++++++++
 11 files changed, 231 insertions(+), 10 deletions(-)
 create mode 100644 assets/images/zed_logo.svg
 create mode 100644 assets/images/zed_x_copilot.svg
 create mode 100644 crates/gpui_macros/src/derive_path_static_str.rs
 create mode 100644 crates/ui/src/components/image.rs

diff --git a/assets/images/zed_logo.svg b/assets/images/zed_logo.svg
new file mode 100644
index 00000000000000..d1769449c19840
--- /dev/null
+++ b/assets/images/zed_logo.svg
@@ -0,0 +1,10 @@
+<svg width="96" height="96" viewBox="0 0 96 96" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_1957_1318)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M9 6C7.34315 6 6 7.34315 6 9V75H0V9C0 4.02944 4.02944 0 9 0H89.3787C93.3878 0 95.3955 4.84715 92.5607 7.68198L43.0551 57.1875H57V51H63V58.6875C63 61.1728 60.9853 63.1875 58.5 63.1875H37.0551L26.7426 73.5H73.5V36H79.5V73.5C79.5 76.8137 76.8137 79.5 73.5 79.5H20.7426L10.2426 90H87C88.6569 90 90 88.6569 90 87V21H96V87C96 91.9706 91.9706 96 87 96H6.62132C2.61224 96 0.604504 91.1529 3.43934 88.318L52.7574 39H39V45H33V37.5C33 35.0147 35.0147 33 37.5 33H58.7574L69.2574 22.5H22.5V60H16.5V22.5C16.5 19.1863 19.1863 16.5 22.5 16.5H75.2574L85.7574 6H9Z" fill="black"/>
+</g>
+<defs>
+<clipPath id="clip0_1957_1318">
+<rect width="96" height="96" fill="white"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/assets/images/zed_x_copilot.svg b/assets/images/zed_x_copilot.svg
new file mode 100644
index 00000000000000..3c5be71074c195
--- /dev/null
+++ b/assets/images/zed_x_copilot.svg
@@ -0,0 +1,14 @@
+<svg width="93" height="32" viewBox="0 0 93 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M9.03994 7.04962C8.00934 7.67635 7.30394 8.63219 7.30394 10.0149C7.30394 11.6908 7.72423 12.5893 8.20468 13.0744C8.68379 13.5581 9.40524 13.8149 10.4054 13.8149C11.815 13.8149 13.0291 13.5336 13.8802 12.9464C14.6756 12.3977 15.2708 11.5042 15.3438 9.96182C15.3991 8.79382 15.3678 8.01341 15.0568 7.45711C14.8094 7.01449 14.2326 6.47436 12.4901 6.27416C11.4684 6.15678 10.1114 6.39804 9.03994 7.04962ZM7.8731 5.13084C9.39145 4.2075 11.2531 3.87155 12.7464 4.04312C14.8843 4.28874 16.2844 5.05049 17.0171 6.36142C17.6863 7.55867 17.6384 8.98348 17.587 10.068C17.484 12.2439 16.5804 13.8118 15.1554 14.7949C13.7861 15.7396 12.0582 16.0606 10.4054 16.0606C9.04199 16.0606 7.65126 15.7069 6.60911 14.6547C5.5683 13.6038 5.05823 12.0408 5.05823 10.0149C5.05823 7.6958 6.31388 6.07903 7.8731 5.13084Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M13.983 18.2811C14.6595 18.2811 15.2079 18.8295 15.2079 19.506V22.16C15.2079 22.8365 14.6595 23.385 13.983 23.385C13.3065 23.385 12.758 22.8365 12.758 22.16V19.506C12.758 18.8295 13.3065 18.2811 13.983 18.2811Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M5.25567 14.8903C5.48362 14.039 5.99219 12.9059 7.20735 12.5361L7.92069 14.8798L7.92376 14.8785C7.92375 14.8785 7.92323 14.8778 7.92069 14.8798C7.91365 14.8852 7.89134 14.9052 7.85879 14.951C7.78817 15.0505 7.70058 15.2311 7.62217 15.524C7.46355 16.1164 7.40615 16.9168 7.40617 17.7813V22.1675C7.43457 22.3571 7.45083 22.438 7.48149 22.5189C7.50698 22.5862 7.55955 22.695 7.72277 22.8617C8.0938 23.2406 8.94056 23.8264 10.9275 24.7081C12.5399 25.4236 13.2749 25.7456 13.9586 25.9166C14.6053 26.0784 15.2382 26.1115 16.6666 26.1115V28.5613C15.2536 28.5613 14.3395 28.5372 13.3641 28.2932C12.452 28.0651 11.5174 27.6502 10.0614 27.004C10.0193 26.9853 9.9768 26.9664 9.93383 26.9474C7.89761 26.0438 6.6867 25.3053 5.97233 24.5757C5.59285 24.1882 5.34579 23.7967 5.19056 23.387C5.05419 23.0271 5.00551 22.6875 4.9751 22.4754C4.97301 22.4608 4.971 22.4468 4.96906 22.4335L4.9563 22.3458V17.7814C4.95628 16.8606 5.01201 15.8003 5.25567 14.8903Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M3.98306 15.3589C4.62844 14.6695 5.39976 13.9884 5.99652 13.6348L7.24552 15.7424C6.93706 15.9252 6.34938 16.4159 5.77155 17.0332C5.21994 17.6224 4.85695 18.1377 4.73071 18.4254C4.70277 18.6674 4.71195 19.116 4.78977 19.648C4.87834 20.2536 5.01731 20.7033 5.10492 20.8628L5.19261 21.0224L5.23006 21.2007C5.28661 21.4698 5.55952 21.8651 6.30146 22.3907C6.88143 22.8015 7.56502 23.1703 8.29605 23.5648C8.45794 23.6521 8.62215 23.7407 8.78809 23.8313C9.5952 24.2156 10.848 24.7773 12.0191 25.2425C12.613 25.4784 13.1698 25.6831 13.6288 25.8268C13.8584 25.8987 14.0505 25.9512 14.2021 25.9847C14.3503 26.0175 14.4185 26.0227 14.4277 26.0234C14.4288 26.0234 14.4281 26.0234 14.4277 26.0234L14.4287 28.4733C13.9646 28.4733 13.3889 28.3188 12.8968 28.1648C12.3562 27.9955 11.7367 27.7664 11.1147 27.5193C9.86871 27.0244 8.54832 26.4314 7.70298 26.028L7.67249 26.0135L7.64284 25.9973C7.49779 25.918 7.34502 25.8357 7.18702 25.7506C6.4505 25.354 5.60004 24.896 4.88539 24.3898C4.08363 23.8219 3.18153 23.0135 2.87437 21.8785C2.61828 21.3365 2.4557 20.618 2.3657 20.0026C2.26537 19.3167 2.2169 18.4951 2.33888 17.8727L2.35434 17.7938L2.37996 17.7176C2.6522 16.9085 3.36219 16.0221 3.98306 15.3589Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M3.48529 21.264V17.1402H5.93516V21.264H3.48529Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M24.2932 7.04962C25.3238 7.67635 26.0292 8.63219 26.0292 10.0149C26.0292 11.6908 25.609 12.5893 25.1285 13.0744C24.6494 13.5581 23.9279 13.8149 22.9278 13.8149C21.5182 13.8149 20.3041 13.5336 19.453 12.9464C18.6576 12.3977 18.0624 11.5042 17.9894 9.96182C17.9341 8.79382 17.9654 8.01341 18.2764 7.45711C18.5238 7.01449 19.1006 6.47436 20.8431 6.27416C21.8648 6.15678 23.2218 6.39804 24.2932 7.04962ZM25.4601 5.13084C23.9417 4.2075 22.0801 3.87155 20.5868 4.04312C18.4489 4.28874 17.0488 5.05049 16.3161 6.36142C15.6469 7.55867 15.6948 8.98348 15.7462 10.068C15.8492 12.2439 16.7528 13.8118 18.1778 14.7949C19.5471 15.7396 21.275 16.0606 22.9278 16.0606C24.2912 16.0606 25.6819 15.7069 26.7241 14.6547C27.7649 13.6038 28.275 12.0408 28.275 10.0149C28.275 7.6958 27.0193 6.07903 25.4601 5.13084Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M19.3502 18.2811C18.6737 18.2811 18.1253 18.8295 18.1253 19.506V22.16C18.1253 22.8365 18.6737 23.385 19.3502 23.385C20.0267 23.385 20.5752 22.8365 20.5752 22.16V19.506C20.5752 18.8295 20.0267 18.2811 19.3502 18.2811Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M28.0775 14.8903C27.8496 14.039 27.341 12.9059 26.1259 12.5361L25.4125 14.8798L25.4095 14.8785C25.4095 14.8785 25.41 14.8778 25.4125 14.8798C25.4196 14.8852 25.4419 14.9052 25.4744 14.951C25.545 15.0505 25.6326 15.2311 25.711 15.524C25.8697 16.1164 25.9271 16.9168 25.927 17.7813V22.1675C25.8986 22.3571 25.8824 22.438 25.8517 22.5189C25.8262 22.5862 25.7737 22.695 25.6104 22.8617C25.2394 23.2406 24.3927 23.8264 22.4057 24.7081C20.7933 25.4236 20.0583 25.7456 19.3746 25.9166C18.7279 26.0784 18.0949 26.1115 16.6666 26.1115V28.5613C18.0796 28.5613 18.9937 28.5372 19.9691 28.2932C20.8812 28.0651 21.8158 27.6502 23.2718 27.004C23.3139 26.9853 23.3564 26.9664 23.3994 26.9474C25.4356 26.0438 26.6465 25.3053 27.3609 24.5757C27.7404 24.1882 27.9874 23.7967 28.1427 23.387C28.279 23.0271 28.3277 22.6875 28.3581 22.4754C28.3602 22.4608 28.3622 22.4468 28.3642 22.4335L28.3769 22.3458V17.7814C28.3769 16.8606 28.3212 15.8003 28.0775 14.8903Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M29.3501 15.3589C28.7048 14.6695 27.9334 13.9884 27.3367 13.6348L26.0877 15.7424C26.3961 15.9252 26.9838 16.4159 27.5616 17.0332C28.1133 17.6224 28.4763 18.1377 28.6025 18.4254C28.6304 18.6674 28.6213 19.116 28.5434 19.648C28.4549 20.2536 28.3159 20.7033 28.2283 20.8628L28.1406 21.0224L28.1031 21.2007C28.0466 21.4698 27.7737 21.8651 27.0317 22.3907C26.4518 22.8015 25.7682 23.1703 25.0372 23.5648C24.8753 23.6521 24.711 23.7407 24.5451 23.8313C23.738 24.2156 22.4852 24.7773 21.3141 25.2425C20.7202 25.4784 20.1634 25.6831 19.7044 25.8268C19.4748 25.8987 19.2827 25.9512 19.1311 25.9847C18.9829 26.0175 18.9147 26.0227 18.9055 26.0234C18.9051 26.0234 18.9044 26.0234 18.9055 26.0234L18.9045 28.4733C19.3686 28.4733 19.9443 28.3188 20.4364 28.1648C20.977 27.9955 21.5965 27.7664 22.2185 27.5193C23.4645 27.0244 24.7849 26.4314 25.6302 26.028L25.6607 26.0135L25.6904 25.9973C25.8354 25.918 25.9882 25.8357 26.1462 25.7506C26.8827 25.354 27.7332 24.896 28.4478 24.3898C29.2496 23.8219 30.1517 23.0135 30.4588 21.8785C30.7149 21.3365 30.8775 20.618 30.9675 20.0026C31.0678 19.3167 31.1163 18.4951 30.9943 17.8727L30.9789 17.7938L30.9532 17.7176C30.681 16.9085 29.971 16.0221 29.3501 15.3589Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M29.8479 21.264V17.1402H27.398V21.264H29.8479Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M48.6666 11C49.2189 11 49.6666 11.4477 49.6666 12V15H52.6666C53.2189 15 53.6666 15.4477 53.6666 16C53.6666 16.5523 53.2189 17 52.6666 17H49.6666V20C49.6666 20.5523 49.2189 21 48.6666 21C48.1143 21 47.6666 20.5523 47.6666 20V17H44.6666C44.1143 17 43.6666 16.5523 43.6666 16C43.6666 15.4477 44.1143 15 44.6666 15H47.6666V12C47.6666 11.4477 48.1143 11 48.6666 11Z" fill="black" fill-opacity="0.5"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M67.1666 4.33329C66.7064 4.33329 66.3333 4.70639 66.3333 5.16663V23.5H64.6666V5.16663C64.6666 3.78591 65.7859 2.66663 67.1666 2.66663H89.494C90.6077 2.66663 91.1654 4.01306 90.3779 4.80051L76.6264 18.552H80.5V16.8333H82.1666V18.9687C82.1666 19.6591 81.607 20.2187 80.9166 20.2187H74.9597L72.0951 23.0833H85.0833V12.6666H86.75V23.0833C86.75 24.0038 86.0038 24.75 85.0833 24.75H70.4285L67.5118 27.6666H88.8333C89.2935 27.6666 89.6666 27.2935 89.6666 26.8333V8.49996H91.3333V26.8333C91.3333 28.214 90.214 29.3333 88.8333 29.3333H66.5059C65.3922 29.3333 64.8345 27.9869 65.622 27.1994L79.3214 13.5H75.5V15.1666H73.8333V13.0833C73.8333 12.3929 74.3929 11.8333 75.0833 11.8333H80.9881L83.9048 8.91663H70.9166V19.3333H69.25V8.91663C69.25 7.99615 69.9962 7.24996 70.9166 7.24996H85.5714L88.4881 4.33329H67.1666Z" fill="black"/>
+</svg>
diff --git a/crates/assets/src/assets.rs b/crates/assets/src/assets.rs
index 395cbf62f6ce5e..ee990085f6de17 100644
--- a/crates/assets/src/assets.rs
+++ b/crates/assets/src/assets.rs
@@ -8,6 +8,7 @@ use rust_embed::RustEmbed;
 #[folder = "../../assets"]
 #[include = "fonts/**/*"]
 #[include = "icons/**/*"]
+#[include = "images/**/*"]
 #[include = "themes/**/*"]
 #[exclude = "themes/src/*"]
 #[include = "sounds/**/*"]
diff --git a/crates/copilot/src/sign_in.rs b/crates/copilot/src/sign_in.rs
index 1d14e5c1aadc55..da6b969b7222bb 100644
--- a/crates/copilot/src/sign_in.rs
+++ b/crates/copilot/src/sign_in.rs
@@ -1,10 +1,10 @@
 use crate::{request::PromptUserDeviceFlow, Copilot, Status};
 use gpui::{
-    div, svg, AppContext, ClipboardItem, DismissEvent, Element, EventEmitter, FocusHandle,
+    div, AppContext, ClipboardItem, DismissEvent, Element, EventEmitter, FocusHandle,
     FocusableView, InteractiveElement, IntoElement, Model, MouseDownEvent, ParentElement, Render,
     Styled, Subscription, ViewContext,
 };
-use ui::{prelude::*, Button, IconName, Label};
+use ui::{prelude::*, Button, Label, Vector, VectorName};
 use workspace::ModalView;
 
 const COPILOT_SIGN_UP_URL: &str = "https://github.com/features/copilot";
@@ -198,12 +198,8 @@ impl Render for CopilotCodeVerification {
                 cx.focus(&this.focus_handle);
             }))
             .child(
-                svg()
-                    .w_32()
-                    .h_16()
-                    .flex_none()
-                    .path(IconName::ZedXCopilot.path())
-                    .text_color(cx.theme().colors().icon),
+                Vector::new(VectorName::ZedXCopilot, rems(8.), rems(4.))
+                    .color(Color::Custom(cx.theme().colors().icon)),
             )
             .child(prompt)
     }
diff --git a/crates/gpui_macros/src/derive_path_static_str.rs b/crates/gpui_macros/src/derive_path_static_str.rs
new file mode 100644
index 00000000000000..25531fd2adf9d5
--- /dev/null
+++ b/crates/gpui_macros/src/derive_path_static_str.rs
@@ -0,0 +1,73 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, Attribute, Data, DeriveInput, Lit, Meta, NestedMeta};
+
+pub fn derive_path_static_str(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+
+    let prefix = get_attr_value(&input.attrs, "prefix").unwrap_or_else(|| "".to_string());
+    let suffix = get_attr_value(&input.attrs, "suffix").unwrap_or_else(|| "".to_string());
+    let delimiter = get_attr_value(&input.attrs, "delimiter").unwrap_or_else(|| "/".to_string());
+
+    let path_str_impl = impl_path_str(name, &input.data, &prefix, &suffix, &delimiter);
+
+    let expanded = quote! {
+        impl #name {
+            pub fn path_str(&self) -> &'static str {
+                #path_str_impl
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}
+
+fn impl_path_str(
+    name: &syn::Ident,
+    data: &Data,
+    prefix: &str,
+    suffix: &str,
+    delimiter: &str,
+) -> proc_macro2::TokenStream {
+    match *data {
+        Data::Enum(ref data) => {
+            let match_arms = data.variants.iter().map(|variant| {
+                let ident = &variant.ident;
+                let path = format!("{}{}{}{}{}", prefix, delimiter, ident, delimiter, suffix);
+                quote! {
+                    #name::#ident => #path,
+                }
+            });
+
+            quote! {
+                match self {
+                    #(#match_arms)*
+                }
+            }
+        }
+        _ => panic!("DerivePathStr only supports enums"),
+    }
+}
+
+fn get_attr_value(attrs: &[Attribute], key: &str) -> Option<String> {
+    attrs
+        .iter()
+        .filter(|attr| attr.path.is_ident("derive_path_static_str"))
+        .find_map(|attr| {
+            if let Ok(Meta::List(meta_list)) = attr.parse_meta() {
+                meta_list.nested.iter().find_map(|nested_meta| {
+                    if let NestedMeta::Meta(Meta::NameValue(name_value)) = nested_meta {
+                        if name_value.path.is_ident(key) {
+                            if let Lit::Str(lit_str) = &name_value.lit {
+                                return Some(lit_str.value());
+                            }
+                        }
+                    }
+                    None
+                })
+            } else {
+                None
+            }
+        })
+}
diff --git a/crates/gpui_macros/src/gpui_macros.rs b/crates/gpui_macros/src/gpui_macros.rs
index c4cf5358b3e756..09cf4027d2f37c 100644
--- a/crates/gpui_macros/src/gpui_macros.rs
+++ b/crates/gpui_macros/src/gpui_macros.rs
@@ -1,4 +1,5 @@
 mod derive_into_element;
+mod derive_path_static_str;
 mod derive_render;
 mod register_action;
 mod styles;
@@ -27,6 +28,12 @@ pub fn derive_render(input: TokenStream) -> TokenStream {
     derive_render::derive_render(input)
 }
 
+#[proc_macro_derive(PathStaticStr)]
+#[doc(hidden)]
+pub fn derive_path_static_str(input: TokenStream) -> TokenStream {
+    derive_path_static_str::derive_path_static_str(input)
+}
+
 /// Used by GPUI to generate the style helpers.
 #[proc_macro]
 #[doc(hidden)]
diff --git a/crates/storybook/src/assets.rs b/crates/storybook/src/assets.rs
index da874e5f2de143..f45d1457df91fc 100644
--- a/crates/storybook/src/assets.rs
+++ b/crates/storybook/src/assets.rs
@@ -8,6 +8,7 @@ use rust_embed::RustEmbed;
 #[folder = "../../assets"]
 #[include = "fonts/**/*"]
 #[include = "icons/**/*"]
+#[include = "images/**/*"]
 #[include = "themes/**/*"]
 #[include = "sounds/**/*"]
 #[include = "*.md"]
diff --git a/crates/storybook/src/story_selector.rs b/crates/storybook/src/story_selector.rs
index 5df02b1df2f488..881fd83f8f21b9 100644
--- a/crates/storybook/src/story_selector.rs
+++ b/crates/storybook/src/story_selector.rs
@@ -40,6 +40,7 @@ pub enum ComponentStory {
     ToolStrip,
     ViewportUnits,
     WithRemSize,
+    Vector,
 }
 
 impl ComponentStory {
@@ -75,6 +76,7 @@ impl ComponentStory {
             Self::ToolStrip => cx.new_view(|_| ui::ToolStripStory).into(),
             Self::ViewportUnits => cx.new_view(|_| crate::stories::ViewportUnitsStory).into(),
             Self::WithRemSize => cx.new_view(|_| crate::stories::WithRemSizeStory).into(),
+            Self::Vector => cx.new_view(|_| ui::VectorStory).into(),
         }
     }
 }
diff --git a/crates/ui/src/components.rs b/crates/ui/src/components.rs
index 3a56e46eae49c7..fe63b035027afb 100644
--- a/crates/ui/src/components.rs
+++ b/crates/ui/src/components.rs
@@ -7,6 +7,7 @@ mod divider;
 mod dropdown_menu;
 mod facepile;
 mod icon;
+mod image;
 mod indicator;
 mod keybinding;
 mod label;
@@ -37,6 +38,7 @@ pub use divider::*;
 pub use dropdown_menu::*;
 pub use facepile::*;
 pub use icon::*;
+pub use image::*;
 pub use indicator::*;
 pub use keybinding::*;
 pub use label::*;
@@ -55,5 +57,7 @@ pub use tab_bar::*;
 pub use tool_strip::*;
 pub use tooltip::*;
 
+#[cfg(feature = "stories")]
+pub use image::story::*;
 #[cfg(feature = "stories")]
 pub use stories::*;
diff --git a/crates/ui/src/components/icon.rs b/crates/ui/src/components/icon.rs
index 0001ab4a2b275b..fd4f17ac0e0ef7 100644
--- a/crates/ui/src/components/icon.rs
+++ b/crates/ui/src/components/icon.rs
@@ -271,7 +271,6 @@ pub enum IconName {
     XCircle,
     ZedAssistant,
     ZedAssistantFilled,
-    ZedXCopilot,
     Visible,
 }
 
@@ -443,7 +442,6 @@ impl IconName {
             IconName::XCircle => "icons/error.svg",
             IconName::ZedAssistant => "icons/zed_assistant.svg",
             IconName::ZedAssistantFilled => "icons/zed_assistant_filled.svg",
-            IconName::ZedXCopilot => "icons/zed_x_copilot.svg",
             IconName::Visible => "icons/visible.svg",
         }
     }
diff --git a/crates/ui/src/components/image.rs b/crates/ui/src/components/image.rs
new file mode 100644
index 00000000000000..286fe7f56f3e31
--- /dev/null
+++ b/crates/ui/src/components/image.rs
@@ -0,0 +1,115 @@
+use gpui::{svg, IntoElement, Rems, RenderOnce, Size, Styled, WindowContext};
+use serde::{Deserialize, Serialize};
+use strum::{EnumIter, EnumString, IntoStaticStr};
+use ui_macros::{path_str, DerivePathStr};
+
+use crate::Color;
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    Copy,
+    Clone,
+    EnumIter,
+    EnumString,
+    IntoStaticStr,
+    Serialize,
+    Deserialize,
+    DerivePathStr,
+)]
+#[strum(serialize_all = "snake_case")]
+#[path_str(prefix = "images", suffix = ".svg")]
+pub enum VectorName {
+    ZedLogo,
+    ZedXCopilot,
+}
+
+/// A vector image, such as an SVG.
+///
+/// A [Vector] is different from an [Icon] in that it is intended
+/// to be displayed at a specific size, or series of sizes, rather
+/// than conforming to the standard size of an icons.
+#[derive(IntoElement)]
+pub struct Vector {
+    path: &'static str,
+    color: Color,
+    size: Size<Rems>,
+}
+
+impl Vector {
+    /// Create a new [Vector] image with the given [VectorName] and size.
+    pub fn new(vector: VectorName, width: Rems, height: Rems) -> Self {
+        Self {
+            path: vector.path(),
+            color: Color::default(),
+            size: Size { width, height },
+        }
+    }
+
+    /// Create a new [Vector] image where the width and height are the same.
+    pub fn square(vector: VectorName, size: Rems) -> Self {
+        Self::new(vector, size, size)
+    }
+
+    /// Set the image color
+    pub fn color(mut self, color: Color) -> Self {
+        self.color = color;
+        self
+    }
+
+    /// Set the image size
+    pub fn size(mut self, size: impl Into<Size<Rems>>) -> Self {
+        let size = size.into();
+
+        self.size = size;
+        self
+    }
+}
+
+impl RenderOnce for Vector {
+    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
+        let width = self.size.width;
+        let height = self.size.height;
+
+        svg()
+            // By default, prevent the SVG from stretching
+            // to fill its container.
+            .flex_none()
+            .w(width)
+            .h(height)
+            .path(self.path)
+            .text_color(self.color.color(cx))
+    }
+}
+
+#[cfg(feature = "stories")]
+pub mod story {
+    use gpui::Render;
+    use story::{Story, StoryItem, StorySection};
+    use strum::IntoEnumIterator;
+
+    use crate::prelude::*;
+
+    use super::{Vector, VectorName};
+
+    pub struct VectorStory;
+
+    impl Render for VectorStory {
+        fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+            Story::container().child(StorySection::new().children(VectorName::iter().map(
+                |vector| StoryItem::new(format!("{:?}", vector), Vector::square(vector, rems(8.))),
+            )))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn vector_path() {
+        assert_eq!(VectorName::ZedLogo.path(), "images/zed_logo.svg");
+    }
+}

From e8a2dd92c82f56d01067aa9966eaaf095a7e657c Mon Sep 17 00:00:00 2001
From: Nate Butler <iamnbutler@gmail.com>
Date: Fri, 13 Sep 2024 21:12:29 -0400
Subject: [PATCH 076/762] Derive icon paths (#17816)

This PR improves adding and working with icons by using the new
`DerivePathStr` to derive icon paths.

This means paths no longer need to be manually specified, and the
`IconName` and file name will always be consistent between icons.

This PR does not do any work to standardize icons visually, remove
unused icons, or any other such cleanup.

Release Notes:

- N/A
---
 assets/icons/audio_off.svg                    |   1 +
 assets/icons/audio_on.svg                     |   1 +
 ...ase_insensitive.svg => case_sensitive.svg} |   0
 assets/icons/{x.svg => close.svg}             |   0
 .../{text_select.svg => cursor_i_beam.svg}    |   0
 .../{text-cursor.svg => cursor_text.svg}      |   0
 assets/icons/{feedback.svg => envelope.svg}   |   0
 assets/icons/file_doc.svg                     |   6 +
 assets/icons/file_generic.svg                 |   5 +
 assets/icons/file_git.svg                     |   6 +
 assets/icons/file_lock.svg                    |   4 +
 assets/icons/file_rust.svg                    |   4 +
 assets/icons/file_toml.svg                    |   5 +
 assets/icons/{project.svg => file_tree.svg}   |   0
 assets/icons/folder.svg                       |   3 +
 assets/icons/folder_open.svg                  |   4 +
 .../icons/{stop_sharing.svg => folder_x.svg}  |   0
 ...{conversations.svg => message_bubbles.svg} |   0
 assets/icons/{desktop.svg => screen.svg}      |   0
 assets/icons/settings.svg                     |   4 +
 .../{sliders-alt.svg => settings_alt.svg}     |   0
 assets/icons/speaker_off.svg                  |   8 -
 .../{user_group_16.svg => user_group.svg}     |   0
 .../icons/{word_search.svg => whole_word.svg} |   0
 assets/icons/{error.svg => x_circle.svg}      |   0
 .../src/activity_indicator.rs                 |   6 +-
 crates/assistant/src/assistant_panel.rs       |   6 +-
 crates/assistant/src/inline_assistant.rs      |   2 +-
 .../src/slash_command/diagnostics_command.rs  |   4 +-
 .../src/terminal_inline_assistant.rs          |   2 +-
 crates/collab_ui/src/collab_panel.rs          |   2 +-
 crates/diagnostics/src/diagnostics.rs         |   4 +-
 crates/diagnostics/src/items.rs               |   4 +-
 crates/diagnostics/src/toolbar_controls.rs    |   2 +-
 .../quick_action_bar/src/quick_action_bar.rs  |   2 +-
 crates/terminal_view/src/terminal_view.rs     |   2 +-
 crates/ui/src/components/icon.rs              | 219 +++---------------
 .../ui/src/components/stories/list_header.rs  |   2 +-
 crates/workspace/src/notifications.rs         |  14 +-
 39 files changed, 96 insertions(+), 226 deletions(-)
 create mode 100644 assets/icons/audio_off.svg
 create mode 100644 assets/icons/audio_on.svg
 rename assets/icons/{case_insensitive.svg => case_sensitive.svg} (100%)
 rename assets/icons/{x.svg => close.svg} (100%)
 rename assets/icons/{text_select.svg => cursor_i_beam.svg} (100%)
 rename assets/icons/{text-cursor.svg => cursor_text.svg} (100%)
 rename assets/icons/{feedback.svg => envelope.svg} (100%)
 create mode 100644 assets/icons/file_doc.svg
 create mode 100644 assets/icons/file_generic.svg
 create mode 100644 assets/icons/file_git.svg
 create mode 100644 assets/icons/file_lock.svg
 create mode 100644 assets/icons/file_rust.svg
 create mode 100644 assets/icons/file_toml.svg
 rename assets/icons/{project.svg => file_tree.svg} (100%)
 create mode 100644 assets/icons/folder.svg
 create mode 100644 assets/icons/folder_open.svg
 rename assets/icons/{stop_sharing.svg => folder_x.svg} (100%)
 rename assets/icons/{conversations.svg => message_bubbles.svg} (100%)
 rename assets/icons/{desktop.svg => screen.svg} (100%)
 create mode 100644 assets/icons/settings.svg
 rename assets/icons/{sliders-alt.svg => settings_alt.svg} (100%)
 delete mode 100644 assets/icons/speaker_off.svg
 rename assets/icons/{user_group_16.svg => user_group.svg} (100%)
 rename assets/icons/{word_search.svg => whole_word.svg} (100%)
 rename assets/icons/{error.svg => x_circle.svg} (100%)

diff --git a/assets/icons/audio_off.svg b/assets/icons/audio_off.svg
new file mode 100644
index 00000000000000..93b98471ca1a15
--- /dev/null
+++ b/assets/icons/audio_off.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-volume-off"><path d="M16 9a5 5 0 0 1 .95 2.293"/><path d="M19.364 5.636a9 9 0 0 1 1.889 9.96"/><path d="m2 2 20 20"/><path d="m7 7-.587.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298V11"/><path d="M9.828 4.172A.686.686 0 0 1 11 4.657v.686"/></svg>
diff --git a/assets/icons/audio_on.svg b/assets/icons/audio_on.svg
new file mode 100644
index 00000000000000..42310ea32c289e
--- /dev/null
+++ b/assets/icons/audio_on.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-volume-2"><path d="M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"/><path d="M16 9a5 5 0 0 1 0 6"/><path d="M19.364 18.364a9 9 0 0 0 0-12.728"/></svg>
diff --git a/assets/icons/case_insensitive.svg b/assets/icons/case_sensitive.svg
similarity index 100%
rename from assets/icons/case_insensitive.svg
rename to assets/icons/case_sensitive.svg
diff --git a/assets/icons/x.svg b/assets/icons/close.svg
similarity index 100%
rename from assets/icons/x.svg
rename to assets/icons/close.svg
diff --git a/assets/icons/text_select.svg b/assets/icons/cursor_i_beam.svg
similarity index 100%
rename from assets/icons/text_select.svg
rename to assets/icons/cursor_i_beam.svg
diff --git a/assets/icons/text-cursor.svg b/assets/icons/cursor_text.svg
similarity index 100%
rename from assets/icons/text-cursor.svg
rename to assets/icons/cursor_text.svg
diff --git a/assets/icons/feedback.svg b/assets/icons/envelope.svg
similarity index 100%
rename from assets/icons/feedback.svg
rename to assets/icons/envelope.svg
diff --git a/assets/icons/file_doc.svg b/assets/icons/file_doc.svg
new file mode 100644
index 00000000000000..3b11995f36759e
--- /dev/null
+++ b/assets/icons/file_doc.svg
@@ -0,0 +1,6 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M13 11V11.8374C13 11.9431 12.9665 12.046 12.9044 12.1315L12.1498 13.1691C12.0557 13.2985 11.9054 13.375 11.7454 13.375H4.25461C4.09464 13.375 3.94433 13.2985 3.85024 13.1691L3.09563 12.1315C3.03348 12.046 3 11.9431 3 11.8374V3" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+<path d="M3 13V11L8 12H13V13H3Z" fill="black"/>
+<path d="M6.63246 3.04418C7.44914 3.31641 8 4.08069 8 4.94155V11.7306C8 12.0924 7.62757 12.3345 7.29693 12.1875L3.79693 10.632C3.61637 10.5518 3.5 10.3727 3.5 10.1751V2.69374C3.5 2.35246 3.83435 2.11148 4.15811 2.2194L6.63246 3.04418Z" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M9.5 3C8.67157 3 8 3.67157 8 4.5V13C8 12.1954 11.2366 12.0382 12.5017 12.0075C12.7778 12.0008 13 11.7761 13 11.5V3.5C13 3.22386 12.7761 3 12.5 3H9.5Z" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
diff --git a/assets/icons/file_generic.svg b/assets/icons/file_generic.svg
new file mode 100644
index 00000000000000..3c72bd3320d9e8
--- /dev/null
+++ b/assets/icons/file_generic.svg
@@ -0,0 +1,5 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3 5H11" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+<path d="M3 8H13" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+<path d="M3 11H9" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+</svg>
diff --git a/assets/icons/file_git.svg b/assets/icons/file_git.svg
new file mode 100644
index 00000000000000..197db2e9e60f26
--- /dev/null
+++ b/assets/icons/file_git.svg
@@ -0,0 +1,6 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5 13C6.10457 13 7 12.1046 7 11C7 9.89543 6.10457 9 5 9C3.89543 9 3 9.89543 3 11C3 12.1046 3.89543 13 5 13Z" stroke="black" stroke-width="1.5"/>
+<path d="M11 7C12.1046 7 13 6.10457 13 5C13 3.89543 12.1046 3 11 3C9.89543 3 9 3.89543 9 5C9 6.10457 9.89543 7 11 7Z" fill="black" stroke="black" stroke-width="1.5"/>
+<path d="M4.625 3.625V8.375" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+<path d="M11 7C11 9.20914 9.20914 11 7 11" stroke="black" stroke-width="1.5"/>
+</svg>
diff --git a/assets/icons/file_lock.svg b/assets/icons/file_lock.svg
new file mode 100644
index 00000000000000..6bfef249b4516f
--- /dev/null
+++ b/assets/icons/file_lock.svg
@@ -0,0 +1,4 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5 5C5 3.89543 5.89543 3 7 3H9C10.1046 3 11 3.89543 11 5V6H5V5Z" stroke="black" stroke-width="1.5"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M3.25 6.5C3.25 5.80964 3.80964 5.25 4.5 5.25H11.5C12.1904 5.25 12.75 5.80964 12.75 6.5V12.5C12.75 13.1904 12.1904 13.75 11.5 13.75H4.5C3.80964 13.75 3.25 13.1904 3.25 12.5V6.5ZM8.75 9.66146C8.90559 9.48517 9 9.25361 9 9C9 8.44772 8.55228 8 8 8C7.44772 8 7 8.44772 7 9C7 9.25361 7.09441 9.48517 7.25 9.66146V11C7.25 11.4142 7.58579 11.75 8 11.75C8.41421 11.75 8.75 11.4142 8.75 11V9.66146Z" fill="black"/>
+</svg>
diff --git a/assets/icons/file_rust.svg b/assets/icons/file_rust.svg
new file mode 100644
index 00000000000000..5db753628af10c
--- /dev/null
+++ b/assets/icons/file_rust.svg
@@ -0,0 +1,4 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5.27935 10.9821C5.32063 10.4038 4.9204 9.89049 4.35998 9.80276L3.60081 9.68387C3.37979 9.64945 3.20167 9.48001 3.15225 9.25614L3.01378 8.63511C2.96382 8.41235 3.05233 8.1807 3.23696 8.05125L3.8631 7.61242C4.33337 7.28297 4.47456 6.6369 4.18621 6.13364L3.79467 5.45092C3.68118 5.25261 3.69801 5.00374 3.83757 4.82321L4.22314 4.32436C4.3627 4.14438 4.59621 4.06994 4.81071 4.13772L5.57531 4.37769C6.11944 4.54879 6.70048 4.26159 6.90683 3.71886L7.1811 2.99782C7.26255 2.78395 7.46345 2.64285 7.68772 2.6423L8.31007 2.64063C8.53434 2.64007 8.73579 2.78006 8.81834 2.99337L9.09965 3.72275C9.30821 4.26214 9.88655 4.54712 10.429 4.37714L11.1632 4.14716C11.3772 4.07994 11.6096 4.15382 11.7492 4.3327L12.1374 4.83099" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M8.76988 11.5933C8.76988 11.6595 8.8236 11.7133 8.88988 11.7133H8.97588C9.32602 11.7133 9.60988 11.9971 9.60988 12.3472C9.60988 12.6974 9.32602 12.9812 8.97588 12.9812H7.05587C6.70573 12.9812 6.42188 12.6974 6.42188 12.3472C6.42188 11.9971 6.70573 11.7133 7.05587 11.7133H7.14188C7.20815 11.7133 7.26188 11.6595 7.26188 11.5933V7.66925C7.26188 7.60298 7.20815 7.54925 7.14188 7.54925H7.05588C6.70573 7.54925 6.42188 7.2654 6.42188 6.91525C6.42188 6.5651 6.70573 6.28125 7.05588 6.28125H9.89988C11.0518 6.28125 12.8619 6.71487 12.8619 8.15185C12.8619 8.67078 12.7284 9.10362 12.4642 9.45348C12.1981 9.79765 11.8458 10.0564 11.4056 10.2293C11.3782 10.2401 11.3673 10.273 11.3829 10.298L12.2163 11.6342C12.247 11.6834 12.3008 11.7133 12.3588 11.7133H12.7319C13.082 11.7133 13.3659 11.9971 13.3659 12.3472C13.3659 12.6974 13.082 12.9812 12.7319 12.9812H11.5637C11.4955 12.9812 11.432 12.9465 11.3952 12.889L9.96523 10.6541C9.92847 10.5966 9.86495 10.5618 9.79675 10.5618H8.96988C8.85942 10.5618 8.76988 10.6514 8.76988 10.7619V11.5933ZM9.61188 7.54925C10.0296 7.54925 11.125 7.54925 11.2339 8.18785C11.2975 8.56123 11.1181 8.86557 10.8812 9.07715C10.6423 9.29046 10.2053 9.38985 9.58788 9.38985H8.86988C8.81465 9.38985 8.76988 9.34508 8.76988 9.28985V7.64925C8.76988 7.59402 8.81465 7.54925 8.86988 7.54925H9.61188Z" fill="black"/>
+</svg>
diff --git a/assets/icons/file_toml.svg b/assets/icons/file_toml.svg
new file mode 100644
index 00000000000000..9ab78af50f9302
--- /dev/null
+++ b/assets/icons/file_toml.svg
@@ -0,0 +1,5 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M6 6H10" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+<path d="M8 6V11" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+<path d="M5 3H3.5C3.22386 3 3 3.22386 3 3.5V12.5C3 12.7761 3.22386 13 3.5 13H5M11 3H12.5C12.7761 3 13 3.22386 13 3.5V12.5C13 12.7761 12.7761 13 12.5 13H11" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+</svg>
diff --git a/assets/icons/project.svg b/assets/icons/file_tree.svg
similarity index 100%
rename from assets/icons/project.svg
rename to assets/icons/file_tree.svg
diff --git a/assets/icons/folder.svg b/assets/icons/folder.svg
new file mode 100644
index 00000000000000..a76dc63d1a6639
--- /dev/null
+++ b/assets/icons/folder.svg
@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M8.26046 3.97337C8.3527 4.17617 8.4795 4.47151 8.57375 4.69341C8.65258 4.87898 8.83437 4.99999 9.03599 4.99999H12.5C12.7761 4.99999 13 5.22385 13 5.49999V12.125C13 12.4011 12.7761 12.625 12.5 12.625H3.5C3.22386 12.625 3 12.4011 3 12.125V3.86932C3 3.59318 3.22386 3.36932 3.5 3.36932H7.34219C7.74141 3.36932 8.09483 3.60924 8.26046 3.97337Z" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+</svg>
diff --git a/assets/icons/folder_open.svg b/assets/icons/folder_open.svg
new file mode 100644
index 00000000000000..ef37f55f83a38f
--- /dev/null
+++ b/assets/icons/folder_open.svg
@@ -0,0 +1,4 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M4.42782 7.2487C4.43495 6.97194 4.65009 6.75 4.91441 6.75H13.5293C13.7935 6.75 14.007 6.97194 13.9998 7.2487C13.9628 8.6885 13.7533 12.75 12.5721 12.75H3.375C4.55631 12.75 4.3907 8.6885 4.42782 7.2487Z" fill="black" stroke="black" stroke-width="1.5" stroke-linejoin="round"/>
+<path d="M5.19598 12.625H3.66515C3.42618 12.625 3.22289 12.4453 3.18626 12.2017L1.94333 3.93602C1.89776 3.63295 2.12496 3.35938 2.42223 3.35938H5.78585C6.11241 3.35938 6.41702 3.52903 6.59618 3.81071L6.94517 4.35938H9.92811C10.4007 4.35938 10.8044 4.71102 10.8836 5.1917L11.1251 6.65624" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
diff --git a/assets/icons/stop_sharing.svg b/assets/icons/folder_x.svg
similarity index 100%
rename from assets/icons/stop_sharing.svg
rename to assets/icons/folder_x.svg
diff --git a/assets/icons/conversations.svg b/assets/icons/message_bubbles.svg
similarity index 100%
rename from assets/icons/conversations.svg
rename to assets/icons/message_bubbles.svg
diff --git a/assets/icons/desktop.svg b/assets/icons/screen.svg
similarity index 100%
rename from assets/icons/desktop.svg
rename to assets/icons/screen.svg
diff --git a/assets/icons/settings.svg b/assets/icons/settings.svg
new file mode 100644
index 00000000000000..081d25bf482472
--- /dev/null
+++ b/assets/icons/settings.svg
@@ -0,0 +1,4 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3.16089 10.2476L3.99598 10.3784C4.61244 10.4749 5.05269 11.0395 5.00728 11.6755L4.94576 12.5377C4.92784 12.789 5.06165 13.0255 5.28326 13.1348L5.90091 13.4391C6.12253 13.5485 6.38717 13.5075 6.56817 13.3371L7.1888 12.7505C7.64641 12.3178 8.35245 12.3178 8.81059 12.7505L9.43121 13.3371C9.61222 13.5081 9.87629 13.5485 10.0985 13.4391L10.7173 13.1341C10.9384 13.0255 11.0716 12.7895 11.0537 12.539L10.9921 11.6755C10.9467 11.0395 11.3869 10.4749 12.0033 10.3784L12.8385 10.2476C13.0817 10.2097 13.2776 10.0233 13.3325 9.77768L13.4848 9.09455C13.5398 8.8489 13.4425 8.59408 13.2393 8.45229L12.5422 7.96404C12.0279 7.60355 11.8708 6.89963 12.1814 6.34659L12.6025 5.59745C12.7249 5.3793 12.7047 5.10616 12.5511 4.9094L12.1241 4.36128C11.9706 4.16451 11.7149 4.08325 11.4795 4.15719L10.6719 4.41016C10.0752 4.59714 9.43903 4.28367 9.20962 3.69035L8.90017 2.88803C8.80937 2.65339 8.58777 2.4994 8.34108 2.5L7.65649 2.50184C7.40979 2.50244 7.1888 2.65766 7.09921 2.89291L6.79751 3.68607C6.57053 4.28307 5.93138 4.59898 5.33284 4.41077L4.49178 4.1468C4.25583 4.07225 3.99897 4.15413 3.84545 4.35212L3.42133 4.90084C3.26781 5.09943 3.2493 5.37319 3.37414 5.59133L3.80483 6.34232C4.12201 6.89591 3.96671 7.60659 3.44941 7.96897L2.76065 8.45169C2.55756 8.59408 2.4602 8.84891 2.51516 9.09393L2.66747 9.77708C2.72184 10.0233 2.91777 10.2097 3.16089 10.2476Z" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M9.41432 6.83576C8.63332 6.05481 7.36676 6.05476 6.58575 6.83571C5.8048 7.61672 5.80476 8.88327 6.58571 9.66427C7.36671 10.4452 8.63326 10.4452 9.41426 9.66432C10.1952 8.88332 10.1952 7.61676 9.41432 6.83576Z" fill="black"/>
+</svg>
diff --git a/assets/icons/sliders-alt.svg b/assets/icons/settings_alt.svg
similarity index 100%
rename from assets/icons/sliders-alt.svg
rename to assets/icons/settings_alt.svg
diff --git a/assets/icons/speaker_off.svg b/assets/icons/speaker_off.svg
deleted file mode 100644
index f60c35de7f3f5b..00000000000000
--- a/assets/icons/speaker_off.svg
+++ /dev/null
@@ -1,8 +0,0 @@
-<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <path
-    fill-rule="evenodd"
-    clip-rule="evenodd"
-    d="M7.72361 1.05279C7.893 1.13749 8 1.31062 8 1.5V13.5C8 13.6894 7.893 13.8625 7.72361 13.9472C7.55421 14.0319 7.35151 14.0136 7.2 13.9L3.33333 11H1.5C0.671573 11 0 10.3284 0 9.5V5.5C0 4.67158 0.671573 4 1.5 4H3.33333L7.2 1.1C7.35151 0.986371 7.55421 0.968093 7.72361 1.05279ZM7 2.5L3.8 4.9C3.71345 4.96491 3.60819 5 3.5 5H1.5C1.22386 5 1 5.22386 1 5.5V9.5C1 9.77614 1.22386 10 1.5 10H3.5C3.60819 10 3.71345 10.0351 3.8 10.1L7 12.5V2.5ZM14.8536 5.14645C15.0488 5.34171 15.0488 5.65829 14.8536 5.85355L13.2071 7.5L14.8536 9.14645C15.0488 9.34171 15.0488 9.65829 14.8536 9.85355C14.6583 10.0488 14.3417 10.0488 14.1464 9.85355L12.5 8.20711L10.8536 9.85355C10.6583 10.0488 10.3417 10.0488 10.1464 9.85355C9.95118 9.65829 9.95118 9.34171 10.1464 9.14645L11.7929 7.5L10.1464 5.85355C9.95118 5.65829 9.95118 5.34171 10.1464 5.14645C10.3417 4.95118 10.6583 4.95118 10.8536 5.14645L12.5 6.79289L14.1464 5.14645C14.3417 4.95118 14.6583 4.95118 14.8536 5.14645Z"
-    fill="currentColor"
-  />
-</svg>
diff --git a/assets/icons/user_group_16.svg b/assets/icons/user_group.svg
similarity index 100%
rename from assets/icons/user_group_16.svg
rename to assets/icons/user_group.svg
diff --git a/assets/icons/word_search.svg b/assets/icons/whole_word.svg
similarity index 100%
rename from assets/icons/word_search.svg
rename to assets/icons/whole_word.svg
diff --git a/assets/icons/error.svg b/assets/icons/x_circle.svg
similarity index 100%
rename from assets/icons/error.svg
rename to assets/icons/x_circle.svg
diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs
index 4b6508edb074fd..3f567c9e802b80 100644
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -262,7 +262,7 @@ impl ActivityIndicator {
         if !failed.is_empty() {
             return Some(Content {
                 icon: Some(
-                    Icon::new(IconName::ExclamationTriangle)
+                    Icon::new(IconName::Warning)
                         .size(IconSize::Small)
                         .into_any_element(),
                 ),
@@ -280,7 +280,7 @@ impl ActivityIndicator {
         if let Some(failure) = self.project.read(cx).last_formatting_failure() {
             return Some(Content {
                 icon: Some(
-                    Icon::new(IconName::ExclamationTriangle)
+                    Icon::new(IconName::Warning)
                         .size(IconSize::Small)
                         .into_any_element(),
                 ),
@@ -333,7 +333,7 @@ impl ActivityIndicator {
                 }),
                 AutoUpdateStatus::Errored => Some(Content {
                     icon: Some(
-                        Icon::new(IconName::ExclamationTriangle)
+                        Icon::new(IconName::Warning)
                             .size(IconSize::Small)
                             .into_any_element(),
                     ),
diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 51c9aa9b4ea901..af3abec67c8100 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -4110,7 +4110,7 @@ impl ContextEditor {
                         h_flex()
                             .gap_3()
                             .child(
-                                Icon::new(IconName::ExclamationTriangle)
+                                Icon::new(IconName::Warning)
                                     .size(IconSize::Small)
                                     .color(Color::Warning),
                             )
@@ -5235,7 +5235,7 @@ fn quote_selection_fold_placeholder(title: String, editor: WeakView<Editor>) ->
                 ButtonLike::new(fold_id)
                     .style(ButtonStyle::Filled)
                     .layer(ElevationIndex::ElevatedSurface)
-                    .child(Icon::new(IconName::TextSelect))
+                    .child(Icon::new(IconName::CursorIBeam))
                     .child(Label::new(title.clone()).single_line())
                     .on_click(move |_, cx| {
                         editor
@@ -5339,7 +5339,7 @@ fn render_docs_slash_command_trailer(
             div()
                 .id(("latest-error", row.0))
                 .child(
-                    Icon::new(IconName::ExclamationTriangle)
+                    Icon::new(IconName::Warning)
                         .size(IconSize::Small)
                         .color(Color::Warning),
                 )
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index b01a712a7e4e40..8b71e54746dad6 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -1478,7 +1478,7 @@ impl Render for PromptEditor {
                     .child(
                         ModelSelector::new(
                             self.fs.clone(),
-                            IconButton::new("context", IconName::SlidersAlt)
+                            IconButton::new("context", IconName::SettingsAlt)
                                 .shape(IconButtonShape::Square)
                                 .icon_size(IconSize::Small)
                                 .icon_color(Color::Muted)
diff --git a/crates/assistant/src/slash_command/diagnostics_command.rs b/crates/assistant/src/slash_command/diagnostics_command.rs
index 6c821bd7b4a5c9..21058306519787 100644
--- a/crates/assistant/src/slash_command/diagnostics_command.rs
+++ b/crates/assistant/src/slash_command/diagnostics_command.rs
@@ -193,11 +193,11 @@ impl SlashCommand for DiagnosticsSlashCommand {
                 .map(|(range, placeholder_type)| SlashCommandOutputSection {
                     range,
                     icon: match placeholder_type {
-                        PlaceholderType::Root(_, _) => IconName::ExclamationTriangle,
+                        PlaceholderType::Root(_, _) => IconName::Warning,
                         PlaceholderType::File(_) => IconName::File,
                         PlaceholderType::Diagnostic(DiagnosticType::Error, _) => IconName::XCircle,
                         PlaceholderType::Diagnostic(DiagnosticType::Warning, _) => {
-                            IconName::ExclamationTriangle
+                            IconName::Warning
                         }
                     },
                     label: match placeholder_type {
diff --git a/crates/assistant/src/terminal_inline_assistant.rs b/crates/assistant/src/terminal_inline_assistant.rs
index 61a8813f6c55ed..d5c085b646cd86 100644
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -585,7 +585,7 @@ impl Render for PromptEditor {
                     .gap_2()
                     .child(ModelSelector::new(
                         self.fs.clone(),
-                        IconButton::new("context", IconName::SlidersAlt)
+                        IconButton::new("context", IconName::SettingsAlt)
                             .shape(IconButtonShape::Square)
                             .icon_size(IconSize::Small)
                             .icon_color(Color::Muted)
diff --git a/crates/collab_ui/src/collab_panel.rs b/crates/collab_ui/src/collab_panel.rs
index 72701101816995..59f83e06548a6b 100644
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -2831,7 +2831,7 @@ impl Panel for CollabPanel {
     fn icon(&self, cx: &gpui::WindowContext) -> Option<ui::IconName> {
         CollaborationPanelSettings::get_global(cx)
             .button
-            .then_some(ui::IconName::Collab)
+            .then_some(ui::IconName::UserGroup)
     }
 
     fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {
diff --git a/crates/diagnostics/src/diagnostics.rs b/crates/diagnostics/src/diagnostics.rs
index ced97be2dc87cd..ddf39e0bfa2424 100644
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -667,7 +667,7 @@ impl Item for ProjectDiagnosticsEditor {
                     then.child(
                         h_flex()
                             .gap_1()
-                            .child(Icon::new(IconName::ExclamationTriangle).color(Color::Warning))
+                            .child(Icon::new(IconName::Warning).color(Color::Warning))
                             .child(
                                 Label::new(self.summary.warning_count.to_string())
                                     .color(params.text_color()),
@@ -804,7 +804,7 @@ fn diagnostic_header_renderer(diagnostic: Diagnostic) -> RenderBlock {
                                         icon.path(IconName::XCircle.path())
                                             .text_color(Color::Error.color(cx))
                                     } else {
-                                        icon.path(IconName::ExclamationTriangle.path())
+                                        icon.path(IconName::Warning.path())
                                             .text_color(Color::Warning.color(cx))
                                     }
                                 }),
diff --git a/crates/diagnostics/src/items.rs b/crates/diagnostics/src/items.rs
index 80b31b999c653b..72a4ac9bcfb01e 100644
--- a/crates/diagnostics/src/items.rs
+++ b/crates/diagnostics/src/items.rs
@@ -30,7 +30,7 @@ impl Render for DiagnosticIndicator {
             (0, warning_count) => h_flex()
                 .gap_1()
                 .child(
-                    Icon::new(IconName::ExclamationTriangle)
+                    Icon::new(IconName::Warning)
                         .size(IconSize::Small)
                         .color(Color::Warning),
                 )
@@ -52,7 +52,7 @@ impl Render for DiagnosticIndicator {
                 )
                 .child(Label::new(error_count.to_string()).size(LabelSize::Small))
                 .child(
-                    Icon::new(IconName::ExclamationTriangle)
+                    Icon::new(IconName::Warning)
                         .size(IconSize::Small)
                         .color(Color::Warning),
                 )
diff --git a/crates/diagnostics/src/toolbar_controls.rs b/crates/diagnostics/src/toolbar_controls.rs
index 64eb2683047171..b546db50a064ba 100644
--- a/crates/diagnostics/src/toolbar_controls.rs
+++ b/crates/diagnostics/src/toolbar_controls.rs
@@ -50,7 +50,7 @@ impl Render for ToolbarControls {
                 )
             })
             .child(
-                IconButton::new("toggle-warnings", IconName::ExclamationTriangle)
+                IconButton::new("toggle-warnings", IconName::Warning)
                     .tooltip(move |cx| Tooltip::text(tooltip, cx))
                     .on_click(cx.listener(|this, _, cx| {
                         if let Some(editor) = this.editor() {
diff --git a/crates/quick_action_bar/src/quick_action_bar.rs b/crates/quick_action_bar/src/quick_action_bar.rs
index 0d530d6821bc83..57418b54b7e05a 100644
--- a/crates/quick_action_bar/src/quick_action_bar.rs
+++ b/crates/quick_action_bar/src/quick_action_bar.rs
@@ -150,7 +150,7 @@ impl Render for QuickActionBar {
             let focus = editor.focus_handle(cx);
             PopoverMenu::new("editor-selections-dropdown")
                 .trigger(
-                    IconButton::new("toggle_editor_selections_icon", IconName::TextCursor)
+                    IconButton::new("toggle_editor_selections_icon", IconName::CursorIBeam)
                         .shape(IconButtonShape::Square)
                         .icon_size(IconSize::Small)
                         .style(ButtonStyle::Subtle)
diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs
index 903e9eebd272bb..1869e33383d177 100644
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -991,7 +991,7 @@ impl Item for TerminalView {
             Some(terminal_task) => match &terminal_task.status {
                 TaskStatus::Running => (IconName::Play, Color::Disabled, None),
                 TaskStatus::Unknown => (
-                    IconName::ExclamationTriangle,
+                    IconName::Warning,
                     Color::Warning,
                     Some(rerun_button(terminal_task.id.clone())),
                 ),
diff --git a/crates/ui/src/components/icon.rs b/crates/ui/src/components/icon.rs
index fd4f17ac0e0ef7..c2743ecbd9bd72 100644
--- a/crates/ui/src/components/icon.rs
+++ b/crates/ui/src/components/icon.rs
@@ -1,6 +1,7 @@
 use gpui::{svg, AnimationElement, Hsla, IntoElement, Rems, Transformation};
 use serde::{Deserialize, Serialize};
 use strum::{EnumIter, EnumString, IntoStaticStr};
+use ui_macros::DerivePathStr;
 
 use crate::{prelude::*, Indicator};
 
@@ -102,15 +103,27 @@ impl IconSize {
 }
 
 #[derive(
-    Debug, PartialEq, Eq, Copy, Clone, EnumIter, EnumString, IntoStaticStr, Serialize, Deserialize,
+    Debug,
+    PartialEq,
+    Eq,
+    Copy,
+    Clone,
+    EnumIter,
+    EnumString,
+    IntoStaticStr,
+    Serialize,
+    Deserialize,
+    DerivePathStr,
 )]
+#[strum(serialize_all = "snake_case")]
+#[path_str(prefix = "icons", suffix = ".svg")]
 pub enum IconName {
     Ai,
     AiAnthropic,
     AiAnthropicHosted,
-    AiOpenAi,
     AiGoogle,
     AiOllama,
+    AiOpenAi,
     AiZed,
     ArrowCircle,
     ArrowDown,
@@ -135,15 +148,13 @@ pub enum IconName {
     CaseSensitive,
     Check,
     ChevronDown,
-    /// This chevron indicates a popover menu.
-    ChevronDownSmall,
+    ChevronDownSmall, // This chevron indicates a popover menu.
     ChevronLeft,
     ChevronRight,
     ChevronUp,
     ChevronUpDown,
     Close,
     Code,
-    Collab,
     Command,
     Context,
     Control,
@@ -153,6 +164,8 @@ pub enum IconName {
     CopilotInit,
     Copy,
     CountdownTimer,
+    CursorIBeam,
+    CursorText,
     Dash,
     DatabaseZap,
     Delete,
@@ -162,21 +175,20 @@ pub enum IconName {
     EllipsisVertical,
     Envelope,
     Escape,
-    ExclamationTriangle,
     Exit,
     ExpandVertical,
     ExternalLink,
     Eye,
     File,
+    FileCode,
     FileDoc,
     FileGeneric,
     FileGit,
     FileLock,
     FileRust,
+    FileText,
     FileToml,
     FileTree,
-    FileText,
-    FileCode,
     Filter,
     Folder,
     FolderOpen,
@@ -184,11 +196,11 @@ pub enum IconName {
     Font,
     FontSize,
     FontWeight,
-    Github,
-    GenericMinimize,
-    GenericMaximize,
     GenericClose,
+    GenericMaximize,
+    GenericMinimize,
     GenericRestore,
+    Github,
     Hash,
     HistoryRerun,
     Indicator,
@@ -228,21 +240,21 @@ pub enum IconName {
     Rerun,
     Return,
     Reveal,
-    Route,
     RotateCcw,
     RotateCw,
+    Route,
     Save,
     Screen,
-    SearchSelection,
     SearchCode,
+    SearchSelection,
     SelectAll,
     Server,
     Settings,
+    SettingsAlt,
     Shift,
     Slash,
     SlashSquare,
     Sliders,
-    SlidersAlt,
     Snip,
     Space,
     Sparkle,
@@ -260,191 +272,18 @@ pub enum IconName {
     SupermavenInit,
     Tab,
     Terminal,
-    TextCursor,
-    TextSelect,
     Trash,
     TriangleRight,
     Undo,
     Unpin,
     Update,
+    UserGroup,
+    Visible,
+    Warning,
     WholeWord,
     XCircle,
     ZedAssistant,
     ZedAssistantFilled,
-    Visible,
-}
-
-impl IconName {
-    pub fn path(self) -> &'static str {
-        match self {
-            IconName::Ai => "icons/ai.svg",
-            IconName::AiAnthropic => "icons/ai_anthropic.svg",
-            IconName::AiAnthropicHosted => "icons/ai_anthropic_hosted.svg",
-            IconName::AiOpenAi => "icons/ai_open_ai.svg",
-            IconName::AiGoogle => "icons/ai_google.svg",
-            IconName::AiOllama => "icons/ai_ollama.svg",
-            IconName::AiZed => "icons/ai_zed.svg",
-            IconName::ArrowCircle => "icons/arrow_circle.svg",
-            IconName::ArrowDown => "icons/arrow_down.svg",
-            IconName::ArrowDownFromLine => "icons/arrow_down_from_line.svg",
-            IconName::ArrowLeft => "icons/arrow_left.svg",
-            IconName::ArrowRight => "icons/arrow_right.svg",
-            IconName::ArrowUp => "icons/arrow_up.svg",
-            IconName::ArrowUpFromLine => "icons/arrow_up_from_line.svg",
-            IconName::ArrowUpRight => "icons/arrow_up_right.svg",
-            IconName::AtSign => "icons/at_sign.svg",
-            IconName::AudioOff => "icons/speaker_off.svg",
-            IconName::AudioOn => "icons/speaker_loud.svg",
-            IconName::Backspace => "icons/backspace.svg",
-            IconName::Bell => "icons/bell.svg",
-            IconName::BellDot => "icons/bell_dot.svg",
-            IconName::BellOff => "icons/bell_off.svg",
-            IconName::BellRing => "icons/bell_ring.svg",
-            IconName::Bolt => "icons/bolt.svg",
-            IconName::Book => "icons/book.svg",
-            IconName::BookCopy => "icons/book_copy.svg",
-            IconName::BookPlus => "icons/book_plus.svg",
-            IconName::CaseSensitive => "icons/case_insensitive.svg",
-            IconName::Check => "icons/check.svg",
-            IconName::ChevronDown => "icons/chevron_down.svg",
-            IconName::ChevronDownSmall => "icons/chevron_down_small.svg",
-            IconName::ChevronLeft => "icons/chevron_left.svg",
-            IconName::ChevronRight => "icons/chevron_right.svg",
-            IconName::ChevronUp => "icons/chevron_up.svg",
-            IconName::ChevronUpDown => "icons/chevron_up_down.svg",
-            IconName::Close => "icons/x.svg",
-            IconName::Code => "icons/code.svg",
-            IconName::Collab => "icons/user_group_16.svg",
-            IconName::Command => "icons/command.svg",
-            IconName::Context => "icons/context.svg",
-            IconName::Control => "icons/control.svg",
-            IconName::Copilot => "icons/copilot.svg",
-            IconName::CopilotDisabled => "icons/copilot_disabled.svg",
-            IconName::CopilotError => "icons/copilot_error.svg",
-            IconName::CopilotInit => "icons/copilot_init.svg",
-            IconName::Copy => "icons/copy.svg",
-            IconName::CountdownTimer => "icons/countdown_timer.svg",
-            IconName::Dash => "icons/dash.svg",
-            IconName::DatabaseZap => "icons/database_zap.svg",
-            IconName::Delete => "icons/delete.svg",
-            IconName::Disconnected => "icons/disconnected.svg",
-            IconName::Download => "icons/download.svg",
-            IconName::Ellipsis => "icons/ellipsis.svg",
-            IconName::EllipsisVertical => "icons/ellipsis_vertical.svg",
-            IconName::Envelope => "icons/feedback.svg",
-            IconName::Escape => "icons/escape.svg",
-            IconName::ExclamationTriangle => "icons/warning.svg",
-            IconName::Exit => "icons/exit.svg",
-            IconName::ExpandVertical => "icons/expand_vertical.svg",
-            IconName::ExternalLink => "icons/external_link.svg",
-            IconName::Eye => "icons/eye.svg",
-            IconName::File => "icons/file.svg",
-            IconName::FileDoc => "icons/file_icons/book.svg",
-            IconName::FileGeneric => "icons/file_icons/file.svg",
-            IconName::FileGit => "icons/file_icons/git.svg",
-            IconName::FileLock => "icons/file_icons/lock.svg",
-            IconName::FileRust => "icons/file_icons/rust.svg",
-            IconName::FileToml => "icons/file_icons/toml.svg",
-            IconName::FileTree => "icons/project.svg",
-            IconName::FileCode => "icons/file_code.svg",
-            IconName::FileText => "icons/file_text.svg",
-            IconName::Filter => "icons/filter.svg",
-            IconName::Folder => "icons/file_icons/folder.svg",
-            IconName::FolderOpen => "icons/file_icons/folder_open.svg",
-            IconName::FolderX => "icons/stop_sharing.svg",
-            IconName::Font => "icons/font.svg",
-            IconName::FontSize => "icons/font_size.svg",
-            IconName::FontWeight => "icons/font_weight.svg",
-            IconName::Github => "icons/github.svg",
-            IconName::GenericMinimize => "icons/generic_minimize.svg",
-            IconName::GenericMaximize => "icons/generic_maximize.svg",
-            IconName::GenericClose => "icons/generic_close.svg",
-            IconName::GenericRestore => "icons/generic_restore.svg",
-            IconName::Hash => "icons/hash.svg",
-            IconName::HistoryRerun => "icons/history_rerun.svg",
-            IconName::Indicator => "icons/indicator.svg",
-            IconName::IndicatorX => "icons/indicator_x.svg",
-            IconName::InlayHint => "icons/inlay_hint.svg",
-            IconName::Library => "icons/library.svg",
-            IconName::LineHeight => "icons/line_height.svg",
-            IconName::Link => "icons/link.svg",
-            IconName::ListTree => "icons/list_tree.svg",
-            IconName::MagnifyingGlass => "icons/magnifying_glass.svg",
-            IconName::MailOpen => "icons/mail_open.svg",
-            IconName::Maximize => "icons/maximize.svg",
-            IconName::Menu => "icons/menu.svg",
-            IconName::MessageBubbles => "icons/conversations.svg",
-            IconName::Mic => "icons/mic.svg",
-            IconName::MicMute => "icons/mic_mute.svg",
-            IconName::Microscope => "icons/microscope.svg",
-            IconName::Minimize => "icons/minimize.svg",
-            IconName::Option => "icons/option.svg",
-            IconName::PageDown => "icons/page_down.svg",
-            IconName::PageUp => "icons/page_up.svg",
-            IconName::Pencil => "icons/pencil.svg",
-            IconName::Person => "icons/person.svg",
-            IconName::Pin => "icons/pin.svg",
-            IconName::Play => "icons/play.svg",
-            IconName::Plus => "icons/plus.svg",
-            IconName::PocketKnife => "icons/pocket_knife.svg",
-            IconName::Public => "icons/public.svg",
-            IconName::PullRequest => "icons/pull_request.svg",
-            IconName::Quote => "icons/quote.svg",
-            IconName::Regex => "icons/regex.svg",
-            IconName::ReplNeutral => "icons/repl_neutral.svg",
-            IconName::Replace => "icons/replace.svg",
-            IconName::ReplaceAll => "icons/replace_all.svg",
-            IconName::ReplaceNext => "icons/replace_next.svg",
-            IconName::ReplyArrowRight => "icons/reply_arrow_right.svg",
-            IconName::Rerun => "icons/rerun.svg",
-            IconName::Return => "icons/return.svg",
-            IconName::Reveal => "icons/reveal.svg",
-            IconName::RotateCcw => "icons/rotate_ccw.svg",
-            IconName::RotateCw => "icons/rotate_cw.svg",
-            IconName::Route => "icons/route.svg",
-            IconName::Save => "icons/save.svg",
-            IconName::Screen => "icons/desktop.svg",
-            IconName::SearchSelection => "icons/search_selection.svg",
-            IconName::SearchCode => "icons/search_code.svg",
-            IconName::SelectAll => "icons/select_all.svg",
-            IconName::Server => "icons/server.svg",
-            IconName::Settings => "icons/file_icons/settings.svg",
-            IconName::Shift => "icons/shift.svg",
-            IconName::Slash => "icons/slash.svg",
-            IconName::SlashSquare => "icons/slash_square.svg",
-            IconName::Sliders => "icons/sliders.svg",
-            IconName::SlidersAlt => "icons/sliders-alt.svg",
-            IconName::Snip => "icons/snip.svg",
-            IconName::Space => "icons/space.svg",
-            IconName::Sparkle => "icons/sparkle.svg",
-            IconName::SparkleAlt => "icons/sparkle_alt.svg",
-            IconName::SparkleFilled => "icons/sparkle_filled.svg",
-            IconName::Spinner => "icons/spinner.svg",
-            IconName::Split => "icons/split.svg",
-            IconName::Star => "icons/star.svg",
-            IconName::StarFilled => "icons/star_filled.svg",
-            IconName::Stop => "icons/stop.svg",
-            IconName::Strikethrough => "icons/strikethrough.svg",
-            IconName::Supermaven => "icons/supermaven.svg",
-            IconName::SupermavenDisabled => "icons/supermaven_disabled.svg",
-            IconName::SupermavenError => "icons/supermaven_error.svg",
-            IconName::SupermavenInit => "icons/supermaven_init.svg",
-            IconName::Tab => "icons/tab.svg",
-            IconName::Terminal => "icons/terminal.svg",
-            IconName::TextCursor => "icons/text-cursor.svg",
-            IconName::TextSelect => "icons/text_select.svg",
-            IconName::Trash => "icons/trash.svg",
-            IconName::TriangleRight => "icons/triangle_right.svg",
-            IconName::Unpin => "icons/unpin.svg",
-            IconName::Update => "icons/update.svg",
-            IconName::Undo => "icons/undo.svg",
-            IconName::WholeWord => "icons/word_search.svg",
-            IconName::XCircle => "icons/error.svg",
-            IconName::ZedAssistant => "icons/zed_assistant.svg",
-            IconName::ZedAssistantFilled => "icons/zed_assistant_filled.svg",
-            IconName::Visible => "icons/visible.svg",
-        }
-    }
 }
 
 #[derive(IntoElement)]
diff --git a/crates/ui/src/components/stories/list_header.rs b/crates/ui/src/components/stories/list_header.rs
index 358dc26a875c67..afcae0215abffd 100644
--- a/crates/ui/src/components/stories/list_header.rs
+++ b/crates/ui/src/components/stories/list_header.rs
@@ -24,7 +24,7 @@ impl Render for ListHeaderStory {
             .child(
                 ListHeader::new("Section 4")
                     .end_slot(IconButton::new("action_1", IconName::Bolt))
-                    .end_slot(IconButton::new("action_2", IconName::ExclamationTriangle))
+                    .end_slot(IconButton::new("action_2", IconName::Warning))
                     .end_slot(IconButton::new("action_3", IconName::Plus)),
             )
     }
diff --git a/crates/workspace/src/notifications.rs b/crates/workspace/src/notifications.rs
index 2f8b14ddb725ac..ffab276dd1aedb 100644
--- a/crates/workspace/src/notifications.rs
+++ b/crates/workspace/src/notifications.rs
@@ -311,15 +311,11 @@ impl Render for LanguageServerPrompt {
                                                 .mt(px(-2.0))
                                                 .map(|icon| {
                                                     if severity == DiagnosticSeverity::ERROR {
-                                                        icon.path(
-                                                            IconName::ExclamationTriangle.path(),
-                                                        )
-                                                        .text_color(Color::Error.color(cx))
+                                                        icon.path(IconName::Warning.path())
+                                                            .text_color(Color::Error.color(cx))
                                                     } else {
-                                                        icon.path(
-                                                            IconName::ExclamationTriangle.path(),
-                                                        )
-                                                        .text_color(Color::Warning.color(cx))
+                                                        icon.path(IconName::Warning.path())
+                                                            .text_color(Color::Warning.color(cx))
                                                     }
                                                 })
                                         }),
@@ -421,7 +417,7 @@ impl Render for ErrorMessagePrompt {
                                     .mr_2()
                                     .mt(px(-2.0))
                                     .map(|icon| {
-                                        icon.path(IconName::ExclamationTriangle.path())
+                                        icon.path(IconName::Warning.path())
                                             .text_color(Color::Error.color(cx))
                                     }),
                             )

From 4d8c3855c229d5aff02d39dd3eac10cf2007585c Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Sat, 14 Sep 2024 15:44:54 -0400
Subject: [PATCH 077/762] theme: Clamp font sizes between 6px and 100px
 (#17829)

This PR clamps the `ui_font_size` and `buffer_font_size` settings
between 6px and 100px.

Release Notes:

- Changed `ui_font_size` and `buffer_font_size` to require values to be
between 6px and 100px (inclusive).
---
 crates/theme/src/settings.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/theme/src/settings.rs b/crates/theme/src/settings.rs
index 5b88d5fcb5ba29..4d0b4f0215aada 100644
--- a/crates/theme/src/settings.rs
+++ b/crates/theme/src/settings.rs
@@ -609,10 +609,14 @@ impl settings::Settings for ThemeSettings {
             this.apply_theme_overrides();
 
             merge(&mut this.ui_font_size, value.ui_font_size.map(Into::into));
+            this.ui_font_size = this.ui_font_size.clamp(px(6.), px(100.));
+
             merge(
                 &mut this.buffer_font_size,
                 value.buffer_font_size.map(Into::into),
             );
+            this.buffer_font_size = this.buffer_font_size.clamp(px(6.), px(100.));
+
             merge(&mut this.buffer_line_height, value.buffer_line_height);
 
             // Clamp the `unnecessary_code_fade` to ensure text can't disappear entirely.

From 00c0a7254a85c1728f8fdca06bce839360139db5 Mon Sep 17 00:00:00 2001
From: Zhang <17492978+zhang0098@users.noreply.github.com>
Date: Sun, 15 Sep 2024 03:49:53 +0800
Subject: [PATCH 078/762] gpui: Allow TextInput example to lose and gain focus
 (#17823)

Improved the input.rs example file in gpui crate.

The new code
* allow this text field to lose and gain input focus.
* change TextInput's height from full to fix.

Release Notes:

- N/A
---
 crates/gpui/examples/input.rs | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/crates/gpui/examples/input.rs b/crates/gpui/examples/input.rs
index cdce4c61c744c9..7e7de269b11462 100644
--- a/crates/gpui/examples/input.rs
+++ b/crates/gpui/examples/input.rs
@@ -467,9 +467,12 @@ impl Element for TextElement {
         let line = prepaint.line.take().unwrap();
         line.paint(bounds.origin, cx.line_height(), cx).unwrap();
 
-        if let Some(cursor) = prepaint.cursor.take() {
-            cx.paint_quad(cursor);
+        if focus_handle.is_focused(cx) {
+            if let Some(cursor) = prepaint.cursor.take() {
+                cx.paint_quad(cursor);
+            }
         }
+
         self.input.update(cx, |input, _cx| {
             input.last_layout = Some(line);
             input.last_bounds = Some(bounds);
@@ -499,7 +502,6 @@ impl Render for TextInput {
             .on_mouse_up_out(MouseButton::Left, cx.listener(Self::on_mouse_up))
             .on_mouse_move(cx.listener(Self::on_mouse_move))
             .bg(rgb(0xeeeeee))
-            .size_full()
             .line_height(px(30.))
             .text_size(px(24.))
             .child(
@@ -524,6 +526,13 @@ impl FocusableView for TextInput {
 struct InputExample {
     text_input: View<TextInput>,
     recent_keystrokes: Vec<Keystroke>,
+    focus_handle: FocusHandle,
+}
+
+impl FocusableView for InputExample {
+    fn focus_handle(&self, _: &AppContext) -> FocusHandle {
+        self.focus_handle.clone()
+    }
 }
 
 impl InputExample {
@@ -540,6 +549,7 @@ impl Render for InputExample {
         let num_keystrokes = self.recent_keystrokes.len();
         div()
             .bg(rgb(0xaaaaaa))
+            .track_focus(&self.focus_handle)
             .flex()
             .flex_col()
             .size_full()
@@ -615,9 +625,10 @@ fn main() {
                         last_bounds: None,
                         is_selecting: false,
                     });
-                    cx.new_view(|_| InputExample {
+                    cx.new_view(|cx| InputExample {
                         text_input,
                         recent_keystrokes: vec![],
+                        focus_handle: cx.focus_handle(),
                     })
                 },
             )

From 40a00fb2249fd9d359eb26a61e2af73950cd8f70 Mon Sep 17 00:00:00 2001
From: krizej <60076189+krizej@users.noreply.github.com>
Date: Sat, 14 Sep 2024 22:06:03 +0200
Subject: [PATCH 079/762] Add missing operators and keywords to the C syntax
 highlighting (#17541)

Based on https://en.cppreference.com/w/c/language/expressions#Operators

Release Notes:

- Added missing operators and keywords to the C syntax highlighting
---
 crates/languages/src/c/highlights.scm | 40 +++++++++++++++++++++------
 1 file changed, 31 insertions(+), 9 deletions(-)

diff --git a/crates/languages/src/c/highlights.scm b/crates/languages/src/c/highlights.scm
index 0a8c12f06ff0c6..634f8d81c4ad93 100644
--- a/crates/languages/src/c/highlights.scm
+++ b/crates/languages/src/c/highlights.scm
@@ -9,6 +9,7 @@
   "enum"
   "extern"
   "for"
+  "goto"
   "if"
   "inline"
   "return"
@@ -35,27 +36,48 @@
 ] @keyword
 
 [
+  "="
+  "+="
+  "-="
+  "*="
+  "/="
+  "%="
+  "&="
+  "|="
+  "^="
+  "<<="
+  ">>="
+  "++"
   "--"
+  "+"
   "-"
-  "-="
-  "->"
-  "="
-  "!="
   "*"
+  "/"
+  "%"
+  "~"
   "&"
+  "|"
+  "^"
+  "<<"
+  ">>"
+  "!"
   "&&"
-  "+"
-  "++"
-  "+="
-  "<"
+  "||"
   "=="
+  "!="
+  "<"
   ">"
-  "||"
+  "<="
+  ">="
+  "->"
+  "?"
+  ":"
 ] @operator
 
 [
   "."
   ";"
+  ","
 ] @punctuation.delimiter
 
 [

From d5268c519721241be876605dc37294edf7eed4a1 Mon Sep 17 00:00:00 2001
From: Junkui Zhang <364772080@qq.com>
Date: Sun, 15 Sep 2024 04:17:38 +0800
Subject: [PATCH 080/762] docs: Add proxy settings (#17797)

I'm not sure if I placed `Network Proxy` in the correct position. What I
noticed is that the first half of the documentation seems to be
organized alphabetically, but the second half is not. I tried to
position `Network Proxy` in a spot that seemed reasonable while
maintaining alphabetical order. If there's a better suggestion, I'd be
happy to make adjustments.

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 docs/src/configuring-zed.md | 39 +++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 82f5a244845b57..1c4aee533d176a 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -1061,6 +1061,45 @@ The following settings can be overridden for each specific language:
 
 These values take in the same options as the root-level settings with the same name.
 
+## Network Proxy
+
+- Description: Configure a network proxy for Zed.
+- Setting: `proxy`
+- Default: `null`
+
+**Options**
+
+The proxy setting must contain a URL to the proxy.
+
+The following URI schemes are supported:
+
+- `http`
+- `https`
+- `socks4`
+- `socks4a`
+- `socks5`
+- `socks5h`
+
+`http` will be used when no scheme is specified.
+
+By default no proxy will be used, or Zed will attempt to retrieve proxy settings from environment variables, such as `http_proxy`, `HTTP_PROXY`, `https_proxy`, `HTTPS_PROXY`, `all_proxy`, `ALL_PROXY`.
+
+For example, to set an `http` proxy, add the following to your settings:
+
+```json
+{
+  "proxy": "http://127.0.0.1:10809"
+}
+```
+
+Or to set a `socks5` proxy:
+
+```json
+{
+  "proxy": "socks5://localhost:10808"
+}
+```
+
 ## Preview tabs
 
 - Description:

From d56fa258304dacc3a18fb4da94f130047ffdb691 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Sat, 14 Sep 2024 17:00:37 -0400
Subject: [PATCH 081/762] context_servers: Hide actions when no context servers
 are configured (#17833)

This PR filters out the context servers actions from the command palette
when no context servers are configured.

Release Notes:

- N/A
---
 Cargo.lock                                    |  1 +
 crates/context_servers/Cargo.toml             |  1 +
 crates/context_servers/src/context_servers.rs |  3 ++
 crates/context_servers/src/manager.rs         | 50 +++++++++++++------
 4 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 79f4e803a8461a..4cb7a85e359c6e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2780,6 +2780,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "collections",
+ "command_palette_hooks",
  "futures 0.3.30",
  "gpui",
  "log",
diff --git a/crates/context_servers/Cargo.toml b/crates/context_servers/Cargo.toml
index 21bf6a1fc86166..9c0336f1217ef0 100644
--- a/crates/context_servers/Cargo.toml
+++ b/crates/context_servers/Cargo.toml
@@ -14,6 +14,7 @@ path = "src/context_servers.rs"
 [dependencies]
 anyhow.workspace = true
 collections.workspace = true
+command_palette_hooks.workspace = true
 futures.workspace = true
 gpui.workspace = true
 log.workspace = true
diff --git a/crates/context_servers/src/context_servers.rs b/crates/context_servers/src/context_servers.rs
index 3333f95f9fe7aa..55634bb77cc944 100644
--- a/crates/context_servers/src/context_servers.rs
+++ b/crates/context_servers/src/context_servers.rs
@@ -12,6 +12,9 @@ pub use registry::*;
 
 actions!(context_servers, [Restart]);
 
+/// The namespace for the context servers actions.
+const CONTEXT_SERVERS_NAMESPACE: &'static str = "context_servers";
+
 pub fn init(cx: &mut AppContext) {
     log::info!("initializing context server client");
     manager::init(cx);
diff --git a/crates/context_servers/src/manager.rs b/crates/context_servers/src/manager.rs
index 1596a54eb9bfc6..08e403a43442ea 100644
--- a/crates/context_servers/src/manager.rs
+++ b/crates/context_servers/src/manager.rs
@@ -15,6 +15,7 @@
 //! and react to changes in settings.
 
 use collections::{HashMap, HashSet};
+use command_palette_hooks::CommandPaletteFilter;
 use gpui::{AppContext, AsyncAppContext, Context, EventEmitter, Global, Model, ModelContext, Task};
 use log;
 use parking_lot::RwLock;
@@ -24,6 +25,7 @@ use settings::{Settings, SettingsSources, SettingsStore};
 use std::path::Path;
 use std::sync::Arc;
 
+use crate::CONTEXT_SERVERS_NAMESPACE;
 use crate::{
     client::{self, Client},
     types,
@@ -148,26 +150,28 @@ impl ContextServerManager {
         cx: &mut ModelContext<Self>,
     ) -> Task<anyhow::Result<()>> {
         let server_id = config.id.clone();
-        let server_id2 = config.id.clone();
 
         if self.servers.contains_key(&server_id) || self.pending_servers.contains(&server_id) {
             return Task::ready(Ok(()));
         }
 
-        let task = cx.spawn(|this, mut cx| async move {
-            let server = Arc::new(ContextServer::new(config));
-            server.start(&cx).await?;
-            this.update(&mut cx, |this, cx| {
-                this.servers.insert(server_id.clone(), server);
-                this.pending_servers.remove(&server_id);
-                cx.emit(Event::ServerStarted {
-                    server_id: server_id.clone(),
-                });
-            })?;
-            Ok(())
-        });
+        let task = {
+            let server_id = server_id.clone();
+            cx.spawn(|this, mut cx| async move {
+                let server = Arc::new(ContextServer::new(config));
+                server.start(&cx).await?;
+                this.update(&mut cx, |this, cx| {
+                    this.servers.insert(server_id.clone(), server);
+                    this.pending_servers.remove(&server_id);
+                    cx.emit(Event::ServerStarted {
+                        server_id: server_id.clone(),
+                    });
+                })?;
+                Ok(())
+            })
+        };
 
-        self.pending_servers.insert(server_id2);
+        self.pending_servers.insert(server_id);
         task
     }
 
@@ -243,15 +247,20 @@ impl GlobalContextServerManager {
 pub fn init(cx: &mut AppContext) {
     ContextServerSettings::register(cx);
     GlobalContextServerManager::register(cx);
+
+    CommandPaletteFilter::update_global(cx, |filter, _cx| {
+        filter.hide_namespace(CONTEXT_SERVERS_NAMESPACE);
+    });
+
     cx.observe_global::<SettingsStore>(|cx| {
         let manager = ContextServerManager::global(cx);
         cx.update_model(&manager, |manager, cx| {
             let settings = ContextServerSettings::get_global(cx);
-            let current_servers: HashMap<String, ServerConfig> = manager
+            let current_servers = manager
                 .servers()
                 .into_iter()
                 .map(|server| (server.id.clone(), server.config.clone()))
-                .collect();
+                .collect::<HashMap<_, _>>();
 
             let new_servers = settings
                 .servers
@@ -279,6 +288,15 @@ pub fn init(cx: &mut AppContext) {
             for id in servers_to_remove {
                 manager.remove_server(&id, cx).detach_and_log_err(cx);
             }
+
+            let has_any_context_servers = !manager.servers().is_empty();
+            CommandPaletteFilter::update_global(cx, |filter, _cx| {
+                if has_any_context_servers {
+                    filter.show_namespace(CONTEXT_SERVERS_NAMESPACE);
+                } else {
+                    filter.hide_namespace(CONTEXT_SERVERS_NAMESPACE);
+                }
+            });
         })
     })
     .detach();

From 6f337de440687bdc233c4e6f845f88d44a8f9740 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Sat, 14 Sep 2024 17:26:56 -0400
Subject: [PATCH 082/762] ui: Clean up doc comments for `Vector` (#17834)

This PR cleans up the doc comments for the `Vector` component.

Release Notes:

- N/A
---
 crates/ui/src/components/image.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/crates/ui/src/components/image.rs b/crates/ui/src/components/image.rs
index 286fe7f56f3e31..e7eefe5fea3100 100644
--- a/crates/ui/src/components/image.rs
+++ b/crates/ui/src/components/image.rs
@@ -27,9 +27,9 @@ pub enum VectorName {
 
 /// A vector image, such as an SVG.
 ///
-/// A [Vector] is different from an [Icon] in that it is intended
+/// A [`Vector`] is different from an [`Icon`] in that it is intended
 /// to be displayed at a specific size, or series of sizes, rather
-/// than conforming to the standard size of an icons.
+/// than conforming to the standard size of an icon.
 #[derive(IntoElement)]
 pub struct Vector {
     path: &'static str,
@@ -38,7 +38,7 @@ pub struct Vector {
 }
 
 impl Vector {
-    /// Create a new [Vector] image with the given [VectorName] and size.
+    /// Creates a new [`Vector`] image with the given [`VectorName`] and size.
     pub fn new(vector: VectorName, width: Rems, height: Rems) -> Self {
         Self {
             path: vector.path(),
@@ -47,18 +47,18 @@ impl Vector {
         }
     }
 
-    /// Create a new [Vector] image where the width and height are the same.
+    /// Creates a new [`Vector`] image where the width and height are the same.
     pub fn square(vector: VectorName, size: Rems) -> Self {
         Self::new(vector, size, size)
     }
 
-    /// Set the image color
+    /// Sets the vector color.
     pub fn color(mut self, color: Color) -> Self {
         self.color = color;
         self
     }
 
-    /// Set the image size
+    /// Sets the vector size.
     pub fn size(mut self, size: impl Into<Size<Rems>>) -> Self {
         let size = size.into();
 

From 4f251429c7e9596641d6716479fbd7a931245197 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Sun, 15 Sep 2024 19:45:06 -0400
Subject: [PATCH 083/762] Add perplexity extension readme (#17861)

Release Notes:

- N/A
---
 extensions/perplexity/README.md | 41 +++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 extensions/perplexity/README.md

diff --git a/extensions/perplexity/README.md b/extensions/perplexity/README.md
new file mode 100644
index 00000000000000..094a876885e97f
--- /dev/null
+++ b/extensions/perplexity/README.md
@@ -0,0 +1,41 @@
+# Zed Perplexity Extension
+
+This example extension adds the `/perplexity` [slash command](https://zed.dev/docs/assistant/commands) to the Zed AI assistant.
+
+## Usage
+
+Open the AI Assistant panel (`cmd-r` or `ctrl-r`) and enter:
+
+```
+/perplexity What's the weather in Boulder, CO tomorrow evening?
+```
+
+## Development Setup
+
+1. Install the rust toolchain and clone the zed repo:
+```
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+mkdir -p ~/code
+cd ~/code
+git clone https://github.com/zed-industries/zed
+```
+
+2. Launch Zed and Open Zed Extensions (`cmd-shift-x` / `ctrl-shift-x`)
+3. Open Zed
+4. Open Zed Extensions (`cmd-shift-x` / `ctrl-shift-x`)
+5. Click "Install Dev Extension"
+6. Navigate to the "extensions/perplexity" folder inside the zed git repo.
+7. Ensure your `PERPLEXITY_API_KEY` environment variable is set (instructions below)
+```sh
+env |grep PERPLEXITY_API_KEY
+```
+8. Quit and relaunch Zed
+
+## PERPLEXITY_API_KEY
+
+This extension requires a Perplexity API key to be available via the `PERPLEXITY_API_KEY` environment variable.
+
+To onbtain a Perplexity.ai API token, login to your Perplexity.ai account and go [Settings->API](https://www.perplexity.ai/settings/api) and under "API Keys" click "Generate".  This will require you to have [Perplexity Pro](https://www.perplexity.ai/pro) or to buy API credits. By default the extension uses `llama-3.1-sonar-small-128k-online`, currently cheapest model available which is roughly half a penny per request + a penny per 50,000 tokens.  So most requests will cost less than $0.01 USD.
+
+Take your API key and add it to your environment by adding `export PERPLEXITY_API_KEY="pplx-0123456789abcdef..."` to your `~/.zshrc` or `~/.bashrc`. Reload close and reopen your terminal session. Check with `env |grep PERPLEXITY_API_KEY`.

From 524a1a6fec96d1824a2999c068df6ccc84956553 Mon Sep 17 00:00:00 2001
From: Chris Veness <chrisv@movable-type.co.uk>
Date: Mon, 16 Sep 2024 00:45:48 +0100
Subject: [PATCH 084/762] Note in initial_user_settings.json how to access the
 command palette (#17854)

Newcomers might not know / remember how to access the command palette.

Release Notes:

- N/A
---
 assets/settings/initial_user_settings.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/assets/settings/initial_user_settings.json b/assets/settings/initial_user_settings.json
index d8ac1a00216834..71f3beb1d6076e 100644
--- a/assets/settings/initial_user_settings.json
+++ b/assets/settings/initial_user_settings.json
@@ -5,7 +5,7 @@
 //
 // To see all of Zed's default settings without changing your
 // custom settings, run `zed: open default settings` from the
-// command palette
+// command palette (cmd-shift-p / ctrl-shift-p)
 {
   "ui_font_size": 16,
   "buffer_font_size": 16,

From cdc3791544bbba0ee36c7b85b51f3df502511249 Mon Sep 17 00:00:00 2001
From: Nate Butler <iamnbutler@gmail.com>
Date: Mon, 16 Sep 2024 00:24:18 -0400
Subject: [PATCH 085/762] Fix incorrect icons  (#17856)

---
 assets/icons/cursor_i_beam.svg          | 2 +-
 assets/icons/cursor_text.svg            | 1 -
 assets/icons/text_snippet.svg           | 1 +
 crates/assistant/src/assistant_panel.rs | 2 +-
 crates/ui/src/components/icon.rs        | 2 +-
 5 files changed, 4 insertions(+), 4 deletions(-)
 delete mode 100644 assets/icons/cursor_text.svg
 create mode 100644 assets/icons/text_snippet.svg

diff --git a/assets/icons/cursor_i_beam.svg b/assets/icons/cursor_i_beam.svg
index 255635de6a049d..2e7b95b2039455 100644
--- a/assets/icons/cursor_i_beam.svg
+++ b/assets/icons/cursor_i_beam.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-text-select"><path d="M5 3a2 2 0 0 0-2 2"/><path d="M19 3a2 2 0 0 1 2 2"/><path d="M21 19a2 2 0 0 1-2 2"/><path d="M5 21a2 2 0 0 1-2-2"/><path d="M9 3h1"/><path d="M9 21h1"/><path d="M14 3h1"/><path d="M14 21h1"/><path d="M3 9v1"/><path d="M21 9v1"/><path d="M3 14v1"/><path d="M21 14v1"/><line x1="7" x2="15" y1="8" y2="8"/><line x1="7" x2="17" y1="12" y2="12"/><line x1="7" x2="13" y1="16" y2="16"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-text-cursor"><path d="M17 22h-1a4 4 0 0 1-4-4V6a4 4 0 0 1 4-4h1"/><path d="M7 22h1a4 4 0 0 0 4-4v-1"/><path d="M7 2h1a4 4 0 0 1 4 4v1"/></svg>
diff --git a/assets/icons/cursor_text.svg b/assets/icons/cursor_text.svg
deleted file mode 100644
index 2e7b95b2039455..00000000000000
--- a/assets/icons/cursor_text.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-text-cursor"><path d="M17 22h-1a4 4 0 0 1-4-4V6a4 4 0 0 1 4-4h1"/><path d="M7 22h1a4 4 0 0 0 4-4v-1"/><path d="M7 2h1a4 4 0 0 1 4 4v1"/></svg>
diff --git a/assets/icons/text_snippet.svg b/assets/icons/text_snippet.svg
new file mode 100644
index 00000000000000..255635de6a049d
--- /dev/null
+++ b/assets/icons/text_snippet.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-text-select"><path d="M5 3a2 2 0 0 0-2 2"/><path d="M19 3a2 2 0 0 1 2 2"/><path d="M21 19a2 2 0 0 1-2 2"/><path d="M5 21a2 2 0 0 1-2-2"/><path d="M9 3h1"/><path d="M9 21h1"/><path d="M14 3h1"/><path d="M14 21h1"/><path d="M3 9v1"/><path d="M21 9v1"/><path d="M3 14v1"/><path d="M21 14v1"/><line x1="7" x2="15" y1="8" y2="8"/><line x1="7" x2="17" y1="12" y2="12"/><line x1="7" x2="13" y1="16" y2="16"/></svg>
diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index af3abec67c8100..8d158193a60f2b 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -5235,7 +5235,7 @@ fn quote_selection_fold_placeholder(title: String, editor: WeakView<Editor>) ->
                 ButtonLike::new(fold_id)
                     .style(ButtonStyle::Filled)
                     .layer(ElevationIndex::ElevatedSurface)
-                    .child(Icon::new(IconName::CursorIBeam))
+                    .child(Icon::new(IconName::TextSnippet))
                     .child(Label::new(title.clone()).single_line())
                     .on_click(move |_, cx| {
                         editor
diff --git a/crates/ui/src/components/icon.rs b/crates/ui/src/components/icon.rs
index c2743ecbd9bd72..a2f70244db2690 100644
--- a/crates/ui/src/components/icon.rs
+++ b/crates/ui/src/components/icon.rs
@@ -165,7 +165,7 @@ pub enum IconName {
     Copy,
     CountdownTimer,
     CursorIBeam,
-    CursorText,
+    TextSnippet,
     Dash,
     DatabaseZap,
     Delete,

From 29a5def12ce233f5e98454f60af5ee4af20f25e5 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Mon, 16 Sep 2024 07:12:07 -0400
Subject: [PATCH 086/762] Refine assistant config UI (#17871)

This PR does a little bit of a touch-up on the copywriting on the
assistant config UI. I had friends reporting to me that some of the
writing could be clearer, and hopefully, this goes into that direction!

Release Notes:

- N/A
---
 assets/icons/sliders_alt.svg                   |  6 ++++++
 assets/icons/sliders_vertical.svg              | 11 +++++++++++
 crates/assistant/src/assistant_panel.rs        |  4 +++-
 .../language_model/src/provider/anthropic.rs   | 10 ++++------
 .../src/provider/copilot_chat.rs               |  2 +-
 crates/language_model/src/provider/google.rs   | 10 ++++------
 crates/language_model/src/provider/open_ai.rs  | 18 +++++++++++-------
 crates/ui/src/components/icon.rs               |  2 ++
 8 files changed, 42 insertions(+), 21 deletions(-)
 create mode 100644 assets/icons/sliders_alt.svg
 create mode 100644 assets/icons/sliders_vertical.svg

diff --git a/assets/icons/sliders_alt.svg b/assets/icons/sliders_alt.svg
new file mode 100644
index 00000000000000..36c3feccfede20
--- /dev/null
+++ b/assets/icons/sliders_alt.svg
@@ -0,0 +1,6 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3 4H8" stroke="black" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M6 10L11 10" stroke="black" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/>
+<circle cx="4" cy="10" r="1.875" stroke="black" stroke-width="1.75"/>
+<circle cx="10" cy="4" r="1.875" stroke="black" stroke-width="1.75"/>
+</svg>
diff --git a/assets/icons/sliders_vertical.svg b/assets/icons/sliders_vertical.svg
new file mode 100644
index 00000000000000..ab61037a513e8c
--- /dev/null
+++ b/assets/icons/sliders_vertical.svg
@@ -0,0 +1,11 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M3.6665 14V9.33333" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M3.6665 6.66667V2" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M8 14V8" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M8 5.33333V2" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M12.3335 14V10.6667" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M12.3335 8V2" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M2.3335 9.33333H5.00016" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M6.6665 5.33334H9.33317" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M11 10.6667H13.6667" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 8d158193a60f2b..59f5e81d054c3f 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -4117,9 +4117,11 @@ impl ContextEditor {
                             .child(Label::new(label)),
                     )
                     .child(
-                        Button::new("open-configuration", "Open configuration")
+                        Button::new("open-configuration", "Configure Providers")
                             .size(ButtonSize::Compact)
+                            .icon(Some(IconName::SlidersVertical))
                             .icon_size(IconSize::Small)
+                            .icon_position(IconPosition::Start)
                             .style(ButtonStyle::Filled)
                             .on_click({
                                 let focus_handle = self.focus_handle(cx).clone();
diff --git a/crates/language_model/src/provider/anthropic.rs b/crates/language_model/src/provider/anthropic.rs
index 9f7135aef7d73f..1e3d2750949f16 100644
--- a/crates/language_model/src/provider/anthropic.rs
+++ b/crates/language_model/src/provider/anthropic.rs
@@ -657,11 +657,10 @@ impl ConfigurationView {
 impl Render for ConfigurationView {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         const ANTHROPIC_CONSOLE_URL: &str = "https://console.anthropic.com/settings/keys";
-        const INSTRUCTIONS: [&str; 4] = [
-            "To use the assistant panel or inline assistant, you need to add your Anthropic API key.",
-            "You can create an API key at:",
-            "",
-            "Paste your Anthropic API key below and hit enter to use the assistant:",
+        const INSTRUCTIONS: [&str; 3] = [
+            "To use Zed's assistant with Anthropic, you need to add an API key. Follow these steps:",
+            "- Create one at:",
+            "- Paste your API key below and hit enter to use the assistant:",
         ];
         let env_var_set = self.state.read(cx).api_key_from_env;
 
@@ -682,7 +681,6 @@ impl Render for ConfigurationView {
                     )
                 )
                 .child(Label::new(INSTRUCTIONS[2]))
-                .child(Label::new(INSTRUCTIONS[3]))
                 .child(
                     h_flex()
                         .w_full()
diff --git a/crates/language_model/src/provider/copilot_chat.rs b/crates/language_model/src/provider/copilot_chat.rs
index e21060e54d1e6e..58b486921ab811 100644
--- a/crates/language_model/src/provider/copilot_chat.rs
+++ b/crates/language_model/src/provider/copilot_chat.rs
@@ -358,7 +358,7 @@ impl Render for ConfigurationView {
                     }
                     _ => {
                         const LABEL: &str =
-                    "To use the assistant panel or inline assistant, you must login to GitHub Copilot. Your GitHub account must have an active Copilot Chat subscription.";
+                    "To use Zed's assistant with GitHub Copilot, you need to be logged in to GitHub. Note that your GitHub account must have an active Copilot Chat subscription.";
                         v_flex().gap_6().child(Label::new(LABEL)).child(
                             v_flex()
                                 .gap_2()
diff --git a/crates/language_model/src/provider/google.rs b/crates/language_model/src/provider/google.rs
index 005f35ff8b1bfe..daa07cdc3977fe 100644
--- a/crates/language_model/src/provider/google.rs
+++ b/crates/language_model/src/provider/google.rs
@@ -446,11 +446,10 @@ impl ConfigurationView {
 impl Render for ConfigurationView {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         const GOOGLE_CONSOLE_URL: &str = "https://aistudio.google.com/app/apikey";
-        const INSTRUCTIONS: [&str; 4] = [
-            "To use the Google AI assistant, you need to add your Google AI API key.",
-            "You can create an API key at:",
-            "",
-            "Paste your Google AI API key below and hit enter to use the assistant:",
+        const INSTRUCTIONS: [&str; 3] = [
+            "To use Zed's assistant with Google AI, you need to add an API key. Follow these steps:",
+            "- Create one by visiting:",
+            "- Paste your API key below and hit enter to use the assistant",
         ];
 
         let env_var_set = self.state.read(cx).api_key_from_env;
@@ -472,7 +471,6 @@ impl Render for ConfigurationView {
                     )
                 )
                 .child(Label::new(INSTRUCTIONS[2]))
-                .child(Label::new(INSTRUCTIONS[3]))
                 .child(
                     h_flex()
                         .w_full()
diff --git a/crates/language_model/src/provider/open_ai.rs b/crates/language_model/src/provider/open_ai.rs
index 222c1530412aab..a4efb3baf021ef 100644
--- a/crates/language_model/src/provider/open_ai.rs
+++ b/crates/language_model/src/provider/open_ai.rs
@@ -497,13 +497,11 @@ impl ConfigurationView {
 impl Render for ConfigurationView {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         const OPENAI_CONSOLE_URL: &str = "https://platform.openai.com/api-keys";
-        const INSTRUCTIONS: [&str; 6] = [
-            "To use the assistant panel or inline assistant, you need to add your OpenAI API key.",
-            " - You can create an API key at: ",
-            " - Make sure your OpenAI account has credits",
-            " - Having a subscription for another service like GitHub Copilot won't work.",
-            "",
-            "Paste your OpenAI API key below and hit enter to use the assistant:",
+        const INSTRUCTIONS: [&str; 4] = [
+            "To use Zed's assistant with OpenAI, you need to add an API key. Follow these steps:",
+            " - Create one by visiting:",
+            " - Ensure your OpenAI account has credits",
+            " - Paste your API key below and hit enter to start using the assistant",
         ];
 
         let env_var_set = self.state.read(cx).api_key_from_env;
@@ -543,6 +541,12 @@ impl Render for ConfigurationView {
                     )
                     .size(LabelSize::Small),
                 )
+                .child(
+                    Label::new(
+                        "Note that having a subscription for another service like GitHub Copilot won't work.".to_string(),
+                    )
+                    .size(LabelSize::Small),
+                )
                 .into_any()
         } else {
             h_flex()
diff --git a/crates/ui/src/components/icon.rs b/crates/ui/src/components/icon.rs
index a2f70244db2690..a71c3e98720917 100644
--- a/crates/ui/src/components/icon.rs
+++ b/crates/ui/src/components/icon.rs
@@ -255,6 +255,7 @@ pub enum IconName {
     Slash,
     SlashSquare,
     Sliders,
+    SlidersVertical,
     Snip,
     Space,
     Sparkle,
@@ -284,6 +285,7 @@ pub enum IconName {
     XCircle,
     ZedAssistant,
     ZedAssistantFilled,
+    ZedXCopilot,
 }
 
 #[derive(IntoElement)]

From 96a5daaf3f5a4424840705ba282c11ed5c4e8e77 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Mon, 16 Sep 2024 07:12:24 -0400
Subject: [PATCH 087/762] Refine symbolic link project tooltip (#17869)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR uses the tooltip with meta to display the info that a project
panel item is actually a symbolic link.

| Before | After |
|--------|--------|
| <img width="826" alt="Screenshot 2024-09-16 at 11 20 15 AM"
src="https://github.com/user-attachments/assets/7823f1f2-ed92-4b9a-b95e-c0777cb32387">
| <img width="638" alt="Screenshot 2024-09-16 at 11 19 12 AM"
src="https://github.com/user-attachments/assets/5d441ba5-6741-482c-bf2a-ec7e172953df">
|

Release Notes:

- N/A
---
 crates/project_panel/src/project_panel.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index c8e1ce28eb5938..cd4196dbc67b15 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -2298,7 +2298,7 @@ impl ProjectPanel {
                                 .id("symlink_icon")
                                 .pr_3()
                                 .tooltip(move |cx| {
-                                    Tooltip::text(format!("{path} • Symbolic Link"), cx)
+                                    Tooltip::with_meta(path.to_string(), None, "Symbolic Link", cx)
                                 })
                                 .child(
                                     Icon::new(IconName::ArrowUpRight)
@@ -2767,7 +2767,6 @@ impl Render for ProjectPanel {
                 .track_focus(&self.focus_handle)
                 .child(
                     Button::new("open_project", "Open a project")
-                        .style(ButtonStyle::Filled)
                         .full_width()
                         .key_binding(KeyBinding::for_action(&workspace::Open, cx))
                         .on_click(cx.listener(|this, _, cx| {

From 4e1bb68620f746a4683af4c335acdd207775a017 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Mon, 16 Sep 2024 08:28:27 -0400
Subject: [PATCH 088/762] Use buffer font for the inline assistant (#17875)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes https://github.com/zed-industries/zed/issues/17738

This PR is motivated by having also noticed what the issue above
mentions. Looked it further and it does seem the inline assistant had a
slightly bigger font-size even though it was using the configured UI
font-size as per https://github.com/zed-industries/zed/pull/17542. I'm
not sure why that was, technically speaking. However, I ended up
realizing that, given we're within the editor, it'd make more sense to
use the buffer font instead. With this change, the size mismatch seems
to be gone.

<img width="900" alt="Screenshot 2024-09-16 at 2 13 28 PM"
src="https://github.com/user-attachments/assets/fe2f3096-d5dd-4986-ba96-f2ca7578d84d">

Release Notes:

- N/A
---
 crates/assistant/src/inline_assistant.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index 8b71e54746dad6..30a5c98a54372a 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -1465,7 +1465,7 @@ impl Render for PromptEditor {
             .border_y_1()
             .border_color(cx.theme().status().info_border)
             .size_full()
-            .py(cx.line_height() / 2.)
+            .py(cx.line_height() / 2.5)
             .on_action(cx.listener(Self::confirm))
             .on_action(cx.listener(Self::cancel))
             .on_action(cx.listener(Self::move_up))
@@ -1918,12 +1918,11 @@ impl PromptEditor {
             } else {
                 cx.theme().colors().text
             },
-            font_family: settings.ui_font.family.clone(),
-            font_features: settings.ui_font.features.clone(),
-            font_fallbacks: settings.ui_font.fallbacks.clone(),
-            font_size: settings.ui_font_size.into(),
-            font_weight: settings.ui_font.weight,
-            line_height: relative(1.3),
+            font_family: settings.buffer_font.family.clone(),
+            font_fallbacks: settings.buffer_font.fallbacks.clone(),
+            font_size: settings.buffer_font_size.into(),
+            font_weight: settings.buffer_font.weight,
+            line_height: relative(settings.buffer_line_height.value()),
             ..Default::default()
         };
         EditorElement::new(

From 02dfe08ce8c025a6475905d3f233a37b61ffd3cf Mon Sep 17 00:00:00 2001
From: Nate Butler <iamnbutler@gmail.com>
Date: Mon, 16 Sep 2024 08:29:46 -0400
Subject: [PATCH 089/762] Welcome tweaks (#17874)

This PR adds "Open Settings" and "Open Docs" to the welcome page, as
well as some minor design polish.

The welcome page needs a full redesign at some point so I didn't too to
much here in terms of structure/content.

Before | After:

![CleanShot 2024-09-16 at 08 12
23@2x](https://github.com/user-attachments/assets/722175ec-d129-4060-827f-f02f572115da)

---

Release Notes:

- Improved welcome page design and added additional links.
---
 Cargo.lock                    |  1 +
 crates/welcome/Cargo.toml     |  3 ++-
 crates/welcome/src/welcome.rs | 43 ++++++++++++++++++++++++-----------
 3 files changed, 33 insertions(+), 14 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4cb7a85e359c6e..b752fc82927666 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -13273,6 +13273,7 @@ dependencies = [
  "util",
  "vim",
  "workspace",
+ "zed_actions",
 ]
 
 [[package]]
diff --git a/crates/welcome/Cargo.toml b/crates/welcome/Cargo.toml
index e747072cdeba70..0db1af9252ebcd 100644
--- a/crates/welcome/Cargo.toml
+++ b/crates/welcome/Cargo.toml
@@ -17,11 +17,11 @@ test-support = []
 [dependencies]
 anyhow.workspace = true
 client.workspace = true
-inline_completion_button.workspace = true
 db.workspace = true
 extensions_ui.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
+inline_completion_button.workspace = true
 install_cli.workspace = true
 picker.workspace = true
 project.workspace = true
@@ -33,6 +33,7 @@ ui.workspace = true
 util.workspace = true
 vim.workspace = true
 workspace.workspace = true
+zed_actions.workspace = true
 
 [dev-dependencies]
 editor = { workspace = true, features = ["test-support"] }
diff --git a/crates/welcome/src/welcome.rs b/crates/welcome/src/welcome.rs
index fc837c68671a31..1be2567c0af003 100644
--- a/crates/welcome/src/welcome.rs
+++ b/crates/welcome/src/welcome.rs
@@ -25,6 +25,7 @@ pub use multibuffer_hint::*;
 actions!(welcome, [ResetHints]);
 
 pub const FIRST_OPEN: &str = "first_open";
+pub const DOCS_URL: &str = "https://zed.dev/docs/";
 
 pub fn init(cx: &mut AppContext) {
     BaseKeymap::register(cx);
@@ -74,27 +75,22 @@ impl Render for WelcomePage {
             .track_focus(&self.focus_handle)
             .child(
                 v_flex()
-                    .w_96()
-                    .gap_4()
+                    .w_80()
+                    .gap_6()
                     .mx_auto()
                     .child(
                         svg()
                             .path("icons/logo_96.svg")
-                            .text_color(gpui::white())
-                            .w(px(96.))
-                            .h(px(96.))
+                            .text_color(cx.theme().colors().icon_disabled)
+                            .w(px(80.))
+                            .h(px(80.))
                             .mx_auto(),
                     )
-                    .child(
-                        h_flex()
-                            .justify_center()
-                            .child(Label::new("Code at the speed of thought")),
-                    )
                     .child(
                         v_flex()
                             .gap_2()
                             .child(
-                                Button::new("choose-theme", "Choose a theme")
+                                Button::new("choose-theme", "Choose Theme")
                                     .full_width()
                                     .on_click(cx.listener(|this, _, cx| {
                                         this.telemetry.report_app_event(
@@ -112,7 +108,7 @@ impl Render for WelcomePage {
                                     })),
                             )
                             .child(
-                                Button::new("choose-keymap", "Choose a keymap")
+                                Button::new("choose-keymap", "Choose Keymap")
                                     .full_width()
                                     .on_click(cx.listener(|this, _, cx| {
                                         this.telemetry.report_app_event(
@@ -129,6 +125,27 @@ impl Render for WelcomePage {
                                             .ok();
                                     })),
                             )
+                            .child(
+                                Button::new("edit settings", "Edit Settings")
+                                    .full_width()
+                                    .on_click(cx.listener(|this, _, cx| {
+                                        this.telemetry.report_app_event(
+                                            "welcome page: edit settings".to_string(),
+                                        );
+                                        cx.dispatch_action(Box::new(zed_actions::OpenSettings));
+                                    })),
+                            )
+                            .child(Button::new("view docs", "View Docs").full_width().on_click(
+                                cx.listener(|this, _, cx| {
+                                    this.telemetry
+                                        .report_app_event("welcome page: view docs".to_string());
+                                    cx.open_url(DOCS_URL);
+                                }),
+                            )),
+                    )
+                    .child(
+                        v_flex()
+                            .gap_2()
                             .when(cfg!(target_os = "macos"), |el| {
                                 el.child(
                                     Button::new("install-cli", "Install the CLI")
@@ -304,7 +321,7 @@ impl Item for WelcomePage {
     type Event = ItemEvent;
 
     fn tab_content_text(&self, _cx: &WindowContext) -> Option<SharedString> {
-        Some("Welcome to Zed!".into())
+        Some("Welcome".into())
     }
 
     fn telemetry_event_text(&self) -> Option<&'static str> {

From f986513d0dc0f5ddc88089229970afcbb3f4453b Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Mon, 16 Sep 2024 09:00:20 -0400
Subject: [PATCH 090/762] gpui: Remove debug print statement (#17878)

Release Notes:

- N/A
---
 crates/gpui/src/app.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index ac7d5eb47bb99e..564b8934897734 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -1504,9 +1504,3 @@ pub struct KeystrokeEvent {
     /// The action that was resolved for the keystroke, if any
     pub action: Option<Box<dyn Action>>,
 }
-
-impl Drop for AppContext {
-    fn drop(&mut self) {
-        println!("Dropping the App Context");
-    }
-}

From e3d54b22118f54d13488707bc3cb9f0e9143b1c8 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Mon, 16 Sep 2024 09:01:20 -0400
Subject: [PATCH 091/762] vim: Fix ctrl-b not moving the cursor (#17808)

Closes #17687

Release Notes:

- Fixed `ctrl-b` not moving the cursor.

---------

Co-authored-by: Abdelhakim Qbaich <abdelhakim@qbaich.com>
Co-authored-by: Pete LeVasseur <plevasseur@gmail.com>
---
 crates/editor/src/scroll/scroll_amount.rs | 29 ++++++-
 crates/vim/src/normal/scroll.rs           | 92 +++++++++++++++++++++--
 crates/vim/test_data/test_ctrl_f_b.json   | 24 ++++++
 3 files changed, 136 insertions(+), 9 deletions(-)
 create mode 100644 crates/vim/test_data/test_ctrl_f_b.json

diff --git a/crates/editor/src/scroll/scroll_amount.rs b/crates/editor/src/scroll/scroll_amount.rs
index d115be68a0d4d0..ee80b3d86f7aa9 100644
--- a/crates/editor/src/scroll/scroll_amount.rs
+++ b/crates/editor/src/scroll/scroll_amount.rs
@@ -1,6 +1,18 @@
 use serde::Deserialize;
 use ui::{px, Pixels};
 
+#[derive(Debug)]
+pub enum ScrollDirection {
+    Upwards,
+    Downwards,
+}
+
+impl ScrollDirection {
+    pub fn is_upwards(&self) -> bool {
+        matches!(self, ScrollDirection::Upwards)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Deserialize)]
 pub enum ScrollAmount {
     // Scroll N lines (positive is towards the end of the document)
@@ -15,7 +27,7 @@ impl ScrollAmount {
             Self::Line(count) => *count,
             Self::Page(count) => {
                 // for full pages subtract one to leave an anchor line
-                if count.abs() == 1.0 {
+                if self.is_full_page() {
                     visible_line_count -= 1.0
                 }
                 (visible_line_count * count).trunc()
@@ -29,4 +41,19 @@ impl ScrollAmount {
             ScrollAmount::Page(x) => px(height.0 * x),
         }
     }
+
+    pub fn is_full_page(&self) -> bool {
+        match self {
+            ScrollAmount::Page(count) if count.abs() == 1.0 => true,
+            _ => false,
+        }
+    }
+
+    pub fn direction(&self) -> ScrollDirection {
+        match self {
+            Self::Line(amount) if amount.is_sign_positive() => ScrollDirection::Downwards,
+            Self::Page(amount) if amount.is_sign_positive() => ScrollDirection::Downwards,
+            _ => ScrollDirection::Upwards,
+        }
+    }
 }
diff --git a/crates/vim/src/normal/scroll.rs b/crates/vim/src/normal/scroll.rs
index f89faa3748372f..8d1443e6339028 100644
--- a/crates/vim/src/normal/scroll.rs
+++ b/crates/vim/src/normal/scroll.rs
@@ -73,14 +73,24 @@ fn scroll_editor(
         return;
     }
 
-    editor.scroll_screen(amount, cx);
+    let full_page_up = amount.is_full_page() && amount.direction().is_upwards();
+    let amount = match (amount.is_full_page(), editor.visible_line_count()) {
+        (true, Some(visible_line_count)) => {
+            if amount.direction().is_upwards() {
+                ScrollAmount::Line(amount.lines(visible_line_count) + 1.0)
+            } else {
+                ScrollAmount::Line(amount.lines(visible_line_count) - 1.0)
+            }
+        }
+        _ => amount.clone(),
+    };
+
+    editor.scroll_screen(&amount, cx);
     if !should_move_cursor {
         return;
     }
 
-    let visible_line_count = if let Some(visible_line_count) = editor.visible_line_count() {
-        visible_line_count
-    } else {
+    let Some(visible_line_count) = editor.visible_line_count() else {
         return;
     };
 
@@ -115,11 +125,18 @@ fn scroll_editor(
             } else {
                 DisplayRow(top.row().0 + vertical_scroll_margin)
             };
-            let max_row = DisplayRow(map.max_point().row().0.max(top.row().0.saturating_add(
-                (visible_line_count as u32).saturating_sub(1 + vertical_scroll_margin),
-            )));
 
-            let new_row = if head.row() < min_row {
+            let max_visible_row = top.row().0.saturating_add(
+                (visible_line_count as u32).saturating_sub(1 + vertical_scroll_margin),
+            );
+            let max_row = DisplayRow(map.max_point().row().0.max(max_visible_row));
+
+            let new_row = if full_page_up {
+                // Special-casing ctrl-b/page-up, which is special-cased by Vim, it seems
+                // to always put the cursor on the last line of the page, even if the cursor
+                // was before that.
+                DisplayRow(max_visible_row)
+            } else if head.row() < min_row {
                 min_row
             } else if head.row() > max_row {
                 max_row
@@ -251,6 +268,7 @@ mod test {
             )
         });
     }
+
     #[gpui::test]
     async fn test_ctrl_d_u(cx: &mut gpui::TestAppContext) {
         let mut cx = NeovimBackedTestContext::new(cx).await;
@@ -282,6 +300,64 @@ mod test {
         cx.shared_state().await.assert_matches();
     }
 
+    #[gpui::test]
+    async fn test_ctrl_f_b(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+
+        let visible_lines = 10;
+        cx.set_scroll_height(visible_lines).await;
+
+        // First test without vertical scroll margin
+        cx.neovim.set_option(&format!("scrolloff={}", 0)).await;
+        cx.update_global(|store: &mut SettingsStore, cx| {
+            store.update_user_settings::<EditorSettings>(cx, |s| {
+                s.vertical_scroll_margin = Some(0.0)
+            });
+        });
+
+        let content = "ˇ".to_owned() + &sample_text(26, 2, 'a');
+        cx.set_shared_state(&content).await;
+
+        // scroll down: ctrl-f
+        cx.simulate_shared_keystrokes("ctrl-f").await;
+        cx.shared_state().await.assert_matches();
+
+        cx.simulate_shared_keystrokes("ctrl-f").await;
+        cx.shared_state().await.assert_matches();
+
+        // scroll up: ctrl-b
+        cx.simulate_shared_keystrokes("ctrl-b").await;
+        cx.shared_state().await.assert_matches();
+
+        cx.simulate_shared_keystrokes("ctrl-b").await;
+        cx.shared_state().await.assert_matches();
+
+        // Now go back to start of file, and test with vertical scroll margin
+        cx.simulate_shared_keystrokes("g g").await;
+        cx.shared_state().await.assert_matches();
+
+        cx.neovim.set_option(&format!("scrolloff={}", 3)).await;
+        cx.update_global(|store: &mut SettingsStore, cx| {
+            store.update_user_settings::<EditorSettings>(cx, |s| {
+                s.vertical_scroll_margin = Some(3.0)
+            });
+        });
+
+        // scroll down: ctrl-f
+        cx.simulate_shared_keystrokes("ctrl-f").await;
+        cx.shared_state().await.assert_matches();
+
+        cx.simulate_shared_keystrokes("ctrl-f").await;
+        cx.shared_state().await.assert_matches();
+
+        // scroll up: ctrl-b
+        cx.simulate_shared_keystrokes("ctrl-b").await;
+        cx.shared_state().await.assert_matches();
+
+        cx.simulate_shared_keystrokes("ctrl-b").await;
+        cx.shared_state().await.assert_matches();
+    }
+
     #[gpui::test]
     async fn test_scroll_beyond_last_line(cx: &mut gpui::TestAppContext) {
         let mut cx = NeovimBackedTestContext::new(cx).await;
diff --git a/crates/vim/test_data/test_ctrl_f_b.json b/crates/vim/test_data/test_ctrl_f_b.json
new file mode 100644
index 00000000000000..19c94d8b6e94b2
--- /dev/null
+++ b/crates/vim/test_data/test_ctrl_f_b.json
@@ -0,0 +1,24 @@
+{"SetOption":{"value":"scrolloff=3"}}
+{"SetOption":{"value":"lines=12"}}
+{"SetOption":{"value":"scrolloff=0"}}
+{"Put":{"state":"ˇaa\nbb\ncc\ndd\nee\nff\ngg\nhh\nii\njj\nkk\nll\nmm\nnn\noo\npp\nqq\nrr\nss\ntt\nuu\nvv\nww\nxx\nyy\nzz"}}
+{"Key":"ctrl-f"}
+{"Get":{"state":"aa\nbb\ncc\ndd\nee\nff\ngg\nhh\nˇii\njj\nkk\nll\nmm\nnn\noo\npp\nqq\nrr\nss\ntt\nuu\nvv\nww\nxx\nyy\nzz","mode":"Normal"}}
+{"Key":"ctrl-f"}
+{"Get":{"state":"aa\nbb\ncc\ndd\nee\nff\ngg\nhh\nii\njj\nkk\nll\nmm\nnn\noo\npp\nˇqq\nrr\nss\ntt\nuu\nvv\nww\nxx\nyy\nzz","mode":"Normal"}}
+{"Key":"ctrl-b"}
+{"Get":{"state":"aa\nbb\ncc\ndd\nee\nff\ngg\nhh\nii\njj\nkk\nll\nmm\nnn\noo\npp\nqq\nˇrr\nss\ntt\nuu\nvv\nww\nxx\nyy\nzz","mode":"Normal"}}
+{"Key":"ctrl-b"}
+{"Get":{"state":"aa\nbb\ncc\ndd\nee\nff\ngg\nhh\nii\nˇjj\nkk\nll\nmm\nnn\noo\npp\nqq\nrr\nss\ntt\nuu\nvv\nww\nxx\nyy\nzz","mode":"Normal"}}
+{"Key":"g"}
+{"Key":"g"}
+{"Get":{"state":"ˇaa\nbb\ncc\ndd\nee\nff\ngg\nhh\nii\njj\nkk\nll\nmm\nnn\noo\npp\nqq\nrr\nss\ntt\nuu\nvv\nww\nxx\nyy\nzz","mode":"Normal"}}
+{"SetOption":{"value":"scrolloff=3"}}
+{"Key":"ctrl-f"}
+{"Get":{"state":"aa\nbb\ncc\ndd\nee\nff\ngg\nhh\nii\njj\nkk\nˇll\nmm\nnn\noo\npp\nqq\nrr\nss\ntt\nuu\nvv\nww\nxx\nyy\nzz","mode":"Normal"}}
+{"Key":"ctrl-f"}
+{"Get":{"state":"aa\nbb\ncc\ndd\nee\nff\ngg\nhh\nii\njj\nkk\nll\nmm\nnn\noo\npp\nqq\nrr\nss\nˇtt\nuu\nvv\nww\nxx\nyy\nzz","mode":"Normal"}}
+{"Key":"ctrl-b"}
+{"Get":{"state":"aa\nbb\ncc\ndd\nee\nff\ngg\nhh\nii\njj\nkk\nll\nmm\nnn\nˇoo\npp\nqq\nrr\nss\ntt\nuu\nvv\nww\nxx\nyy\nzz","mode":"Normal"}}
+{"Key":"ctrl-b"}
+{"Get":{"state":"aa\nbb\ncc\ndd\nee\nff\nˇgg\nhh\nii\njj\nkk\nll\nmm\nnn\noo\npp\nqq\nrr\nss\ntt\nuu\nvv\nww\nxx\nyy\nzz","mode":"Normal"}}

From 2baa704af7e6150e99da63d19a9fa42223e8acce Mon Sep 17 00:00:00 2001
From: ihavecoke <mixboip@gmail.com>
Date: Mon, 16 Sep 2024 22:29:42 +0800
Subject: [PATCH 092/762] Clamp `tab_size` setting between 1 and 16 (#17882)

Release Notes:

- Changed `tab_size` setting to require values be between 1 and 16
(inclusive).


### jetbrains settings

#### Max value

![image](https://github.com/user-attachments/assets/54b772fd-e670-4d77-b3e9-757b08659f55)

When the maximum value is exceeded, the configuration box turns red to
remind the user


![image](https://github.com/user-attachments/assets/fcdb6313-be97-4528-b654-5900bcaeafec)

If the user still saves, jetbrains does not process it and resets it to
the system default value of 4

<img width="700" alt="image"
src="https://github.com/user-attachments/assets/a76b1cba-d23f-4a32-95ee-f05d208ca186">

Without restrictions, I feel not good. Here is a random setting of a
relatively large value



https://github.com/user-attachments/assets/c3bdf262-ba08-4bc2-996a-5ad2a37c567f

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 crates/language/src/language_settings.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index e1fcaaba28b4f1..b465173cee1e4d 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -1027,6 +1027,10 @@ fn merge_settings(settings: &mut LanguageSettings, src: &LanguageSettingsContent
     }
 
     merge(&mut settings.tab_size, src.tab_size);
+    settings.tab_size = settings
+        .tab_size
+        .clamp(NonZeroU32::new(1).unwrap(), NonZeroU32::new(16).unwrap());
+
     merge(&mut settings.hard_tabs, src.hard_tabs);
     merge(&mut settings.soft_wrap, src.soft_wrap);
     merge(&mut settings.use_autoclose, src.use_autoclose);

From 2cae6f3e088b1031a0a3ffe304613b1aaed454d1 Mon Sep 17 00:00:00 2001
From: Yohanes Bandung Bondowoso <hi@ybbond.id>
Date: Mon, 16 Sep 2024 22:03:51 +0700
Subject: [PATCH 093/762] dart: Respect LSP binary settings (#17494)

Enable configuring Dart's LSP from other means of installation types.

Some users don't install the `dart` binary, but uses version manager.

In the example, I uses [FVM](https://fvm.app/) (short for "Flutter
Version Manager").

I have tested this with "Install Dev Extensions".

Release Notes:

- N/A

cc other maintainer: @agent3bood @flo80

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 docs/src/languages/dart.md     | 17 ++++++++++++
 extensions/dart/extension.toml |  2 +-
 extensions/dart/src/dart.rs    | 51 ++++++++++++++++++++++++++++++----
 3 files changed, 63 insertions(+), 7 deletions(-)

diff --git a/docs/src/languages/dart.md b/docs/src/languages/dart.md
index 6f80857c88cc90..6571166b6d3061 100644
--- a/docs/src/languages/dart.md
+++ b/docs/src/languages/dart.md
@@ -5,6 +5,23 @@ Dart support is available through the [Dart extension](https://github.com/zed-in
 - Tree Sitter: [UserNobody14/tree-sitter-dart](https://github.com/UserNobody14/tree-sitter-dart)
 - Language Server: [dart language-server](https://github.com/dart-lang/sdk)
 
+## Configuration
+
+The `dart` binary can be configured in a Zed settings file with:
+
+```json
+{
+  "lsp": {
+    "dart": {
+      "binary": {
+        "path": "/opt/homebrew/bin/fvm",
+        "arguments": ["dart", "language-server", "--protocol=lsp"]
+      }
+    }
+  }
+}
+```
+
 <!--
 TBD: Document Dart. pubspec.yaml
 - https://github.com/dart-lang/sdk/blob/main/pkg/analysis_server/tool/lsp_spec/README.md
diff --git a/extensions/dart/extension.toml b/extensions/dart/extension.toml
index 6d87957fc6e58e..2aea50e72b3c3b 100644
--- a/extensions/dart/extension.toml
+++ b/extensions/dart/extension.toml
@@ -3,7 +3,7 @@ name = "Dart"
 description = "Dart support."
 version = "0.0.3"
 schema_version = 1
-authors = ["Abdullah Alsigar <abdullah.alsigar@gmail.com>", "Flo <flo80@users.noreply.github.com>"]
+authors = ["Abdullah Alsigar <abdullah.alsigar@gmail.com>", "Flo <flo80@users.noreply.github.com>", "ybbond <hi@ybbond.id>"]
 repository = "https://github.com/zed-industries/zed"
 
 [language_servers.dart]
diff --git a/extensions/dart/src/dart.rs b/extensions/dart/src/dart.rs
index e541846256fcbd..38a2cf25a690f5 100644
--- a/extensions/dart/src/dart.rs
+++ b/extensions/dart/src/dart.rs
@@ -3,8 +3,47 @@ use zed::settings::LspSettings;
 use zed::{CodeLabel, CodeLabelSpan};
 use zed_extension_api::{self as zed, serde_json, Result};
 
+struct DartBinary {
+    pub path: String,
+    pub args: Option<Vec<String>>,
+}
+
 struct DartExtension;
 
+impl DartExtension {
+    fn language_server_binary(
+        &mut self,
+        _language_server_id: &zed::LanguageServerId,
+        worktree: &zed::Worktree,
+    ) -> Result<DartBinary> {
+        let binary_settings = LspSettings::for_worktree("dart", worktree)
+            .ok()
+            .and_then(|lsp_settings| lsp_settings.binary);
+        let binary_args = binary_settings
+            .as_ref()
+            .and_then(|binary_settings| binary_settings.arguments.clone());
+
+        if let Some(path) = binary_settings.and_then(|binary_settings| binary_settings.path) {
+            return Ok(DartBinary {
+                path,
+                args: binary_args,
+            });
+        }
+
+        if let Some(path) = worktree.which("dart") {
+            return Ok(DartBinary {
+                path,
+                args: binary_args,
+            });
+        }
+
+        Err(
+            "dart must be installed from dart.dev/get-dart or pointed to by the LSP binary settings"
+                .to_string(),
+        )
+    }
+}
+
 impl zed::Extension for DartExtension {
     fn new() -> Self {
         Self
@@ -12,16 +51,16 @@ impl zed::Extension for DartExtension {
 
     fn language_server_command(
         &mut self,
-        _language_server_id: &zed::LanguageServerId,
+        language_server_id: &zed::LanguageServerId,
         worktree: &zed::Worktree,
     ) -> Result<zed::Command> {
-        let path = worktree
-            .which("dart")
-            .ok_or_else(|| "dart must be installed from dart.dev/get-dart".to_string())?;
+        let dart_binary = self.language_server_binary(language_server_id, worktree)?;
 
         Ok(zed::Command {
-            command: path,
-            args: vec!["language-server".to_string(), "--protocol=lsp".to_string()],
+            command: dart_binary.path,
+            args: dart_binary.args.unwrap_or_else(|| {
+                vec!["language-server".to_string(), "--protocol=lsp".to_string()]
+            }),
             env: Default::default(),
         })
     }

From 22db569adf5f9bf328a99d7a9a8fed01b5c24b7d Mon Sep 17 00:00:00 2001
From: Finn Evers <finn.evers@outlook.de>
Date: Mon, 16 Sep 2024 17:04:56 +0200
Subject: [PATCH 094/762] docs: Use `json` to fix syntax highlighting (#17884)

This follows up the [issue with mdbook notpeter
mentioned](https://github.com/zed-industries/zed/pull/17864#issuecomment-2353089065)
by replacing `jsonc` where used in the docs with `json`.

Additionally, one missing `json` - highlight was added for the
search-section.

Release Notes:

- N/A
---
 docs/src/configuring-zed.md      | 30 +++++++++++++++---------------
 docs/src/languages/csharp.md     | 10 +++++-----
 docs/src/languages/typescript.md |  8 ++++----
 3 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 1c4aee533d176a..d677b08200908c 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -1179,7 +1179,7 @@ Or to set a `socks5` proxy:
 - Setting: `search`
 - Default:
 
-```
+```json
 "search": {
   "whole_word": false,
   "case_sensitive": false,
@@ -1516,14 +1516,14 @@ The name of any font family installed on the user's system
 
 See Buffer Font Features
 
-```jsonc
+```json
 {
   "terminal": {
     "font_features": {
-      "calt": false,
+      "calt": false
       // See Buffer Font Features for more features
-    },
-  },
+    }
+  }
 }
 ```
 
@@ -1537,33 +1537,33 @@ See Buffer Font Features
 
 1. Use a line height that's `comfortable` for reading, 1.618. (default)
 
-```jsonc
+```json
 {
   "terminal": {
-    "line_height": "comfortable",
-  },
+    "line_height": "comfortable"
+  }
 }
 ```
 
 2. Use a `standard` line height, 1.3. This option is useful for TUIs, particularly if they use box characters
 
-```jsonc
+```json
 {
   "terminal": {
-    "line_height": "standard",
-  },
+    "line_height": "standard"
+  }
 }
 ```
 
 3.  Use a custom line height.
 
-```jsonc
+```json
 {
   "terminal": {
     "line_height": {
-      "custom": 2,
-    },
-  },
+      "custom": 2
+    }
+  }
 }
 ```
 
diff --git a/docs/src/languages/csharp.md b/docs/src/languages/csharp.md
index 27d758e2fc9f05..bf3b793c34f53e 100644
--- a/docs/src/languages/csharp.md
+++ b/docs/src/languages/csharp.md
@@ -11,15 +11,15 @@ C# support is available through the [C# extension](https://github.com/zed-indust
 
 The `OmniSharp` binary can be configured in a Zed settings file with:
 
-```jsonc
+```json
 {
   "lsp": {
     "omnisharp": {
       "binary": {
         "path": "/path/to/OmniSharp",
-        "args": ["optional", "additional", "args", "-lsp"],
-      },
-    },
-  },
+        "args": ["optional", "additional", "args", "-lsp"]
+      }
+    }
+  }
 }
 ```
diff --git a/docs/src/languages/typescript.md b/docs/src/languages/typescript.md
index bfe63c5b2c1a6c..feb7d76622f121 100644
--- a/docs/src/languages/typescript.md
+++ b/docs/src/languages/typescript.md
@@ -33,14 +33,14 @@ You can configure the use of [typescript-language-server](https://github.com/typ
 
 Prettier will also be used for TypeScript files by default. To disable this:
 
-```jsonc
+```json
 {
   "languages": {
     "TypeScript": {
-      "prettier": { "allowed": false },
-    },
+      "prettier": { "allowed": false }
+    }
     //...
-  },
+  }
 }
 ```
 

From 761129e3739efacb7b8763eaa0fa8a109e935447 Mon Sep 17 00:00:00 2001
From: jvmncs <7891333+jvmncs@users.noreply.github.com>
Date: Mon, 16 Sep 2024 11:09:31 -0400
Subject: [PATCH 095/762] Update nightly tag every night (#17879)

Previous `release_nightly` workflow would trigger every night or on push
to the `nightly` tag, which means `nightly` tag wasn't always in sync
with the nightly we bundle. This change syncs the tag up with the
bundled releases.

Release Notes:

- N/A
---
 .github/workflows/bump_nightly_tag.yml | 23 +++++++++++++++++++++++
 .github/workflows/release_nightly.yml  |  3 ---
 2 files changed, 23 insertions(+), 3 deletions(-)
 create mode 100644 .github/workflows/bump_nightly_tag.yml

diff --git a/.github/workflows/bump_nightly_tag.yml b/.github/workflows/bump_nightly_tag.yml
new file mode 100644
index 00000000000000..54a3970a1cd83d
--- /dev/null
+++ b/.github/workflows/bump_nightly_tag.yml
@@ -0,0 +1,23 @@
+name: Update Nightly Tag
+
+on:
+  schedule:
+    # Fire every day at 7:00am UTC (Roughly before EU workday and after US workday)
+    - cron: "0 7 * * *"
+
+jobs:
+  update-nightly-tag:
+    if: github.repository_owner == 'zed-industries'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Update nightly tag
+        run: |
+          git config user.name github-actions
+          git config user.email github-actions@github.com
+          git tag -f nightly
+          git push origin nightly --force
diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml
index e1fc5a39f2eff8..8371840984bb3e 100644
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -1,9 +1,6 @@
 name: Release Nightly
 
 on:
-  schedule:
-    # Fire every day at 7:00am UTC (Roughly before EU workday and after US workday)
-    - cron: "0 7 * * *"
   push:
     tags:
       - "nightly"

From fb79346e6fa4825061316bb5babc06c7e42cb1c8 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 16 Sep 2024 11:57:34 -0400
Subject: [PATCH 096/762] dart: Bump to v0.1.0 (#17887)

This PR bumps the Dart extension to v0.1.0.

Changes:

- https://github.com/zed-industries/zed/pull/16955
- https://github.com/zed-industries/zed/pull/17494

Release Notes:

- N/A
---
 Cargo.lock                     | 2 +-
 extensions/dart/Cargo.toml     | 2 +-
 extensions/dart/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b752fc82927666..a6d351099b9351 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14376,7 +14376,7 @@ dependencies = [
 
 [[package]]
 name = "zed_dart"
-version = "0.0.3"
+version = "0.1.0"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/dart/Cargo.toml b/extensions/dart/Cargo.toml
index ecc2328083a307..d1b4b290baa51a 100644
--- a/extensions/dart/Cargo.toml
+++ b/extensions/dart/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_dart"
-version = "0.0.3"
+version = "0.1.0"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/dart/extension.toml b/extensions/dart/extension.toml
index 2aea50e72b3c3b..48cd8476181fdf 100644
--- a/extensions/dart/extension.toml
+++ b/extensions/dart/extension.toml
@@ -1,7 +1,7 @@
 id = "dart"
 name = "Dart"
 description = "Dart support."
-version = "0.0.3"
+version = "0.1.0"
 schema_version = 1
 authors = ["Abdullah Alsigar <abdullah.alsigar@gmail.com>", "Flo <flo80@users.noreply.github.com>", "ybbond <hi@ybbond.id>"]
 repository = "https://github.com/zed-industries/zed"

From 90b77e125ab3ed3bb7e7c623d91210dc77cf1689 Mon Sep 17 00:00:00 2001
From: Zhang <17492978+zhang0098@users.noreply.github.com>
Date: Tue, 17 Sep 2024 00:00:49 +0800
Subject: [PATCH 097/762] Don't show extra row in toolbar if it is empty
 (#17888)

Closes #17851

Release Notes:

- Removed an extra row in the toolbar if it was empty.
---
 crates/workspace/src/toolbar.rs | 64 +++++++++++++++++----------------
 1 file changed, 33 insertions(+), 31 deletions(-)

diff --git a/crates/workspace/src/toolbar.rs b/crates/workspace/src/toolbar.rs
index 1cd550d8b5f819..0cbeb6dd20fb49 100644
--- a/crates/workspace/src/toolbar.rs
+++ b/crates/workspace/src/toolbar.rs
@@ -104,37 +104,39 @@ impl Render for Toolbar {
             .border_b_1()
             .border_color(cx.theme().colors().border_variant)
             .bg(cx.theme().colors().toolbar_background)
-            .child(
-                h_flex()
-                    .min_h(rems_from_px(24.))
-                    .justify_between()
-                    .gap(Spacing::Large.rems(cx))
-                    .when(has_left_items, |this| {
-                        this.child(
-                            h_flex()
-                                .flex_auto()
-                                .justify_start()
-                                .overflow_x_hidden()
-                                .children(self.left_items().map(|item| item.to_any())),
-                        )
-                    })
-                    .when(has_right_items, |this| {
-                        this.child(
-                            h_flex()
-                                .map(|el| {
-                                    if has_left_items {
-                                        // We're using `flex_none` here to prevent some flickering that can occur when the
-                                        // size of the left items container changes.
-                                        el.flex_none()
-                                    } else {
-                                        el.flex_auto()
-                                    }
-                                })
-                                .justify_end()
-                                .children(self.right_items().map(|item| item.to_any())),
-                        )
-                    }),
-            )
+            .when(has_left_items || has_right_items, |this| {
+                this.child(
+                    h_flex()
+                        .min_h(rems_from_px(24.))
+                        .justify_between()
+                        .gap(Spacing::Large.rems(cx))
+                        .when(has_left_items, |this| {
+                            this.child(
+                                h_flex()
+                                    .flex_auto()
+                                    .justify_start()
+                                    .overflow_x_hidden()
+                                    .children(self.left_items().map(|item| item.to_any())),
+                            )
+                        })
+                        .when(has_right_items, |this| {
+                            this.child(
+                                h_flex()
+                                    .map(|el| {
+                                        if has_left_items {
+                                            // We're using `flex_none` here to prevent some flickering that can occur when the
+                                            // size of the left items container changes.
+                                            el.flex_none()
+                                        } else {
+                                            el.flex_auto()
+                                        }
+                                    })
+                                    .justify_end()
+                                    .children(self.right_items().map(|item| item.to_any())),
+                            )
+                        }),
+                )
+            })
             .children(secondary_item)
     }
 }

From 28fb1fd19b619a30d44d7ee6f03c2dcef505c482 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 16 Sep 2024 12:17:41 -0400
Subject: [PATCH 098/762] Regenerate terms.rtf fixing Privacy Policy link
 (#17877)

---
 script/terms/terms.rtf | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/script/terms/terms.rtf b/script/terms/terms.rtf
index 818a2cc9f6c59f..79fa65b73dcd10 100644
--- a/script/terms/terms.rtf
+++ b/script/terms/terms.rtf
@@ -101,7 +101,7 @@ Usage Data is associated with a secure random telemetry ID which may be linked t
 \f1\b \cf0 3.3.5. Privacy Policy\
 \pard\pardeftab720\sa240\partightenfactor0
 
-\f0\b0 \cf0 You and Zed are bound by the terms and conditions contained in the Zed Privacy Policy which is incorporated by reference hereto. The Zed Privacy Policy is available at the following URL: {\field{\*\fldinst{HYPERLINK "https://zed.dev/privacy"}}{\fldrslt \cf3 \ul \ulc3 \strokec3 https://zed.dev/privacy-policy}}.\
+\f0\b0 \cf0 You and Zed are bound by the terms and conditions contained in the Zed Privacy Policy which is incorporated by reference hereto. The Zed Privacy Policy is available at the following URL: {\field{\*\fldinst{HYPERLINK "https://zed.dev/privacy-policy"}}{\fldrslt \cf3 \ul \ulc3 \strokec3 https://zed.dev/privacy-policy}}.\
 \pard\pardeftab720\sa298\partightenfactor0
 
 \f1\b\fs36 \cf0 4. TERM AND TERMINATION\
@@ -212,6 +212,6 @@ Usage Data is associated with a secure random telemetry ID which may be linked t
 \f0\b0\fs24 \cf0 This Agreement is the complete and exclusive statement of the mutual understanding of the parties and supersedes and cancels all previous written and oral agreements, communications, and other understandings relating to the subject matter of this Agreement, and all waivers and modifications must be in a writing signed by both parties, except as otherwise provided herein. Any term or provision of this Agreement held to be illegal or unenforceable shall be, to the fullest extent possible, interpreted so as to be construed as valid, but in any event the validity or enforceability of the remainder hereof shall not be affected.\
 \pard\pardeftab720\sa240\partightenfactor0
 
-\f1\b \cf0 DATE: August 16, 2024
+\f1\b \cf0 DATE: August 19, 2024
 \f0\b0 \
 }
\ No newline at end of file

From ba5c1322ced2edf3409c8cb2036d1756c55795d8 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 16 Sep 2024 12:40:56 -0400
Subject: [PATCH 099/762] collab: Add missing dependencies for building Docker
 image (#17893)

This PR adds some missing dependencies to the Docker image that are now
needed in order to build collab.

When trying to build the docker image at
761129e3739efacb7b8763eaa0fa8a109e935447 it fails with the following
error:

```
985.3   = note: /usr/bin/ld: cannot find -lxkbcommon: No such file or directory
985.3           /usr/bin/ld: cannot find -lxkbcommon-x11: No such file or directory
985.3           collect2: error: ld returned 1 exit status
985.3
985.3
985.4 error: could not compile `collab` (bin "collab") due to 1 previous error
```

The last time we built the Docker image for collab was:

- Staging: 4f408ec65a3867278322a189b4eb20f1ab51f508
- Production: fc4c533d0a8c489e5636a4249d2b52a80039fbd7

Release Notes:

- N/A
---
 Dockerfile | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/Dockerfile b/Dockerfile
index 70c47c9f671e18..efa816bf767084 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -9,6 +9,28 @@ ARG CARGO_PROFILE_RELEASE_PANIC=abort
 ARG GITHUB_SHA
 
 ENV GITHUB_SHA=$GITHUB_SHA
+
+# At some point in the past 3 weeks, additional dependencies on `xkbcommon` and
+# `xkbcommon-x11` were introduced into collab.
+#
+# Now when we try to build collab for the Docker image, it fails with the following
+# error:
+#
+# ```
+# 985.3   = note: /usr/bin/ld: cannot find -lxkbcommon: No such file or directory
+# 985.3           /usr/bin/ld: cannot find -lxkbcommon-x11: No such file or directory
+# 985.3           collect2: error: ld returned 1 exit status
+# ```
+#
+# The last successful deploys were at:
+# - Staging: `4f408ec65a3867278322a189b4eb20f1ab51f508`
+# - Production: `fc4c533d0a8c489e5636a4249d2b52a80039fbd7`
+#
+# Installing these as a temporary workaround, but I think ideally we'd want to figure
+# out what caused them to be included in the first place.
+RUN apt-get update; \
+    apt-get install -y --no-install-recommends libxkbcommon-dev libxkbcommon-x11-dev
+
 RUN --mount=type=cache,target=./script/node_modules \
     --mount=type=cache,target=/usr/local/cargo/registry \
     --mount=type=cache,target=/usr/local/cargo/git \

From 784c3093aedd49c6edba835a958007a0cfd75be6 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 16 Sep 2024 12:41:33 -0400
Subject: [PATCH 100/762] Remove incorrect documentation for language-specific
 theme overrides (#17894)

Zed does not support this, the documentation was added in error. And if it were supported, the key would be `experimental.theme_overrides` not `theme_overrides`.
---
 docs/src/configuring-languages.md | 26 +++-----------------------
 1 file changed, 3 insertions(+), 23 deletions(-)

diff --git a/docs/src/configuring-languages.md b/docs/src/configuring-languages.md
index b2c9571bd47a9f..65e9f822b94786 100644
--- a/docs/src/configuring-languages.md
+++ b/docs/src/configuring-languages.md
@@ -295,7 +295,9 @@ Zed offers customization options for syntax highlighting and themes, allowing yo
 
 ### Customizing Syntax Highlighting
 
-Zed uses Tree-sitter grammars for syntax highlighting. Override the default highlighting using the `experimental.theme_overrides` setting:
+Zed uses Tree-sitter grammars for syntax highlighting. Override the default highlighting using the `experimental.theme_overrides` setting.
+
+This example makes comments italic and changes the color of strings:
 
 ```json
 "experimental.theme_overrides": {
@@ -310,28 +312,6 @@ Zed uses Tree-sitter grammars for syntax highlighting. Override the default high
 }
 ```
 
-This example makes comments italic and changes the color of strings.
-
-### Language-Specific Theme Overrides
-
-Apply theme overrides for specific languages:
-
-```json
-"languages": {
-  "Python": {
-    "theme_overrides": {
-      "syntax": {
-        "function": {
-          "color": "#0000FF"
-        }
-      }
-    }
-  }
-}
-```
-
-This configuration changes the color of function names in Python files.
-
 ### Selecting and Customizing Themes
 
 Change your theme:

From 2c9d07663a7bd0cb01e7b053df0c763442a055c9 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Mon, 16 Sep 2024 18:45:11 +0200
Subject: [PATCH 101/762] rust: Lookup rust-analyzer on PATH by default
 (#17885)

This is a highly and frequently requested change. Users are confused why
rust-analyzer isn't used if it's on their `$PATH`.

Previously I didn't enable this by default, because rust-analyzer would
complain about an "Unknown binary", like this

Unknown binary 'rust-analyzer' in official toolchain
'1.81-aarch64-apple-darwin'.\n

But turns out that only happens when you have installed rust-analyzer
via the rustup toolchain, it's in your `$PATH`, and the
`rust-toolchain.toml` of the repository doesn't mention it.

The fix is to delete `~/.cargo/bin/rust-analyzer` and, if preferred, use
`rust-analyzer` by installing the binary manually.

Release Notes:

- Changed rust-analyzer support to lookup `rust-analyzer` binaries by
default in `$PATH`. That changes the default value to something users
requested.
---
 crates/languages/src/rust.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs
index a32b4f55da1c81..20e6c575749314 100644
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -57,12 +57,13 @@ impl LspAdapter for RustLspAdapter {
                         }
                         (Some(path.into()), None)
                     }
-                    (None, Some(true)) => {
+                    (None, Some(true)) | (None, None) => {
+                        // Try to lookup rust-analyzer in PATH by default.
                         let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
                         let env = delegate.shell_env().await;
                         (Some(path), Some(env))
                     }
-                    (None, Some(false)) | (None, None) => (None, None),
+                    (None, Some(false)) => (None, None),
                 };
                 path.map(|path| LanguageServerBinary {
                     path,

From f3769322ad1bc782e90fcdf96e5861f69137565a Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 16 Sep 2024 13:41:22 -0400
Subject: [PATCH 102/762] collab: Mark RunPod environment variables as optional
 in Kubernetes template (#17895)

This PR marks the RunPod environment variables as optional in the
Kubernetes template so that we can deploy without them being present.

Collab is already accounting for their absence.

Release Notes:

- N/A
---
 crates/collab/k8s/collab.template.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/collab/k8s/collab.template.yml b/crates/collab/k8s/collab.template.yml
index f5e454c3fcf04d..7ddb871503cccb 100644
--- a/crates/collab/k8s/collab.template.yml
+++ b/crates/collab/k8s/collab.template.yml
@@ -154,11 +154,13 @@ spec:
                 secretKeyRef:
                   name: runpod
                   key: api_key
+                  optional: true
             - name: RUNPOD_API_SUMMARY_URL
               valueFrom:
                 secretKeyRef:
                   name: runpod
                   key: summary
+                  optional: true
             - name: BLOB_STORE_ACCESS_KEY
               valueFrom:
                 secretKeyRef:

From b48c2c5846e6e4ed11380786143f37e99f8a5a48 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 16 Sep 2024 13:41:31 -0400
Subject: [PATCH 103/762] Update comment to point to culpable commit (#17896)

This PR updates the comment added in #17893 to reference the commit that
was identified by `git bisect`.

Release Notes:

- N/A
---
 Dockerfile | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Dockerfile b/Dockerfile
index efa816bf767084..2185eb6cb4d959 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -13,6 +13,8 @@ ENV GITHUB_SHA=$GITHUB_SHA
 # At some point in the past 3 weeks, additional dependencies on `xkbcommon` and
 # `xkbcommon-x11` were introduced into collab.
 #
+# A `git bisect` points to this commit as being the culprit: `b8e6098f60e5dabe98fe8281f993858dacc04a55`.
+#
 # Now when we try to build collab for the Docker image, it fails with the following
 # error:
 #

From dea85099a21fc6f0976e2f5c866c79e0ee31f702 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 16 Sep 2024 14:17:15 -0400
Subject: [PATCH 104/762] collab: Override Cargo configuration in the
 `Dockerfile` (#17901)

This PR moves the override for the Cargo configuration for collab into
the `Dockerfile` rather than having it be something some in the external
environment.

This makes it possible to build the Docker image locally without having
to replace `.cargo/config.toml` with the contents of
`.cargo/collab-config.toml`.

Release Notes:

- N/A
---
 .github/workflows/deploy_collab.yml | 3 ---
 Dockerfile                          | 3 +++
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/deploy_collab.yml b/.github/workflows/deploy_collab.yml
index 4555698ecd5690..6801be2a5494cd 100644
--- a/.github/workflows/deploy_collab.yml
+++ b/.github/workflows/deploy_collab.yml
@@ -75,9 +75,6 @@ jobs:
         with:
           clean: false
 
-      - name: Set up default .cargo/config.toml
-        run: cp ./.cargo/collab-config.toml ./.cargo/config.toml
-
       - name: Build docker image
         run: docker build . --build-arg GITHUB_SHA=$GITHUB_SHA --tag registry.digitalocean.com/zed/collab:$GITHUB_SHA
 
diff --git a/Dockerfile b/Dockerfile
index 2185eb6cb4d959..2fb5f0414787f8 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -4,6 +4,9 @@ FROM rust:1.81-bookworm as builder
 WORKDIR app
 COPY . .
 
+# Replace the Cargo configuration with the one used by collab.
+COPY ./.cargo/collab-config.toml ./.cargo/config.toml
+
 # Compile collab server
 ARG CARGO_PROFILE_RELEASE_PANIC=abort
 ARG GITHUB_SHA

From ca2cce79edb68623f18d7b24f32446fcd04fb181 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Mon, 16 Sep 2024 12:22:39 -0600
Subject: [PATCH 105/762] ssh lsp completions (#17665)

Release Notes:

* ssh-remoting: Fixed shell environment loading for remote shells.
---
 crates/language/src/language_registry.rs      | 15 ++--
 crates/markdown/examples/markdown.rs          |  5 +-
 crates/markdown/examples/markdown_as_child.rs |  5 +-
 crates/project/src/environment.rs             | 80 +++++++++++--------
 crates/project/src/lsp_store.rs               | 11 ++-
 crates/remote_server/src/headless_project.rs  |  6 +-
 crates/repl/src/repl_editor.rs                |  7 +-
 crates/zed/src/main.rs                        | 23 +++---
 8 files changed, 74 insertions(+), 78 deletions(-)

diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index dcce78d6cee371..69e44ee4ace186 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -12,7 +12,7 @@ use collections::{hash_map, HashMap, HashSet};
 use futures::{
     channel::{mpsc, oneshot},
     future::Shared,
-    Future, FutureExt as _,
+    Future,
 };
 use globset::GlobSet;
 use gpui::{AppContext, BackgroundExecutor, Task};
@@ -79,7 +79,6 @@ impl<'a> From<&'a str> for LanguageName {
 pub struct LanguageRegistry {
     state: RwLock<LanguageRegistryState>,
     language_server_download_dir: Option<Arc<Path>>,
-    login_shell_env_loaded: Shared<Task<()>>,
     executor: BackgroundExecutor,
     lsp_binary_status_tx: LspBinaryStatusSender,
 }
@@ -204,7 +203,7 @@ struct LspBinaryStatusSender {
 }
 
 impl LanguageRegistry {
-    pub fn new(login_shell_env_loaded: Task<()>, executor: BackgroundExecutor) -> Self {
+    pub fn new(executor: BackgroundExecutor) -> Self {
         let this = Self {
             state: RwLock::new(LanguageRegistryState {
                 next_language_server_id: 0,
@@ -224,7 +223,6 @@ impl LanguageRegistry {
                 fake_server_txs: Default::default(),
             }),
             language_server_download_dir: None,
-            login_shell_env_loaded: login_shell_env_loaded.shared(),
             lsp_binary_status_tx: Default::default(),
             executor,
         };
@@ -234,7 +232,7 @@ impl LanguageRegistry {
 
     #[cfg(any(test, feature = "test-support"))]
     pub fn test(executor: BackgroundExecutor) -> Self {
-        let mut this = Self::new(Task::ready(()), executor);
+        let mut this = Self::new(executor);
         this.language_server_download_dir = Some(Path::new("/the-download-dir").into());
         this
     }
@@ -828,7 +826,7 @@ impl LanguageRegistry {
         adapter: Arc<CachedLspAdapter>,
         root_path: Arc<Path>,
         delegate: Arc<dyn LspAdapterDelegate>,
-        cli_environment: Option<HashMap<String, String>>,
+        cli_environment: Shared<Task<Option<HashMap<String, String>>>>,
         cx: &mut AppContext,
     ) -> Option<PendingLanguageServer> {
         let server_id = self.state.write().next_language_server_id();
@@ -844,15 +842,12 @@ impl LanguageRegistry {
             .log_err()?;
         let container_dir: Arc<Path> = Arc::from(download_dir.join(adapter.name.0.as_ref()));
         let root_path = root_path.clone();
-        let login_shell_env_loaded = self.login_shell_env_loaded.clone();
         let this = Arc::downgrade(self);
 
         let task = cx.spawn({
             let container_dir = container_dir.clone();
             move |mut cx| async move {
-                // If we want to install a binary globally, we need to wait for
-                // the login shell to be set on our process.
-                login_shell_env_loaded.await;
+                let cli_environment = cli_environment.await;
 
                 let binary_result = adapter
                     .clone()
diff --git a/crates/markdown/examples/markdown.rs b/crates/markdown/examples/markdown.rs
index 62ca4d6f7cb4c9..c2f3ab8158609a 100644
--- a/crates/markdown/examples/markdown.rs
+++ b/crates/markdown/examples/markdown.rs
@@ -1,5 +1,5 @@
 use assets::Assets;
-use gpui::{prelude::*, rgb, App, KeyBinding, StyleRefinement, Task, View, WindowOptions};
+use gpui::{prelude::*, rgb, App, KeyBinding, StyleRefinement, View, WindowOptions};
 use language::{language_settings::AllLanguageSettings, LanguageRegistry};
 use markdown::{Markdown, MarkdownStyle};
 use node_runtime::FakeNodeRuntime;
@@ -105,8 +105,7 @@ pub fn main() {
         let node_runtime = FakeNodeRuntime::new();
         theme::init(LoadThemes::JustBase, cx);
 
-        let language_registry =
-            LanguageRegistry::new(Task::ready(()), cx.background_executor().clone());
+        let language_registry = LanguageRegistry::new(cx.background_executor().clone());
         language_registry.set_theme(cx.theme().clone());
         let language_registry = Arc::new(language_registry);
         languages::init(language_registry.clone(), node_runtime, cx);
diff --git a/crates/markdown/examples/markdown_as_child.rs b/crates/markdown/examples/markdown_as_child.rs
index dad124ab9c926b..829e69436a6bea 100644
--- a/crates/markdown/examples/markdown_as_child.rs
+++ b/crates/markdown/examples/markdown_as_child.rs
@@ -29,10 +29,7 @@ pub fn main() {
         cx.bind_keys([KeyBinding::new("cmd-c", markdown::Copy, None)]);
 
         let node_runtime = FakeNodeRuntime::new();
-        let language_registry = Arc::new(LanguageRegistry::new(
-            Task::ready(()),
-            cx.background_executor().clone(),
-        ));
+        let language_registry = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
         languages::init(language_registry.clone(), node_runtime, cx);
         theme::init(LoadThemes::JustBase, cx);
         Assets.load_fonts(cx).unwrap();
diff --git a/crates/project/src/environment.rs b/crates/project/src/environment.rs
index 9742b8b6d58e32..641ad206c05b27 100644
--- a/crates/project/src/environment.rs
+++ b/crates/project/src/environment.rs
@@ -1,10 +1,7 @@
-use anyhow::{anyhow, Context as _, Result};
+use anyhow::Result;
 use futures::{future::Shared, FutureExt};
-use std::{
-    path::{Path, PathBuf},
-    sync::Arc,
-};
-use util::{parse_env_output, ResultExt};
+use std::{path::Path, sync::Arc};
+use util::ResultExt;
 
 use collections::HashMap;
 use gpui::{AppContext, Context, Model, ModelContext, Task};
@@ -168,10 +165,53 @@ impl From<EnvironmentOrigin> for String {
     }
 }
 
+#[cfg(any(test, feature = "test-support"))]
+async fn load_shell_environment(
+    _dir: &Path,
+    _load_direnv: &DirenvSettings,
+) -> Result<HashMap<String, String>> {
+    Ok([("ZED_FAKE_TEST_ENV".into(), "true".into())]
+        .into_iter()
+        .collect())
+}
+
+#[cfg(not(any(test, feature = "test-support")))]
 async fn load_shell_environment(
     dir: &Path,
     load_direnv: &DirenvSettings,
 ) -> Result<HashMap<String, String>> {
+    use anyhow::{anyhow, Context};
+    use std::path::PathBuf;
+    use util::parse_env_output;
+
+    async fn load_direnv_environment(dir: &Path) -> Result<Option<HashMap<String, String>>> {
+        let Ok(direnv_path) = which::which("direnv") else {
+            return Ok(None);
+        };
+
+        let direnv_output = smol::process::Command::new(direnv_path)
+            .args(["export", "json"])
+            .current_dir(dir)
+            .output()
+            .await
+            .context("failed to spawn direnv to get local environment variables")?;
+
+        anyhow::ensure!(
+            direnv_output.status.success(),
+            "direnv exited with error {:?}",
+            direnv_output.status
+        );
+
+        let output = String::from_utf8_lossy(&direnv_output.stdout);
+        if output.is_empty() {
+            return Ok(None);
+        }
+
+        Ok(Some(
+            serde_json::from_str(&output).context("failed to parse direnv output")?,
+        ))
+    }
+
     let direnv_environment = match load_direnv {
         DirenvSettings::ShellHook => None,
         DirenvSettings::Direct => load_direnv_environment(dir).await?,
@@ -248,31 +288,3 @@ async fn load_shell_environment(
 
     Ok(parsed_env)
 }
-
-async fn load_direnv_environment(dir: &Path) -> Result<Option<HashMap<String, String>>> {
-    let Ok(direnv_path) = which::which("direnv") else {
-        return Ok(None);
-    };
-
-    let direnv_output = smol::process::Command::new(direnv_path)
-        .args(["export", "json"])
-        .current_dir(dir)
-        .output()
-        .await
-        .context("failed to spawn direnv to get local environment variables")?;
-
-    anyhow::ensure!(
-        direnv_output.status.success(),
-        "direnv exited with error {:?}",
-        direnv_output.status
-    );
-
-    let output = String::from_utf8_lossy(&direnv_output.stdout);
-    if output.is_empty() {
-        return Ok(None);
-    }
-
-    Ok(Some(
-        serde_json::from_str(&output).context("failed to parse direnv output")?,
-    ))
-}
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index cdf1fa4be492dc..668bdae4dc735b 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -4629,14 +4629,13 @@ impl LspStore {
             return;
         }
 
+        let local = self.as_local().unwrap();
+
         let stderr_capture = Arc::new(Mutex::new(Some(String::new())));
         let lsp_adapter_delegate = ProjectLspAdapterDelegate::for_local(self, worktree_handle, cx);
-        let cli_environment = self
-            .as_local()
-            .unwrap()
-            .environment
-            .read(cx)
-            .get_cli_environment();
+        let cli_environment = local.environment.update(cx, |environment, cx| {
+            environment.get_environment(Some(worktree_id), Some(worktree_path.clone()), cx)
+        });
 
         let pending_server = match self.languages.create_pending_language_server(
             stderr_capture.clone(),
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index e654e2a190ca73..c8ec49cc1e2860 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -1,6 +1,6 @@
 use anyhow::{anyhow, Result};
 use fs::Fs;
-use gpui::{AppContext, AsyncAppContext, Context, Model, ModelContext, Task};
+use gpui::{AppContext, AsyncAppContext, Context, Model, ModelContext};
 use language::LanguageRegistry;
 use project::{
     buffer_store::BufferStore, project_settings::SettingsObserver, search::SearchQuery,
@@ -36,9 +36,7 @@ impl HeadlessProject {
     }
 
     pub fn new(session: Arc<SshSession>, fs: Arc<dyn Fs>, cx: &mut ModelContext<Self>) -> Self {
-        // TODO: we should load the env correctly (as we do in login_shell_env_loaded when stdout is not a pty). Can we re-use the ProjectEnvironment for that?
-        let mut languages =
-            LanguageRegistry::new(Task::ready(()), cx.background_executor().clone());
+        let mut languages = LanguageRegistry::new(cx.background_executor().clone());
         languages
             .set_language_server_download_dir(PathBuf::from("/Users/conrad/what-could-go-wrong"));
 
diff --git a/crates/repl/src/repl_editor.rs b/crates/repl/src/repl_editor.rs
index 868594aaf18185..1f0935a5c55a02 100644
--- a/crates/repl/src/repl_editor.rs
+++ b/crates/repl/src/repl_editor.rs
@@ -321,7 +321,7 @@ fn get_language(editor: WeakView<Editor>, cx: &mut AppContext) -> Option<Arc<Lan
 #[cfg(test)]
 mod tests {
     use super::*;
-    use gpui::{Context, Task};
+    use gpui::Context;
     use indoc::indoc;
     use language::{Buffer, Language, LanguageConfig, LanguageRegistry};
 
@@ -475,10 +475,7 @@ mod tests {
         let typescript =
             languages::language("typescript", tree_sitter_typescript::language_typescript());
         let python = languages::language("python", tree_sitter_python::language());
-        let language_registry = Arc::new(LanguageRegistry::new(
-            Task::ready(()),
-            cx.background_executor().clone(),
-        ));
+        let language_registry = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
         language_registry.add(markdown.clone());
         language_registry.add(typescript.clone());
         language_registry.add(python.clone());
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 284baddf663731..eb6d2853fdad7e 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -400,16 +400,16 @@ fn main() {
         paths::keymap_file().clone(),
     );
 
-    let login_shell_env_loaded = if stdout_is_a_pty() {
-        Task::ready(())
-    } else {
-        app.background_executor().spawn(async {
-            #[cfg(unix)]
-            {
-                load_shell_from_passwd().await.log_err();
-            }
-            load_login_shell_environment().await.log_err();
-        })
+    if !stdout_is_a_pty() {
+        app.background_executor()
+            .spawn(async {
+                #[cfg(unix)]
+                {
+                    load_shell_from_passwd().await.log_err();
+                }
+                load_login_shell_environment().await.log_err();
+            })
+            .detach()
     };
 
     app.on_open_urls({
@@ -451,8 +451,7 @@ fn main() {
         client::init_settings(cx);
         let client = Client::production(cx);
         cx.set_http_client(client.http_client().clone());
-        let mut languages =
-            LanguageRegistry::new(login_shell_env_loaded, cx.background_executor().clone());
+        let mut languages = LanguageRegistry::new(cx.background_executor().clone());
         languages.set_language_server_download_dir(paths::languages_dir().clone());
         let languages = Arc::new(languages);
         let node_runtime = RealNodeRuntime::new(client.http_client());

From 01bb10f5186deb69db6120ac1572bed4fb69b55d Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Mon, 16 Sep 2024 14:50:30 -0700
Subject: [PATCH 106/762] Move ProtoClient to RPC crate, behind feature flag
 disabled in collab (#17908)

This fixes a bug where we accidentally added a `gpui` transitive
dependency in `collab`.

Release Notes:

- N/A
---
 Cargo.lock                                   |  4 +---
 crates/assistant/Cargo.toml                  |  1 +
 crates/assistant/src/context_store.rs        |  2 +-
 crates/channel/src/channel_buffer.rs         |  4 ++--
 crates/channel/src/channel_chat.rs           |  2 +-
 crates/client/Cargo.toml                     |  2 +-
 crates/client/src/client.rs                  |  1 -
 crates/project/src/buffer_store.rs           |  5 +----
 crates/project/src/lsp_store.rs              |  2 +-
 crates/project/src/project.rs                |  5 +----
 crates/project/src/project_settings.rs       |  5 +----
 crates/project/src/worktree_store.rs         |  4 ++--
 crates/proto/Cargo.toml                      |  3 ---
 crates/proto/src/proto.rs                    |  2 --
 crates/remote/Cargo.toml                     |  2 +-
 crates/remote/src/ssh_session.rs             |  6 +++---
 crates/remote_server/src/headless_project.rs |  4 ++--
 crates/rpc/Cargo.toml                        |  2 +-
 crates/{proto => rpc}/src/proto_client.rs    | 10 +++++-----
 crates/rpc/src/rpc.rs                        |  5 +++++
 crates/worktree/src/worktree.rs              |  2 +-
 21 files changed, 31 insertions(+), 42 deletions(-)
 rename crates/{proto => rpc}/src/proto_client.rs (99%)

diff --git a/Cargo.lock b/Cargo.lock
index a6d351099b9351..d0af85057d251a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -418,6 +418,7 @@ dependencies = [
  "regex",
  "release_channel",
  "rope",
+ "rpc",
  "schemars",
  "search",
  "semantic_index",
@@ -8553,9 +8554,6 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "collections",
- "futures 0.3.30",
- "gpui",
- "parking_lot",
  "prost",
  "prost-build",
  "serde",
diff --git a/crates/assistant/Cargo.toml b/crates/assistant/Cargo.toml
index d2b5aed9bd8bba..b700702062c0a7 100644
--- a/crates/assistant/Cargo.toml
+++ b/crates/assistant/Cargo.toml
@@ -65,6 +65,7 @@ proto.workspace = true
 regex.workspace = true
 release_channel.workspace = true
 rope.workspace = true
+rpc.workspace = true
 schemars.workspace = true
 search.workspace = true
 semantic_index.workspace = true
diff --git a/crates/assistant/src/context_store.rs b/crates/assistant/src/context_store.rs
index b6e1650c41dbf8..867d9067914854 100644
--- a/crates/assistant/src/context_store.rs
+++ b/crates/assistant/src/context_store.rs
@@ -2,7 +2,6 @@ use crate::{
     prompts::PromptBuilder, Context, ContextEvent, ContextId, ContextOperation, ContextVersion,
     SavedContext, SavedContextMetadata,
 };
-use ::proto::AnyProtoClient;
 use anyhow::{anyhow, Context as _, Result};
 use client::{proto, telemetry::Telemetry, Client, TypedEnvelope};
 use clock::ReplicaId;
@@ -16,6 +15,7 @@ use language::LanguageRegistry;
 use paths::contexts_dir;
 use project::Project;
 use regex::Regex;
+use rpc::AnyProtoClient;
 use std::{
     cmp::Reverse,
     ffi::OsStr,
diff --git a/crates/channel/src/channel_buffer.rs b/crates/channel/src/channel_buffer.rs
index bf32185b22043e..2041b16a6da12b 100644
--- a/crates/channel/src/channel_buffer.rs
+++ b/crates/channel/src/channel_buffer.rs
@@ -5,8 +5,8 @@ use collections::HashMap;
 use gpui::{AppContext, AsyncAppContext, Context, EventEmitter, Model, ModelContext, Task};
 use language::proto::serialize_version;
 use rpc::{
-    proto::{self, AnyProtoClient, PeerId},
-    TypedEnvelope,
+    proto::{self, PeerId},
+    AnyProtoClient, TypedEnvelope,
 };
 use std::{sync::Arc, time::Duration};
 use text::BufferId;
diff --git a/crates/channel/src/channel_chat.rs b/crates/channel/src/channel_chat.rs
index 7cbc362ff3500b..286eb46a916004 100644
--- a/crates/channel/src/channel_chat.rs
+++ b/crates/channel/src/channel_chat.rs
@@ -11,7 +11,7 @@ use gpui::{
     AppContext, AsyncAppContext, Context, EventEmitter, Model, ModelContext, Task, WeakModel,
 };
 use rand::prelude::*;
-use rpc::proto::AnyProtoClient;
+use rpc::AnyProtoClient;
 use std::{
     ops::{ControlFlow, Range},
     sync::Arc,
diff --git a/crates/client/Cargo.toml b/crates/client/Cargo.toml
index 72ca8ffc2478fd..82237ebaa5abbd 100644
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -34,7 +34,7 @@ parking_lot.workspace = true
 postage.workspace = true
 rand.workspace = true
 release_channel.workspace = true
-rpc.workspace = true
+rpc = { workspace = true, features = ["gpui"] }
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 8787e2ed9675fe..6e1362c43e16fb 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -22,7 +22,6 @@ use gpui::{actions, AppContext, AsyncAppContext, Global, Model, Task, WeakModel}
 use http_client::{AsyncBody, HttpClient, HttpClientWithUrl};
 use parking_lot::RwLock;
 use postage::watch;
-use proto::{AnyProtoClient, EntityMessageSubscriber, ProtoClient, ProtoMessageHandlerSet};
 use rand::prelude::*;
 use release_channel::{AppVersion, ReleaseChannel};
 use rpc::proto::{AnyTypedEnvelope, EnvelopedMessage, PeerId, RequestMessage};
diff --git a/crates/project/src/buffer_store.rs b/crates/project/src/buffer_store.rs
index 9bbc2f43589229..403b53745a51e9 100644
--- a/crates/project/src/buffer_store.rs
+++ b/crates/project/src/buffer_store.rs
@@ -17,10 +17,7 @@ use language::{
     proto::{deserialize_line_ending, deserialize_version, serialize_version, split_operations},
     Buffer, Capability, Event as BufferEvent, File as _, Language, Operation,
 };
-use rpc::{
-    proto::{self, AnyProtoClient},
-    ErrorExt as _, TypedEnvelope,
-};
+use rpc::{proto, AnyProtoClient, ErrorExt as _, TypedEnvelope};
 use smol::channel::Receiver;
 use std::{io, path::Path, str::FromStr as _, sync::Arc, time::Instant};
 use text::BufferId;
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 668bdae4dc735b..854915e82d66fc 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -49,7 +49,7 @@ use parking_lot::{Mutex, RwLock};
 use postage::watch;
 use rand::prelude::*;
 
-use rpc::proto::AnyProtoClient;
+use rpc::AnyProtoClient;
 use serde::Serialize;
 use settings::{Settings, SettingsLocation, SettingsStore};
 use sha2::{Digest, Sha256};
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index f67423b0738514..8fca2ea6863546 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -62,10 +62,7 @@ use paths::{local_tasks_file_relative_path, local_vscode_tasks_file_relative_pat
 use prettier_support::{DefaultPrettier, PrettierInstance};
 use project_settings::{LspSettings, ProjectSettings, SettingsObserver};
 use remote::SshSession;
-use rpc::{
-    proto::{AnyProtoClient, SSH_PROJECT_ID},
-    ErrorCode,
-};
+use rpc::{proto::SSH_PROJECT_ID, AnyProtoClient, ErrorCode};
 use search::{SearchInputKind, SearchQuery, SearchResult};
 use search_history::SearchHistory;
 use settings::{watch_config_file, Settings, SettingsLocation, SettingsStore};
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index 70b2eccf237c62..2eeb8408961186 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -2,10 +2,7 @@ use collections::HashMap;
 use fs::Fs;
 use gpui::{AppContext, AsyncAppContext, BorrowAppContext, Model, ModelContext};
 use paths::local_settings_file_relative_path;
-use rpc::{
-    proto::{self, AnyProtoClient},
-    TypedEnvelope,
-};
+use rpc::{proto, AnyProtoClient, TypedEnvelope};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources, SettingsStore};
diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 6e03e614da84b7..8b620de43e0838 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -17,8 +17,8 @@ use gpui::{
 };
 use postage::oneshot;
 use rpc::{
-    proto::{self, AnyProtoClient, SSH_PROJECT_ID},
-    TypedEnvelope,
+    proto::{self, SSH_PROJECT_ID},
+    AnyProtoClient, TypedEnvelope,
 };
 use smol::{
     channel::{Receiver, Sender},
diff --git a/crates/proto/Cargo.toml b/crates/proto/Cargo.toml
index e1d111366c9986..eca020a92ddc9d 100644
--- a/crates/proto/Cargo.toml
+++ b/crates/proto/Cargo.toml
@@ -19,11 +19,8 @@ doctest = false
 [dependencies]
 anyhow.workspace = true
 collections.workspace = true
-futures.workspace = true
-parking_lot.workspace = true
 prost.workspace = true
 serde.workspace = true
-gpui.workspace = true
 
 [build-dependencies]
 prost-build.workspace = true
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 7af66a6a6be093..a1853ed4a3bb5b 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -2,11 +2,9 @@
 
 pub mod error;
 mod macros;
-mod proto_client;
 mod typed_envelope;
 
 pub use error::*;
-pub use proto_client::*;
 pub use typed_envelope::*;
 
 use collections::HashMap;
diff --git a/crates/remote/Cargo.toml b/crates/remote/Cargo.toml
index 2e96d8062e6f44..5c291b59d344e7 100644
--- a/crates/remote/Cargo.toml
+++ b/crates/remote/Cargo.toml
@@ -26,7 +26,7 @@ gpui.workspace = true
 log.workspace = true
 parking_lot.workspace = true
 prost.workspace = true
-rpc.workspace = true
+rpc = { workspace = true, features = ["gpui"] }
 serde.workspace = true
 serde_json.workspace = true
 smol.workspace = true
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 5ff11fe09931c9..4762a785dbdcd2 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -13,9 +13,9 @@ use futures::{
 };
 use gpui::{AppContext, AsyncAppContext, Model, SemanticVersion};
 use parking_lot::Mutex;
-use rpc::proto::{
-    self, build_typed_envelope, EntityMessageSubscriber, Envelope, EnvelopedMessage, PeerId,
-    ProtoClient, ProtoMessageHandlerSet, RequestMessage,
+use rpc::{
+    proto::{self, build_typed_envelope, Envelope, EnvelopedMessage, PeerId, RequestMessage},
+    EntityMessageSubscriber, ProtoClient, ProtoMessageHandlerSet,
 };
 use smol::{
     fs,
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index c8ec49cc1e2860..08723daa01d063 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -8,8 +8,8 @@ use project::{
 };
 use remote::SshSession;
 use rpc::{
-    proto::{self, AnyProtoClient, SSH_PEER_ID, SSH_PROJECT_ID},
-    TypedEnvelope,
+    proto::{self, SSH_PEER_ID, SSH_PROJECT_ID},
+    AnyProtoClient, TypedEnvelope,
 };
 use smol::stream::StreamExt;
 use std::{
diff --git a/crates/rpc/Cargo.toml b/crates/rpc/Cargo.toml
index 79cb811afa5bae..f664085f04c239 100644
--- a/crates/rpc/Cargo.toml
+++ b/crates/rpc/Cargo.toml
@@ -14,6 +14,7 @@ path = "src/rpc.rs"
 doctest = false
 
 [features]
+gpui = ["dep:gpui"]
 test-support = ["collections/test-support", "gpui/test-support", "proto/test-support"]
 
 [dependencies]
@@ -39,7 +40,6 @@ zstd = "0.11"
 [target.'cfg(target_os = "linux")'.dependencies]
 zstd = { version = "0.11", features = [ "pkg-config" ] }
 
-
 [dev-dependencies]
 collections = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
diff --git a/crates/proto/src/proto_client.rs b/crates/rpc/src/proto_client.rs
similarity index 99%
rename from crates/proto/src/proto_client.rs
rename to crates/rpc/src/proto_client.rs
index edcb6417d8fc98..4a990a84336dfd 100644
--- a/crates/proto/src/proto_client.rs
+++ b/crates/rpc/src/proto_client.rs
@@ -1,7 +1,3 @@
-use crate::{
-    error::ErrorExt as _, AnyTypedEnvelope, EntityMessage, Envelope, EnvelopedMessage,
-    RequestMessage, TypedEnvelope,
-};
 use anyhow::anyhow;
 use collections::HashMap;
 use futures::{
@@ -9,7 +5,11 @@ use futures::{
     Future, FutureExt as _,
 };
 use gpui::{AnyModel, AnyWeakModel, AsyncAppContext, Model};
-pub use prost::Message;
+// pub use prost::Message;
+use proto::{
+    error::ErrorExt as _, AnyTypedEnvelope, EntityMessage, Envelope, EnvelopedMessage,
+    RequestMessage, TypedEnvelope,
+};
 use std::{any::TypeId, sync::Arc};
 
 #[derive(Clone)]
diff --git a/crates/rpc/src/rpc.rs b/crates/rpc/src/rpc.rs
index 2e8b1ef6b7a0f6..9c62238733215f 100644
--- a/crates/rpc/src/rpc.rs
+++ b/crates/rpc/src/rpc.rs
@@ -14,4 +14,9 @@ pub use peer::*;
 pub use proto::{error::*, Receipt, TypedEnvelope};
 mod macros;
 
+#[cfg(feature = "gpui")]
+mod proto_client;
+#[cfg(feature = "gpui")]
+pub use proto_client::*;
+
 pub const PROTOCOL_VERSION: u32 = 68;
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index 584524a1d7b6fe..776c01c49c2868 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -36,7 +36,7 @@ use postage::{
     prelude::{Sink as _, Stream as _},
     watch,
 };
-use rpc::proto::{self, AnyProtoClient};
+use rpc::{proto, AnyProtoClient};
 pub use settings::WorktreeId;
 use settings::{Settings, SettingsLocation, SettingsStore};
 use smallvec::{smallvec, SmallVec};

From e66ea9e5d46395c3675060883a98e72fe4f6579c Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Mon, 16 Sep 2024 16:20:17 -0600
Subject: [PATCH 107/762] Fix renames over language server for SSH remoting
 (#17897)

Release Notes:

- ssh remoting: Fix rename over language server

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
Co-authored-by: Max <max@zed.dev>
---
 Cargo.lock                                    |   1 +
 crates/assistant/src/context.rs               |   6 +-
 crates/call/src/room.rs                       |   2 +
 crates/channel/src/channel_buffer.rs          |   6 +-
 crates/collab/src/db/queries/projects.rs      |   5 +-
 crates/collab/src/db/tests/db_tests.rs        |   6 +-
 crates/collab/src/rpc.rs                      |   1 +
 crates/collab/src/tests/editor_tests.rs       |  16 +-
 crates/collab/src/tests/integration_tests.rs  |  62 ++---
 .../random_project_collaboration_tests.rs     |   2 +-
 .../src/chat_panel/message_editor.rs          |   4 +-
 crates/copilot/src/copilot.rs                 |   9 +-
 crates/editor/src/editor_tests.rs             |  14 +-
 crates/editor/src/git/blame.rs                |   4 +-
 crates/editor/src/inlay_hint_cache.rs         |  12 +-
 .../src/test/editor_lsp_test_context.rs       |   2 +-
 crates/extension/src/extension_store_test.rs  |   9 +-
 crates/language/src/buffer.rs                 |  32 +--
 crates/language/src/buffer_tests.rs           |  20 +-
 crates/language/src/language.rs               |  21 +-
 crates/language/src/language_registry.rs      | 143 ++++++-----
 crates/language_tools/src/lsp_log_tests.rs    |   2 +-
 crates/multi_buffer/src/multi_buffer.rs       |  32 +--
 crates/project/src/buffer_store.rs            |  10 +-
 crates/project/src/lsp_command.rs             |  26 +-
 crates/project/src/lsp_ext_command.rs         |   2 +-
 crates/project/src/lsp_store.rs               |   7 +-
 crates/project/src/project.rs                 |  24 +-
 crates/project/src/project_tests.rs           | 236 +++++++++---------
 crates/project_symbols/src/project_symbols.rs |   2 +-
 crates/proto/proto/zed.proto                  |   1 +
 crates/remote_server/Cargo.toml               |   2 +
 crates/remote_server/src/headless_project.rs  |  43 +++-
 .../remote_server/src/remote_editing_tests.rs |  70 +++++-
 34 files changed, 505 insertions(+), 329 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d0af85057d251a..0ce1c9bd970c57 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9058,6 +9058,7 @@ dependencies = [
  "http_client",
  "language",
  "log",
+ "lsp",
  "node_runtime",
  "project",
  "remote",
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index 7702207d8d2ad9..38ccddb962d336 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -997,14 +997,14 @@ impl Context {
     fn handle_buffer_event(
         &mut self,
         _: Model<Buffer>,
-        event: &language::Event,
+        event: &language::BufferEvent,
         cx: &mut ModelContext<Self>,
     ) {
         match event {
-            language::Event::Operation(operation) => cx.emit(ContextEvent::Operation(
+            language::BufferEvent::Operation(operation) => cx.emit(ContextEvent::Operation(
                 ContextOperation::BufferOperation(operation.clone()),
             )),
-            language::Event::Edited => {
+            language::BufferEvent::Edited => {
                 self.count_remaining_tokens(cx);
                 self.reparse(cx);
                 // Use `inclusive = true` to invalidate a step when an edit occurs
diff --git a/crates/call/src/room.rs b/crates/call/src/room.rs
index 12516685293c88..3c36c5f8775b78 100644
--- a/crates/call/src/room.rs
+++ b/crates/call/src/room.rs
@@ -1200,6 +1200,7 @@ impl Room {
                 room_id: self.id(),
                 worktrees: vec![],
                 dev_server_project_id: Some(dev_server_project_id.0),
+                is_ssh_project: false,
             })
         } else {
             if let Some(project_id) = project.read(cx).remote_id() {
@@ -1210,6 +1211,7 @@ impl Room {
                 room_id: self.id(),
                 worktrees: project.read(cx).worktree_metadata_protos(cx),
                 dev_server_project_id: None,
+                is_ssh_project: project.read(cx).is_via_ssh(),
             })
         };
 
diff --git a/crates/channel/src/channel_buffer.rs b/crates/channel/src/channel_buffer.rs
index 2041b16a6da12b..df3e66483f873f 100644
--- a/crates/channel/src/channel_buffer.rs
+++ b/crates/channel/src/channel_buffer.rs
@@ -171,11 +171,11 @@ impl ChannelBuffer {
     fn on_buffer_update(
         &mut self,
         _: Model<language::Buffer>,
-        event: &language::Event,
+        event: &language::BufferEvent,
         cx: &mut ModelContext<Self>,
     ) {
         match event {
-            language::Event::Operation(operation) => {
+            language::BufferEvent::Operation(operation) => {
                 if *ZED_ALWAYS_ACTIVE {
                     if let language::Operation::UpdateSelections { selections, .. } = operation {
                         if selections.is_empty() {
@@ -191,7 +191,7 @@ impl ChannelBuffer {
                     })
                     .log_err();
             }
-            language::Event::Edited => {
+            language::BufferEvent::Edited => {
                 cx.emit(ChannelBufferEvent::BufferEdited);
             }
             _ => {}
diff --git a/crates/collab/src/db/queries/projects.rs b/crates/collab/src/db/queries/projects.rs
index c6db54b5729f4f..b514d4bb03601b 100644
--- a/crates/collab/src/db/queries/projects.rs
+++ b/crates/collab/src/db/queries/projects.rs
@@ -30,6 +30,7 @@ impl Database {
         room_id: RoomId,
         connection: ConnectionId,
         worktrees: &[proto::WorktreeMetadata],
+        is_ssh_project: bool,
         dev_server_project_id: Option<DevServerProjectId>,
     ) -> Result<TransactionGuard<(ProjectId, proto::Room)>> {
         self.room_transaction(room_id, |tx| async move {
@@ -121,12 +122,14 @@ impl Database {
                 .await?;
             }
 
+            let replica_id = if is_ssh_project { 1 } else { 0 };
+
             project_collaborator::ActiveModel {
                 project_id: ActiveValue::set(project.id),
                 connection_id: ActiveValue::set(connection.id as i32),
                 connection_server_id: ActiveValue::set(ServerId(connection.owner_id as i32)),
                 user_id: ActiveValue::set(participant.user_id),
-                replica_id: ActiveValue::set(ReplicaId(0)),
+                replica_id: ActiveValue::set(ReplicaId(replica_id)),
                 is_host: ActiveValue::set(true),
                 ..Default::default()
             }
diff --git a/crates/collab/src/db/tests/db_tests.rs b/crates/collab/src/db/tests/db_tests.rs
index 9a4ca3c11ab314..626335028770ec 100644
--- a/crates/collab/src/db/tests/db_tests.rs
+++ b/crates/collab/src/db/tests/db_tests.rs
@@ -540,18 +540,18 @@ async fn test_project_count(db: &Arc<Database>) {
         .unwrap();
     assert_eq!(db.project_count_excluding_admins().await.unwrap(), 0);
 
-    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[], None)
+    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[], false, None)
         .await
         .unwrap();
     assert_eq!(db.project_count_excluding_admins().await.unwrap(), 1);
 
-    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[], None)
+    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[], false, None)
         .await
         .unwrap();
     assert_eq!(db.project_count_excluding_admins().await.unwrap(), 2);
 
     // Projects shared by admins aren't counted.
-    db.share_project(room_id, ConnectionId { owner_id, id: 0 }, &[], None)
+    db.share_project(room_id, ConnectionId { owner_id, id: 0 }, &[], false, None)
         .await
         .unwrap();
     assert_eq!(db.project_count_excluding_admins().await.unwrap(), 2);
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index 7db446b2b8a725..4146eafb870a44 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -1996,6 +1996,7 @@ async fn share_project(
             RoomId::from_proto(request.room_id),
             session.connection_id,
             &request.worktrees,
+            request.is_ssh_project,
             request
                 .dev_server_project_id
                 .map(DevServerProjectId::from_proto),
diff --git a/crates/collab/src/tests/editor_tests.rs b/crates/collab/src/tests/editor_tests.rs
index 3f205b7f937c96..de0314477491a6 100644
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -284,7 +284,7 @@ async fn test_collaborating_with_completion(cx_a: &mut TestAppContext, cx_b: &mu
     let active_call_a = cx_a.read(ActiveCall::global);
 
     client_a.language_registry().add(rust_lang());
-    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
+    let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -552,7 +552,7 @@ async fn test_collaborating_with_code_actions(
     client_a.language_registry().add(rust_lang());
     let mut fake_language_servers = client_a
         .language_registry()
-        .register_fake_lsp_adapter("Rust", FakeLspAdapter::default());
+        .register_fake_lsp("Rust", FakeLspAdapter::default());
 
     client_a
         .fs()
@@ -757,7 +757,7 @@ async fn test_collaborating_with_renames(cx_a: &mut TestAppContext, cx_b: &mut T
 
     // Set up a fake language server.
     client_a.language_registry().add(rust_lang());
-    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
+    let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -982,7 +982,7 @@ async fn test_language_server_statuses(cx_a: &mut TestAppContext, cx_b: &mut Tes
     cx_b.update(editor::init);
 
     client_a.language_registry().add(rust_lang());
-    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
+    let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             name: "the-language-server",
@@ -1268,7 +1268,7 @@ async fn test_on_input_format_from_host_to_guest(
     let active_call_a = cx_a.read(ActiveCall::global);
 
     client_a.language_registry().add(rust_lang());
-    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
+    let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -1388,7 +1388,7 @@ async fn test_on_input_format_from_guest_to_host(
     let active_call_a = cx_a.read(ActiveCall::global);
 
     client_a.language_registry().add(rust_lang());
-    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
+    let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -1545,7 +1545,7 @@ async fn test_mutual_editor_inlay_hint_cache_update(
 
     client_a.language_registry().add(rust_lang());
     client_b.language_registry().add(rust_lang());
-    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
+    let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -1807,7 +1807,7 @@ async fn test_inlay_hint_refresh_is_forwarded(
 
     client_a.language_registry().add(rust_lang());
     client_b.language_registry().add(rust_lang());
-    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
+    let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
diff --git a/crates/collab/src/tests/integration_tests.rs b/crates/collab/src/tests/integration_tests.rs
index b6d7aca2e078a0..245d0eda1b6fbf 100644
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -3859,7 +3859,7 @@ async fn test_collaborating_with_diagnostics(
     )));
     let mut fake_language_servers = client_a
         .language_registry()
-        .register_fake_lsp_adapter("Rust", Default::default());
+        .register_fake_lsp("Rust", Default::default());
 
     // Share a project as client A
     client_a
@@ -4126,7 +4126,7 @@ async fn test_collaborating_with_lsp_progress_updates_and_diagnostics_ordering(
         .await;
 
     client_a.language_registry().add(rust_lang());
-    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
+    let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             disk_based_diagnostics_progress_token: Some("the-disk-based-token".into()),
@@ -4349,7 +4349,7 @@ async fn test_formatting_buffer(
     client_a.language_registry().add(rust_lang());
     let mut fake_language_servers = client_a
         .language_registry()
-        .register_fake_lsp_adapter("Rust", FakeLspAdapter::default());
+        .register_fake_lsp("Rust", FakeLspAdapter::default());
 
     // Here we insert a fake tree with a directory that exists on disk. This is needed
     // because later we'll invoke a command, which requires passing a working directory
@@ -4460,7 +4460,7 @@ async fn test_prettier_formatting_buffer(
         },
         Some(tree_sitter_rust::language()),
     )));
-    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
+    let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "TypeScript",
         FakeLspAdapter {
             prettier_plugins: vec![test_plugin],
@@ -4576,7 +4576,7 @@ async fn test_definition(
 
     let mut fake_language_servers = client_a
         .language_registry()
-        .register_fake_lsp_adapter("Rust", Default::default());
+        .register_fake_lsp("Rust", Default::default());
     client_a.language_registry().add(rust_lang());
 
     client_a
@@ -4712,7 +4712,7 @@ async fn test_references(
     let active_call_a = cx_a.read(ActiveCall::global);
 
     client_a.language_registry().add(rust_lang());
-    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
+    let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             name: "my-fake-lsp-adapter",
@@ -4983,7 +4983,7 @@ async fn test_document_highlights(
 
     let mut fake_language_servers = client_a
         .language_registry()
-        .register_fake_lsp_adapter("Rust", Default::default());
+        .register_fake_lsp("Rust", Default::default());
     client_a.language_registry().add(rust_lang());
 
     let (project_a, worktree_id) = client_a.build_local_project("/root-1", cx_a).await;
@@ -5079,28 +5079,30 @@ async fn test_lsp_hover(
 
     client_a.language_registry().add(rust_lang());
     let language_server_names = ["rust-analyzer", "CrabLang-ls"];
-    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
-        "Rust",
-        FakeLspAdapter {
-            name: "rust-analyzer",
-            capabilities: lsp::ServerCapabilities {
-                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
-                ..lsp::ServerCapabilities::default()
+    let mut language_servers = [
+        client_a.language_registry().register_fake_lsp(
+            "Rust",
+            FakeLspAdapter {
+                name: "rust-analyzer",
+                capabilities: lsp::ServerCapabilities {
+                    hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
             },
-            ..FakeLspAdapter::default()
-        },
-    );
-    let _other_server = client_a.language_registry().register_fake_lsp_adapter(
-        "Rust",
-        FakeLspAdapter {
-            name: "CrabLang-ls",
-            capabilities: lsp::ServerCapabilities {
-                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
-                ..lsp::ServerCapabilities::default()
+        ),
+        client_a.language_registry().register_fake_lsp(
+            "Rust",
+            FakeLspAdapter {
+                name: "CrabLang-ls",
+                capabilities: lsp::ServerCapabilities {
+                    hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
             },
-            ..FakeLspAdapter::default()
-        },
-    );
+        ),
+    ];
 
     let (project_a, worktree_id) = client_a.build_local_project("/root-1", cx_a).await;
     let project_id = active_call_a
@@ -5115,7 +5117,7 @@ async fn test_lsp_hover(
 
     let mut servers_with_hover_requests = HashMap::default();
     for i in 0..language_server_names.len() {
-        let new_server = fake_language_servers.next().await.unwrap_or_else(|| {
+        let new_server = language_servers[i].next().await.unwrap_or_else(|| {
             panic!(
                 "Failed to get language server #{i} with name {}",
                 &language_server_names[i]
@@ -5260,7 +5262,7 @@ async fn test_project_symbols(
     client_a.language_registry().add(rust_lang());
     let mut fake_language_servers = client_a
         .language_registry()
-        .register_fake_lsp_adapter("Rust", Default::default());
+        .register_fake_lsp("Rust", Default::default());
 
     client_a
         .fs()
@@ -5362,7 +5364,7 @@ async fn test_open_buffer_while_getting_definition_pointing_to_it(
     client_a.language_registry().add(rust_lang());
     let mut fake_language_servers = client_a
         .language_registry()
-        .register_fake_lsp_adapter("Rust", Default::default());
+        .register_fake_lsp("Rust", Default::default());
 
     client_a
         .fs()
diff --git a/crates/collab/src/tests/random_project_collaboration_tests.rs b/crates/collab/src/tests/random_project_collaboration_tests.rs
index 2324f03cd423eb..831114ba1a0c9c 100644
--- a/crates/collab/src/tests/random_project_collaboration_tests.rs
+++ b/crates/collab/src/tests/random_project_collaboration_tests.rs
@@ -1047,7 +1047,7 @@ impl RandomizedTest for ProjectCollaborationTest {
             },
             None,
         )));
-        client.language_registry().register_fake_lsp_adapter(
+        client.language_registry().register_fake_lsp(
             "Rust",
             FakeLspAdapter {
                 name: "the-fake-language-server",
diff --git a/crates/collab_ui/src/chat_panel/message_editor.rs b/crates/collab_ui/src/chat_panel/message_editor.rs
index 028e148cbac039..38aaf2faa3b329 100644
--- a/crates/collab_ui/src/chat_panel/message_editor.rs
+++ b/crates/collab_ui/src/chat_panel/message_editor.rs
@@ -228,10 +228,10 @@ impl MessageEditor {
     fn on_buffer_event(
         &mut self,
         buffer: Model<Buffer>,
-        event: &language::Event,
+        event: &language::BufferEvent,
         cx: &mut ViewContext<Self>,
     ) {
-        if let language::Event::Reparsed | language::Event::Edited = event {
+        if let language::BufferEvent::Reparsed | language::BufferEvent::Edited = event {
             let buffer = buffer.read(cx).snapshot();
             self.mentions_task = Some(cx.spawn(|this, cx| async move {
                 cx.background_executor()
diff --git a/crates/copilot/src/copilot.rs b/crates/copilot/src/copilot.rs
index 5fc86480e6577a..cdbe65ba1dcca1 100644
--- a/crates/copilot/src/copilot.rs
+++ b/crates/copilot/src/copilot.rs
@@ -691,17 +691,17 @@ impl Copilot {
     fn handle_buffer_event(
         &mut self,
         buffer: Model<Buffer>,
-        event: &language::Event,
+        event: &language::BufferEvent,
         cx: &mut ModelContext<Self>,
     ) -> Result<()> {
         if let Ok(server) = self.server.as_running() {
             if let Some(registered_buffer) = server.registered_buffers.get_mut(&buffer.entity_id())
             {
                 match event {
-                    language::Event::Edited => {
+                    language::BufferEvent::Edited => {
                         drop(registered_buffer.report_changes(&buffer, cx));
                     }
-                    language::Event::Saved => {
+                    language::BufferEvent::Saved => {
                         server
                             .lsp
                             .notify::<lsp::notification::DidSaveTextDocument>(
@@ -713,7 +713,8 @@ impl Copilot {
                                 },
                             )?;
                     }
-                    language::Event::FileHandleChanged | language::Event::LanguageChanged => {
+                    language::BufferEvent::FileHandleChanged
+                    | language::BufferEvent::LanguageChanged => {
                         let new_language_id = id_for_language(buffer.read(cx).language());
                         let new_uri = uri_for_buffer(&buffer, cx);
                         if new_uri != registered_buffer.uri
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 0b1e0385ded4ad..b1ae40e6510c66 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -6205,7 +6205,7 @@ async fn test_document_format_during_save(cx: &mut gpui::TestAppContext) {
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -6361,7 +6361,7 @@ async fn test_multibuffer_format_during_save(cx: &mut gpui::TestAppContext) {
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -6557,7 +6557,7 @@ async fn test_range_format_during_save(cx: &mut gpui::TestAppContext) {
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -6708,7 +6708,7 @@ async fn test_document_format_manual_trigger(cx: &mut gpui::TestAppContext) {
             ..PrettierSettings::default()
         });
     });
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -9488,7 +9488,7 @@ async fn test_on_type_formatting_not_triggered(cx: &mut gpui::TestAppContext) {
         },
         Some(tree_sitter_rust::language()),
     )));
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -9601,7 +9601,7 @@ async fn test_language_server_restart_due_to_settings_change(cx: &mut gpui::Test
         },
         Some(tree_sitter_rust::language()),
     )));
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             name: language_server_name,
@@ -9945,7 +9945,7 @@ async fn test_document_format_with_prettier(cx: &mut gpui::TestAppContext) {
     });
 
     let test_plugin = "test_plugin";
-    let _ = language_registry.register_fake_lsp_adapter(
+    let _ = language_registry.register_fake_lsp(
         "TypeScript",
         FakeLspAdapter {
             prettier_plugins: vec![test_plugin],
diff --git a/crates/editor/src/git/blame.rs b/crates/editor/src/git/blame.rs
index 0cb866fb245048..00531ee88649a5 100644
--- a/crates/editor/src/git/blame.rs
+++ b/crates/editor/src/git/blame.rs
@@ -121,12 +121,12 @@ impl GitBlame {
         );
 
         let buffer_subscriptions = cx.subscribe(&buffer, |this, buffer, event, cx| match event {
-            language::Event::DirtyChanged => {
+            language::BufferEvent::DirtyChanged => {
                 if !buffer.read(cx).is_dirty() {
                     this.generate(cx);
                 }
             }
-            language::Event::Edited => {
+            language::BufferEvent::Edited => {
                 this.regenerate_on_edit(cx);
             }
             _ => {}
diff --git a/crates/editor/src/inlay_hint_cache.rs b/crates/editor/src/inlay_hint_cache.rs
index 01b681dd450fd1..b03674dc48aff9 100644
--- a/crates/editor/src/inlay_hint_cache.rs
+++ b/crates/editor/src/inlay_hint_cache.rs
@@ -1577,7 +1577,7 @@ pub mod tests {
                 },
                 Some(tree_sitter_rust::language()),
             )));
-            let fake_servers = language_registry.register_fake_lsp_adapter(
+            let fake_servers = language_registry.register_fake_lsp(
                 name,
                 FakeLspAdapter {
                     name,
@@ -2273,7 +2273,7 @@ pub mod tests {
 
         let language_registry = project.read_with(cx, |project, _| project.languages().clone());
         language_registry.add(crate::editor_tests::rust_lang());
-        let mut fake_servers = language_registry.register_fake_lsp_adapter(
+        let mut fake_servers = language_registry.register_fake_lsp(
             "Rust",
             FakeLspAdapter {
                 capabilities: lsp::ServerCapabilities {
@@ -2569,7 +2569,7 @@ pub mod tests {
         let language_registry = project.read_with(cx, |project, _| project.languages().clone());
         let language = crate::editor_tests::rust_lang();
         language_registry.add(language);
-        let mut fake_servers = language_registry.register_fake_lsp_adapter(
+        let mut fake_servers = language_registry.register_fake_lsp(
             "Rust",
             FakeLspAdapter {
                 capabilities: lsp::ServerCapabilities {
@@ -2919,7 +2919,7 @@ pub mod tests {
 
         let language_registry = project.read_with(cx, |project, _| project.languages().clone());
         language_registry.add(crate::editor_tests::rust_lang());
-        let mut fake_servers = language_registry.register_fake_lsp_adapter(
+        let mut fake_servers = language_registry.register_fake_lsp(
             "Rust",
             FakeLspAdapter {
                 capabilities: lsp::ServerCapabilities {
@@ -3148,7 +3148,7 @@ pub mod tests {
 
         let language_registry = project.read_with(cx, |project, _| project.languages().clone());
         language_registry.add(crate::editor_tests::rust_lang());
-        let mut fake_servers = language_registry.register_fake_lsp_adapter(
+        let mut fake_servers = language_registry.register_fake_lsp(
             "Rust",
             FakeLspAdapter {
                 capabilities: lsp::ServerCapabilities {
@@ -3389,7 +3389,7 @@ pub mod tests {
 
         let language_registry = project.read_with(cx, |project, _| project.languages().clone());
         language_registry.add(crate::editor_tests::rust_lang());
-        let mut fake_servers = language_registry.register_fake_lsp_adapter(
+        let mut fake_servers = language_registry.register_fake_lsp(
             "Rust",
             FakeLspAdapter {
                 capabilities: lsp::ServerCapabilities {
diff --git a/crates/editor/src/test/editor_lsp_test_context.rs b/crates/editor/src/test/editor_lsp_test_context.rs
index 16735760bff5bf..17959ab50b5c85 100644
--- a/crates/editor/src/test/editor_lsp_test_context.rs
+++ b/crates/editor/src/test/editor_lsp_test_context.rs
@@ -57,7 +57,7 @@ impl EditorLspTestContext {
         let project = Project::test(app_state.fs.clone(), [], cx).await;
 
         let language_registry = project.read_with(cx, |project, _| project.languages().clone());
-        let mut fake_servers = language_registry.register_fake_lsp_adapter(
+        let mut fake_servers = language_registry.register_fake_lsp(
             language.name(),
             FakeLspAdapter {
                 capabilities,
diff --git a/crates/extension/src/extension_store_test.rs b/crates/extension/src/extension_store_test.rs
index da530306d17101..326c713bd563ff 100644
--- a/crates/extension/src/extension_store_test.rs
+++ b/crates/extension/src/extension_store_test.rs
@@ -609,7 +609,14 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
         .await
         .unwrap();
 
-    let mut fake_servers = language_registry.fake_language_servers("Gleam".into());
+    let mut fake_servers = language_registry.register_fake_language_server(
+        LanguageServerName("gleam".into()),
+        lsp::ServerCapabilities {
+            completion_provider: Some(Default::default()),
+            ..Default::default()
+        },
+        None,
+    );
 
     let buffer = project
         .update(cx, |project, cx| {
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 4e8af1ea8cb8de..74080d01622e0d 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -302,7 +302,7 @@ pub enum Operation {
 
 /// An event that occurs in a buffer.
 #[derive(Clone, Debug, PartialEq)]
-pub enum Event {
+pub enum BufferEvent {
     /// The buffer was changed in a way that must be
     /// propagated to its other replicas.
     Operation(Operation),
@@ -809,7 +809,7 @@ impl Buffer {
         self.syntax_map.lock().clear();
         self.language = language;
         self.reparse(cx);
-        cx.emit(Event::LanguageChanged);
+        cx.emit(BufferEvent::LanguageChanged);
     }
 
     /// Assign a language registry to the buffer. This allows the buffer to retrieve
@@ -827,7 +827,7 @@ impl Buffer {
     /// Assign the buffer a new [Capability].
     pub fn set_capability(&mut self, capability: Capability, cx: &mut ModelContext<Self>) {
         self.capability = capability;
-        cx.emit(Event::CapabilityChanged)
+        cx.emit(BufferEvent::CapabilityChanged)
     }
 
     /// This method is called to signal that the buffer has been saved.
@@ -842,13 +842,13 @@ impl Buffer {
             .set((self.saved_version().clone(), false));
         self.has_conflict = false;
         self.saved_mtime = mtime;
-        cx.emit(Event::Saved);
+        cx.emit(BufferEvent::Saved);
         cx.notify();
     }
 
     /// This method is called to signal that the buffer has been discarded.
     pub fn discarded(&mut self, cx: &mut ModelContext<Self>) {
-        cx.emit(Event::Discarded);
+        cx.emit(BufferEvent::Discarded);
         cx.notify();
     }
 
@@ -911,7 +911,7 @@ impl Buffer {
             .set((self.saved_version.clone(), false));
         self.text.set_line_ending(line_ending);
         self.saved_mtime = mtime;
-        cx.emit(Event::Reloaded);
+        cx.emit(BufferEvent::Reloaded);
         cx.notify();
     }
 
@@ -929,7 +929,7 @@ impl Buffer {
                 if !old_file.is_deleted() {
                     file_changed = true;
                     if !self.is_dirty() {
-                        cx.emit(Event::DirtyChanged);
+                        cx.emit(BufferEvent::DirtyChanged);
                     }
                 }
             } else {
@@ -949,7 +949,7 @@ impl Buffer {
         self.file = Some(new_file);
         if file_changed {
             self.non_text_state_update_count += 1;
-            cx.emit(Event::FileHandleChanged);
+            cx.emit(BufferEvent::FileHandleChanged);
             cx.notify();
         }
     }
@@ -974,7 +974,7 @@ impl Buffer {
                 recalc_task.await;
                 buffer
                     .update(&mut cx, |_, cx| {
-                        cx.emit(Event::DiffBaseChanged);
+                        cx.emit(BufferEvent::DiffBaseChanged);
                     })
                     .ok();
             })
@@ -1003,7 +1003,7 @@ impl Buffer {
             this.update(&mut cx, |this, cx| {
                 this.git_diff = buffer_diff;
                 this.non_text_state_update_count += 1;
-                cx.emit(Event::DiffUpdated);
+                cx.emit(BufferEvent::DiffUpdated);
             })
             .ok();
         }))
@@ -1142,7 +1142,7 @@ impl Buffer {
         self.syntax_map.lock().did_parse(syntax_snapshot);
         self.request_autoindent(cx);
         self.parse_status.0.send(ParseStatus::Idle).unwrap();
-        cx.emit(Event::Reparsed);
+        cx.emit(BufferEvent::Reparsed);
         cx.notify();
     }
 
@@ -1900,9 +1900,9 @@ impl Buffer {
 
         self.reparse(cx);
 
-        cx.emit(Event::Edited);
+        cx.emit(BufferEvent::Edited);
         if was_dirty != self.is_dirty() {
-            cx.emit(Event::DirtyChanged);
+            cx.emit(BufferEvent::DirtyChanged);
         }
         cx.notify();
     }
@@ -2106,12 +2106,12 @@ impl Buffer {
             self.non_text_state_update_count += 1;
             self.text.lamport_clock.observe(lamport_timestamp);
             cx.notify();
-            cx.emit(Event::DiagnosticsUpdated);
+            cx.emit(BufferEvent::DiagnosticsUpdated);
         }
     }
 
     fn send_operation(&mut self, operation: Operation, cx: &mut ModelContext<Self>) {
-        cx.emit(Event::Operation(operation));
+        cx.emit(BufferEvent::Operation(operation));
     }
 
     /// Removes the selections for a given peer.
@@ -2300,7 +2300,7 @@ impl Buffer {
     }
 }
 
-impl EventEmitter<Event> for Buffer {}
+impl EventEmitter<BufferEvent> for Buffer {}
 
 impl Deref for Buffer {
     type Target = TextBuffer;
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index 77a1079d3ad56f..7e6f6ef368ee60 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -275,7 +275,7 @@ fn test_edit_events(cx: &mut gpui::AppContext) {
         |buffer, cx| {
             let buffer_1_events = buffer_1_events.clone();
             cx.subscribe(&buffer1, move |_, _, event, _| match event.clone() {
-                Event::Operation(op) => buffer1_ops.lock().push(op),
+                BufferEvent::Operation(op) => buffer1_ops.lock().push(op),
                 event => buffer_1_events.lock().push(event),
             })
             .detach();
@@ -313,15 +313,15 @@ fn test_edit_events(cx: &mut gpui::AppContext) {
     assert_eq!(
         mem::take(&mut *buffer_1_events.lock()),
         vec![
-            Event::Edited,
-            Event::DirtyChanged,
-            Event::Edited,
-            Event::Edited,
+            BufferEvent::Edited,
+            BufferEvent::DirtyChanged,
+            BufferEvent::Edited,
+            BufferEvent::Edited,
         ]
     );
     assert_eq!(
         mem::take(&mut *buffer_2_events.lock()),
-        vec![Event::Edited, Event::DirtyChanged]
+        vec![BufferEvent::Edited, BufferEvent::DirtyChanged]
     );
 
     buffer1.update(cx, |buffer, cx| {
@@ -336,11 +336,11 @@ fn test_edit_events(cx: &mut gpui::AppContext) {
     });
     assert_eq!(
         mem::take(&mut *buffer_1_events.lock()),
-        vec![Event::Edited, Event::DirtyChanged,]
+        vec![BufferEvent::Edited, BufferEvent::DirtyChanged,]
     );
     assert_eq!(
         mem::take(&mut *buffer_2_events.lock()),
-        vec![Event::Edited, Event::DirtyChanged]
+        vec![BufferEvent::Edited, BufferEvent::DirtyChanged]
     );
 }
 
@@ -2411,7 +2411,7 @@ fn test_random_collaboration(cx: &mut AppContext, mut rng: StdRng) {
             buffer.set_group_interval(Duration::from_millis(rng.gen_range(0..=200)));
             let network = network.clone();
             cx.subscribe(&cx.handle(), move |buffer, _, event, _| {
-                if let Event::Operation(op) = event {
+                if let BufferEvent::Operation(op) = event {
                     network
                         .lock()
                         .broadcast(buffer.replica_id(), vec![proto::serialize_operation(op)]);
@@ -2539,7 +2539,7 @@ fn test_random_collaboration(cx: &mut AppContext, mut rng: StdRng) {
                     new_buffer.set_group_interval(Duration::from_millis(rng.gen_range(0..=200)));
                     let network = network.clone();
                     cx.subscribe(&cx.handle(), move |buffer, _, event, _| {
-                        if let Event::Operation(op) = event {
+                        if let BufferEvent::Operation(op) = event {
                             network.lock().broadcast(
                                 buffer.replica_id(),
                                 vec![proto::serialize_operation(op)],
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index 3112d88aa5543c..fa5d79b53fa51b 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -270,11 +270,6 @@ impl CachedLspAdapter {
             .cloned()
             .unwrap_or_else(|| language_name.lsp_id())
     }
-
-    #[cfg(any(test, feature = "test-support"))]
-    fn as_fake(&self) -> Option<&FakeLspAdapter> {
-        self.adapter.as_fake()
-    }
 }
 
 /// [`LspAdapterDelegate`] allows [`LspAdapter]` implementations to interface with the application
@@ -508,11 +503,6 @@ pub trait LspAdapter: 'static + Send + Sync {
     fn language_ids(&self) -> HashMap<String, String> {
         Default::default()
     }
-
-    #[cfg(any(test, feature = "test-support"))]
-    fn as_fake(&self) -> Option<&FakeLspAdapter> {
-        None
-    }
 }
 
 async fn try_fetch_server_binary<L: LspAdapter + 'static + Send + Sync + ?Sized>(
@@ -751,12 +741,13 @@ where
 pub struct FakeLspAdapter {
     pub name: &'static str,
     pub initialization_options: Option<Value>,
-    pub capabilities: lsp::ServerCapabilities,
-    pub initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp::FakeLanguageServer)>>,
+    pub prettier_plugins: Vec<&'static str>,
     pub disk_based_diagnostics_progress_token: Option<String>,
     pub disk_based_diagnostics_sources: Vec<String>,
-    pub prettier_plugins: Vec<&'static str>,
     pub language_server_binary: LanguageServerBinary,
+
+    pub capabilities: lsp::ServerCapabilities,
+    pub initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp::FakeLanguageServer)>>,
 }
 
 /// Configuration of handling bracket pairs for a given language.
@@ -1717,10 +1708,6 @@ impl LspAdapter for FakeLspAdapter {
     ) -> Result<Option<Value>> {
         Ok(self.initialization_options.clone())
     }
-
-    fn as_fake(&self) -> Option<&FakeLspAdapter> {
-        Some(self)
-    }
 }
 
 fn get_capture_indices(query: &Query, captures: &mut [(&str, &mut Option<u32>)]) {
diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index 69e44ee4ace186..e89b73f11b44ce 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -99,10 +99,15 @@ struct LanguageRegistryState {
     reload_count: usize,
 
     #[cfg(any(test, feature = "test-support"))]
-    fake_server_txs: HashMap<
-        LanguageName,
-        Vec<futures::channel::mpsc::UnboundedSender<lsp::FakeLanguageServer>>,
-    >,
+    fake_server_entries: HashMap<LanguageServerName, FakeLanguageServerEntry>,
+}
+
+#[cfg(any(test, feature = "test-support"))]
+pub struct FakeLanguageServerEntry {
+    pub capabilities: lsp::ServerCapabilities,
+    pub initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp::FakeLanguageServer)>>,
+    pub tx: futures::channel::mpsc::UnboundedSender<lsp::FakeLanguageServer>,
+    pub _server: Option<lsp::FakeLanguageServer>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -220,7 +225,7 @@ impl LanguageRegistry {
                 reload_count: 0,
 
                 #[cfg(any(test, feature = "test-support"))]
-                fake_server_txs: Default::default(),
+                fake_server_entries: Default::default(),
             }),
             language_server_download_dir: None,
             lsp_binary_status_tx: Default::default(),
@@ -330,34 +335,63 @@ impl LanguageRegistry {
             .push(CachedLspAdapter::new(adapter));
     }
 
+    /// Register a fake language server and adapter
+    /// The returned channel receives a new instance of the language server every time it is started
     #[cfg(any(feature = "test-support", test))]
-    pub fn register_fake_lsp_adapter(
+    pub fn register_fake_lsp(
         &self,
         language_name: impl Into<LanguageName>,
-        adapter: crate::FakeLspAdapter,
+        mut adapter: crate::FakeLspAdapter,
     ) -> futures::channel::mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
         let language_name = language_name.into();
+        let adapter_name = LanguageServerName(adapter.name.into());
+        let capabilities = adapter.capabilities.clone();
+        let initializer = adapter.initializer.take();
         self.state
             .write()
             .lsp_adapters
             .entry(language_name.clone())
             .or_default()
             .push(CachedLspAdapter::new(Arc::new(adapter)));
-        self.fake_language_servers(language_name)
+        self.register_fake_language_server(adapter_name, capabilities, initializer)
     }
 
+    /// Register a fake lsp adapter (without the language server)
+    /// The returned channel receives a new instance of the language server every time it is started
     #[cfg(any(feature = "test-support", test))]
-    pub fn fake_language_servers(
+    pub fn register_fake_lsp_adapter(
         &self,
-        language_name: LanguageName,
-    ) -> futures::channel::mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
-        let (servers_tx, servers_rx) = futures::channel::mpsc::unbounded();
+        language_name: impl Into<LanguageName>,
+        adapter: crate::FakeLspAdapter,
+    ) {
+        let language_name = language_name.into();
         self.state
             .write()
-            .fake_server_txs
-            .entry(language_name)
+            .lsp_adapters
+            .entry(language_name.clone())
             .or_default()
-            .push(servers_tx);
+            .push(CachedLspAdapter::new(Arc::new(adapter)));
+    }
+
+    /// Register a fake language server (without the adapter)
+    /// The returned channel receives a new instance of the language server every time it is started
+    #[cfg(any(feature = "test-support", test))]
+    pub fn register_fake_language_server(
+        &self,
+        lsp_name: LanguageServerName,
+        capabilities: lsp::ServerCapabilities,
+        initializer: Option<Box<dyn Fn(&mut lsp::FakeLanguageServer) + Send + Sync>>,
+    ) -> futures::channel::mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
+        let (servers_tx, servers_rx) = futures::channel::mpsc::unbounded();
+        self.state.write().fake_server_entries.insert(
+            lsp_name,
+            FakeLanguageServerEntry {
+                tx: servers_tx,
+                capabilities,
+                initializer,
+                _server: None,
+            },
+        );
         servers_rx
     }
 
@@ -835,8 +869,8 @@ impl LanguageRegistry {
             adapter.name.0
         );
 
-        let download_dir = self
-            .language_server_download_dir
+        let download_dir = &self
+                    .language_server_download_dir
             .clone()
             .ok_or_else(|| anyhow!("language server download directory has not been assigned before starting server"))
             .log_err()?;
@@ -877,52 +911,43 @@ impl LanguageRegistry {
 
                 #[cfg(any(test, feature = "test-support"))]
                 if true {
-                    let capabilities = adapter
-                        .as_fake()
-                        .map(|fake_adapter| fake_adapter.capabilities.clone())
-                        .unwrap_or_else(|| lsp::ServerCapabilities {
-                            completion_provider: Some(Default::default()),
-                            ..Default::default()
-                        });
-
-                    let (server, mut fake_server) = lsp::FakeLanguageServer::new(
-                        server_id,
-                        binary,
-                        adapter.name.0.to_string(),
-                        capabilities,
-                        cx.clone(),
-                    );
-
-                    if let Some(fake_adapter) = adapter.as_fake() {
-                        if let Some(initializer) = &fake_adapter.initializer {
-                            initializer(&mut fake_server);
-                        }
-                    }
+                    if let Some(this) = this.upgrade() {
+                        if let Some(fake_entry) = this
+                            .state
+                            .write()
+                            .fake_server_entries
+                            .get_mut(&adapter.name)
+                        {
+                            let (server, mut fake_server) = lsp::FakeLanguageServer::new(
+                                server_id,
+                                binary,
+                                adapter.name.0.to_string(),
+                                fake_entry.capabilities.clone(),
+                                cx.clone(),
+                            );
+                            fake_entry._server = Some(fake_server.clone());
+
+                            if let Some(initializer) = &fake_entry.initializer {
+                                initializer(&mut fake_server);
+                            }
 
-                    cx.background_executor()
-                        .spawn(async move {
-                            if fake_server
-                                .try_receive_notification::<lsp::notification::Initialized>()
-                                .await
-                                .is_some()
-                            {
-                                if let Some(this) = this.upgrade() {
-                                    if let Some(txs) = this
-                                        .state
-                                        .write()
-                                        .fake_server_txs
-                                        .get_mut(&_language_name_for_tests)
+                            let tx = fake_entry.tx.clone();
+                            cx.background_executor()
+                                .spawn(async move {
+                                    if fake_server
+                                        .try_receive_notification::<lsp::notification::Initialized>(
+                                        )
+                                        .await
+                                        .is_some()
                                     {
-                                        for tx in txs {
-                                            tx.unbounded_send(fake_server.clone()).ok();
-                                        }
+                                        tx.unbounded_send(fake_server.clone()).ok();
                                     }
-                                }
-                            }
-                        })
-                        .detach();
+                                })
+                                .detach();
 
-                    return Ok((server, options));
+                            return Ok((server, options));
+                        }
+                    }
                 }
 
                 drop(this);
diff --git a/crates/language_tools/src/lsp_log_tests.rs b/crates/language_tools/src/lsp_log_tests.rs
index b4657736910773..524a8e99963bf7 100644
--- a/crates/language_tools/src/lsp_log_tests.rs
+++ b/crates/language_tools/src/lsp_log_tests.rs
@@ -45,7 +45,7 @@ async fn test_lsp_logs(cx: &mut TestAppContext) {
         },
         Some(tree_sitter_rust::language()),
     )));
-    let mut fake_rust_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_rust_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             name: "the-rust-language-server",
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index 7910b77bd81abb..f7172ccf08d297 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -1673,31 +1673,33 @@ impl MultiBuffer {
     fn on_buffer_event(
         &mut self,
         buffer: Model<Buffer>,
-        event: &language::Event,
+        event: &language::BufferEvent,
         cx: &mut ModelContext<Self>,
     ) {
         cx.emit(match event {
-            language::Event::Edited => Event::Edited {
+            language::BufferEvent::Edited => Event::Edited {
                 singleton_buffer_edited: true,
             },
-            language::Event::DirtyChanged => Event::DirtyChanged,
-            language::Event::Saved => Event::Saved,
-            language::Event::FileHandleChanged => Event::FileHandleChanged,
-            language::Event::Reloaded => Event::Reloaded,
-            language::Event::DiffBaseChanged => Event::DiffBaseChanged,
-            language::Event::DiffUpdated => Event::DiffUpdated { buffer },
-            language::Event::LanguageChanged => Event::LanguageChanged(buffer.read(cx).remote_id()),
-            language::Event::Reparsed => Event::Reparsed(buffer.read(cx).remote_id()),
-            language::Event::DiagnosticsUpdated => Event::DiagnosticsUpdated,
-            language::Event::Closed => Event::Closed,
-            language::Event::Discarded => Event::Discarded,
-            language::Event::CapabilityChanged => {
+            language::BufferEvent::DirtyChanged => Event::DirtyChanged,
+            language::BufferEvent::Saved => Event::Saved,
+            language::BufferEvent::FileHandleChanged => Event::FileHandleChanged,
+            language::BufferEvent::Reloaded => Event::Reloaded,
+            language::BufferEvent::DiffBaseChanged => Event::DiffBaseChanged,
+            language::BufferEvent::DiffUpdated => Event::DiffUpdated { buffer },
+            language::BufferEvent::LanguageChanged => {
+                Event::LanguageChanged(buffer.read(cx).remote_id())
+            }
+            language::BufferEvent::Reparsed => Event::Reparsed(buffer.read(cx).remote_id()),
+            language::BufferEvent::DiagnosticsUpdated => Event::DiagnosticsUpdated,
+            language::BufferEvent::Closed => Event::Closed,
+            language::BufferEvent::Discarded => Event::Discarded,
+            language::BufferEvent::CapabilityChanged => {
                 self.capability = buffer.read(cx).capability();
                 Event::CapabilityChanged
             }
 
             //
-            language::Event::Operation(_) => return,
+            language::BufferEvent::Operation(_) => return,
         });
     }
 
diff --git a/crates/project/src/buffer_store.rs b/crates/project/src/buffer_store.rs
index 403b53745a51e9..ead32359970e25 100644
--- a/crates/project/src/buffer_store.rs
+++ b/crates/project/src/buffer_store.rs
@@ -15,7 +15,7 @@ use gpui::{
 use http_client::Url;
 use language::{
     proto::{deserialize_line_ending, deserialize_version, serialize_version, split_operations},
-    Buffer, Capability, Event as BufferEvent, File as _, Language, Operation,
+    Buffer, BufferEvent, Capability, File as _, Language, Operation,
 };
 use rpc::{proto, AnyProtoClient, ErrorExt as _, TypedEnvelope};
 use smol::channel::Receiver;
@@ -62,7 +62,7 @@ pub enum BufferStoreEvent {
     },
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct ProjectTransaction(pub HashMap<Model<Buffer>, language::Transaction>);
 
 impl EventEmitter<BufferStoreEvent> for BufferStore {}
@@ -1054,7 +1054,11 @@ impl BufferStore {
                         buffer.update(cx, |buffer, cx| buffer.apply_ops(ops, cx))?;
                     }
                     OpenBuffer::Operations(operations) => operations.extend_from_slice(&ops),
-                    OpenBuffer::Weak(_) => {}
+                    OpenBuffer::Weak(buffer) => {
+                        if let Some(buffer) = buffer.upgrade() {
+                            buffer.update(cx, |buffer, cx| buffer.apply_ops(ops, cx))?;
+                        }
+                    }
                 },
                 hash_map::Entry::Vacant(e) => {
                     e.insert(OpenBuffer::Operations(ops));
diff --git a/crates/project/src/lsp_command.rs b/crates/project/src/lsp_command.rs
index 748fa00aa1a5db..2b7b10d9b369a9 100644
--- a/crates/project/src/lsp_command.rs
+++ b/crates/project/src/lsp_command.rs
@@ -46,8 +46,8 @@ pub fn lsp_formatting_options(settings: &LanguageSettings) -> lsp::FormattingOpt
 }
 
 #[async_trait(?Send)]
-pub trait LspCommand: 'static + Sized + Send {
-    type Response: 'static + Default + Send;
+pub trait LspCommand: 'static + Sized + Send + std::fmt::Debug {
+    type Response: 'static + Default + Send + std::fmt::Debug;
     type LspRequest: 'static + Send + lsp::request::Request;
     type ProtoRequest: 'static + Send + proto::RequestMessage;
 
@@ -104,72 +104,80 @@ pub trait LspCommand: 'static + Sized + Send {
     fn buffer_id_from_proto(message: &Self::ProtoRequest) -> Result<BufferId>;
 }
 
+#[derive(Debug)]
 pub(crate) struct PrepareRename {
     pub position: PointUtf16,
 }
 
+#[derive(Debug)]
 pub(crate) struct PerformRename {
     pub position: PointUtf16,
     pub new_name: String,
     pub push_to_history: bool,
 }
 
+#[derive(Debug)]
 pub struct GetDefinition {
     pub position: PointUtf16,
 }
 
+#[derive(Debug)]
 pub(crate) struct GetDeclaration {
     pub position: PointUtf16,
 }
 
+#[derive(Debug)]
 pub(crate) struct GetTypeDefinition {
     pub position: PointUtf16,
 }
 
+#[derive(Debug)]
 pub(crate) struct GetImplementation {
     pub position: PointUtf16,
 }
-
+#[derive(Debug)]
 pub(crate) struct GetReferences {
     pub position: PointUtf16,
 }
 
+#[derive(Debug)]
 pub(crate) struct GetDocumentHighlights {
     pub position: PointUtf16,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct GetSignatureHelp {
     pub position: PointUtf16,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct GetHover {
     pub position: PointUtf16,
 }
 
+#[derive(Debug)]
 pub(crate) struct GetCompletions {
     pub position: PointUtf16,
     pub context: CompletionContext,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub(crate) struct GetCodeActions {
     pub range: Range<Anchor>,
     pub kinds: Option<Vec<lsp::CodeActionKind>>,
 }
-
+#[derive(Debug)]
 pub(crate) struct OnTypeFormatting {
     pub position: PointUtf16,
     pub trigger: String,
     pub options: lsp::FormattingOptions,
     pub push_to_history: bool,
 }
-
+#[derive(Debug)]
 pub(crate) struct InlayHints {
     pub range: Range<Anchor>,
 }
-
+#[derive(Debug)]
 pub(crate) struct LinkedEditingRange {
     pub position: Anchor,
 }
diff --git a/crates/project/src/lsp_ext_command.rs b/crates/project/src/lsp_ext_command.rs
index bf80917df9cd35..9fa1dc548077e6 100644
--- a/crates/project/src/lsp_ext_command.rs
+++ b/crates/project/src/lsp_ext_command.rs
@@ -36,7 +36,7 @@ impl ExpandedMacro {
         self.name.is_empty() && self.expansion.is_empty()
     }
 }
-
+#[derive(Debug)]
 pub struct ExpandMacro {
     pub position: PointUtf16,
 }
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 854915e82d66fc..cea10094a97b27 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -501,15 +501,15 @@ impl LspStore {
     fn on_buffer_event(
         &mut self,
         buffer: Model<Buffer>,
-        event: &language::Event,
+        event: &language::BufferEvent,
         cx: &mut ModelContext<Self>,
     ) {
         match event {
-            language::Event::Edited { .. } => {
+            language::BufferEvent::Edited { .. } => {
                 self.on_buffer_edited(buffer, cx);
             }
 
-            language::Event::Saved => {
+            language::BufferEvent::Saved => {
                 self.on_buffer_saved(buffer, cx);
             }
 
@@ -2930,6 +2930,7 @@ impl LspStore {
             })
             .map(|(_, server)| server.server_id())
             .collect::<Vec<_>>();
+
         let mut response_results = server_ids
             .into_iter()
             .map(|server_id| {
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 8fca2ea6863546..9185670b05c23f 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -50,9 +50,9 @@ use language::{
         deserialize_anchor, serialize_anchor, serialize_line_ending, serialize_version,
         split_operations,
     },
-    Buffer, CachedLspAdapter, Capability, CodeLabel, ContextProvider, DiagnosticEntry, Diff,
-    Documentation, Event as BufferEvent, File as _, Language, LanguageRegistry, LanguageServerName,
-    PointUtf16, ToOffset, ToPointUtf16, Transaction, Unclipped,
+    Buffer, BufferEvent, CachedLspAdapter, Capability, CodeLabel, ContextProvider, DiagnosticEntry,
+    Diff, Documentation, File as _, Language, LanguageRegistry, LanguageServerName, PointUtf16,
+    ToOffset, ToPointUtf16, Transaction, Unclipped,
 };
 use lsp::{CompletionContext, DocumentHighlightKind, LanguageServer, LanguageServerId};
 use lsp_command::*;
@@ -799,6 +799,7 @@ impl Project {
             client.add_model_message_handler(Self::handle_create_buffer_for_peer);
             client.add_model_message_handler(BufferStore::handle_update_buffer_file);
             client.add_model_message_handler(BufferStore::handle_update_diff_base);
+            client.add_model_request_handler(BufferStore::handle_update_buffer);
             LspStore::init(&client);
             SettingsObserver::init(&client);
 
@@ -1367,7 +1368,13 @@ impl Project {
     pub fn replica_id(&self) -> ReplicaId {
         match self.client_state {
             ProjectClientState::Remote { replica_id, .. } => replica_id,
-            _ => 0,
+            _ => {
+                if self.ssh_session.is_some() {
+                    1
+                } else {
+                    0
+                }
+            }
         }
     }
 
@@ -1818,6 +1825,15 @@ impl Project {
         }
     }
 
+    pub fn is_via_ssh(&self) -> bool {
+        match &self.client_state {
+            ProjectClientState::Local | ProjectClientState::Shared { .. } => {
+                self.ssh_session.is_some()
+            }
+            ProjectClientState::Remote { .. } => false,
+        }
+    }
+
     pub fn is_via_collab(&self) -> bool {
         match &self.client_state {
             ProjectClientState::Local | ProjectClientState::Shared { .. } => false,
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index 4662c75477d45f..83deb6fd919133 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -315,7 +315,7 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {
     let project = Project::test(fs.clone(), ["/the-root".as_ref()], cx).await;
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
 
-    let mut fake_rust_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_rust_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             name: "the-rust-language-server",
@@ -335,7 +335,7 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {
             ..Default::default()
         },
     );
-    let mut fake_json_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_json_servers = language_registry.register_fake_lsp(
         "JSON",
         FakeLspAdapter {
             name: "the-json-language-server",
@@ -716,7 +716,7 @@ async fn test_reporting_fs_changes_to_language_servers(cx: &mut gpui::TestAppCon
     let project = Project::test(fs.clone(), ["/the-root".as_ref()], cx).await;
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             name: "the-language-server",
@@ -1125,7 +1125,7 @@ async fn test_disk_based_diagnostics_progress(cx: &mut gpui::TestAppContext) {
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
 
     language_registry.add(rust_lang());
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             disk_based_diagnostics_progress_token: Some(progress_token.into()),
@@ -1247,7 +1247,7 @@ async fn test_restarting_server_with_diagnostics_running(cx: &mut gpui::TestAppC
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             name: "the-language-server",
@@ -1324,8 +1324,7 @@ async fn test_restarting_server_with_diagnostics_published(cx: &mut gpui::TestAp
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
-    let mut fake_servers =
-        language_registry.register_fake_lsp_adapter("Rust", FakeLspAdapter::default());
+    let mut fake_servers = language_registry.register_fake_lsp("Rust", FakeLspAdapter::default());
 
     let buffer = project
         .update(cx, |project, cx| project.open_local_buffer("/dir/a.rs", cx))
@@ -1404,8 +1403,7 @@ async fn test_restarted_server_reporting_invalid_buffer_version(cx: &mut gpui::T
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
 
     language_registry.add(rust_lang());
-    let mut fake_servers =
-        language_registry.register_fake_lsp_adapter("Rust", FakeLspAdapter::default());
+    let mut fake_servers = language_registry.register_fake_lsp("Rust", FakeLspAdapter::default());
 
     let buffer = project
         .update(cx, |project, cx| project.open_local_buffer("/dir/a.rs", cx))
@@ -1445,7 +1443,7 @@ async fn test_cancel_language_server_work(cx: &mut gpui::TestAppContext) {
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             name: "the-language-server",
@@ -1506,14 +1504,14 @@ async fn test_toggling_enable_language_server(cx: &mut gpui::TestAppContext) {
     let project = Project::test(fs, ["/dir".as_ref()], cx).await;
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
 
-    let mut fake_rust_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_rust_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             name: "rust-lsp",
             ..Default::default()
         },
     );
-    let mut fake_js_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_js_servers = language_registry.register_fake_lsp(
         "JavaScript",
         FakeLspAdapter {
             name: "js-lsp",
@@ -1627,7 +1625,7 @@ async fn test_transforming_diagnostics(cx: &mut gpui::TestAppContext) {
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
 
     language_registry.add(rust_lang());
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             disk_based_diagnostics_sources: vec!["disk".into()],
@@ -2049,8 +2047,7 @@ async fn test_edits_from_lsp2_with_past_version(cx: &mut gpui::TestAppContext) {
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
-    let mut fake_servers =
-        language_registry.register_fake_lsp_adapter("Rust", FakeLspAdapter::default());
+    let mut fake_servers = language_registry.register_fake_lsp("Rust", FakeLspAdapter::default());
 
     let buffer = project
         .update(cx, |project, cx| project.open_local_buffer("/dir/a.rs", cx))
@@ -2421,8 +2418,7 @@ async fn test_definition(cx: &mut gpui::TestAppContext) {
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
-    let mut fake_servers =
-        language_registry.register_fake_lsp_adapter("Rust", FakeLspAdapter::default());
+    let mut fake_servers = language_registry.register_fake_lsp("Rust", FakeLspAdapter::default());
 
     let buffer = project
         .update(cx, |project, cx| project.open_local_buffer("/dir/b.rs", cx))
@@ -2515,7 +2511,7 @@ async fn test_completions_without_edit_ranges(cx: &mut gpui::TestAppContext) {
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(typescript_lang());
-    let mut fake_language_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_language_servers = language_registry.register_fake_lsp(
         "TypeScript",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -2607,7 +2603,7 @@ async fn test_completions_with_carriage_returns(cx: &mut gpui::TestAppContext) {
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(typescript_lang());
-    let mut fake_language_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_language_servers = language_registry.register_fake_lsp(
         "TypeScript",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -2668,7 +2664,7 @@ async fn test_apply_code_actions_with_commands(cx: &mut gpui::TestAppContext) {
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(typescript_lang());
-    let mut fake_language_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_language_servers = language_registry.register_fake_lsp(
         "TypeScript",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -3310,7 +3306,10 @@ async fn test_buffer_is_dirty(cx: &mut gpui::TestAppContext) {
         assert!(buffer.is_dirty());
         assert_eq!(
             *events.lock(),
-            &[language::Event::Edited, language::Event::DirtyChanged]
+            &[
+                language::BufferEvent::Edited,
+                language::BufferEvent::DirtyChanged
+            ]
         );
         events.lock().clear();
         buffer.did_save(buffer.version(), buffer.file().unwrap().mtime(), cx);
@@ -3319,7 +3318,7 @@ async fn test_buffer_is_dirty(cx: &mut gpui::TestAppContext) {
     // after saving, the buffer is not dirty, and emits a saved event.
     buffer1.update(cx, |buffer, cx| {
         assert!(!buffer.is_dirty());
-        assert_eq!(*events.lock(), &[language::Event::Saved]);
+        assert_eq!(*events.lock(), &[language::BufferEvent::Saved]);
         events.lock().clear();
 
         buffer.edit([(1..1, "B")], None, cx);
@@ -3333,9 +3332,9 @@ async fn test_buffer_is_dirty(cx: &mut gpui::TestAppContext) {
         assert_eq!(
             *events.lock(),
             &[
-                language::Event::Edited,
-                language::Event::DirtyChanged,
-                language::Event::Edited,
+                language::BufferEvent::Edited,
+                language::BufferEvent::DirtyChanged,
+                language::BufferEvent::Edited,
             ],
         );
         events.lock().clear();
@@ -3349,7 +3348,10 @@ async fn test_buffer_is_dirty(cx: &mut gpui::TestAppContext) {
 
     assert_eq!(
         *events.lock(),
-        &[language::Event::Edited, language::Event::DirtyChanged]
+        &[
+            language::BufferEvent::Edited,
+            language::BufferEvent::DirtyChanged
+        ]
     );
 
     // When a file is deleted, the buffer is considered dirty.
@@ -3374,8 +3376,8 @@ async fn test_buffer_is_dirty(cx: &mut gpui::TestAppContext) {
     assert_eq!(
         *events.lock(),
         &[
-            language::Event::DirtyChanged,
-            language::Event::FileHandleChanged
+            language::BufferEvent::DirtyChanged,
+            language::BufferEvent::FileHandleChanged
         ]
     );
 
@@ -3401,7 +3403,7 @@ async fn test_buffer_is_dirty(cx: &mut gpui::TestAppContext) {
         .await
         .unwrap();
     cx.executor().run_until_parked();
-    assert_eq!(*events.lock(), &[language::Event::FileHandleChanged]);
+    assert_eq!(*events.lock(), &[language::BufferEvent::FileHandleChanged]);
     cx.update(|cx| assert!(buffer3.read(cx).is_dirty()));
 }
 
@@ -3809,7 +3811,7 @@ async fn test_rename(cx: &mut gpui::TestAppContext) {
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
-    let mut fake_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -4696,50 +4698,52 @@ async fn test_multiple_language_server_hovers(cx: &mut gpui::TestAppContext) {
         "ESLintServer",
         "NoHoverCapabilitiesServer",
     ];
-    let mut fake_tsx_language_servers = language_registry.register_fake_lsp_adapter(
-        "tsx",
-        FakeLspAdapter {
-            name: language_server_names[0],
-            capabilities: lsp::ServerCapabilities {
-                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
-                ..lsp::ServerCapabilities::default()
+    let mut language_servers = [
+        language_registry.register_fake_lsp(
+            "tsx",
+            FakeLspAdapter {
+                name: language_server_names[0],
+                capabilities: lsp::ServerCapabilities {
+                    hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
             },
-            ..FakeLspAdapter::default()
-        },
-    );
-    let _a = language_registry.register_fake_lsp_adapter(
-        "tsx",
-        FakeLspAdapter {
-            name: language_server_names[1],
-            capabilities: lsp::ServerCapabilities {
-                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
-                ..lsp::ServerCapabilities::default()
+        ),
+        language_registry.register_fake_lsp(
+            "tsx",
+            FakeLspAdapter {
+                name: language_server_names[1],
+                capabilities: lsp::ServerCapabilities {
+                    hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
             },
-            ..FakeLspAdapter::default()
-        },
-    );
-    let _b = language_registry.register_fake_lsp_adapter(
-        "tsx",
-        FakeLspAdapter {
-            name: language_server_names[2],
-            capabilities: lsp::ServerCapabilities {
-                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
-                ..lsp::ServerCapabilities::default()
+        ),
+        language_registry.register_fake_lsp(
+            "tsx",
+            FakeLspAdapter {
+                name: language_server_names[2],
+                capabilities: lsp::ServerCapabilities {
+                    hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
             },
-            ..FakeLspAdapter::default()
-        },
-    );
-    let _c = language_registry.register_fake_lsp_adapter(
-        "tsx",
-        FakeLspAdapter {
-            name: language_server_names[3],
-            capabilities: lsp::ServerCapabilities {
-                hover_provider: None,
-                ..lsp::ServerCapabilities::default()
+        ),
+        language_registry.register_fake_lsp(
+            "tsx",
+            FakeLspAdapter {
+                name: language_server_names[3],
+                capabilities: lsp::ServerCapabilities {
+                    hover_provider: None,
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
             },
-            ..FakeLspAdapter::default()
-        },
-    );
+        ),
+    ];
 
     let buffer = project
         .update(cx, |p, cx| p.open_local_buffer("/dir/a.tsx", cx))
@@ -4749,7 +4753,7 @@ async fn test_multiple_language_server_hovers(cx: &mut gpui::TestAppContext) {
 
     let mut servers_with_hover_requests = HashMap::default();
     for i in 0..language_server_names.len() {
-        let new_server = fake_tsx_language_servers.next().await.unwrap_or_else(|| {
+        let new_server = language_servers[i].next().await.unwrap_or_else(|| {
             panic!(
                 "Failed to get language server #{i} with name {}",
                 &language_server_names[i]
@@ -4840,7 +4844,7 @@ async fn test_hovers_with_empty_parts(cx: &mut gpui::TestAppContext) {
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(typescript_lang());
-    let mut fake_language_servers = language_registry.register_fake_lsp_adapter(
+    let mut fake_language_servers = language_registry.register_fake_lsp(
         "TypeScript",
         FakeLspAdapter {
             capabilities: lsp::ServerCapabilities {
@@ -4916,50 +4920,53 @@ async fn test_multiple_language_server_actions(cx: &mut gpui::TestAppContext) {
         "ESLintServer",
         "NoActionsCapabilitiesServer",
     ];
-    let mut fake_tsx_language_servers = language_registry.register_fake_lsp_adapter(
-        "tsx",
-        FakeLspAdapter {
-            name: language_server_names[0],
-            capabilities: lsp::ServerCapabilities {
-                code_action_provider: Some(lsp::CodeActionProviderCapability::Simple(true)),
-                ..lsp::ServerCapabilities::default()
+
+    let mut language_server_rxs = [
+        language_registry.register_fake_lsp(
+            "tsx",
+            FakeLspAdapter {
+                name: language_server_names[0],
+                capabilities: lsp::ServerCapabilities {
+                    code_action_provider: Some(lsp::CodeActionProviderCapability::Simple(true)),
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
             },
-            ..FakeLspAdapter::default()
-        },
-    );
-    let _a = language_registry.register_fake_lsp_adapter(
-        "tsx",
-        FakeLspAdapter {
-            name: language_server_names[1],
-            capabilities: lsp::ServerCapabilities {
-                code_action_provider: Some(lsp::CodeActionProviderCapability::Simple(true)),
-                ..lsp::ServerCapabilities::default()
+        ),
+        language_registry.register_fake_lsp(
+            "tsx",
+            FakeLspAdapter {
+                name: language_server_names[1],
+                capabilities: lsp::ServerCapabilities {
+                    code_action_provider: Some(lsp::CodeActionProviderCapability::Simple(true)),
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
             },
-            ..FakeLspAdapter::default()
-        },
-    );
-    let _b = language_registry.register_fake_lsp_adapter(
-        "tsx",
-        FakeLspAdapter {
-            name: language_server_names[2],
-            capabilities: lsp::ServerCapabilities {
-                code_action_provider: Some(lsp::CodeActionProviderCapability::Simple(true)),
-                ..lsp::ServerCapabilities::default()
+        ),
+        language_registry.register_fake_lsp(
+            "tsx",
+            FakeLspAdapter {
+                name: language_server_names[2],
+                capabilities: lsp::ServerCapabilities {
+                    code_action_provider: Some(lsp::CodeActionProviderCapability::Simple(true)),
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
             },
-            ..FakeLspAdapter::default()
-        },
-    );
-    let _c = language_registry.register_fake_lsp_adapter(
-        "tsx",
-        FakeLspAdapter {
-            name: language_server_names[3],
-            capabilities: lsp::ServerCapabilities {
-                code_action_provider: None,
-                ..lsp::ServerCapabilities::default()
+        ),
+        language_registry.register_fake_lsp(
+            "tsx",
+            FakeLspAdapter {
+                name: language_server_names[3],
+                capabilities: lsp::ServerCapabilities {
+                    code_action_provider: None,
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
             },
-            ..FakeLspAdapter::default()
-        },
-    );
+        ),
+    ];
 
     let buffer = project
         .update(cx, |p, cx| p.open_local_buffer("/dir/a.tsx", cx))
@@ -4969,13 +4976,14 @@ async fn test_multiple_language_server_actions(cx: &mut gpui::TestAppContext) {
 
     let mut servers_with_actions_requests = HashMap::default();
     for i in 0..language_server_names.len() {
-        let new_server = fake_tsx_language_servers.next().await.unwrap_or_else(|| {
+        let new_server = language_server_rxs[i].next().await.unwrap_or_else(|| {
             panic!(
                 "Failed to get language server #{i} with name {}",
                 &language_server_names[i]
             )
         });
         let new_server_name = new_server.server.name();
+
         assert!(
             !servers_with_actions_requests.contains_key(new_server_name),
             "Unexpected: initialized server with the same name twice. Name: `{new_server_name}`"
@@ -5023,6 +5031,8 @@ async fn test_multiple_language_server_actions(cx: &mut gpui::TestAppContext) {
     let code_actions_task = project.update(cx, |project, cx| {
         project.code_actions(&buffer, 0..buffer.read(cx).len(), cx)
     });
+
+    // cx.run_until_parked();
     let _: Vec<()> = futures::future::join_all(servers_with_actions_requests.into_values().map(
         |mut code_actions_request| async move {
             code_actions_request
diff --git a/crates/project_symbols/src/project_symbols.rs b/crates/project_symbols/src/project_symbols.rs
index 0cb7ef6c712666..80cf90bf9e072b 100644
--- a/crates/project_symbols/src/project_symbols.rs
+++ b/crates/project_symbols/src/project_symbols.rs
@@ -288,7 +288,7 @@ mod tests {
             None,
         )));
         let mut fake_servers =
-            language_registry.register_fake_lsp_adapter("Rust", FakeLspAdapter::default());
+            language_registry.register_fake_lsp("Rust", FakeLspAdapter::default());
 
         let _buffer = project
             .update(cx, |project, cx| {
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index f59e8146b6f18c..a10b3798a42532 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -497,6 +497,7 @@ message ShareProject {
     uint64 room_id = 1;
     repeated WorktreeMetadata worktrees = 2;
     optional uint64 dev_server_project_id = 3;
+    bool is_ssh_project = 4;
 }
 
 message ShareProjectResponse {
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index 9e9a3fdc42418a..ad5ffbcbfaa4ef 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -46,7 +46,9 @@ gpui = { workspace = true, features = ["test-support"] }
 http_client = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }
 node_runtime = { workspace = true, features = ["test-support"] }
+project = { workspace = true, features = ["test-support"] }
 remote = { workspace = true, features = ["test-support"] }
+lsp = { workspace = true, features=["test-support"] }
 
 serde_json.workspace = true
 
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 08723daa01d063..d85e3a184d5712 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -1,10 +1,13 @@
 use anyhow::{anyhow, Result};
 use fs::Fs;
 use gpui::{AppContext, AsyncAppContext, Context, Model, ModelContext};
-use language::LanguageRegistry;
+use language::{proto::serialize_operation, Buffer, BufferEvent, LanguageRegistry};
 use project::{
-    buffer_store::BufferStore, project_settings::SettingsObserver, search::SearchQuery,
-    worktree_store::WorktreeStore, LspStore, ProjectPath, WorktreeId,
+    buffer_store::{BufferStore, BufferStoreEvent},
+    project_settings::SettingsObserver,
+    search::SearchQuery,
+    worktree_store::WorktreeStore,
+    LspStore, ProjectPath, WorktreeId,
 };
 use remote::SshSession;
 use rpc::{
@@ -26,6 +29,7 @@ pub struct HeadlessProject {
     pub lsp_store: Model<LspStore>,
     pub settings_observer: Model<SettingsObserver>,
     pub next_entry_id: Arc<AtomicUsize>,
+    pub languages: Arc<LanguageRegistry>,
 }
 
 impl HeadlessProject {
@@ -60,7 +64,7 @@ impl HeadlessProject {
                 buffer_store.clone(),
                 worktree_store.clone(),
                 environment,
-                languages,
+                languages.clone(),
                 None,
                 fs.clone(),
                 cx,
@@ -69,6 +73,17 @@ impl HeadlessProject {
             lsp_store
         });
 
+        cx.subscribe(
+            &buffer_store,
+            |_this, _buffer_store, event, cx| match event {
+                BufferStoreEvent::BufferAdded(buffer) => {
+                    cx.subscribe(buffer, Self::on_buffer_event).detach();
+                }
+                _ => {}
+            },
+        )
+        .detach();
+
         let client: AnyProtoClient = session.clone().into();
 
         session.subscribe_to_entity(SSH_PROJECT_ID, &worktree_store);
@@ -103,6 +118,26 @@ impl HeadlessProject {
             buffer_store,
             lsp_store,
             next_entry_id: Default::default(),
+            languages,
+        }
+    }
+
+    fn on_buffer_event(
+        &mut self,
+        buffer: Model<Buffer>,
+        event: &BufferEvent,
+        cx: &mut ModelContext<Self>,
+    ) {
+        match event {
+            BufferEvent::Operation(op) => cx
+                .background_executor()
+                .spawn(self.session.request(proto::UpdateBuffer {
+                    project_id: SSH_PROJECT_ID,
+                    buffer_id: buffer.read(cx).remote_id().to_proto(),
+                    operations: vec![serialize_operation(op)],
+                }))
+                .detach(),
+            _ => {}
         }
     }
 
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 67a2f0b57d8cba..b7fc56d3c60262 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -6,8 +6,9 @@ use gpui::{Context, Model, TestAppContext};
 use http_client::FakeHttpClient;
 use language::{
     language_settings::{all_language_settings, AllLanguageSettings},
-    Buffer, FakeLspAdapter, LanguageConfig, LanguageMatcher, LanguageRegistry,
+    Buffer, FakeLspAdapter, LanguageConfig, LanguageMatcher, LanguageRegistry, LanguageServerName,
 };
+use lsp::{CompletionContext, CompletionResponse, CompletionTriggerKind};
 use node_runtime::FakeNodeRuntime;
 use project::{
     search::{SearchQuery, SearchResult},
@@ -317,6 +318,15 @@ async fn test_remote_lsp(cx: &mut TestAppContext, server_cx: &mut TestAppContext
             },
         )
     });
+
+    let mut fake_lsp = server_cx.update(|cx| {
+        headless.read(cx).languages.register_fake_language_server(
+            LanguageServerName("rust-analyzer".into()),
+            Default::default(),
+            None,
+        )
+    });
+
     cx.run_until_parked();
 
     let worktree_id = project
@@ -339,6 +349,8 @@ async fn test_remote_lsp(cx: &mut TestAppContext, server_cx: &mut TestAppContext
         .unwrap();
     cx.run_until_parked();
 
+    let fake_lsp = fake_lsp.next().await.unwrap();
+
     cx.read(|cx| {
         let file = buffer.read(cx).file();
         assert_eq!(
@@ -370,6 +382,62 @@ async fn test_remote_lsp(cx: &mut TestAppContext, server_cx: &mut TestAppContext
         let lsp_store = headless.read(cx).lsp_store.read(cx);
         assert_eq!(lsp_store.as_local().unwrap().language_servers.len(), 1);
     });
+
+    fake_lsp.handle_request::<lsp::request::Completion, _, _>(|_, _| async move {
+        Ok(Some(CompletionResponse::Array(vec![lsp::CompletionItem {
+            label: "boop".to_string(),
+            ..Default::default()
+        }])))
+    });
+
+    let result = project
+        .update(cx, |project, cx| {
+            project.completions(
+                &buffer,
+                0,
+                CompletionContext {
+                    trigger_kind: CompletionTriggerKind::INVOKED,
+                    trigger_character: None,
+                },
+                cx,
+            )
+        })
+        .await
+        .unwrap();
+
+    assert_eq!(
+        result.into_iter().map(|c| c.label.text).collect::<Vec<_>>(),
+        vec!["boop".to_string()]
+    );
+
+    fake_lsp.handle_request::<lsp::request::Rename, _, _>(|_, _| async move {
+        Ok(Some(lsp::WorkspaceEdit {
+            changes: Some(
+                [(
+                    lsp::Url::from_file_path("/code/project1/src/lib.rs").unwrap(),
+                    vec![lsp::TextEdit::new(
+                        lsp::Range::new(lsp::Position::new(0, 3), lsp::Position::new(0, 6)),
+                        "two".to_string(),
+                    )],
+                )]
+                .into_iter()
+                .collect(),
+            ),
+            ..Default::default()
+        }))
+    });
+
+    project
+        .update(cx, |project, cx| {
+            project.perform_rename(buffer.clone(), 3, "two".to_string(), true, cx)
+        })
+        .await
+        .unwrap();
+
+    cx.run_until_parked();
+    buffer.update(cx, |buffer, _| {
+        assert_eq!(buffer.text(), "fn two() -> usize { 1 }")
+    })
 }
 
 fn init_logger() {

From 67f149a4bcbd3decc9a6c68a35ae3137095580a1 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 16 Sep 2024 18:47:25 -0400
Subject: [PATCH 108/762] Ollama: Specify keep_alive via settings (#17906)

---
 crates/language_model/src/provider/ollama.rs | 6 ++++--
 docs/src/assistant/configuration.md          | 2 ++
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/crates/language_model/src/provider/ollama.rs b/crates/language_model/src/provider/ollama.rs
index cfcca1fb7aa330..6a3190dee7c229 100644
--- a/crates/language_model/src/provider/ollama.rs
+++ b/crates/language_model/src/provider/ollama.rs
@@ -4,7 +4,7 @@ use gpui::{AnyView, AppContext, AsyncAppContext, ModelContext, Subscription, Tas
 use http_client::HttpClient;
 use ollama::{
     get_models, preload_model, stream_chat_completion, ChatMessage, ChatOptions, ChatRequest,
-    ChatResponseDelta, OllamaToolCall,
+    ChatResponseDelta, KeepAlive, OllamaToolCall,
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -42,6 +42,8 @@ pub struct AvailableModel {
     pub display_name: Option<String>,
     /// The Context Length parameter to the model (aka num_ctx or n_ctx)
     pub max_tokens: usize,
+    /// The number of seconds to keep the connection open after the last request
+    pub keep_alive: Option<KeepAlive>,
 }
 
 pub struct OllamaLanguageModelProvider {
@@ -156,7 +158,7 @@ impl LanguageModelProvider for OllamaLanguageModelProvider {
                     name: model.name.clone(),
                     display_name: model.display_name.clone(),
                     max_tokens: model.max_tokens,
-                    keep_alive: None,
+                    keep_alive: model.keep_alive.clone(),
                 },
             );
         }
diff --git a/docs/src/assistant/configuration.md b/docs/src/assistant/configuration.md
index 4d9870e8960a0a..bcdf461e2c3697 100644
--- a/docs/src/assistant/configuration.md
+++ b/docs/src/assistant/configuration.md
@@ -152,6 +152,8 @@ Depending on your hardware or use-case you may wish to limit or increase the con
 
 If you specify a context length that is too large for your hardware, Ollama will log an error. You can watch these logs by running: `tail -f ~/.ollama/logs/ollama.log` (MacOS) or `journalctl -u ollama -f` (Linux). Depending on the memory available on your machine, you may need to adjust the context length to a smaller value.
 
+You may also optionally specify a value for `keep_alive` for each available model. This can be an integer (seconds) or alternately a string duration like "5m", "10m", "1h", "1d", etc., For example `"keep_alive": "120s"` will allow the remote server to unload the model (freeing up GPU VRAM) after 120seconds.
+
 ### OpenAI {#openai}
 
 1. Visit the OpenAI platform and [create an API key](https://platform.openai.com/account/api-keys)

From 243629cce8a3681315b9d674eaa4cad3fdabc210 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Mon, 16 Sep 2024 15:50:12 -0700
Subject: [PATCH 109/762] Fix keystroke observer leak in vim crate (#17913)

Release Notes:

- Fixed a performance problem that happened when using vim mode after
opening and closing many editors

Co-authored-by: Antonio <antonio@zed.dev>
Co-authored-by: Nathan <nathan@zed.dev>
---
 crates/gpui/src/app.rs    | 14 +++++++--
 crates/gpui/src/window.rs | 54 +++++++++++++++++++++++++++--------
 crates/vim/src/vim.rs     | 60 +++++++++++++++++++--------------------
 3 files changed, 82 insertions(+), 46 deletions(-)

diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index 564b8934897734..ee7a6ef191a6e2 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -204,7 +204,8 @@ impl App {
 
 type Handler = Box<dyn FnMut(&mut AppContext) -> bool + 'static>;
 type Listener = Box<dyn FnMut(&dyn Any, &mut AppContext) -> bool + 'static>;
-type KeystrokeObserver = Box<dyn FnMut(&KeystrokeEvent, &mut WindowContext) + 'static>;
+pub(crate) type KeystrokeObserver =
+    Box<dyn FnMut(&KeystrokeEvent, &mut WindowContext) -> bool + 'static>;
 type QuitHandler = Box<dyn FnOnce(&mut AppContext) -> LocalBoxFuture<'static, ()> + 'static>;
 type ReleaseListener = Box<dyn FnOnce(&mut dyn Any, &mut AppContext) + 'static>;
 type NewViewListener = Box<dyn FnMut(AnyView, &mut WindowContext) + 'static>;
@@ -1050,7 +1051,7 @@ impl AppContext {
     /// and that this API will not be invoked if the event's propagation is stopped.
     pub fn observe_keystrokes(
         &mut self,
-        f: impl FnMut(&KeystrokeEvent, &mut WindowContext) + 'static,
+        mut f: impl FnMut(&KeystrokeEvent, &mut WindowContext) + 'static,
     ) -> Subscription {
         fn inner(
             keystroke_observers: &mut SubscriberSet<(), KeystrokeObserver>,
@@ -1060,7 +1061,14 @@ impl AppContext {
             activate();
             subscription
         }
-        inner(&mut self.keystroke_observers, Box::new(f))
+
+        inner(
+            &mut self.keystroke_observers,
+            Box::new(move |event, cx| {
+                f(event, cx);
+                true
+            }),
+        )
     }
 
     /// Register key bindings.
diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs
index dce136bddddb53..57066b0ce64c5e 100644
--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -4,16 +4,17 @@ use crate::{
     Context, Corners, CursorStyle, Decorations, DevicePixels, DispatchActionListener,
     DispatchNodeId, DispatchTree, DisplayId, Edges, Effect, Entity, EntityId, EventEmitter,
     FileDropEvent, Flatten, FontId, GPUSpecs, Global, GlobalElementId, GlyphId, Hsla, InputHandler,
-    IsZero, KeyBinding, KeyContext, KeyDownEvent, KeyEvent, Keystroke, KeystrokeEvent, LayoutId,
-    LineLayoutIndex, Model, ModelContext, Modifiers, ModifiersChangedEvent, MonochromeSprite,
-    MouseButton, MouseEvent, MouseMoveEvent, MouseUpEvent, Path, Pixels, PlatformAtlas,
-    PlatformDisplay, PlatformInput, PlatformInputHandler, PlatformWindow, Point, PolychromeSprite,
-    PromptLevel, Quad, Render, RenderGlyphParams, RenderImage, RenderImageParams, RenderSvgParams,
-    Replay, ResizeEdge, ScaledPixels, Scene, Shadow, SharedString, Size, StrikethroughStyle, Style,
-    SubscriberSet, Subscription, TaffyLayoutEngine, Task, TextStyle, TextStyleRefinement,
-    TransformationMatrix, Underline, UnderlineStyle, View, VisualContext, WeakView,
-    WindowAppearance, WindowBackgroundAppearance, WindowBounds, WindowControls, WindowDecorations,
-    WindowOptions, WindowParams, WindowTextSystem, SUBPIXEL_VARIANTS,
+    IsZero, KeyBinding, KeyContext, KeyDownEvent, KeyEvent, Keystroke, KeystrokeEvent,
+    KeystrokeObserver, LayoutId, LineLayoutIndex, Model, ModelContext, Modifiers,
+    ModifiersChangedEvent, MonochromeSprite, MouseButton, MouseEvent, MouseMoveEvent, MouseUpEvent,
+    Path, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput, PlatformInputHandler,
+    PlatformWindow, Point, PolychromeSprite, PromptLevel, Quad, Render, RenderGlyphParams,
+    RenderImage, RenderImageParams, RenderSvgParams, Replay, ResizeEdge, ScaledPixels, Scene,
+    Shadow, SharedString, Size, StrikethroughStyle, Style, SubscriberSet, Subscription,
+    TaffyLayoutEngine, Task, TextStyle, TextStyleRefinement, TransformationMatrix, Underline,
+    UnderlineStyle, View, VisualContext, WeakView, WindowAppearance, WindowBackgroundAppearance,
+    WindowBounds, WindowControls, WindowDecorations, WindowOptions, WindowParams, WindowTextSystem,
+    SUBPIXEL_VARIANTS,
 };
 use anyhow::{anyhow, Context as _, Result};
 use collections::{FxHashMap, FxHashSet};
@@ -1043,8 +1044,7 @@ impl<'a> WindowContext<'a> {
                         action: action.as_ref().map(|action| action.boxed_clone()),
                     },
                     self,
-                );
-                true
+                )
             });
     }
 
@@ -4250,6 +4250,36 @@ impl<'a, V: 'static> ViewContext<'a, V> {
         subscription
     }
 
+    /// Register a callback to be invoked when a keystroke is received by the application
+    /// in any window. Note that this fires after all other action and event mechanisms have resolved
+    /// and that this API will not be invoked if the event's propagation is stopped.
+    pub fn observe_keystrokes(
+        &mut self,
+        mut f: impl FnMut(&mut V, &KeystrokeEvent, &mut ViewContext<V>) + 'static,
+    ) -> Subscription {
+        fn inner(
+            keystroke_observers: &mut SubscriberSet<(), KeystrokeObserver>,
+            handler: KeystrokeObserver,
+        ) -> Subscription {
+            let (subscription, activate) = keystroke_observers.insert((), handler);
+            activate();
+            subscription
+        }
+
+        let view = self.view.downgrade();
+        inner(
+            &mut self.keystroke_observers,
+            Box::new(move |event, cx| {
+                if let Some(view) = view.upgrade() {
+                    view.update(cx, |view, cx| f(view, event, cx));
+                    true
+                } else {
+                    false
+                }
+            }),
+        )
+    }
+
     /// Register a callback to be invoked when the window's pending input changes.
     pub fn observe_pending_input(
         &mut self,
diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs
index 6e03374c22595e..fc5097d8451282 100644
--- a/crates/vim/src/vim.rs
+++ b/crates/vim/src/vim.rs
@@ -24,7 +24,7 @@ use editor::{
 };
 use gpui::{
     actions, impl_actions, Action, AppContext, Entity, EventEmitter, KeyContext, KeystrokeEvent,
-    Render, View, ViewContext, WeakView,
+    Render, Subscription, View, ViewContext, WeakView,
 };
 use insert::NormalBefore;
 use language::{CursorShape, Point, Selection, SelectionGoal, TransactionId};
@@ -166,6 +166,8 @@ pub(crate) struct Vim {
     pub search: SearchState,
 
     editor: WeakView<Editor>,
+
+    _subscriptions: Vec<Subscription>,
 }
 
 // Hack: Vim intercepts events dispatched to a window and updates the view in response.
@@ -189,36 +191,32 @@ impl Vim {
     pub fn new(cx: &mut ViewContext<Editor>) -> View<Self> {
         let editor = cx.view().clone();
 
-        cx.new_view(|cx: &mut ViewContext<Vim>| {
-            cx.subscribe(&editor, |vim, _, event, cx| {
-                vim.handle_editor_event(event, cx)
-            })
-            .detach();
-
-            let listener = cx.listener(Vim::observe_keystrokes);
-            cx.observe_keystrokes(listener).detach();
-
-            Vim {
-                mode: Mode::Normal,
-                last_mode: Mode::Normal,
-                pre_count: None,
-                post_count: None,
-                operator_stack: Vec::new(),
-                replacements: Vec::new(),
-
-                marks: HashMap::default(),
-                stored_visual_mode: None,
-                change_list: Vec::new(),
-                change_list_position: None,
-                current_tx: None,
-                current_anchor: None,
-                undo_modes: HashMap::default(),
-
-                selected_register: None,
-                search: SearchState::default(),
-
-                editor: editor.downgrade(),
-            }
+        cx.new_view(|cx| Vim {
+            mode: Mode::Normal,
+            last_mode: Mode::Normal,
+            pre_count: None,
+            post_count: None,
+            operator_stack: Vec::new(),
+            replacements: Vec::new(),
+
+            marks: HashMap::default(),
+            stored_visual_mode: None,
+            change_list: Vec::new(),
+            change_list_position: None,
+            current_tx: None,
+            current_anchor: None,
+            undo_modes: HashMap::default(),
+
+            selected_register: None,
+            search: SearchState::default(),
+
+            editor: editor.downgrade(),
+            _subscriptions: vec![
+                cx.observe_keystrokes(Self::observe_keystrokes),
+                cx.subscribe(&editor, |this, _, event, cx| {
+                    this.handle_editor_event(event, cx)
+                }),
+            ],
         })
     }
 

From e7d18ef359608bca4ddb8ca1320ec947b3f1dd9d Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Mon, 16 Sep 2024 17:05:26 -0600
Subject: [PATCH 110/762] See language server status on remote (#17912)

Release Notes:

- ssh-remoting: Show LSP status in status bar

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 Cargo.lock                                   |  1 +
 crates/project/src/lsp_store.rs              | 12 +++++++++
 crates/project/src/project.rs                | 21 ---------------
 crates/remote_server/Cargo.toml              |  1 +
 crates/remote_server/src/headless_project.rs | 28 +++++++++++++++++++-
 5 files changed, 41 insertions(+), 22 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0ce1c9bd970c57..59d2c6847ea786 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9069,6 +9069,7 @@ dependencies = [
  "shellexpand 2.1.2",
  "smol",
  "toml 0.8.19",
+ "util",
  "worktree",
 ]
 
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index cea10094a97b27..ee02492dd8cfda 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -3314,6 +3314,12 @@ impl LspStore {
         }
 
         cx.emit(LspStoreEvent::DiskBasedDiagnosticsStarted { language_server_id });
+        cx.emit(LspStoreEvent::LanguageServerUpdate {
+            language_server_id,
+            message: proto::update_language_server::Variant::DiskBasedDiagnosticsUpdating(
+                Default::default(),
+            ),
+        })
     }
 
     pub fn disk_based_diagnostics_finished(
@@ -3328,6 +3334,12 @@ impl LspStore {
         }
 
         cx.emit(LspStoreEvent::DiskBasedDiagnosticsFinished { language_server_id });
+        cx.emit(LspStoreEvent::LanguageServerUpdate {
+            language_server_id,
+            message: proto::update_language_server::Variant::DiskBasedDiagnosticsUpdated(
+                Default::default(),
+            ),
+        })
     }
 
     // After saving a buffer using a language server that doesn't provide a disk-based progress token,
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 9185670b05c23f..14524180ab556d 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -2188,32 +2188,11 @@ impl Project {
                 cx.emit(Event::DiskBasedDiagnosticsStarted {
                     language_server_id: *language_server_id,
                 });
-                if self.is_local_or_ssh() {
-                    self.enqueue_buffer_ordered_message(BufferOrderedMessage::LanguageServerUpdate {
-                        language_server_id: *language_server_id,
-                        message: proto::update_language_server::Variant::DiskBasedDiagnosticsUpdating(
-                            Default::default(),
-                        ),
-                    })
-                    .ok();
-                }
             }
             LspStoreEvent::DiskBasedDiagnosticsFinished { language_server_id } => {
                 cx.emit(Event::DiskBasedDiagnosticsFinished {
                     language_server_id: *language_server_id,
                 });
-                if self.is_local_or_ssh() {
-                    self.enqueue_buffer_ordered_message(
-                        BufferOrderedMessage::LanguageServerUpdate {
-                            language_server_id: *language_server_id,
-                            message:
-                                proto::update_language_server::Variant::DiskBasedDiagnosticsUpdated(
-                                    Default::default(),
-                                ),
-                        },
-                    )
-                    .ok();
-                }
             }
             LspStoreEvent::LanguageServerUpdate {
                 language_server_id,
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index ad5ffbcbfaa4ef..f5efa21bd0fb6a 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -37,6 +37,7 @@ shellexpand.workspace = true
 smol.workspace = true
 worktree.workspace = true
 language.workspace = true
+util.workspace = true
 
 [dev-dependencies]
 client = { workspace = true, features = ["test-support"] }
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index d85e3a184d5712..58f5cb0c203cf1 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -7,7 +7,7 @@ use project::{
     project_settings::SettingsObserver,
     search::SearchQuery,
     worktree_store::WorktreeStore,
-    LspStore, ProjectPath, WorktreeId,
+    LspStore, LspStoreEvent, ProjectPath, WorktreeId,
 };
 use remote::SshSession;
 use rpc::{
@@ -19,6 +19,7 @@ use std::{
     path::{Path, PathBuf},
     sync::{atomic::AtomicUsize, Arc},
 };
+use util::ResultExt;
 use worktree::Worktree;
 
 pub struct HeadlessProject {
@@ -73,6 +74,8 @@ impl HeadlessProject {
             lsp_store
         });
 
+        cx.subscribe(&lsp_store, Self::on_lsp_store_event).detach();
+
         cx.subscribe(
             &buffer_store,
             |_this, _buffer_store, event, cx| match event {
@@ -141,6 +144,29 @@ impl HeadlessProject {
         }
     }
 
+    fn on_lsp_store_event(
+        &mut self,
+        _lsp_store: Model<LspStore>,
+        event: &LspStoreEvent,
+        _cx: &mut ModelContext<Self>,
+    ) {
+        match event {
+            LspStoreEvent::LanguageServerUpdate {
+                language_server_id,
+                message,
+            } => {
+                self.session
+                    .send(proto::UpdateLanguageServer {
+                        project_id: SSH_PROJECT_ID,
+                        language_server_id: language_server_id.to_proto(),
+                        variant: Some(message.clone()),
+                    })
+                    .log_err();
+            }
+            _ => {}
+        }
+    }
+
     pub async fn handle_add_worktree(
         this: Model<Self>,
         message: TypedEnvelope<proto::AddWorktree>,

From b54b3d6246e4fe94d1fb6fcdbceacae20d86e757 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 16 Sep 2024 19:58:22 -0400
Subject: [PATCH 111/762] editor: Add rewrap command (#17909)

This PR adds a rewrap command to the editor.

Executing this command will rewrap the text in the selection to the
maximum line width:


https://github.com/user-attachments/assets/69aa9428-17fd-4315-89f1-f354d0f5f459

If there isn't an active selection, the selection will be expanded to
contiguous text from the cursor's location.

Rewrapping only works in Markdown, Plain Text, and within comments for
any other language.

Release Notes:

- Added an `editor: rewrap` command for rewrapping text to the maximum
line width.

---------

Co-authored-by: Antonio Scandurra <me@as-cii.com>
Co-authored-by: Bennet <bennet@zed.dev>
---
 Cargo.lock                        |   1 +
 crates/editor/Cargo.toml          |   1 +
 crates/editor/src/actions.rs      |   1 +
 crates/editor/src/editor.rs       | 156 +++++++++++++++++++
 crates/editor/src/editor_tests.rs | 239 ++++++++++++++++++++++++++++++
 crates/editor/src/element.rs      |   1 +
 6 files changed, 399 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 59d2c6847ea786..2d5ef55ebc173c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3708,6 +3708,7 @@ dependencies = [
  "serde",
  "serde_json",
  "settings",
+ "similar",
  "smallvec",
  "smol",
  "snippet",
diff --git a/crates/editor/Cargo.toml b/crates/editor/Cargo.toml
index b1cc59ace60322..b6b22ef64d33f6 100644
--- a/crates/editor/Cargo.toml
+++ b/crates/editor/Cargo.toml
@@ -61,6 +61,7 @@ schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
+similar.workspace = true
 smallvec.workspace = true
 smol.workspace = true
 snippet.workspace = true
diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs
index 319286d252d793..5811ec7b921d2f 100644
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -284,6 +284,7 @@ gpui::actions!(
         Redo,
         RedoSelection,
         Rename,
+        Rewrap,
         RestartLanguageServer,
         RevealInFileManager,
         ReverseLines,
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 515cde1908abb5..8d17e9cfbd3f8f 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -98,6 +98,7 @@ use language::{
 };
 use language::{point_to_lsp, BufferRow, CharClassifier, Runnable, RunnableRange};
 use linked_editing_ranges::refresh_linked_ranges;
+use similar::{ChangeTag, TextDiff};
 use task::{ResolvedTask, TaskTemplate, TaskVariables};
 
 use hover_links::{find_file, HoverLink, HoveredLinkState, InlayHighlight};
@@ -6659,6 +6660,161 @@ impl Editor {
         });
     }
 
+    pub fn rewrap(&mut self, _: &Rewrap, cx: &mut ViewContext<Self>) {
+        let buffer = self.buffer.read(cx).snapshot(cx);
+        let selections = self.selections.all::<Point>(cx);
+        let mut selections = selections.iter().peekable();
+
+        let mut edits = Vec::new();
+        let mut rewrapped_row_ranges = Vec::<RangeInclusive<u32>>::new();
+
+        while let Some(selection) = selections.next() {
+            let mut start_row = selection.start.row;
+            let mut end_row = selection.end.row;
+
+            // Skip selections that overlap with a range that has already been rewrapped.
+            let selection_range = start_row..end_row;
+            if rewrapped_row_ranges
+                .iter()
+                .any(|range| range.overlaps(&selection_range))
+            {
+                continue;
+            }
+
+            let mut should_rewrap = false;
+
+            if let Some(language_scope) = buffer.language_scope_at(selection.head()) {
+                match language_scope.language_name().0.as_ref() {
+                    "Markdown" | "Plain Text" => {
+                        should_rewrap = true;
+                    }
+                    _ => {}
+                }
+            }
+
+            let row = selection.head().row;
+            let indent_size = buffer.indent_size_for_line(MultiBufferRow(row));
+            let indent_end = Point::new(row, indent_size.len);
+
+            let mut line_prefix = indent_size.chars().collect::<String>();
+
+            if selection.is_empty() {
+                if let Some(comment_prefix) =
+                    buffer
+                        .language_scope_at(selection.head())
+                        .and_then(|language| {
+                            language
+                                .line_comment_prefixes()
+                                .iter()
+                                .find(|prefix| buffer.contains_str_at(indent_end, prefix))
+                                .cloned()
+                        })
+                {
+                    line_prefix.push_str(&comment_prefix);
+                    should_rewrap = true;
+                }
+
+                'expand_upwards: while start_row > 0 {
+                    let prev_row = start_row - 1;
+                    if buffer.contains_str_at(Point::new(prev_row, 0), &line_prefix)
+                        && buffer.line_len(MultiBufferRow(prev_row)) as usize > line_prefix.len()
+                    {
+                        start_row = prev_row;
+                    } else {
+                        break 'expand_upwards;
+                    }
+                }
+
+                'expand_downwards: while end_row < buffer.max_point().row {
+                    let next_row = end_row + 1;
+                    if buffer.contains_str_at(Point::new(next_row, 0), &line_prefix)
+                        && buffer.line_len(MultiBufferRow(next_row)) as usize > line_prefix.len()
+                    {
+                        end_row = next_row;
+                    } else {
+                        break 'expand_downwards;
+                    }
+                }
+            }
+
+            if !should_rewrap {
+                continue;
+            }
+
+            let start = Point::new(start_row, 0);
+            let end = Point::new(end_row, buffer.line_len(MultiBufferRow(end_row)));
+            let selection_text = buffer.text_for_range(start..end).collect::<String>();
+            let unwrapped_text = selection_text
+                .lines()
+                .map(|line| line.strip_prefix(&line_prefix).unwrap())
+                .join(" ");
+            let wrap_column = buffer
+                .settings_at(Point::new(start_row, 0), cx)
+                .preferred_line_length as usize;
+            let mut wrapped_text = String::new();
+            let mut current_line = line_prefix.clone();
+            for word in unwrapped_text.split_whitespace() {
+                if current_line.len() + word.len() >= wrap_column {
+                    wrapped_text.push_str(&current_line);
+                    wrapped_text.push('\n');
+                    current_line.truncate(line_prefix.len());
+                }
+
+                if current_line.len() > line_prefix.len() {
+                    current_line.push(' ');
+                }
+
+                current_line.push_str(word);
+            }
+
+            if !current_line.is_empty() {
+                wrapped_text.push_str(&current_line);
+            }
+
+            let diff = TextDiff::from_lines(&selection_text, &wrapped_text);
+            let mut offset = start.to_offset(&buffer);
+            let mut moved_since_edit = true;
+
+            for change in diff.iter_all_changes() {
+                let value = change.value();
+                match change.tag() {
+                    ChangeTag::Equal => {
+                        offset += value.len();
+                        moved_since_edit = true;
+                    }
+                    ChangeTag::Delete => {
+                        let start = buffer.anchor_after(offset);
+                        let end = buffer.anchor_before(offset + value.len());
+
+                        if moved_since_edit {
+                            edits.push((start..end, String::new()));
+                        } else {
+                            edits.last_mut().unwrap().0.end = end;
+                        }
+
+                        offset += value.len();
+                        moved_since_edit = false;
+                    }
+                    ChangeTag::Insert => {
+                        if moved_since_edit {
+                            let anchor = buffer.anchor_after(offset);
+                            edits.push((anchor..anchor, value.to_string()));
+                        } else {
+                            edits.last_mut().unwrap().1.push_str(value);
+                        }
+
+                        moved_since_edit = false;
+                    }
+                }
+            }
+
+            rewrapped_row_ranges.push(start_row..=end_row);
+        }
+
+        self.buffer
+            .update(cx, |buffer, cx| buffer.edit(edits, None, cx));
+    }
+
     pub fn cut(&mut self, _: &Cut, cx: &mut ViewContext<Self>) {
         let mut text = String::new();
         let buffer = self.buffer.read(cx).snapshot(cx);
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index b1ae40e6510c66..43b3e2e5e8f080 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -3979,6 +3979,245 @@ fn test_transpose(cx: &mut TestAppContext) {
     });
 }
 
+#[gpui::test]
+async fn test_rewrap(cx: &mut TestAppContext) {
+    init_test(cx, |_| {});
+
+    let mut cx = EditorTestContext::new(cx).await;
+
+    {
+        let language = Arc::new(Language::new(
+            LanguageConfig {
+                line_comments: vec!["// ".into()],
+                ..LanguageConfig::default()
+            },
+            None,
+        ));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
+
+        let unwrapped_text = indoc! {"
+            // ˇLorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus auctor, eu lacinia sapien scelerisque. Vivamus sit amet neque et quam tincidunt hendrerit. Praesent semper egestas tellus id dignissim. Pellentesque odio lectus, iaculis ac volutpat et, blandit quis urna. Sed vestibulum nisi sit amet nisl venenatis tempus. Donec molestie blandit quam, et porta nunc laoreet in. Integer sit amet scelerisque nisi. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras egestas porta metus, eu viverra ipsum efficitur quis. Donec luctus eros turpis, id vulputate turpis porttitor id. Aliquam id accumsan eros.
+        "};
+
+        let wrapped_text = indoc! {"
+            // Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit
+            // purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus
+            // auctor, eu lacinia sapien scelerisque. Vivamus sit amet neque et quam
+            // tincidunt hendrerit. Praesent semper egestas tellus id dignissim.
+            // Pellentesque odio lectus, iaculis ac volutpat et, blandit quis urna. Sed
+            // vestibulum nisi sit amet nisl venenatis tempus. Donec molestie blandit quam,
+            // et porta nunc laoreet in. Integer sit amet scelerisque nisi. Lorem ipsum
+            // dolor sit amet, consectetur adipiscing elit. Cras egestas porta metus, eu
+            // viverra ipsum efficitur quis. Donec luctus eros turpis, id vulputate turpis
+            // porttitor id. Aliquam id accumsan eros.ˇ
+        "};
+
+        cx.set_state(unwrapped_text);
+        cx.update_editor(|e, cx| e.rewrap(&Rewrap, cx));
+        cx.assert_editor_state(wrapped_text);
+    }
+
+    // Test that cursors that expand to the same region are collapsed.
+    {
+        let language = Arc::new(Language::new(
+            LanguageConfig {
+                line_comments: vec!["// ".into()],
+                ..LanguageConfig::default()
+            },
+            None,
+        ));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
+
+        let unwrapped_text = indoc! {"
+            // ˇLorem ipsum dolor sit amet, consectetur adipiscing elit.
+            // ˇVivamus mollis elit purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus auctor, eu lacinia sapien scelerisque.
+            // ˇVivamus sit amet neque et quam tincidunt hendrerit. Praesent semper egestas tellus id dignissim. Pellentesque odio lectus, iaculis ac volutpat et,
+            // ˇblandit quis urna. Sed vestibulum nisi sit amet nisl venenatis tempus. Donec molestie blandit quam, et porta nunc laoreet in. Integer sit amet scelerisque nisi. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras egestas porta metus, eu viverra ipsum efficitur quis. Donec luctus eros turpis, id vulputate turpis porttitor id. Aliquam id accumsan eros.
+        "};
+
+        let wrapped_text = indoc! {"
+            // Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit
+            // purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus
+            // auctor, eu lacinia sapien scelerisque. Vivamus sit amet neque et quam
+            // tincidunt hendrerit. Praesent semper egestas tellus id dignissim.
+            // Pellentesque odio lectus, iaculis ac volutpat et, blandit quis urna. Sed
+            // vestibulum nisi sit amet nisl venenatis tempus. Donec molestie blandit quam,
+            // et porta nunc laoreet in. Integer sit amet scelerisque nisi. Lorem ipsum
+            // dolor sit amet, consectetur adipiscing elit. Cras egestas porta metus, eu
+            // viverra ipsum efficitur quis. Donec luctus eros turpis, id vulputate turpis
+            // porttitor id. Aliquam id accumsan eros.ˇˇˇˇ
+        "};
+
+        cx.set_state(unwrapped_text);
+        cx.update_editor(|e, cx| e.rewrap(&Rewrap, cx));
+        cx.assert_editor_state(wrapped_text);
+    }
+
+    // Test that non-contiguous selections are treated separately.
+    {
+        let language = Arc::new(Language::new(
+            LanguageConfig {
+                line_comments: vec!["// ".into()],
+                ..LanguageConfig::default()
+            },
+            None,
+        ));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
+
+        let unwrapped_text = indoc! {"
+            // ˇLorem ipsum dolor sit amet, consectetur adipiscing elit.
+            // ˇVivamus mollis elit purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus auctor, eu lacinia sapien scelerisque.
+            //
+            // ˇVivamus sit amet neque et quam tincidunt hendrerit. Praesent semper egestas tellus id dignissim. Pellentesque odio lectus, iaculis ac volutpat et,
+            // ˇblandit quis urna. Sed vestibulum nisi sit amet nisl venenatis tempus. Donec molestie blandit quam, et porta nunc laoreet in. Integer sit amet scelerisque nisi. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras egestas porta metus, eu viverra ipsum efficitur quis. Donec luctus eros turpis, id vulputate turpis porttitor id. Aliquam id accumsan eros.
+        "};
+
+        let wrapped_text = indoc! {"
+            // Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit
+            // purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus
+            // auctor, eu lacinia sapien scelerisque.ˇˇ
+            //
+            // Vivamus sit amet neque et quam tincidunt hendrerit. Praesent semper egestas
+            // tellus id dignissim. Pellentesque odio lectus, iaculis ac volutpat et,
+            // blandit quis urna. Sed vestibulum nisi sit amet nisl venenatis tempus. Donec
+            // molestie blandit quam, et porta nunc laoreet in. Integer sit amet scelerisque
+            // nisi. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras egestas
+            // porta metus, eu viverra ipsum efficitur quis. Donec luctus eros turpis, id
+            // vulputate turpis porttitor id. Aliquam id accumsan eros.ˇˇ
+        "};
+
+        cx.set_state(unwrapped_text);
+        cx.update_editor(|e, cx| e.rewrap(&Rewrap, cx));
+        cx.assert_editor_state(wrapped_text);
+    }
+
+    // Test that different comment prefixes are supported.
+    {
+        let language = Arc::new(Language::new(
+            LanguageConfig {
+                line_comments: vec!["# ".into()],
+                ..LanguageConfig::default()
+            },
+            None,
+        ));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
+
+        let unwrapped_text = indoc! {"
+            # ˇLorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus auctor, eu lacinia sapien scelerisque. Vivamus sit amet neque et quam tincidunt hendrerit. Praesent semper egestas tellus id dignissim. Pellentesque odio lectus, iaculis ac volutpat et, blandit quis urna. Sed vestibulum nisi sit amet nisl venenatis tempus. Donec molestie blandit quam, et porta nunc laoreet in. Integer sit amet scelerisque nisi. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras egestas porta metus, eu viverra ipsum efficitur quis. Donec luctus eros turpis, id vulputate turpis porttitor id. Aliquam id accumsan eros.
+        "};
+
+        let wrapped_text = indoc! {"
+            # Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit
+            # purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus auctor,
+            # eu lacinia sapien scelerisque. Vivamus sit amet neque et quam tincidunt
+            # hendrerit. Praesent semper egestas tellus id dignissim. Pellentesque odio
+            # lectus, iaculis ac volutpat et, blandit quis urna. Sed vestibulum nisi sit
+            # amet nisl venenatis tempus. Donec molestie blandit quam, et porta nunc laoreet
+            # in. Integer sit amet scelerisque nisi. Lorem ipsum dolor sit amet, consectetur
+            # adipiscing elit. Cras egestas porta metus, eu viverra ipsum efficitur quis.
+            # Donec luctus eros turpis, id vulputate turpis porttitor id. Aliquam id
+            # accumsan eros.ˇ
+        "};
+
+        cx.set_state(unwrapped_text);
+        cx.update_editor(|e, cx| e.rewrap(&Rewrap, cx));
+        cx.assert_editor_state(wrapped_text);
+    }
+
+    // Test that rewrapping is ignored outside of comments in most languages.
+    {
+        let language = Arc::new(Language::new(
+            LanguageConfig {
+                line_comments: vec!["// ".into(), "/// ".into()],
+                ..LanguageConfig::default()
+            },
+            Some(tree_sitter_rust::language()),
+        ));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
+
+        let unwrapped_text = indoc! {"
+            /// Adds two numbers.
+            /// Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit purus, a ornare lacus gravida vitae.ˇ
+            fn add(a: u32, b: u32) -> u32 {
+                a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + bˇ
+            }
+        "};
+
+        let wrapped_text = indoc! {"
+            /// Adds two numbers. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+            /// Vivamus mollis elit purus, a ornare lacus gravida vitae.ˇ
+            fn add(a: u32, b: u32) -> u32 {
+                a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + b + a + bˇ
+            }
+        "};
+
+        cx.set_state(unwrapped_text);
+        cx.update_editor(|e, cx| e.rewrap(&Rewrap, cx));
+        cx.assert_editor_state(wrapped_text);
+    }
+
+    // Test that rewrapping works in Markdown and Plain Text languages.
+    {
+        let markdown_language = Arc::new(Language::new(
+            LanguageConfig {
+                name: "Markdown".into(),
+                ..LanguageConfig::default()
+            },
+            None,
+        ));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(markdown_language), cx));
+
+        let unwrapped_text = indoc! {"
+            # Hello
+
+            Lorem ipsum dolor sit amet, ˇconsectetur adipiscing elit. Vivamus mollis elit purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus auctor, eu lacinia sapien scelerisque. Vivamus sit amet neque et quam tincidunt hendrerit. Praesent semper egestas tellus id dignissim. Pellentesque odio lectus, iaculis ac volutpat et, blandit quis urna. Sed vestibulum nisi sit amet nisl venenatis tempus. Donec molestie blandit quam, et porta nunc laoreet in. Integer sit amet scelerisque nisi.
+        "};
+
+        let wrapped_text = indoc! {"
+            # Hello
+
+            Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit
+            purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus auctor,
+            eu lacinia sapien scelerisque. Vivamus sit amet neque et quam tincidunt
+            hendrerit. Praesent semper egestas tellus id dignissim. Pellentesque odio
+            lectus, iaculis ac volutpat et, blandit quis urna. Sed vestibulum nisi sit amet
+            nisl venenatis tempus. Donec molestie blandit quam, et porta nunc laoreet in.
+            Integer sit amet scelerisque nisi.ˇ
+        "};
+
+        cx.set_state(unwrapped_text);
+        cx.update_editor(|e, cx| e.rewrap(&Rewrap, cx));
+        cx.assert_editor_state(wrapped_text);
+
+        let plaintext_language = Arc::new(Language::new(
+            LanguageConfig {
+                name: "Plain Text".into(),
+                ..LanguageConfig::default()
+            },
+            None,
+        ));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(plaintext_language), cx));
+
+        let unwrapped_text = indoc! {"
+            Lorem ipsum dolor sit amet, ˇconsectetur adipiscing elit. Vivamus mollis elit purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus auctor, eu lacinia sapien scelerisque. Vivamus sit amet neque et quam tincidunt hendrerit. Praesent semper egestas tellus id dignissim. Pellentesque odio lectus, iaculis ac volutpat et, blandit quis urna. Sed vestibulum nisi sit amet nisl venenatis tempus. Donec molestie blandit quam, et porta nunc laoreet in. Integer sit amet scelerisque nisi.
+        "};
+
+        let wrapped_text = indoc! {"
+            Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit
+            purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus auctor,
+            eu lacinia sapien scelerisque. Vivamus sit amet neque et quam tincidunt
+            hendrerit. Praesent semper egestas tellus id dignissim. Pellentesque odio
+            lectus, iaculis ac volutpat et, blandit quis urna. Sed vestibulum nisi sit amet
+            nisl venenatis tempus. Donec molestie blandit quam, et porta nunc laoreet in.
+            Integer sit amet scelerisque nisi.ˇ
+        "};
+
+        cx.set_state(unwrapped_text);
+        cx.update_editor(|e, cx| e.rewrap(&Rewrap, cx));
+        cx.assert_editor_state(wrapped_text);
+    }
+}
+
 #[gpui::test]
 async fn test_clipboard(cx: &mut gpui::TestAppContext) {
     init_test(cx, |_| {});
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index d4f5c565c27ef0..7e2b3cc63f725e 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -216,6 +216,7 @@ impl EditorElement {
         register_action(view, cx, Editor::move_line_up);
         register_action(view, cx, Editor::move_line_down);
         register_action(view, cx, Editor::transpose);
+        register_action(view, cx, Editor::rewrap);
         register_action(view, cx, Editor::cut);
         register_action(view, cx, Editor::copy);
         register_action(view, cx, Editor::paste);

From bc5ed1334ff019e026cbf7a6bbad4a8c2c5d68df Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Mon, 16 Sep 2024 17:10:57 -0700
Subject: [PATCH 112/762] Upgrade tree sitter and all grammars (#17734)

Fixes https://github.com/zed-industries/zed/issues/5291

Release Notes:

- Fixed a bug where the 'toggle comments' command didn't use the right
comment syntax in JSX and TSX elements.

---------

Co-authored-by: Conrad <conrad@zed.dev>
Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>
Co-authored-by: Kirill Bulatov <mail4score@gmail.com>
---
 .github/workflows/ci.yml                      |  33 +-
 .github/workflows/release_nightly.yml         |  19 +-
 Cargo.lock                                    | 350 +++++++++---------
 Cargo.toml                                    |  54 ++-
 crates/assistant/src/inline_assistant.rs      |   2 +-
 crates/collab/src/tests.rs                    |   2 +-
 crates/collab/src/tests/integration_tests.rs  |   8 +-
 crates/editor/src/display_map.rs              |   6 +-
 crates/editor/src/editor_tests.rs             |  54 +--
 .../editor/src/highlight_matching_bracket.rs  |   2 +-
 crates/editor/src/inlay_hint_cache.rs         |   2 +-
 crates/editor/src/items.rs                    |   2 +-
 .../src/test/editor_lsp_test_context.rs       |   4 +-
 crates/extension/src/extension_builder.rs     |  12 +-
 crates/extension/src/wasm_host.rs             |   3 +-
 crates/extension/src/wasm_host/wit.rs         |  26 +-
 .../src/wasm_host/wit/since_v0_0_6.rs         |  10 +-
 crates/extension_cli/src/main.rs              |   2 +-
 crates/language/src/buffer_tests.rs           |  24 +-
 crates/language/src/language.rs               |  13 +-
 crates/language/src/language_registry.rs      |   4 +-
 .../src/syntax_map/syntax_map_tests.rs        |  10 +-
 crates/language_tools/src/lsp_log_tests.rs    |   2 +-
 crates/languages/src/c.rs                     |   2 +-
 crates/languages/src/cpp/highlights.scm       |   2 +-
 crates/languages/src/css.rs                   |   2 +-
 crates/languages/src/go.rs                    |   2 +-
 crates/languages/src/lib.rs                   |  38 +-
 crates/languages/src/python.rs                |   2 +-
 crates/languages/src/rust.rs                  |   6 +-
 crates/languages/src/typescript.rs            |   5 +-
 .../markdown_preview/src/markdown_parser.rs   |   2 +-
 crates/outline/src/outline.rs                 |   2 +-
 crates/outline_panel/src/outline_panel.rs     |   2 +-
 crates/project/src/project_tests.rs           |   6 +-
 crates/repl/src/repl_editor.rs                |  10 +-
 crates/semantic_index/src/chunking.rs         |   2 +-
 crates/settings/src/settings_store.rs         |  12 +-
 crates/tasks_ui/src/lib.rs                    |   4 +-
 crates/vim/src/test.rs                        |   2 +-
 crates/zed/src/zed.rs                         |   4 +-
 41 files changed, 364 insertions(+), 385 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 02bec287144357..12b7dbd806e144 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -110,8 +110,7 @@ jobs:
     timeout-minutes: 60
     name: (Linux) Run Clippy and tests
     runs-on:
-      - self-hosted
-      - deploy
+      - hosted-linux-x86-1
     steps:
       - name: Add Rust to the PATH
         run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
@@ -121,6 +120,9 @@ jobs:
         with:
           clean: false
 
+      - name: Install Linux dependencies
+        run: ./script/linux
+
       - name: cargo clippy
         run: ./script/clippy
 
@@ -271,22 +273,21 @@ jobs:
     timeout-minutes: 60
     name: Create a Linux bundle
     runs-on:
-      - self-hosted
-      - deploy
+      - hosted-linux-x86-1
     if: ${{ startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
     needs: [linux_tests]
     env:
       ZED_CLIENT_CHECKSUM_SEED: ${{ secrets.ZED_CLIENT_CHECKSUM_SEED }}
       ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
-      - name: Add Rust to the PATH
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
-
       - name: Checkout repo
         uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
         with:
           clean: false
 
+      - name: Install Linux dependencies
+        run: ./script/linux
+
       - name: Limit target directory size
         run: script/clear-target-dir-if-larger-than 100
 
@@ -354,23 +355,9 @@ jobs:
         uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
         with:
           clean: false
-      - name: "Setup jq"
-        uses: dcarbone/install-jq-action@8867ddb4788346d7c22b72ea2e2ffe4d514c7bcb # v2
-
-      - name: Set up Clang
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y llvm-15 clang-15 build-essential cmake pkg-config libasound2-dev libfontconfig-dev libwayland-dev libxkbcommon-x11-dev libssl-dev libsqlite3-dev libzstd-dev libvulkan1 libgit2-dev
-          echo "/usr/lib/llvm-15/bin" >> $GITHUB_PATH
 
-      - uses: rui314/setup-mold@0bf4f07ef9048ec62a45f9dbf2f098afa49695f0 # v1
-        with:
-          mold-version: 2.32.0
-
-      - name: rustup
-        run: |
-          curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+      - name: Install Linux dependencies
+        run: ./script/linux
 
       - name: Limit target directory size
         run: script/clear-target-dir-if-larger-than 100
diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml
index 8371840984bb3e..d8e6b6d919093b 100644
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -145,23 +145,8 @@ jobs:
         with:
           clean: false
 
-      - name: "Setup jq"
-        uses: dcarbone/install-jq-action@8867ddb4788346d7c22b72ea2e2ffe4d514c7bcb # v2
-
-      - name: Set up Clang
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y llvm-10 clang-10 build-essential cmake pkg-config libasound2-dev libfontconfig-dev libwayland-dev libxkbcommon-x11-dev libssl-dev libsqlite3-dev libzstd-dev libvulkan1 libgit2-dev
-          echo "/usr/lib/llvm-10/bin" >> $GITHUB_PATH
-
-      - uses: rui314/setup-mold@0bf4f07ef9048ec62a45f9dbf2f098afa49695f0 # v1
-        with:
-          mold-version: 2.32.0
-
-      - name: rustup
-        run: |
-          curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+      - name: Install Linux dependencies
+        run: ./script/linux
 
       - name: Limit target directory size
         run: script/clear-target-dir-if-larger-than 100
diff --git a/Cargo.lock b/Cargo.lock
index 2d5ef55ebc173c..203fc934e7c45e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -25,7 +25,7 @@ version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
 dependencies = [
- "gimli 0.29.0",
+ "gimli",
 ]
 
 [[package]]
@@ -1486,7 +1486,7 @@ dependencies = [
  "cfg-if",
  "libc",
  "miniz_oxide 0.7.4",
- "object 0.36.4",
+ "object",
  "rustc-demangle",
 ]
 
@@ -3033,27 +3033,38 @@ dependencies = [
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.108.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29daf137addc15da6bab6eae2c4a11e274b1d270bf2759508e62f6145e863ef6"
+checksum = "b80c3a50b9c4c7e5b5f73c0ed746687774fc9e36ef652b110da8daebf0c6e0e6"
 dependencies = [
  "cranelift-entity",
 ]
 
+[[package]]
+name = "cranelift-bitset"
+version = "0.111.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38778758c2ca918b05acb2199134e0c561fb577c50574259b26190b6c2d95ded"
+dependencies = [
+ "serde",
+ "serde_derive",
+]
+
 [[package]]
 name = "cranelift-codegen"
-version = "0.108.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de619867d5de4c644b7fd9904d6e3295269c93d8a71013df796ab338681222d4"
+checksum = "58258667ad10e468bfc13a8d620f50dfcd4bb35d668123e97defa2549b9ad397"
 dependencies = [
  "bumpalo",
  "cranelift-bforest",
+ "cranelift-bitset",
  "cranelift-codegen-meta",
  "cranelift-codegen-shared",
  "cranelift-control",
  "cranelift-entity",
  "cranelift-isle",
- "gimli 0.28.1",
+ "gimli",
  "hashbrown 0.14.5",
  "log",
  "regalloc2",
@@ -3064,43 +3075,44 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.108.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29f5cf277490037d8dae9513d35e0ee8134670ae4a964a5ed5b198d4249d7c10"
+checksum = "043f0b702e529dcb07ff92bd7d40e7d5317b5493595172c5eb0983343751ee06"
 dependencies = [
  "cranelift-codegen-shared",
 ]
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.108.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c3e22ecad1123343a3c09ac6ecc532bb5c184b6fcb7888df0ea953727f79924"
+checksum = "7763578888ab53eca5ce7da141953f828e82c2bfadcffc106d10d1866094ffbb"
 
 [[package]]
 name = "cranelift-control"
-version = "0.108.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53ca3ec6d30bce84ccf59c81fead4d16381a3ef0ef75e8403bc1e7385980da09"
+checksum = "32db15f08c05df570f11e8ab33cb1ec449a64b37c8a3498377b77650bef33d8b"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.108.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7eabb8d36b0ca8906bec93c78ea516741cac2d7e6b266fa7b0ffddcc09004990"
+checksum = "5289cdb399381a27e7bbfa1b42185916007c3d49aeef70b1d01cb4caa8010130"
 dependencies = [
+ "cranelift-bitset",
  "serde",
  "serde_derive",
 ]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.108.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44b42630229e49a8cfcae90bdc43c8c4c08f7a7aa4618b67f79265cd2f996dd2"
+checksum = "31ba8ab24eb9470477e98ddfa3c799a649ac5a0d9a2042868c4c952133c234e8"
 dependencies = [
  "cranelift-codegen",
  "log",
@@ -3110,15 +3122,15 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.108.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "918d1e36361805dfe0b6cdfd5a5ffdb5d03fa796170c5717d2727cbe623b93a0"
+checksum = "2b72a3c5c166a70426dcb209bdd0bb71a787c1ea76023dc0974fbabca770e8f9"
 
 [[package]]
 name = "cranelift-native"
-version = "0.108.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75aea85a0d7e1800b14ce9d3f53adf8ad4d1ee8a9e23b0269bdc50285e93b9b3"
+checksum = "46a42424c956bbc31fc5c2706073df896156c5420ae8fa2a5d48dbc7b295d71b"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -3127,9 +3139,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-wasm"
-version = "0.108.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dac491fd3473944781f0cf9528c90cc899d18ad438da21961a839a3a44d57dfb"
+checksum = "49778df4289933d735b93c30a345513e030cf83101de0036e19b760f8aa09f68"
 dependencies = [
  "cranelift-codegen",
  "cranelift-entity",
@@ -3137,7 +3149,7 @@ dependencies = [
  "itertools 0.12.1",
  "log",
  "smallvec",
- "wasmparser 0.207.0",
+ "wasmparser 0.215.0",
  "wasmtime-types",
 ]
 
@@ -4091,8 +4103,8 @@ dependencies = [
  "ui",
  "url",
  "util",
- "wasm-encoder 0.201.0",
- "wasmparser 0.201.0",
+ "wasm-encoder 0.215.0",
+ "wasmparser 0.215.0",
  "wasmtime",
  "wasmtime-wasi",
  "wit-component",
@@ -4804,21 +4816,15 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.28.1"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
+checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
 dependencies = [
  "fallible-iterator",
  "indexmap 2.4.0",
  "stable_deref_trait",
 ]
 
-[[package]]
-name = "gimli"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
-
 [[package]]
 name = "git"
 version = "0.1.0"
@@ -5187,6 +5193,7 @@ checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 dependencies = [
  "ahash 0.8.11",
  "allocator-api2",
+ "serde",
 ]
 
 [[package]]
@@ -7408,9 +7415,9 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.33.0"
+version = "0.36.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8dd6c0cdf9429bce006e1362bfce61fa1bfd8c898a643ed8d2b471934701d3d"
+checksum = "084f1a5821ac4c651660a94a7153d27ac9d8a53736203f58b31945ded098070a"
 dependencies = [
  "crc32fast",
  "hashbrown 0.14.5",
@@ -7418,15 +7425,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "object"
-version = "0.36.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "084f1a5821ac4c651660a94a7153d27ac9d8a53736203f58b31945ded098070a"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "oboe"
 version = "0.6.1"
@@ -8569,11 +8567,10 @@ checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94"
 [[package]]
 name = "protols-tree-sitter-proto"
 version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bac092da66e21a71eb832925de7b542f8ac34f75fd05cd2fc3e272863e3fd2b"
+source = "git+https://github.com/zed-industries/tree-sitter-proto?rev=0848bd30a64be48772e15fbb9d5ba8c0cc5772ad#0848bd30a64be48772e15fbb9d5ba8c0cc5772ad"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
@@ -11971,110 +11968,112 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter"
-version = "0.22.6"
-source = "git+https://github.com/tree-sitter/tree-sitter?rev=7f4a57817d58a2f134fe863674acad6bbf007228#7f4a57817d58a2f134fe863674acad6bbf007228"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20f4cd3642c47a85052a887d86704f4eac272969f61b686bdd3f772122aabaff"
 dependencies = [
  "cc",
  "regex",
+ "regex-syntax 0.8.4",
  "tree-sitter-language",
  "wasmtime-c-api-impl",
 ]
 
 [[package]]
 name = "tree-sitter-bash"
-version = "0.21.0"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5244703ad2e08a616d859a0557d7aa290adcd5e0990188a692e628ffe9dce40"
+checksum = "3aa5e1c6bd02c0053f3f68edcf5d8866b38a8640584279e30fca88149ce14dda"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-c"
-version = "0.21.4"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f956d5351d62652864a4ff3ae861747e7a1940dc96c9998ae400ac0d3ce30427"
+checksum = "e795ad541f7ae6a80d22975296340a75a12a29afd3a7089f4368021613728e17"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-cpp"
-version = "0.22.3"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d509a22a992790d38f2c291961ff8a1ff016c437c7ec6befc9220b8eec8918c"
+checksum = "c0a588a816017469b69f2e3544742e34a5a59dddfb4b9457b657a6052e2ea39c"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-css"
-version = "0.21.1"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e08e324b1cf60fd3291774b49724c66de2ce8fcf4d358d0b4b82e37b41b1c9b"
+checksum = "8d0018d6b1692a806f9cddaa1e5616951fd58840c39a0b21401b55ab3df12292"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-elixir"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df94bf7f057768b1cab2ee1f14812ed4ae33f9e04d09254043eeaa797db4ef70"
+checksum = "6174acad8a059851f6f768d7893f4b25eedc80eb6643283d545dd71bbb38222a"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-embedded-template"
-version = "0.20.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33817ade928c73a32d4f904a602321e09de9fc24b71d106f3b4b3f8ab30dcc38"
+checksum = "9644d7586ebe850c84037ee2f4804dda4a9348eef053be6b1e0d7712342a2495"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-go"
-version = "0.21.2"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8d702a98d3c7e70e466456e58ff2b1ac550bf1e29b97e5770676d2fdabec00d"
+checksum = "caf57626e4c9b6d6efaf8a8d5ee1241c5f178ae7bfdf693713ae6a774f01424e"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-gomod"
 version = "1.0.2"
-source = "git+https://github.com/camdencheek/tree-sitter-go-mod?rev=1f55029bacd0a6a11f6eb894c4312d429dcf735c#1f55029bacd0a6a11f6eb894c4312d429dcf735c"
+source = "git+https://github.com/zed-industries/tree-sitter-go-mod?rev=a9aea5e358cde4d0f8ff20b7bc4fa311e359c7ca#a9aea5e358cde4d0f8ff20b7bc4fa311e359c7ca"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-gowork"
 version = "0.0.1"
-source = "git+https://github.com/d1y/tree-sitter-go-work?rev=dcbabff454703c3a4bc98a23cf8778d4be46fd22#dcbabff454703c3a4bc98a23cf8778d4be46fd22"
+source = "git+https://github.com/zed-industries/tree-sitter-go-work?rev=acb0617bf7f4fda02c6217676cc64acb89536dc7#acb0617bf7f4fda02c6217676cc64acb89536dc7"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-heex"
 version = "0.0.1"
-source = "git+https://github.com/phoenixframework/tree-sitter-heex?rev=6dd0303acf7138dd2b9b432a229e16539581c701#6dd0303acf7138dd2b9b432a229e16539581c701"
+source = "git+https://github.com/zed-industries/tree-sitter-heex?rev=1dd45142fbb05562e35b2040c6129c9bca346592#1dd45142fbb05562e35b2040c6129c9bca346592"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
@@ -12089,96 +12088,96 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-jsdoc"
-version = "0.21.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d07920101ff12a59574890318a37fa7e18d9c06d9aa4be334aa24adbb480f18"
+checksum = "f8c4049eb0ad690e34e5f63640f75ce12a2ff8ba18344d0a13926805b139c0c8"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-json"
-version = "0.21.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b737dcb73c35d74b7d64a5f3dde158113c86a012bf3cee2bfdf2150d23b05db"
+checksum = "86a5d6b3ea17e06e7a34aabeadd68f5866c0d0f9359155d432095f8b751865e4"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-language"
 version = "0.1.0"
-source = "git+https://github.com/tree-sitter/tree-sitter?rev=7f4a57817d58a2f134fe863674acad6bbf007228#7f4a57817d58a2f134fe863674acad6bbf007228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2545046bd1473dac6c626659cc2567c6c0ff302fc8b84a56c4243378276f7f57"
 
 [[package]]
 name = "tree-sitter-md"
-version = "0.2.3"
-source = "git+https://github.com/zed-industries/tree-sitter-markdown?rev=e3855e37f8f2c71aa7513c18a9c95fb7461b1b10#e3855e37f8f2c71aa7513c18a9c95fb7461b1b10"
+version = "0.3.2"
+source = "git+https://github.com/zed-industries/tree-sitter-markdown?rev=4cfa6aad6b75052a5077c80fd934757d9267d81b#4cfa6aad6b75052a5077c80fd934757d9267d81b"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-python"
-version = "0.21.0"
+version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4066c6cf678f962f8c2c4561f205945c84834cce73d981e71392624fdc390a9"
+checksum = "65661b1a3e24139e2e54207e47d910ab07e28790d78efc7d5dc3a11ce2a110eb"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-regex"
-version = "0.21.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ff1286fe9651b2797484839ffa37aa76c8618d4ccb6836d7e31765dfd60c0d5"
+checksum = "0b9a7087b1cf769c96b7e74414947df067fb6135f04d176fd23be08b9396cc0e"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-ruby"
-version = "0.21.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0031f687c0772f2dad7b77104c43428611099a1804c81244ada21560f41f0b1"
+checksum = "6ec5ee842e27791e0adffa0b2a177614de51d2a26e5c7e84d014ed7f097e5ed0"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-rust"
-version = "0.21.2"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "277690f420bf90741dea984f3da038ace46c4fe6047cba57a66822226cde1c93"
+checksum = "cffbbcb780348fbae8395742ae5b34c1fd794e4085d43aac9f259387f9a84dc8"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-typescript"
-version = "0.21.2"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecb35d98a688378e56c18c9c159824fd16f730ccbea19aacf4f206e5d5438ed9"
+checksum = "aecf1585ae2a9dddc2b1d4c0e2140b2ec9876e2a25fd79de47fcf7dae0384685"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
 name = "tree-sitter-yaml"
 version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aad27ec46ad343d8b514f64dd3fdffb478c592ece561b6c935d90ef55589c6b6"
+source = "git+https://github.com/zed-industries/tree-sitter-yaml?rev=baff0b51c64ef6a1fb1f8390f3ad6015b83ec13a#baff0b51c64ef6a1fb1f8390f3ad6015b83ec13a"
 dependencies = [
  "cc",
- "tree-sitter",
+ "tree-sitter-language",
 ]
 
 [[package]]
@@ -12812,9 +12811,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-encoder"
-version = "0.207.0"
+version = "0.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d996306fb3aeaee0d9157adbe2f670df0236caf19f6728b221e92d0f27b3fe17"
+checksum = "4fb56df3e06b8e6b77e37d2969a50ba51281029a9aeb3855e76b7f49b6418847"
 dependencies = [
  "leb128",
 ]
@@ -12848,35 +12847,38 @@ dependencies = [
 
 [[package]]
 name = "wasmparser"
-version = "0.207.0"
+version = "0.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e19bb9f8ab07616da582ef8adb24c54f1424c7ec876720b7da9db8ec0626c92c"
+checksum = "53fbde0881f24199b81cf49b6ff8f9c145ac8eb1b7fc439adb5c099734f7d90e"
 dependencies = [
  "ahash 0.8.11",
  "bitflags 2.6.0",
  "hashbrown 0.14.5",
  "indexmap 2.4.0",
  "semver",
+ "serde",
 ]
 
 [[package]]
 name = "wasmprinter"
-version = "0.207.0"
+version = "0.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c2d8a7b4dabb460208e6b4334d9db5766e84505038b2529e69c3d07ac619115"
+checksum = "d8e9a325d85053408209b3d2ce5eaddd0dd6864d1cff7a007147ba073157defc"
 dependencies = [
  "anyhow",
- "wasmparser 0.207.0",
+ "termcolor",
+ "wasmparser 0.215.0",
 ]
 
 [[package]]
 name = "wasmtime"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f92a1370c66a0022e6d92dcc277e2c84f5dece19569670b8ce7db8162560d8b6"
+checksum = "9a5883d64dfc8423c56e3d8df27cffc44db25336aa468e8e0724fddf30a333d7"
 dependencies = [
  "anyhow",
  "async-trait",
+ "bitflags 2.6.0",
  "bumpalo",
  "cc",
  "cfg-if",
@@ -12888,8 +12890,7 @@ dependencies = [
  "log",
  "mach2",
  "memfd",
- "memoffset",
- "object 0.33.0",
+ "object",
  "once_cell",
  "paste",
  "postcard",
@@ -12901,7 +12902,7 @@ dependencies = [
  "smallvec",
  "sptr",
  "target-lexicon",
- "wasmparser 0.207.0",
+ "wasmparser 0.215.0",
  "wasmtime-asm-macros",
  "wasmtime-component-macro",
  "wasmtime-component-util",
@@ -12917,18 +12918,18 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-asm-macros"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dee8679c974a7f258c03d60d3c747c426ed219945b6d08cbc77fd2eab15b2d1"
+checksum = "1c4dc7e2a379c0dd6be5b55857d14c4b277f43a9c429a9e14403eb61776ae3be"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "wasmtime-c-api-impl"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76af8b62c8d2814b7d5975c5dc140122e4c086150db6c15d25a4b76f11c929dd"
+checksum = "765e302e7d9125e614aaeec3ad6b6083605393004eca00214106a4ff6b47fc58"
 dependencies = [
  "anyhow",
  "log",
@@ -12940,9 +12941,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-c-api-macros"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d74b92f917c9ced9c6262a00e9cb982ebac183e6900b4d44e2480f936b9495eb"
+checksum = "2d09d02eaa84aa2de5babee7b0296557ad6e4903bb10aa8d135e393e753a43d6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -12950,9 +12951,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-component-macro"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32cae30035f1cf97dcc6657c979cf39f99ce6be93583675eddf4aeaa5548509c"
+checksum = "4b07773d1c3dab5f014ec61316ee317aa424033e17e70a63abdf7c3a47e58fcf"
 dependencies = [
  "anyhow",
  "proc-macro2",
@@ -12960,20 +12961,20 @@ dependencies = [
  "syn 2.0.76",
  "wasmtime-component-util",
  "wasmtime-wit-bindgen",
- "wit-parser 0.207.0",
+ "wit-parser 0.215.0",
 ]
 
 [[package]]
 name = "wasmtime-component-util"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7ae611f08cea620c67330925be28a96115bf01f8f393a6cbdf4856a86087134"
+checksum = "e38d735320f4e83478369ce649ad8fe87c6b893220902e798547a225fc0c5874"
 
 [[package]]
 name = "wasmtime-cranelift"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2909406a6007e28be964067167890bca4574bd48a9ff18f1fa9f4856d89ea40"
+checksum = "e570d831d0785d93d7d8c722b1eb9a34e0d0c1534317666f65892818358a2da9"
 dependencies = [
  "anyhow",
  "cfg-if",
@@ -12983,36 +12984,38 @@ dependencies = [
  "cranelift-frontend",
  "cranelift-native",
  "cranelift-wasm",
- "gimli 0.28.1",
+ "gimli",
  "log",
- "object 0.33.0",
+ "object",
  "target-lexicon",
  "thiserror",
- "wasmparser 0.207.0",
+ "wasmparser 0.215.0",
  "wasmtime-environ",
  "wasmtime-versioned-export-macros",
 ]
 
 [[package]]
 name = "wasmtime-environ"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40e227f9ed2f5421473723d6c0352b5986e6e6044fde5410a274a394d726108f"
+checksum = "c5fe80dfbd81687431a7d4f25929fae1ae96894786d5c96b14ae41164ee97377"
 dependencies = [
  "anyhow",
  "cpp_demangle",
+ "cranelift-bitset",
  "cranelift-entity",
- "gimli 0.28.1",
+ "gimli",
  "indexmap 2.4.0",
  "log",
- "object 0.33.0",
+ "object",
  "postcard",
  "rustc-demangle",
+ "semver",
  "serde",
  "serde_derive",
  "target-lexicon",
- "wasm-encoder 0.207.0",
- "wasmparser 0.207.0",
+ "wasm-encoder 0.215.0",
+ "wasmparser 0.215.0",
  "wasmprinter",
  "wasmtime-component-util",
  "wasmtime-types",
@@ -13020,9 +13023,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-fiber"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42edb392586d07038c1638e854382db916b6ca7845a2e6a7f8dc49e08907acdd"
+checksum = "0f39043d13c7b58db69dc9a0feb191a961e75a9ec2402aebf42de183c022bb8a"
 dependencies = [
  "anyhow",
  "cc",
@@ -13035,9 +13038,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-jit-icache-coherence"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afe088f9b56bb353adaf837bf7e10f1c2e1676719dd5be4cac8e37f2ba1ee5bc"
+checksum = "d15de8429db996f0d17a4163a35eccc3f874cbfb50f29c379951ea1bbb39452e"
 dependencies = [
  "anyhow",
  "cfg-if",
@@ -13047,28 +13050,29 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-slab"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ff75cafffe47b04b036385ce3710f209153525b0ed19d57b0cf44a22d446460"
+checksum = "1f68d38fa6b30c5e1fc7d608263062997306f79e577ebd197ddcd6b0f55d87d1"
 
 [[package]]
 name = "wasmtime-types"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f2fa462bfea3220711c84e2b549f147e4df89eeb49b8a2a3d89148f6cc4a8b1"
+checksum = "6634e7079d9c5cfc81af8610ed59b488cc5b7f9777a2f4c1667a2565c2e45249"
 dependencies = [
+ "anyhow",
  "cranelift-entity",
  "serde",
  "serde_derive",
  "smallvec",
- "wasmparser 0.207.0",
+ "wasmparser 0.215.0",
 ]
 
 [[package]]
 name = "wasmtime-versioned-export-macros"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4cedc5bfef3db2a85522ee38564b47ef3b7fc7c92e94cacbce99808e63cdd47"
+checksum = "3850e3511d6c7f11a72d571890b0ed5f6204681f7f050b9de2690e7f13123fed"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -13077,9 +13081,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-wasi"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdbbe94245904d4c96c7c5f7b55bad896cc27908644efd9442063c0748b631fc"
+checksum = "545ae8298ffce025604f7480f9c7d6948c985bef7ce9aee249ef79307813e83c"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13108,16 +13112,16 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-winch"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b27054fed6be4f3800aba5766f7ef435d4220ce290788f021a08d4fa573108"
+checksum = "2a25199625effa4c13dd790d64bd56884b014c69829431bfe43991c740bd5bc1"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
- "gimli 0.28.1",
- "object 0.33.0",
+ "gimli",
+ "object",
  "target-lexicon",
- "wasmparser 0.207.0",
+ "wasmparser 0.215.0",
  "wasmtime-cranelift",
  "wasmtime-environ",
  "winch-codegen",
@@ -13125,14 +13129,14 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-wit-bindgen"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c936a52ce69c28de2aa3b5fb4f2dbbb2966df304f04cccb7aca4ba56d915fda0"
+checksum = "3cb331ac7ed1d5ba49cddcdb6b11973752a857148858bb308777d2fc5584121f"
 dependencies = [
  "anyhow",
  "heck 0.4.1",
  "indexmap 2.4.0",
- "wit-parser 0.207.0",
+ "wit-parser 0.215.0",
 ]
 
 [[package]]
@@ -13313,9 +13317,9 @@ dependencies = [
 
 [[package]]
 name = "wiggle"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a89ea6f74ece6d1cfbd089783006b8eb69a0219ca83cad22068f0d9fa9df3f91"
+checksum = "cc850ca3c02c5835934d23f28cec4c5a3fb66fe0b4ecd968bbb35609dda5ddc0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13328,9 +13332,9 @@ dependencies = [
 
 [[package]]
 name = "wiggle-generate"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36beda94813296ecaf0d91b7ada9da073fd41865ba339bdd3b7764e2e785b8e9"
+checksum = "634b8804a67200bcb43ea8af5f7c53e862439a086b68b16fd333454bc74d5aab"
 dependencies = [
  "anyhow",
  "heck 0.4.1",
@@ -13343,9 +13347,9 @@ dependencies = [
 
 [[package]]
 name = "wiggle-macro"
-version = "21.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b47d2b4442ce93106dba5d1a9c59d5f85b5732878bb3d0598d3c93c0d01b16b"
+checksum = "474b7cbdb942c74031e619d66c600bba7f73867c5800fc2c2306cf307649be2f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -13386,17 +13390,17 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "winch-codegen"
-version = "0.19.1"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dc69899ccb2da7daa4df31426dcfd284b104d1a85e1dae35806df0c46187f87"
+checksum = "073efe897d9ead7fc609874f94580afc831114af5149b6a90ee0a3a39b497fe0"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
- "gimli 0.28.1",
+ "gimli",
  "regalloc2",
  "smallvec",
  "target-lexicon",
- "wasmparser 0.207.0",
+ "wasmparser 0.215.0",
  "wasmtime-cranelift",
  "wasmtime-environ",
 ]
@@ -13903,9 +13907,9 @@ dependencies = [
 
 [[package]]
 name = "wit-parser"
-version = "0.207.0"
+version = "0.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78c83dab33a9618d86cfe3563cc864deffd08c17efc5db31a3b7cd1edeffe6e1"
+checksum = "935a97eaffd57c3b413aa510f8f0b550a4a9fe7d59e79cd8b89a83dcb860321f"
 dependencies = [
  "anyhow",
  "id-arena",
@@ -13916,7 +13920,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "unicode-xid",
- "wasmparser 0.207.0",
+ "wasmparser 0.215.0",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 726ffe0cca3782..e1af231c7e4fee 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -430,43 +430,43 @@ tiny_http = "0.8"
 toml = "0.8"
 tokio = { version = "1", features = ["full"] }
 tower-http = "0.4.4"
-tree-sitter = { version = "0.22", features = ["wasm"] }
-tree-sitter-bash = "0.21"
-tree-sitter-c = "0.21"
-tree-sitter-cpp = "0.22"
-tree-sitter-css = "0.21"
-tree-sitter-elixir = "0.2"
-tree-sitter-embedded-template = "0.20.0"
-tree-sitter-go = "0.21"
-tree-sitter-go-mod = { git = "https://github.com/camdencheek/tree-sitter-go-mod", rev = "1f55029bacd0a6a11f6eb894c4312d429dcf735c", package = "tree-sitter-gomod" }
-tree-sitter-gowork = { git = "https://github.com/d1y/tree-sitter-go-work", rev = "dcbabff454703c3a4bc98a23cf8778d4be46fd22" }
-tree-sitter-heex = { git = "https://github.com/phoenixframework/tree-sitter-heex", rev = "6dd0303acf7138dd2b9b432a229e16539581c701" }
+tree-sitter = { version = "0.23", features = ["wasm"] }
+tree-sitter-bash = "0.23"
+tree-sitter-c = "0.23"
+tree-sitter-cpp = "0.23"
+tree-sitter-css = "0.23"
+tree-sitter-elixir = "0.3"
+tree-sitter-embedded-template = "0.23.0"
+tree-sitter-go = "0.23"
+tree-sitter-go-mod = { git = "https://github.com/zed-industries/tree-sitter-go-mod", rev = "a9aea5e358cde4d0f8ff20b7bc4fa311e359c7ca", package = "tree-sitter-gomod" }
+tree-sitter-gowork = { git = "https://github.com/zed-industries/tree-sitter-go-work", rev = "acb0617bf7f4fda02c6217676cc64acb89536dc7" }
+tree-sitter-heex = { git = "https://github.com/zed-industries/tree-sitter-heex", rev = "1dd45142fbb05562e35b2040c6129c9bca346592" }
 tree-sitter-html = "0.20"
-tree-sitter-jsdoc = "0.21"
-tree-sitter-json = "0.21"
-tree-sitter-md = { git = "https://github.com/zed-industries/tree-sitter-markdown", rev = "e3855e37f8f2c71aa7513c18a9c95fb7461b1b10" }
-protols-tree-sitter-proto = "0.2"
-tree-sitter-python = "0.21"
-tree-sitter-regex = "0.21"
-tree-sitter-ruby = "0.21"
-tree-sitter-rust = "0.21"
-tree-sitter-typescript = "0.21"
-tree-sitter-yaml = "0.6"
+tree-sitter-jsdoc = "0.23"
+tree-sitter-json = "0.23"
+tree-sitter-md = { git = "https://github.com/zed-industries/tree-sitter-markdown", rev = "4cfa6aad6b75052a5077c80fd934757d9267d81b" }
+protols-tree-sitter-proto = { git = "https://github.com/zed-industries/tree-sitter-proto", rev = "0848bd30a64be48772e15fbb9d5ba8c0cc5772ad" }
+tree-sitter-python = "0.23"
+tree-sitter-regex = "0.23"
+tree-sitter-ruby = "0.23"
+tree-sitter-rust = "0.23"
+tree-sitter-typescript = "0.23"
+tree-sitter-yaml =  { git = "https://github.com/zed-industries/tree-sitter-yaml", rev = "baff0b51c64ef6a1fb1f8390f3ad6015b83ec13a" }
 unindent = "0.1.7"
 unicase = "2.6"
 unicode-segmentation = "1.10"
 url = "2.2"
 uuid = { version = "1.1.2", features = ["v4", "v5", "serde"] }
-wasmparser = "0.201"
-wasm-encoder = "0.201"
-wasmtime = { version = "21.0.1", default-features = false, features = [
+wasmparser = "0.215"
+wasm-encoder = "0.215"
+wasmtime = { version = "24", default-features = false, features = [
     "async",
     "demangle",
     "runtime",
     "cranelift",
     "component-model",
 ] }
-wasmtime-wasi = "21.0.1"
+wasmtime-wasi = "24"
 which = "6.0.0"
 wit-component = "0.201"
 
@@ -523,10 +523,6 @@ features = [
     "Win32_UI_WindowsAndMessaging",
 ]
 
-[patch.crates-io]
-# Patch Tree-sitter for updated wasmtime.
-tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "7f4a57817d58a2f134fe863674acad6bbf007228" }
-
 [profile.dev]
 split-debuginfo = "unpacked"
 debug = "limited"
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index 30a5c98a54372a..eb1bc1eee8b0da 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -3359,7 +3359,7 @@ mod tests {
                 },
                 ..Default::default()
             },
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         )
         .with_indents_query(
             r#"
diff --git a/crates/collab/src/tests.rs b/crates/collab/src/tests.rs
index c452705f9be5bf..f6e0bc3036b1c5 100644
--- a/crates/collab/src/tests.rs
+++ b/crates/collab/src/tests.rs
@@ -63,6 +63,6 @@ fn rust_lang() -> Arc<Language> {
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ))
 }
diff --git a/crates/collab/src/tests/integration_tests.rs b/crates/collab/src/tests/integration_tests.rs
index 245d0eda1b6fbf..51593e081e46c1 100644
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -2273,7 +2273,7 @@ async fn test_propagate_saves_and_fs_changes(
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
     let javascript = Arc::new(Language::new(
         LanguageConfig {
@@ -2284,7 +2284,7 @@ async fn test_propagate_saves_and_fs_changes(
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
     for client in [&client_a, &client_b, &client_c] {
         client.language_registry().add(rust.clone());
@@ -3855,7 +3855,7 @@ async fn test_collaborating_with_diagnostics(
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     )));
     let mut fake_language_servers = client_a
         .language_registry()
@@ -4458,7 +4458,7 @@ async fn test_prettier_formatting_buffer(
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     )));
     let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
         "TypeScript",
diff --git a/crates/editor/src/display_map.rs b/crates/editor/src/display_map.rs
index 6cb871555118e4..86ea7ee3fabf95 100644
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -1645,7 +1645,7 @@ pub mod tests {
                     },
                     ..Default::default()
                 },
-                Some(tree_sitter_rust::language()),
+                Some(tree_sitter_rust::LANGUAGE.into()),
             )
             .with_highlights_query(
                 r#"
@@ -1750,7 +1750,7 @@ pub mod tests {
                     },
                     ..Default::default()
                 },
-                Some(tree_sitter_rust::language()),
+                Some(tree_sitter_rust::LANGUAGE.into()),
             )
             .with_highlights_query(
                 r#"
@@ -1833,7 +1833,7 @@ pub mod tests {
                     },
                     ..Default::default()
                 },
-                Some(tree_sitter_rust::language()),
+                Some(tree_sitter_rust::LANGUAGE.into()),
             )
             .with_highlights_query(
                 r#"
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 43b3e2e5e8f080..57471612dbb611 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -2322,7 +2322,7 @@ async fn test_newline_above(cx: &mut gpui::TestAppContext) {
     let language = Arc::new(
         Language::new(
             LanguageConfig::default(),
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         )
         .with_indents_query(r#"(_ "(" ")" @end) @indent"#)
         .unwrap(),
@@ -2370,7 +2370,7 @@ async fn test_newline_below(cx: &mut gpui::TestAppContext) {
     let language = Arc::new(
         Language::new(
             LanguageConfig::default(),
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         )
         .with_indents_query(r#"(_ "(" ")" @end) @indent"#)
         .unwrap(),
@@ -2524,7 +2524,7 @@ async fn test_tab_in_leading_whitespace_auto_indents_lines(cx: &mut gpui::TestAp
     let language = Arc::new(
         Language::new(
             LanguageConfig::default(),
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         )
         .with_indents_query(r#"(_ "(" ")" @end) @indent"#)
         .unwrap(),
@@ -2585,7 +2585,7 @@ async fn test_tab_with_mixed_whitespace(cx: &mut gpui::TestAppContext) {
     let language = Arc::new(
         Language::new(
             LanguageConfig::default(),
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         )
         .with_indents_query(r#"(_ "{" "}" @end) @indent"#)
         .unwrap(),
@@ -4311,7 +4311,7 @@ async fn test_paste_multiline(cx: &mut gpui::TestAppContext) {
     let mut cx = EditorTestContext::new(cx).await;
     let language = Arc::new(Language::new(
         LanguageConfig::default(),
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
     cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
@@ -5022,7 +5022,7 @@ async fn test_select_larger_smaller_syntax_node(cx: &mut gpui::TestAppContext) {
 
     let language = Arc::new(Language::new(
         LanguageConfig::default(),
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
 
     let text = r#"
@@ -5231,7 +5231,7 @@ async fn test_autoindent_selections(cx: &mut gpui::TestAppContext) {
                 },
                 ..Default::default()
             },
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         )
         .with_indents_query(
             r#"
@@ -5324,7 +5324,7 @@ async fn test_autoclose_and_auto_surround_pairs(cx: &mut gpui::TestAppContext) {
             autoclose_before: "})]".to_string(),
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
 
     cx.language_registry().add(language.clone());
@@ -5496,7 +5496,7 @@ async fn test_always_treat_brackets_as_autoclosed_skip_over(cx: &mut gpui::TestA
             autoclose_before: "})]".to_string(),
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
 
     cx.language_registry().add(language.clone());
@@ -5636,7 +5636,7 @@ async fn test_autoclose_with_embedded_language(cx: &mut gpui::TestAppContext) {
             autoclose_before: "})]>".into(),
             ..Default::default()
         },
-        Some(tree_sitter_typescript::language_tsx()),
+        Some(tree_sitter_typescript::LANGUAGE_TSX.into()),
     ));
 
     cx.language_registry().add(html_language.clone());
@@ -5811,7 +5811,7 @@ async fn test_autoclose_with_overrides(cx: &mut gpui::TestAppContext) {
                 autoclose_before: "})]>".into(),
                 ..Default::default()
             },
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         )
         .with_override_query("(string_literal) @string")
         .unwrap(),
@@ -5916,7 +5916,7 @@ async fn test_surround_with_pair(cx: &mut gpui::TestAppContext) {
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
 
     let text = r#"
@@ -6065,7 +6065,7 @@ async fn test_delete_autoclose_pair(cx: &mut gpui::TestAppContext) {
             autoclose_before: "}".to_string(),
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
 
     let text = r#"
@@ -6192,7 +6192,7 @@ async fn test_always_treat_brackets_as_autoclosed_delete(cx: &mut gpui::TestAppC
             autoclose_before: "})]".to_string(),
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
 
     cx.language_registry().add(language.clone());
@@ -6262,7 +6262,7 @@ async fn test_auto_replace_emoji_shortcode(cx: &mut gpui::TestAppContext) {
 
     let language = Arc::new(Language::new(
         LanguageConfig::default(),
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
 
     let buffer = cx.new_model(|cx| Buffer::local("", cx).with_language(language, cx));
@@ -6937,7 +6937,7 @@ async fn test_document_format_manual_trigger(cx: &mut gpui::TestAppContext) {
             },
             ..LanguageConfig::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     )));
     update_test_language_settings(cx, |settings| {
         // Enable Prettier formatting for the same buffer, and ensure
@@ -7272,7 +7272,7 @@ async fn test_handle_input_for_show_signature_help_auto_signature_help_true(
             autoclose_before: "})]".to_string(),
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     );
     let language = Arc::new(language);
 
@@ -7414,7 +7414,7 @@ async fn test_handle_input_with_different_show_signature_settings(cx: &mut gpui:
             autoclose_before: "})]".to_string(),
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     );
     let language = Arc::new(language);
 
@@ -8207,7 +8207,7 @@ async fn test_toggle_comment(cx: &mut gpui::TestAppContext) {
             line_comments: vec!["// ".into(), "//! ".into(), "/// ".into()],
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
     cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
@@ -8328,7 +8328,7 @@ async fn test_advance_downward_on_toggle_comment(cx: &mut gpui::TestAppContext)
             line_comments: vec!["// ".into()],
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ));
 
     let mut cx = EditorTestContext::new(cx).await;
@@ -8481,7 +8481,7 @@ async fn test_toggle_block_comment(cx: &mut gpui::TestAppContext) {
             line_comments: vec!["// ".into()],
             ..Default::default()
         },
-        Some(tree_sitter_typescript::language_tsx()),
+        Some(tree_sitter_typescript::LANGUAGE_TSX.into()),
     ));
 
     cx.language_registry().add(html_language.clone());
@@ -8889,7 +8889,7 @@ async fn test_extra_newline_insertion(cx: &mut gpui::TestAppContext) {
                 },
                 ..Default::default()
             },
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         )
         .with_indents_query("")
         .unwrap(),
@@ -9725,7 +9725,7 @@ async fn test_on_type_formatting_not_triggered(cx: &mut gpui::TestAppContext) {
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     )));
     let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
@@ -9838,7 +9838,7 @@ async fn test_language_server_restart_due_to_settings_change(cx: &mut gpui::Test
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     )));
     let mut fake_servers = language_registry.register_fake_lsp(
         "Rust",
@@ -10071,7 +10071,7 @@ async fn test_completions_in_languages_with_extra_word_characters(cx: &mut gpui:
                 .collect(),
                 ..Default::default()
             },
-            Some(tree_sitter_typescript::language_tsx()),
+            Some(tree_sitter_typescript::LANGUAGE_TSX.into()),
         )
         .with_override_query("(jsx_self_closing_element) @element")
         .unwrap(),
@@ -10174,7 +10174,7 @@ async fn test_document_format_with_prettier(cx: &mut gpui::TestAppContext) {
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     )));
     update_test_language_settings(cx, |settings| {
         settings.defaults.prettier = Some(PrettierSettings {
@@ -13891,7 +13891,7 @@ pub(crate) fn rust_lang() -> Arc<Language> {
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ))
 }
 
diff --git a/crates/editor/src/highlight_matching_bracket.rs b/crates/editor/src/highlight_matching_bracket.rs
index 5ddda65692e114..67915d4d7b4990 100644
--- a/crates/editor/src/highlight_matching_bracket.rs
+++ b/crates/editor/src/highlight_matching_bracket.rs
@@ -78,7 +78,7 @@ mod tests {
                     },
                     ..Default::default()
                 },
-                Some(tree_sitter_rust::language()),
+                Some(tree_sitter_rust::LANGUAGE.into()),
             )
             .with_brackets_query(indoc! {r#"
                 ("{" @open "}" @close)
diff --git a/crates/editor/src/inlay_hint_cache.rs b/crates/editor/src/inlay_hint_cache.rs
index b03674dc48aff9..ce7ec5a4b098c9 100644
--- a/crates/editor/src/inlay_hint_cache.rs
+++ b/crates/editor/src/inlay_hint_cache.rs
@@ -1575,7 +1575,7 @@ pub mod tests {
                     },
                     ..Default::default()
                 },
-                Some(tree_sitter_rust::language()),
+                Some(tree_sitter_rust::LANGUAGE.into()),
             )));
             let fake_servers = language_registry.register_fake_lsp(
                 name,
diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index 1be2092d7dd79b..e3e8ca604b28c3 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -1599,7 +1599,7 @@ mod tests {
                 },
                 ..Default::default()
             },
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         ))
     }
 
diff --git a/crates/editor/src/test/editor_lsp_test_context.rs b/crates/editor/src/test/editor_lsp_test_context.rs
index 17959ab50b5c85..e32d590a60d138 100644
--- a/crates/editor/src/test/editor_lsp_test_context.rs
+++ b/crates/editor/src/test/editor_lsp_test_context.rs
@@ -125,7 +125,7 @@ impl EditorLspTestContext {
                 },
                 ..Default::default()
             },
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         )
         .with_queries(LanguageQueries {
             indents: Some(Cow::from(indoc! {r#"
@@ -184,7 +184,7 @@ impl EditorLspTestContext {
                 word_characters,
                 ..Default::default()
             },
-            Some(tree_sitter_typescript::language_typescript()),
+            Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()),
         )
         .with_queries(LanguageQueries {
             brackets: Some(Cow::from(indoc! {r#"
diff --git a/crates/extension/src/extension_builder.rs b/crates/extension/src/extension_builder.rs
index 8c867bbb987ba5..e42929f78ebb1a 100644
--- a/crates/extension/src/extension_builder.rs
+++ b/crates/extension/src/extension_builder.rs
@@ -18,7 +18,7 @@ use wasm_encoder::{ComponentSectionId, Encode as _, RawSection, Section as _};
 use wasmparser::Parser;
 use wit_component::ComponentEncoder;
 
-/// Currently, we compile with Rust's `wasm32-wasi` target, which works with WASI `preview1`.
+/// Currently, we compile with Rust's `wasm32-wasip1` target, which works with WASI `preview1`.
 /// But the WASM component model is based on WASI `preview2`. So we need an 'adapter' WASM
 /// module, which implements the `preview1` interface in terms of `preview2`.
 ///
@@ -447,7 +447,7 @@ impl ExtensionBuilder {
     }
 
     // This was adapted from:
-    // https://github.com/bytecodealliance/wasm-tools/1791a8f139722e9f8679a2bd3d8e423e55132b22/src/bin/wasm-tools/strip.rs
+    // https://github.com/bytecodealliance/wasm-tools/blob/1791a8f139722e9f8679a2bd3d8e423e55132b22/src/bin/wasm-tools/strip.rs
     fn strip_custom_sections(&self, input: &Vec<u8>) -> Result<Vec<u8>> {
         use wasmparser::Payload::*;
 
@@ -458,13 +458,15 @@ impl ExtensionBuilder {
 
         for payload in Parser::new(0).parse_all(input) {
             let payload = payload?;
+            let component_header = wasm_encoder::Component::HEADER;
+            let module_header = wasm_encoder::Module::HEADER;
 
             // Track nesting depth, so that we don't mess with inner producer sections:
             match payload {
                 Version { encoding, .. } => {
                     output.extend_from_slice(match encoding {
-                        wasmparser::Encoding::Component => &wasm_encoder::Component::HEADER,
-                        wasmparser::Encoding::Module => &wasm_encoder::Module::HEADER,
+                        wasmparser::Encoding::Component => &component_header,
+                        wasmparser::Encoding::Module => &module_header,
                     });
                 }
                 ModuleSection { .. } | ComponentSection { .. } => {
@@ -476,7 +478,7 @@ impl ExtensionBuilder {
                         Some(c) => c,
                         None => break,
                     };
-                    if output.starts_with(&wasm_encoder::Component::HEADER) {
+                    if output.starts_with(&component_header) {
                         parent.push(ComponentSectionId::Component as u8);
                         output.encode(&mut parent);
                     } else {
diff --git a/crates/extension/src/wasm_host.rs b/crates/extension/src/wasm_host.rs
index 406af87465a800..039f2d923b0d2f 100644
--- a/crates/extension/src/wasm_host.rs
+++ b/crates/extension/src/wasm_host.rs
@@ -127,7 +127,7 @@ impl WasmHost {
                 },
             );
 
-            let (mut extension, instance) = Extension::instantiate_async(
+            let mut extension = Extension::instantiate_async(
                 &mut store,
                 this.release_channel,
                 zed_api_version,
@@ -143,7 +143,6 @@ impl WasmHost {
             let (tx, mut rx) = mpsc::unbounded::<ExtensionCall>();
             executor
                 .spawn(async move {
-                    let _instance = instance;
                     while let Some(call) = rx.next().await {
                         (call)(&mut extension, &mut store).await;
                     }
diff --git a/crates/extension/src/wasm_host/wit.rs b/crates/extension/src/wasm_host/wit.rs
index 1c3cdd77f64eea..6de8c89c773b0a 100644
--- a/crates/extension/src/wasm_host/wit.rs
+++ b/crates/extension/src/wasm_host/wit.rs
@@ -13,7 +13,7 @@ use language::{LanguageServerName, LspAdapterDelegate};
 use semantic_version::SemanticVersion;
 use std::{ops::RangeInclusive, sync::Arc};
 use wasmtime::{
-    component::{Component, Instance, Linker, Resource},
+    component::{Component, Linker, Resource},
     Store,
 };
 
@@ -75,57 +75,55 @@ impl Extension {
         release_channel: ReleaseChannel,
         version: SemanticVersion,
         component: &Component,
-    ) -> Result<(Self, Instance)> {
+    ) -> Result<Self> {
         // Note: The release channel can be used to stage a new version of the extension API.
-        let _ = release_channel;
-
         let allow_latest_version = match release_channel {
             ReleaseChannel::Dev | ReleaseChannel::Nightly => true,
             ReleaseChannel::Stable | ReleaseChannel::Preview => false,
         };
 
         if allow_latest_version && version >= latest::MIN_VERSION {
-            let (extension, instance) =
+            let extension =
                 latest::Extension::instantiate_async(store, component, latest::linker())
                     .await
                     .context("failed to instantiate wasm extension")?;
-            Ok((Self::V020(extension), instance))
+            Ok(Self::V020(extension))
         } else if version >= since_v0_1_0::MIN_VERSION {
-            let (extension, instance) = since_v0_1_0::Extension::instantiate_async(
+            let extension = since_v0_1_0::Extension::instantiate_async(
                 store,
                 component,
                 since_v0_1_0::linker(),
             )
             .await
             .context("failed to instantiate wasm extension")?;
-            Ok((Self::V010(extension), instance))
+            Ok(Self::V010(extension))
         } else if version >= since_v0_0_6::MIN_VERSION {
-            let (extension, instance) = since_v0_0_6::Extension::instantiate_async(
+            let extension = since_v0_0_6::Extension::instantiate_async(
                 store,
                 component,
                 since_v0_0_6::linker(),
             )
             .await
             .context("failed to instantiate wasm extension")?;
-            Ok((Self::V006(extension), instance))
+            Ok(Self::V006(extension))
         } else if version >= since_v0_0_4::MIN_VERSION {
-            let (extension, instance) = since_v0_0_4::Extension::instantiate_async(
+            let extension = since_v0_0_4::Extension::instantiate_async(
                 store,
                 component,
                 since_v0_0_4::linker(),
             )
             .await
             .context("failed to instantiate wasm extension")?;
-            Ok((Self::V004(extension), instance))
+            Ok(Self::V004(extension))
         } else {
-            let (extension, instance) = since_v0_0_1::Extension::instantiate_async(
+            let extension = since_v0_0_1::Extension::instantiate_async(
                 store,
                 component,
                 since_v0_0_1::linker(),
             )
             .await
             .context("failed to instantiate wasm extension")?;
-            Ok((Self::V001(extension), instance))
+            Ok(Self::V001(extension))
         }
     }
 
diff --git a/crates/extension/src/wasm_host/wit/since_v0_0_6.rs b/crates/extension/src/wasm_host/wit/since_v0_0_6.rs
index f53b0b5ab7f1db..29b00ac97d1bec 100644
--- a/crates/extension/src/wasm_host/wit/since_v0_0_6.rs
+++ b/crates/extension/src/wasm_host/wit/since_v0_0_6.rs
@@ -30,15 +30,7 @@ pub type ExtensionWorktree = Arc<dyn LspAdapterDelegate>;
 
 pub fn linker() -> &'static Linker<WasmState> {
     static LINKER: OnceLock<Linker<WasmState>> = OnceLock::new();
-    LINKER.get_or_init(|| {
-        super::new_linker(|linker, f| {
-            Extension::add_to_linker(linker, f)?;
-            latest::zed::extension::github::add_to_linker(linker, f)?;
-            latest::zed::extension::nodejs::add_to_linker(linker, f)?;
-            latest::zed::extension::platform::add_to_linker(linker, f)?;
-            Ok(())
-        })
-    })
+    LINKER.get_or_init(|| super::new_linker(Extension::add_to_linker))
 }
 
 impl From<Command> for latest::Command {
diff --git a/crates/extension_cli/src/main.rs b/crates/extension_cli/src/main.rs
index 0c1ebd69a05ec6..029c560e57db81 100644
--- a/crates/extension_cli/src/main.rs
+++ b/crates/extension_cli/src/main.rs
@@ -39,7 +39,7 @@ async fn main() -> Result<()> {
     let args = Args::parse();
     let fs = Arc::new(RealFs::default());
     let engine = wasmtime::Engine::default();
-    let mut wasm_store = WasmStore::new(engine)?;
+    let mut wasm_store = WasmStore::new(&engine)?;
 
     let extension_path = args
         .source_dir
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index 7e6f6ef368ee60..5162269f4f6be8 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -79,7 +79,7 @@ fn test_select_language(cx: &mut AppContext) {
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     )));
     registry.add(Arc::new(Language::new(
         LanguageConfig {
@@ -90,7 +90,7 @@ fn test_select_language(cx: &mut AppContext) {
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     )));
 
     // matching file extension
@@ -1671,7 +1671,7 @@ fn test_autoindent_language_without_indents_query(cx: &mut AppContext) {
                     auto_indent_using_last_non_empty_line: false,
                     ..Default::default()
                 },
-                Some(tree_sitter_json::language()),
+                Some(tree_sitter_json::LANGUAGE.into()),
             )),
             cx,
         );
@@ -1999,7 +1999,7 @@ fn test_language_scope_at_with_javascript(cx: &mut AppContext) {
                 .collect(),
                 ..Default::default()
             },
-            Some(tree_sitter_typescript::language_tsx()),
+            Some(tree_sitter_typescript::LANGUAGE_TSX.into()),
         )
         .with_override_query(
             r#"
@@ -2121,7 +2121,7 @@ fn test_language_scope_at_with_rust(cx: &mut AppContext) {
                 },
                 ..Default::default()
             },
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         )
         .with_override_query(
             r#"
@@ -2731,7 +2731,7 @@ fn ruby_lang() -> Language {
             line_comments: vec!["# ".into()],
             ..Default::default()
         },
-        Some(tree_sitter_ruby::language()),
+        Some(tree_sitter_ruby::LANGUAGE.into()),
     )
     .with_indents_query(
         r#"
@@ -2782,7 +2782,7 @@ fn erb_lang() -> Language {
             block_comment: Some(("<%#".into(), "%>".into())),
             ..Default::default()
         },
-        Some(tree_sitter_embedded_template::language()),
+        Some(tree_sitter_embedded_template::LANGUAGE.into()),
     )
     .with_injection_query(
         r#"
@@ -2812,7 +2812,7 @@ fn rust_lang() -> Language {
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     )
     .with_indents_query(
         r#"
@@ -2870,7 +2870,7 @@ fn json_lang() -> Language {
             },
             ..Default::default()
         },
-        Some(tree_sitter_json::language()),
+        Some(tree_sitter_json::LANGUAGE.into()),
     )
 }
 
@@ -2880,7 +2880,7 @@ fn javascript_lang() -> Language {
             name: "JavaScript".into(),
             ..Default::default()
         },
-        Some(tree_sitter_typescript::language_tsx()),
+        Some(tree_sitter_typescript::LANGUAGE_TSX.into()),
     )
     .with_brackets_query(
         r#"
@@ -2907,7 +2907,7 @@ pub fn markdown_lang() -> Language {
             },
             ..Default::default()
         },
-        Some(tree_sitter_md::language()),
+        Some(tree_sitter_md::LANGUAGE.into()),
     )
     .with_injection_query(
         r#"
@@ -2930,7 +2930,7 @@ pub fn markdown_inline_lang() -> Language {
             hidden: true,
             ..LanguageConfig::default()
         },
-        Some(tree_sitter_md::inline_language()),
+        Some(tree_sitter_md::INLINE_LANGUAGE.into()),
     )
     .with_highlights_query("(emphasis) @emphasis")
     .unwrap()
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index fa5d79b53fa51b..8cd8c8079d7f0a 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -94,7 +94,7 @@ where
     let mut parser = PARSERS.lock().pop().unwrap_or_else(|| {
         let mut parser = Parser::new();
         parser
-            .set_wasm_store(WasmStore::new(WASM_ENGINE.clone()).unwrap())
+            .set_wasm_store(WasmStore::new(&WASM_ENGINE).unwrap())
             .unwrap();
         parser
     });
@@ -1485,6 +1485,13 @@ impl LanguageScope {
         }
     }
 
+    pub fn override_name(&self) -> Option<&str> {
+        let id = self.override_id?;
+        let grammar = self.language.grammar.as_ref()?;
+        let override_config = grammar.override_config.as_ref()?;
+        override_config.values.get(&id).map(|e| e.0.as_str())
+    }
+
     fn config_override(&self) -> Option<&LanguageConfigOverride> {
         let id = self.override_id?;
         let grammar = self.language.grammar.as_ref()?;
@@ -1755,8 +1762,8 @@ mod tests {
         let languages = LanguageRegistry::test(cx.executor());
         let languages = Arc::new(languages);
         languages.register_native_grammars([
-            ("json", tree_sitter_json::language()),
-            ("rust", tree_sitter_rust::language()),
+            ("json", tree_sitter_json::LANGUAGE),
+            ("rust", tree_sitter_rust::LANGUAGE),
         ]);
         languages.register_test_language(LanguageConfig {
             name: "JSON".into(),
diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index e89b73f11b44ce..4870c4ed539157 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -439,12 +439,12 @@ impl LanguageRegistry {
     /// grammar controls how the source code is parsed.
     pub fn register_native_grammars(
         &self,
-        grammars: impl IntoIterator<Item = (impl Into<Arc<str>>, tree_sitter::Language)>,
+        grammars: impl IntoIterator<Item = (impl Into<Arc<str>>, impl Into<tree_sitter::Language>)>,
     ) {
         self.state.write().grammars.extend(
             grammars
                 .into_iter()
-                .map(|(name, grammar)| (name.into(), AvailableGrammar::Native(grammar))),
+                .map(|(name, grammar)| (name.into(), AvailableGrammar::Native(grammar.into()))),
         );
     }
 
diff --git a/crates/language/src/syntax_map/syntax_map_tests.rs b/crates/language/src/syntax_map/syntax_map_tests.rs
index b1334332ec38cc..6f42252da56cfd 100644
--- a/crates/language/src/syntax_map/syntax_map_tests.rs
+++ b/crates/language/src/syntax_map/syntax_map_tests.rs
@@ -1160,7 +1160,7 @@ fn ruby_lang() -> Language {
             },
             ..Default::default()
         },
-        Some(tree_sitter_ruby::language()),
+        Some(tree_sitter_ruby::LANGUAGE.into()),
     )
     .with_highlights_query(
         r#"
@@ -1182,7 +1182,7 @@ fn erb_lang() -> Language {
             },
             ..Default::default()
         },
-        Some(tree_sitter_embedded_template::language()),
+        Some(tree_sitter_embedded_template::LANGUAGE.into()),
     )
     .with_highlights_query(
         r#"
@@ -1218,7 +1218,7 @@ fn rust_lang() -> Language {
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     )
     .with_highlights_query(
         r#"
@@ -1247,7 +1247,7 @@ fn elixir_lang() -> Language {
             },
             ..Default::default()
         },
-        Some(tree_sitter_elixir::language()),
+        Some(tree_sitter_elixir::LANGUAGE.into()),
     )
     .with_highlights_query(
         r#"
@@ -1267,7 +1267,7 @@ fn heex_lang() -> Language {
             },
             ..Default::default()
         },
-        Some(tree_sitter_heex::language()),
+        Some(tree_sitter_heex::LANGUAGE.into()),
     )
     .with_injection_query(
         r#"
diff --git a/crates/language_tools/src/lsp_log_tests.rs b/crates/language_tools/src/lsp_log_tests.rs
index 524a8e99963bf7..3ead6954340e88 100644
--- a/crates/language_tools/src/lsp_log_tests.rs
+++ b/crates/language_tools/src/lsp_log_tests.rs
@@ -43,7 +43,7 @@ async fn test_lsp_logs(cx: &mut TestAppContext) {
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     )));
     let mut fake_rust_servers = language_registry.register_fake_lsp(
         "Rust",
diff --git a/crates/languages/src/c.rs b/crates/languages/src/c.rs
index 243f61b084c4e8..4ebb4569ef1406 100644
--- a/crates/languages/src/c.rs
+++ b/crates/languages/src/c.rs
@@ -346,7 +346,7 @@ mod tests {
                 });
             });
         });
-        let language = crate::language("c", tree_sitter_c::language());
+        let language = crate::language("c", tree_sitter_c::LANGUAGE.into());
 
         cx.new_model(|cx| {
             let mut buffer = Buffer::local("", cx).with_language(language, cx);
diff --git a/crates/languages/src/cpp/highlights.scm b/crates/languages/src/cpp/highlights.scm
index 5cebb6fe8f54b7..42d05bde33e0ab 100644
--- a/crates/languages/src/cpp/highlights.scm
+++ b/crates/languages/src/cpp/highlights.scm
@@ -94,12 +94,12 @@
   "typename"
   "union"
   "using"
+  "virtual"
   "while"
   (primitive_type)
   (sized_type_specifier)
   (storage_class_specifier)
   (type_qualifier)
-  (virtual)
 ] @keyword
 
 [
diff --git a/crates/languages/src/css.rs b/crates/languages/src/css.rs
index 8faf512aedfcd7..cf259d69d321a8 100644
--- a/crates/languages/src/css.rs
+++ b/crates/languages/src/css.rs
@@ -140,7 +140,7 @@ mod tests {
 
     #[gpui::test]
     async fn test_outline(cx: &mut TestAppContext) {
-        let language = crate::language("css", tree_sitter_css::language());
+        let language = crate::language("css", tree_sitter_css::LANGUAGE.into());
 
         let text = r#"
             /* Import statement */
diff --git a/crates/languages/src/go.rs b/crates/languages/src/go.rs
index 55850411ca88db..a83a11fd49ee34 100644
--- a/crates/languages/src/go.rs
+++ b/crates/languages/src/go.rs
@@ -614,7 +614,7 @@ mod tests {
     #[gpui::test]
     async fn test_go_label_for_completion() {
         let adapter = Arc::new(GoLspAdapter);
-        let language = language("go", tree_sitter_go::language());
+        let language = language("go", tree_sitter_go::LANGUAGE.into());
 
         let theme = SyntaxTheme::new_test([
             ("type", Hsla::default()),
diff --git a/crates/languages/src/lib.rs b/crates/languages/src/lib.rs
index a499444c44f216..0a3fc71d08961d 100644
--- a/crates/languages/src/lib.rs
+++ b/crates/languages/src/lib.rs
@@ -36,25 +36,25 @@ pub fn init(
     cx: &mut AppContext,
 ) {
     languages.register_native_grammars([
-        ("bash", tree_sitter_bash::language()),
-        ("c", tree_sitter_c::language()),
-        ("cpp", tree_sitter_cpp::language()),
-        ("css", tree_sitter_css::language()),
-        ("go", tree_sitter_go::language()),
-        ("gomod", tree_sitter_go_mod::language()),
-        ("gowork", tree_sitter_gowork::language()),
-        ("jsdoc", tree_sitter_jsdoc::language()),
-        ("json", tree_sitter_json::language()),
-        ("jsonc", tree_sitter_json::language()),
-        ("markdown", tree_sitter_md::language()),
-        ("markdown-inline", tree_sitter_md::inline_language()),
-        ("proto", protols_tree_sitter_proto::language()),
-        ("python", tree_sitter_python::language()),
-        ("regex", tree_sitter_regex::language()),
-        ("rust", tree_sitter_rust::language()),
-        ("tsx", tree_sitter_typescript::language_tsx()),
-        ("typescript", tree_sitter_typescript::language_typescript()),
-        ("yaml", tree_sitter_yaml::language()),
+        ("bash", tree_sitter_bash::LANGUAGE),
+        ("c", tree_sitter_c::LANGUAGE),
+        ("cpp", tree_sitter_cpp::LANGUAGE),
+        ("css", tree_sitter_css::LANGUAGE),
+        ("go", tree_sitter_go::LANGUAGE),
+        ("gomod", tree_sitter_go_mod::LANGUAGE),
+        ("gowork", tree_sitter_gowork::LANGUAGE),
+        ("jsdoc", tree_sitter_jsdoc::LANGUAGE),
+        ("json", tree_sitter_json::LANGUAGE),
+        ("jsonc", tree_sitter_json::LANGUAGE),
+        ("markdown", tree_sitter_md::LANGUAGE),
+        ("markdown-inline", tree_sitter_md::INLINE_LANGUAGE),
+        ("proto", protols_tree_sitter_proto::LANGUAGE),
+        ("python", tree_sitter_python::LANGUAGE),
+        ("regex", tree_sitter_regex::LANGUAGE),
+        ("rust", tree_sitter_rust::LANGUAGE),
+        ("tsx", tree_sitter_typescript::LANGUAGE_TSX),
+        ("typescript", tree_sitter_typescript::LANGUAGE_TYPESCRIPT),
+        ("yaml", tree_sitter_yaml::LANGUAGE),
     ]);
 
     macro_rules! language {
diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs
index a0005e6f97878c..99018647ead465 100644
--- a/crates/languages/src/python.rs
+++ b/crates/languages/src/python.rs
@@ -307,7 +307,7 @@ mod tests {
     #[gpui::test]
     async fn test_python_autoindent(cx: &mut TestAppContext) {
         cx.executor().set_block_on_ticks(usize::MAX..=usize::MAX);
-        let language = crate::language("python", tree_sitter_python::language());
+        let language = crate::language("python", tree_sitter_python::LANGUAGE.into());
         cx.update(|cx| {
             let test_settings = SettingsStore::test(cx);
             cx.set_global(test_settings);
diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs
index 20e6c575749314..d102276e440c09 100644
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -743,7 +743,7 @@ mod tests {
     #[gpui::test]
     async fn test_rust_label_for_completion() {
         let adapter = Arc::new(RustLspAdapter);
-        let language = language("rust", tree_sitter_rust::language());
+        let language = language("rust", tree_sitter_rust::LANGUAGE.into());
         let grammar = language.grammar().unwrap();
         let theme = SyntaxTheme::new_test([
             ("type", Hsla::default()),
@@ -868,7 +868,7 @@ mod tests {
     #[gpui::test]
     async fn test_rust_label_for_symbol() {
         let adapter = Arc::new(RustLspAdapter);
-        let language = language("rust", tree_sitter_rust::language());
+        let language = language("rust", tree_sitter_rust::LANGUAGE.into());
         let grammar = language.grammar().unwrap();
         let theme = SyntaxTheme::new_test([
             ("type", Hsla::default()),
@@ -920,7 +920,7 @@ mod tests {
             });
         });
 
-        let language = crate::language("rust", tree_sitter_rust::language());
+        let language = crate::language("rust", tree_sitter_rust::LANGUAGE.into());
 
         cx.new_model(|cx| {
             let mut buffer = Buffer::local("", cx).with_language(language, cx);
diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs
index cc52df2922a210..c65b74aa9bb14e 100644
--- a/crates/languages/src/typescript.rs
+++ b/crates/languages/src/typescript.rs
@@ -555,7 +555,10 @@ mod tests {
 
     #[gpui::test]
     async fn test_outline(cx: &mut TestAppContext) {
-        let language = crate::language("typescript", tree_sitter_typescript::language_typescript());
+        let language = crate::language(
+            "typescript",
+            tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into(),
+        );
 
         let text = r#"
             function a() {
diff --git a/crates/markdown_preview/src/markdown_parser.rs b/crates/markdown_preview/src/markdown_parser.rs
index 7e503fb609efa9..7ad6c97597aff3 100644
--- a/crates/markdown_preview/src/markdown_parser.rs
+++ b/crates/markdown_preview/src/markdown_parser.rs
@@ -1234,7 +1234,7 @@ fn main() {
                 collapsed_placeholder: " /* ... */ ".to_string(),
                 ..Default::default()
             },
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         ))
     }
 
diff --git a/crates/outline/src/outline.rs b/crates/outline/src/outline.rs
index c906663db727f6..cd641636349e39 100644
--- a/crates/outline/src/outline.rs
+++ b/crates/outline/src/outline.rs
@@ -484,7 +484,7 @@ mod tests {
                     },
                     ..Default::default()
                 },
-                Some(tree_sitter_rust::language()),
+                Some(tree_sitter_rust::LANGUAGE.into()),
             )
             .with_outline_query(
                 r#"(struct_item
diff --git a/crates/outline_panel/src/outline_panel.rs b/crates/outline_panel/src/outline_panel.rs
index c5f0187c229fa8..73570dd5afc775 100644
--- a/crates/outline_panel/src/outline_panel.rs
+++ b/crates/outline_panel/src/outline_panel.rs
@@ -4787,7 +4787,7 @@ mod tests {
                 },
                 ..Default::default()
             },
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         )
         .with_highlights_query(
             r#"
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index 83deb6fd919133..72a38ccba7d781 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -5339,7 +5339,7 @@ fn rust_lang() -> Arc<Language> {
             },
             ..Default::default()
         },
-        Some(tree_sitter_rust::language()),
+        Some(tree_sitter_rust::LANGUAGE.into()),
     ))
 }
 
@@ -5353,7 +5353,7 @@ fn typescript_lang() -> Arc<Language> {
             },
             ..Default::default()
         },
-        Some(tree_sitter_typescript::language_typescript()),
+        Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()),
     ))
 }
 
@@ -5367,7 +5367,7 @@ fn tsx_lang() -> Arc<Language> {
             },
             ..Default::default()
         },
-        Some(tree_sitter_typescript::language_tsx()),
+        Some(tree_sitter_typescript::LANGUAGE_TSX.into()),
     ))
 }
 
diff --git a/crates/repl/src/repl_editor.rs b/crates/repl/src/repl_editor.rs
index 1f0935a5c55a02..6c86257f30456e 100644
--- a/crates/repl/src/repl_editor.rs
+++ b/crates/repl/src/repl_editor.rs
@@ -471,10 +471,12 @@ mod tests {
 
     #[gpui::test]
     fn test_markdown_code_blocks(cx: &mut AppContext) {
-        let markdown = languages::language("markdown", tree_sitter_md::language());
-        let typescript =
-            languages::language("typescript", tree_sitter_typescript::language_typescript());
-        let python = languages::language("python", tree_sitter_python::language());
+        let markdown = languages::language("markdown", tree_sitter_md::LANGUAGE.into());
+        let typescript = languages::language(
+            "typescript",
+            tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into(),
+        );
+        let python = languages::language("python", tree_sitter_python::LANGUAGE.into());
         let language_registry = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
         language_registry.add(markdown.clone());
         language_registry.add(typescript.clone());
diff --git a/crates/semantic_index/src/chunking.rs b/crates/semantic_index/src/chunking.rs
index da3ff92331fe7c..70f992263310b5 100644
--- a/crates/semantic_index/src/chunking.rs
+++ b/crates/semantic_index/src/chunking.rs
@@ -398,7 +398,7 @@ mod tests {
                     },
                     ..Default::default()
                 },
-                Some(tree_sitter_rust::language()),
+                Some(tree_sitter_rust::LANGUAGE.into()),
             )
             .with_outline_query(
                 "
diff --git a/crates/settings/src/settings_store.rs b/crates/settings/src/settings_store.rs
index 3e645415161c8d..3ef8bffe2d3ded 100644
--- a/crates/settings/src/settings_store.rs
+++ b/crates/settings/src/settings_store.rs
@@ -15,7 +15,6 @@ use std::{
     sync::{Arc, LazyLock},
 };
 use tree_sitter::Query;
-use tree_sitter_json::language;
 use util::{merge_non_null_json_value_into, RangeExt, ResultExt as _};
 
 use crate::{SettingsJsonSchemaParams, WorktreeId};
@@ -955,12 +954,17 @@ fn replace_value_in_json_text(
     new_value: &serde_json::Value,
 ) -> (Range<usize>, String) {
     static PAIR_QUERY: LazyLock<Query> = LazyLock::new(|| {
-        Query::new(&language(), "(pair key: (string) @key value: (_) @value)")
-            .expect("Failed to create PAIR_QUERY")
+        Query::new(
+            &tree_sitter_json::LANGUAGE.into(),
+            "(pair key: (string) @key value: (_) @value)",
+        )
+        .expect("Failed to create PAIR_QUERY")
     });
 
     let mut parser = tree_sitter::Parser::new();
-    parser.set_language(&tree_sitter_json::language()).unwrap();
+    parser
+        .set_language(&tree_sitter_json::LANGUAGE.into())
+        .unwrap();
     let syntax_tree = parser.parse(text, None).unwrap();
 
     let mut cursor = tree_sitter::QueryCursor::new();
diff --git a/crates/tasks_ui/src/lib.rs b/crates/tasks_ui/src/lib.rs
index 703c112c7a2835..4ea4a8fa2ccdc0 100644
--- a/crates/tasks_ui/src/lib.rs
+++ b/crates/tasks_ui/src/lib.rs
@@ -226,7 +226,7 @@ mod tests {
         let rust_language = Arc::new(
             Language::new(
                 LanguageConfig::default(),
-                Some(tree_sitter_rust::language()),
+                Some(tree_sitter_rust::LANGUAGE.into()),
             )
             .with_outline_query(
                 r#"(function_item
@@ -240,7 +240,7 @@ mod tests {
         let typescript_language = Arc::new(
             Language::new(
                 LanguageConfig::default(),
-                Some(tree_sitter_typescript::language_typescript()),
+                Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()),
             )
             .with_outline_query(
                 r#"(function_declaration
diff --git a/crates/vim/src/test.rs b/crates/vim/src/test.rs
index 9c61e9cd938292..9cb0b79ec5fd18 100644
--- a/crates/vim/src/test.rs
+++ b/crates/vim/src/test.rs
@@ -1192,7 +1192,7 @@ async fn test_toggle_comments(cx: &mut gpui::TestAppContext) {
             line_comments: vec!["// ".into(), "//! ".into(), "/// ".into()],
             ..Default::default()
         },
-        Some(language::tree_sitter_rust::language()),
+        Some(language::tree_sitter_rust::LANGUAGE.into()),
     ));
     cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index 93fee57ecdb654..b0e023f42e0a01 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -3445,7 +3445,7 @@ mod tests {
                 },
                 ..Default::default()
             },
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         ))
     }
 
@@ -3459,7 +3459,7 @@ mod tests {
                 },
                 ..Default::default()
             },
-            Some(tree_sitter_md::language()),
+            Some(tree_sitter_md::LANGUAGE.into()),
         ))
     }
 

From d7c45ccf2f61e8b4e7c2c62fa4c4613d1091c59f Mon Sep 17 00:00:00 2001
From: Fernando Tagawa <fernando.tagawa.gamail.com@gmail.com>
Date: Mon, 16 Sep 2024 21:46:03 -0300
Subject: [PATCH 113/762] x11: Fix preedit for CJK and partially fix
 unresponsive keyboard with xim (#17373)

Closes #15833
Related to [#12495
comment](https://github.com/zed-industries/zed/pull/12495#issuecomment-2328356125)

Destroying and recreating the Input context was the only way to reset
the IME but it's making the keyboard unresponsive sometimes due to a XIM
error.

The keyboard will still be unresponsive if you close your IME while
using zed, but I don't know how to fix this.

* Fixed preedit drawing for CJK
* Fixed unresponsive keyboard by properly implementing reset_ic in
`xim-rs`

Release Notes:

- N/A
---
 Cargo.lock                                    |  6 ++---
 crates/gpui/Cargo.toml                        |  2 +-
 crates/gpui/src/platform/linux/x11/client.rs  | 27 +++++++------------
 .../src/platform/linux/x11/xim_handler.rs     | 16 +----------
 4 files changed, 15 insertions(+), 36 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 203fc934e7c45e..111360b96547bd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14079,7 +14079,7 @@ dependencies = [
 [[package]]
 name = "xim"
 version = "0.4.0"
-source = "git+https://github.com/npmania/xim-rs?rev=27132caffc5b9bc9c432ca4afad184ab6e7c16af#27132caffc5b9bc9c432ca4afad184ab6e7c16af"
+source = "git+https://github.com/XDeme1/xim-rs?rev=d50d461764c2213655cd9cf65a0ea94c70d3c4fd#d50d461764c2213655cd9cf65a0ea94c70d3c4fd"
 dependencies = [
  "ahash 0.8.11",
  "hashbrown 0.14.5",
@@ -14092,7 +14092,7 @@ dependencies = [
 [[package]]
 name = "xim-ctext"
 version = "0.3.0"
-source = "git+https://github.com/npmania/xim-rs?rev=27132caffc5b9bc9c432ca4afad184ab6e7c16af#27132caffc5b9bc9c432ca4afad184ab6e7c16af"
+source = "git+https://github.com/XDeme1/xim-rs?rev=d50d461764c2213655cd9cf65a0ea94c70d3c4fd#d50d461764c2213655cd9cf65a0ea94c70d3c4fd"
 dependencies = [
  "encoding_rs",
 ]
@@ -14100,7 +14100,7 @@ dependencies = [
 [[package]]
 name = "xim-parser"
 version = "0.2.1"
-source = "git+https://github.com/npmania/xim-rs?rev=27132caffc5b9bc9c432ca4afad184ab6e7c16af#27132caffc5b9bc9c432ca4afad184ab6e7c16af"
+source = "git+https://github.com/XDeme1/xim-rs?rev=d50d461764c2213655cd9cf65a0ea94c70d3c4fd#d50d461764c2213655cd9cf65a0ea94c70d3c4fd"
 dependencies = [
  "bitflags 2.6.0",
 ]
diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml
index 4ce44ffce01f8e..09b546fc3266d2 100644
--- a/crates/gpui/Cargo.toml
+++ b/crates/gpui/Cargo.toml
@@ -143,7 +143,7 @@ xkbcommon = { git = "https://github.com/ConradIrwin/xkbcommon-rs", rev = "fcbb46
     "wayland",
     "x11",
 ] }
-xim = { git = "https://github.com/npmania/xim-rs", rev = "27132caffc5b9bc9c432ca4afad184ab6e7c16af", features = [
+xim = { git = "https://github.com/XDeme1/xim-rs", rev = "d50d461764c2213655cd9cf65a0ea94c70d3c4fd", features = [
     "x11rb-xcb",
     "x11rb-client",
 ] }
diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs
index 0909d09f25438b..d6c806236a9e47 100644
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -201,9 +201,7 @@ impl X11ClientStatePtr {
             .build_ic_attributes()
             .push(
                 xim::AttributeName::InputStyle,
-                xim::InputStyle::PREEDIT_CALLBACKS
-                    | xim::InputStyle::STATUS_NOTHING
-                    | xim::InputStyle::PREEDIT_POSITION,
+                xim::InputStyle::PREEDIT_CALLBACKS,
             )
             .push(xim::AttributeName::ClientWindow, xim_handler.window)
             .push(xim::AttributeName::FocusWindow, xim_handler.window)
@@ -572,12 +570,7 @@ impl X11Client {
         let mut xim_handler = state.xim_handler.take().unwrap();
         let mut ic_attributes = ximc
             .build_ic_attributes()
-            .push(
-                AttributeName::InputStyle,
-                InputStyle::PREEDIT_CALLBACKS
-                    | InputStyle::STATUS_NOTHING
-                    | InputStyle::PREEDIT_NONE,
-            )
+            .push(AttributeName::InputStyle, InputStyle::PREEDIT_CALLBACKS)
             .push(AttributeName::ClientWindow, xim_handler.window)
             .push(AttributeName::FocusWindow, xim_handler.window);
 
@@ -605,12 +598,12 @@ impl X11Client {
         state.ximc = Some(ximc);
     }
 
-    pub fn disable_ime(&self) {
+    pub fn reset_ime(&self) {
         let mut state = self.0.borrow_mut();
         state.composing = false;
         if let Some(mut ximc) = state.ximc.take() {
             let xim_handler = state.xim_handler.as_ref().unwrap();
-            ximc.destroy_ic(xim_handler.im_id, xim_handler.ic_id).ok();
+            ximc.reset_ic(xim_handler.im_id, xim_handler.ic_id).ok();
             state.ximc = Some(ximc);
         }
     }
@@ -768,6 +761,9 @@ impl X11Client {
                 window.set_active(true);
                 let mut state = self.0.borrow_mut();
                 state.keyboard_focused_window = Some(event.event);
+                if let Some(handler) = state.xim_handler.as_mut() {
+                    handler.window = event.event;
+                }
                 drop(state);
                 self.enable_ime();
             }
@@ -781,7 +777,7 @@ impl X11Client {
                 }
                 state.pre_edit_text.take();
                 drop(state);
-                self.disable_ime();
+                self.reset_ime();
                 window.handle_ime_delete();
             }
             Event::XkbNewKeyboardNotify(_) | Event::MapNotify(_) => {
@@ -940,8 +936,7 @@ impl X11Client {
 
                 if state.composing && state.ximc.is_some() {
                     drop(state);
-                    self.disable_ime();
-                    self.enable_ime();
+                    self.reset_ime();
                     window.handle_ime_unmark();
                     state = self.0.borrow_mut();
                 } else if let Some(text) = state.pre_edit_text.take() {
@@ -1199,9 +1194,7 @@ impl X11Client {
                 .build_ic_attributes()
                 .push(
                     xim::AttributeName::InputStyle,
-                    xim::InputStyle::PREEDIT_CALLBACKS
-                        | xim::InputStyle::STATUS_NOTHING
-                        | xim::InputStyle::PREEDIT_POSITION,
+                    xim::InputStyle::PREEDIT_CALLBACKS,
                 )
                 .push(xim::AttributeName::ClientWindow, xim_handler.window)
                 .push(xim::AttributeName::FocusWindow, xim_handler.window)
diff --git a/crates/gpui/src/platform/linux/x11/xim_handler.rs b/crates/gpui/src/platform/linux/x11/xim_handler.rs
index 89b1ec3feb0e05..e1ccfd4cd977b4 100644
--- a/crates/gpui/src/platform/linux/x11/xim_handler.rs
+++ b/crates/gpui/src/platform/linux/x11/xim_handler.rs
@@ -48,12 +48,7 @@ impl<C: Client<XEvent = xproto::KeyPressEvent>> ClientHandler<C> for XimHandler
     ) -> Result<(), ClientError> {
         let ic_attributes = client
             .build_ic_attributes()
-            .push(
-                AttributeName::InputStyle,
-                InputStyle::PREEDIT_CALLBACKS
-                    | InputStyle::STATUS_NOTHING
-                    | InputStyle::PREEDIT_NONE,
-            )
+            .push(AttributeName::InputStyle, InputStyle::PREEDIT_CALLBACKS)
             .push(AttributeName::ClientWindow, self.window)
             .push(AttributeName::FocusWindow, self.window)
             .build();
@@ -110,15 +105,6 @@ impl<C: Client<XEvent = xproto::KeyPressEvent>> ClientHandler<C> for XimHandler
         client.disconnect()
     }
 
-    fn handle_destroy_ic(
-        &mut self,
-        client: &mut C,
-        input_method_id: u16,
-        _input_context_id: u16,
-    ) -> Result<(), ClientError> {
-        client.close(input_method_id)
-    }
-
     fn handle_preedit_draw(
         &mut self,
         _client: &mut C,

From 444115080994413215680f5a43cdf6b5d61cc32d Mon Sep 17 00:00:00 2001
From: Bai <batuhanakkurt000@gmail.com>
Date: Tue, 17 Sep 2024 03:46:49 +0300
Subject: [PATCH 114/762] Add missing Void Linux dependencies (#17827)

Release Notes:

- N/A
---
 script/linux | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/script/linux b/script/linux
index 7639b28310481f..051748ad4556e9 100755
--- a/script/linux
+++ b/script/linux
@@ -120,6 +120,11 @@ fi
 xbps=$(command -v xbps-install || true)
 if [[ -n $xbps ]]; then
   deps=(
+    gettext-devel
+    clang
+    jq
+    elfutils-devel
+    gcc
     alsa-lib-devel
     fontconfig-devel
     libxcb-devel

From 37b2f4b9d36a2a72fd2a1515bdc392cc6916c94b Mon Sep 17 00:00:00 2001
From: bestgopher <84328409@qq.com>
Date: Tue, 17 Sep 2024 10:48:13 +0800
Subject: [PATCH 115/762] Wrap terminal commands in single quotation marks
 instead of backticks (#17637)

before:

![image](https://github.com/user-attachments/assets/ffe8b036-297a-414e-92af-28a0230d3d25)
after:

![image](https://github.com/user-attachments/assets/0cf22775-69ae-4320-b9bd-6b78fe01571f)

Since I often copy the output commands to run in the command line, using
backticks can cause errors because, in shell, backticks mean passing the
execution result of the command inside them to the -c option. Therefore,
I replace backticks with single quotes here.

![image](https://github.com/user-attachments/assets/f1f809fe-c10a-423a-87a2-58148962d8b0)

Release Notes:

- Fix display of task commands to not use backticks

Signed-off-by: bestgopher <84328409@qq.com>
---
 crates/terminal/src/terminal.rs            | 2 +-
 crates/terminal_view/src/terminal_panel.rs | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs
index bd4dfed0fa260a..12a7349af07a93 100644
--- a/crates/terminal/src/terminal.rs
+++ b/crates/terminal/src/terminal.rs
@@ -1596,7 +1596,7 @@ fn task_summary(task: &TaskState, error_code: Option<i32>) -> (bool, String, Str
         }
     };
     let escaped_command_label = task.command_label.replace("\r\n", "\r").replace('\n', "\r");
-    let command_line = format!("{TASK_DELIMITER}Command: '{escaped_command_label}'");
+    let command_line = format!("{TASK_DELIMITER}Command: {escaped_command_label}");
     (success, task_line, command_line)
 }
 
diff --git a/crates/terminal_view/src/terminal_panel.rs b/crates/terminal_view/src/terminal_panel.rs
index 1e8d09f0a68d24..f745fbe348ba40 100644
--- a/crates/terminal_view/src/terminal_panel.rs
+++ b/crates/terminal_view/src/terminal_panel.rs
@@ -397,7 +397,7 @@ impl TerminalPanel {
 
         #[cfg(not(target_os = "windows"))]
         {
-            spawn_task.command_label = format!("{shell} -i -c `{}`", spawn_task.command_label);
+            spawn_task.command_label = format!("{shell} -i -c '{}'", spawn_task.command_label);
         }
         #[cfg(target_os = "windows")]
         {
@@ -405,14 +405,14 @@ impl TerminalPanel {
 
             match windows_shell_type {
                 WindowsShellType::Powershell => {
-                    spawn_task.command_label = format!("{shell} -C `{}`", spawn_task.command_label)
+                    spawn_task.command_label = format!("{shell} -C '{}'", spawn_task.command_label)
                 }
                 WindowsShellType::Cmd => {
-                    spawn_task.command_label = format!("{shell} /C `{}`", spawn_task.command_label)
+                    spawn_task.command_label = format!("{shell} /C '{}'", spawn_task.command_label)
                 }
                 WindowsShellType::Other => {
                     spawn_task.command_label =
-                        format!("{shell} -i -c `{}`", spawn_task.command_label)
+                        format!("{shell} -i -c '{}'", spawn_task.command_label)
                 }
             }
         }

From d315405be1e15ddd03624d64d65b57b1508b9f73 Mon Sep 17 00:00:00 2001
From: Kevin Wang <kevmo314@gmail.com>
Date: Mon, 16 Sep 2024 19:57:58 -0700
Subject: [PATCH 116/762] Return completion proposals from inline completion
 providers (#17578)

Updates the inline completion provider to return a completion proposal
which is then converted to a completion state. This completion proposal
includes more detailed information about which inlays specifically
should be rendered.

Release Notes:

- Added support for fill-in-the-middle style inline completions


![image](https://github.com/user-attachments/assets/1830700f-5a76-4d1f-ac6d-246cc69b64c5)
---
 .../src/copilot_completion_provider.rs        | 15 +++-
 crates/editor/src/editor.rs                   | 88 +++++++++++++------
 .../editor/src/inline_completion_provider.rs  | 18 +++-
 .../src/supermaven_completion_provider.rs     | 85 ++++++++++++++++--
 4 files changed, 167 insertions(+), 39 deletions(-)

diff --git a/crates/copilot/src/copilot_completion_provider.rs b/crates/copilot/src/copilot_completion_provider.rs
index 41ba59a0d51d8f..c54fefad6fe599 100644
--- a/crates/copilot/src/copilot_completion_provider.rs
+++ b/crates/copilot/src/copilot_completion_provider.rs
@@ -1,14 +1,14 @@
 use crate::{Completion, Copilot};
 use anyhow::Result;
 use client::telemetry::Telemetry;
-use editor::{Direction, InlineCompletionProvider};
+use editor::{CompletionProposal, Direction, InlayProposal, InlineCompletionProvider};
 use gpui::{AppContext, EntityId, Model, ModelContext, Task};
 use language::{
     language_settings::{all_language_settings, AllLanguageSettings},
     Buffer, OffsetRangeExt, ToOffset,
 };
 use settings::Settings;
-use std::{ops::Range, path::Path, sync::Arc, time::Duration};
+use std::{path::Path, sync::Arc, time::Duration};
 
 pub const COPILOT_DEBOUNCE_TIMEOUT: Duration = Duration::from_millis(75);
 
@@ -237,7 +237,7 @@ impl InlineCompletionProvider for CopilotCompletionProvider {
         buffer: &Model<Buffer>,
         cursor_position: language::Anchor,
         cx: &'a AppContext,
-    ) -> Option<(&'a str, Option<Range<language::Anchor>>)> {
+    ) -> Option<CompletionProposal> {
         let buffer_id = buffer.entity_id();
         let buffer = buffer.read(cx);
         let completion = self.active_completion()?;
@@ -267,7 +267,14 @@ impl InlineCompletionProvider for CopilotCompletionProvider {
             if completion_text.trim().is_empty() {
                 None
             } else {
-                Some((completion_text, None))
+                Some(CompletionProposal {
+                    inlays: vec![InlayProposal::Suggestion(
+                        cursor_position.bias_right(buffer),
+                        completion_text.into(),
+                    )],
+                    text: completion_text.into(),
+                    delete_range: None,
+                })
             }
         } else {
             None
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 8d17e9cfbd3f8f..e46b87b0e2ffe9 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -414,6 +414,22 @@ impl Default for EditorStyle {
 
 type CompletionId = usize;
 
+#[derive(Clone, Debug)]
+struct CompletionState {
+    // render_inlay_ids represents the inlay hints that are inserted
+    // for rendering the inline completions. They may be discontinuous
+    // in the event that the completion provider returns some intersection
+    // with the existing content.
+    render_inlay_ids: Vec<InlayId>,
+    // text is the resulting rope that is inserted when the user accepts a completion.
+    text: Rope,
+    // position is the position of the cursor when the completion was triggered.
+    position: multi_buffer::Anchor,
+    // delete_range is the range of text that this completion state covers.
+    // if the completion is accepted, this range should be deleted.
+    delete_range: Option<Range<multi_buffer::Anchor>>,
+}
+
 #[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Debug, Default)]
 struct EditorActionId(usize);
 
@@ -557,7 +573,7 @@ pub struct Editor {
     gutter_hovered: bool,
     hovered_link_state: Option<HoveredLinkState>,
     inline_completion_provider: Option<RegisteredInlineCompletionProvider>,
-    active_inline_completion: Option<(Inlay, Option<Range<Anchor>>)>,
+    active_inline_completion: Option<CompletionState>,
     // enable_inline_completions is a switch that Vim can use to disable
     // inline completions based on its mode.
     enable_inline_completions: bool,
@@ -5069,7 +5085,7 @@ impl Editor {
         _: &AcceptInlineCompletion,
         cx: &mut ViewContext<Self>,
     ) {
-        let Some((completion, delete_range)) = self.take_active_inline_completion(cx) else {
+        let Some(completion) = self.take_active_inline_completion(cx) else {
             return;
         };
         if let Some(provider) = self.inline_completion_provider() {
@@ -5081,7 +5097,7 @@ impl Editor {
             text: completion.text.to_string().into(),
         });
 
-        if let Some(range) = delete_range {
+        if let Some(range) = completion.delete_range {
             self.change_selections(None, cx, |s| s.select_ranges([range]))
         }
         self.insert_with_autoindent_mode(&completion.text.to_string(), None, cx);
@@ -5095,7 +5111,7 @@ impl Editor {
         cx: &mut ViewContext<Self>,
     ) {
         if self.selections.count() == 1 && self.has_active_inline_completion(cx) {
-            if let Some((completion, delete_range)) = self.take_active_inline_completion(cx) {
+            if let Some(completion) = self.take_active_inline_completion(cx) {
                 let mut partial_completion = completion
                     .text
                     .chars()
@@ -5116,7 +5132,7 @@ impl Editor {
                     text: partial_completion.clone().into(),
                 });
 
-                if let Some(range) = delete_range {
+                if let Some(range) = completion.delete_range {
                     self.change_selections(None, cx, |s| s.select_ranges([range]))
                 }
                 self.insert_with_autoindent_mode(&partial_completion, None, cx);
@@ -5142,7 +5158,7 @@ impl Editor {
     pub fn has_active_inline_completion(&self, cx: &AppContext) -> bool {
         if let Some(completion) = self.active_inline_completion.as_ref() {
             let buffer = self.buffer.read(cx).read(cx);
-            completion.0.position.is_valid(&buffer)
+            completion.position.is_valid(&buffer)
         } else {
             false
         }
@@ -5151,14 +5167,15 @@ impl Editor {
     fn take_active_inline_completion(
         &mut self,
         cx: &mut ViewContext<Self>,
-    ) -> Option<(Inlay, Option<Range<Anchor>>)> {
+    ) -> Option<CompletionState> {
         let completion = self.active_inline_completion.take()?;
+        let render_inlay_ids = completion.render_inlay_ids.clone();
         self.display_map.update(cx, |map, cx| {
-            map.splice_inlays(vec![completion.0.id], Default::default(), cx);
+            map.splice_inlays(render_inlay_ids, Default::default(), cx);
         });
         let buffer = self.buffer.read(cx).read(cx);
 
-        if completion.0.position.is_valid(&buffer) {
+        if completion.position.is_valid(&buffer) {
             Some(completion)
         } else {
             None
@@ -5179,31 +5196,50 @@ impl Editor {
                 if let Some((buffer, cursor_buffer_position)) =
                     self.buffer.read(cx).text_anchor_for_position(cursor, cx)
                 {
-                    if let Some((text, text_anchor_range)) =
+                    if let Some(proposal) =
                         provider.active_completion_text(&buffer, cursor_buffer_position, cx)
                     {
-                        let text = Rope::from(text);
                         let mut to_remove = Vec::new();
                         if let Some(completion) = self.active_inline_completion.take() {
-                            to_remove.push(completion.0.id);
+                            to_remove.extend(completion.render_inlay_ids.iter());
                         }
 
-                        let completion_inlay =
-                            Inlay::suggestion(post_inc(&mut self.next_inlay_id), cursor, text);
-
-                        let multibuffer_anchor_range = text_anchor_range.and_then(|range| {
-                            let snapshot = self.buffer.read(cx).snapshot(cx);
-                            Some(
-                                snapshot.anchor_in_excerpt(excerpt_id, range.start)?
-                                    ..snapshot.anchor_in_excerpt(excerpt_id, range.end)?,
-                            )
+                        let to_add = proposal
+                            .inlays
+                            .iter()
+                            .filter_map(|inlay| {
+                                let snapshot = self.buffer.read(cx).snapshot(cx);
+                                let id = post_inc(&mut self.next_inlay_id);
+                                match inlay {
+                                    InlayProposal::Hint(position, hint) => {
+                                        let position =
+                                            snapshot.anchor_in_excerpt(excerpt_id, *position)?;
+                                        Some(Inlay::hint(id, position, hint))
+                                    }
+                                    InlayProposal::Suggestion(position, text) => {
+                                        let position =
+                                            snapshot.anchor_in_excerpt(excerpt_id, *position)?;
+                                        Some(Inlay::suggestion(id, position, text.clone()))
+                                    }
+                                }
+                            })
+                            .collect_vec();
+
+                        self.active_inline_completion = Some(CompletionState {
+                            position: cursor,
+                            text: proposal.text,
+                            delete_range: proposal.delete_range.and_then(|range| {
+                                let snapshot = self.buffer.read(cx).snapshot(cx);
+                                let start = snapshot.anchor_in_excerpt(excerpt_id, range.start);
+                                let end = snapshot.anchor_in_excerpt(excerpt_id, range.end);
+                                Some(start?..end?)
+                            }),
+                            render_inlay_ids: to_add.iter().map(|i| i.id).collect(),
                         });
-                        self.active_inline_completion =
-                            Some((completion_inlay.clone(), multibuffer_anchor_range));
 
-                        self.display_map.update(cx, move |map, cx| {
-                            map.splice_inlays(to_remove, vec![completion_inlay], cx)
-                        });
+                        self.display_map
+                            .update(cx, move |map, cx| map.splice_inlays(to_remove, to_add, cx));
+
                         cx.notify();
                         return;
                     }
diff --git a/crates/editor/src/inline_completion_provider.rs b/crates/editor/src/inline_completion_provider.rs
index b7516419b9cb12..1085a6294ef807 100644
--- a/crates/editor/src/inline_completion_provider.rs
+++ b/crates/editor/src/inline_completion_provider.rs
@@ -2,6 +2,18 @@ use crate::Direction;
 use gpui::{AppContext, Model, ModelContext};
 use language::Buffer;
 use std::ops::Range;
+use text::{Anchor, Rope};
+
+pub enum InlayProposal {
+    Hint(Anchor, project::InlayHint),
+    Suggestion(Anchor, Rope),
+}
+
+pub struct CompletionProposal {
+    pub inlays: Vec<InlayProposal>,
+    pub text: Rope,
+    pub delete_range: Option<Range<Anchor>>,
+}
 
 pub trait InlineCompletionProvider: 'static + Sized {
     fn name() -> &'static str;
@@ -32,7 +44,7 @@ pub trait InlineCompletionProvider: 'static + Sized {
         buffer: &Model<Buffer>,
         cursor_position: language::Anchor,
         cx: &'a AppContext,
-    ) -> Option<(&'a str, Option<Range<language::Anchor>>)>;
+    ) -> Option<CompletionProposal>;
 }
 
 pub trait InlineCompletionProviderHandle {
@@ -63,7 +75,7 @@ pub trait InlineCompletionProviderHandle {
         buffer: &Model<Buffer>,
         cursor_position: language::Anchor,
         cx: &'a AppContext,
-    ) -> Option<(&'a str, Option<Range<language::Anchor>>)>;
+    ) -> Option<CompletionProposal>;
 }
 
 impl<T> InlineCompletionProviderHandle for Model<T>
@@ -118,7 +130,7 @@ where
         buffer: &Model<Buffer>,
         cursor_position: language::Anchor,
         cx: &'a AppContext,
-    ) -> Option<(&'a str, Option<Range<language::Anchor>>)> {
+    ) -> Option<CompletionProposal> {
         self.read(cx)
             .active_completion_text(buffer, cursor_position, cx)
     }
diff --git a/crates/supermaven/src/supermaven_completion_provider.rs b/crates/supermaven/src/supermaven_completion_provider.rs
index 8612187c61863d..41197717144265 100644
--- a/crates/supermaven/src/supermaven_completion_provider.rs
+++ b/crates/supermaven/src/supermaven_completion_provider.rs
@@ -1,12 +1,17 @@
 use crate::{Supermaven, SupermavenCompletionStateId};
 use anyhow::Result;
 use client::telemetry::Telemetry;
-use editor::{Direction, InlineCompletionProvider};
+use editor::{CompletionProposal, Direction, InlayProposal, InlineCompletionProvider};
 use futures::StreamExt as _;
 use gpui::{AppContext, EntityId, Model, ModelContext, Task};
-use language::{language_settings::all_language_settings, Anchor, Buffer};
-use std::{ops::Range, path::Path, sync::Arc, time::Duration};
-use text::ToPoint;
+use language::{language_settings::all_language_settings, Anchor, Buffer, BufferSnapshot};
+use std::{
+    ops::{AddAssign, Range},
+    path::Path,
+    sync::Arc,
+    time::Duration,
+};
+use text::{ToOffset, ToPoint};
 
 pub const DEBOUNCE_TIMEOUT: Duration = Duration::from_millis(75);
 
@@ -37,6 +42,69 @@ impl SupermavenCompletionProvider {
     }
 }
 
+// Computes the completion state from the difference between the completion text.
+// this is defined by greedily matching the buffer text against the completion text, with any leftover buffer placed at the end.
+// for example, given the completion text "moo cows are cool" and the buffer text "cowsre pool", the completion state would be
+// the inlays "moo ", " a", and "cool" which will render as "[moo ]cows[ a]re [cool]pool" in the editor.
+fn completion_state_from_diff(
+    snapshot: BufferSnapshot,
+    completion_text: &str,
+    position: Anchor,
+    delete_range: Range<Anchor>,
+) -> CompletionProposal {
+    let buffer_text = snapshot
+        .text_for_range(delete_range.clone())
+        .collect::<String>()
+        .chars()
+        .collect::<Vec<char>>();
+
+    let mut inlays: Vec<InlayProposal> = Vec::new();
+
+    let completion = completion_text.chars().collect::<Vec<char>>();
+
+    let mut offset = position.to_offset(&snapshot);
+
+    let mut i = 0;
+    let mut j = 0;
+    while i < completion.len() && j < buffer_text.len() {
+        // find the next instance of the buffer text in the completion text.
+        let k = completion[i..].iter().position(|c| *c == buffer_text[j]);
+        match k {
+            Some(k) => {
+                if k != 0 {
+                    // the range from the current position to item is an inlay.
+                    inlays.push(InlayProposal::Suggestion(
+                        snapshot.anchor_after(offset),
+                        completion_text[i..i + k].into(),
+                    ));
+                    offset.add_assign(j);
+                }
+                i += k + 1;
+                j += 1;
+            }
+            None => {
+                // there are no more matching completions, so drop the remaining
+                // completion text as an inlay.
+                break;
+            }
+        }
+    }
+
+    if j == buffer_text.len() && i < completion.len() {
+        // there is leftover completion text, so drop it as an inlay.
+        inlays.push(InlayProposal::Suggestion(
+            snapshot.anchor_after(offset),
+            completion_text[i..completion_text.len()].into(),
+        ));
+    }
+
+    CompletionProposal {
+        inlays,
+        text: completion_text.into(),
+        delete_range: Some(delete_range),
+    }
+}
+
 impl InlineCompletionProvider for SupermavenCompletionProvider {
     fn name() -> &'static str {
         "supermaven"
@@ -138,7 +206,7 @@ impl InlineCompletionProvider for SupermavenCompletionProvider {
         buffer: &Model<Buffer>,
         cursor_position: Anchor,
         cx: &'a AppContext,
-    ) -> Option<(&'a str, Option<Range<Anchor>>)> {
+    ) -> Option<CompletionProposal> {
         let completion_text = self
             .supermaven
             .read(cx)
@@ -153,7 +221,12 @@ impl InlineCompletionProvider for SupermavenCompletionProvider {
             let mut point = cursor_position.to_point(&snapshot);
             point.column = snapshot.line_len(point.row);
             let range = cursor_position..snapshot.anchor_after(point);
-            Some((completion_text, Some(range)))
+            Some(completion_state_from_diff(
+                snapshot,
+                completion_text,
+                cursor_position,
+                range,
+            ))
         } else {
             None
         }

From a141415bd31300495ad0d75e5d43a23ae97e9f45 Mon Sep 17 00:00:00 2001
From: thataboy <dearbart@yahoo.com>
Date: Mon, 16 Sep 2024 20:01:43 -0700
Subject: [PATCH 117/762] Add `cursor_shape` setting for the default editor
 (#17572)

Closes https://github.com/zed-industries/zed/issues/16451,
https://github.com/zed-industries/zed/issues/14447,
https://github.com/zed-industries/zed/issues/7203

Addresses but does not closes
https://github.com/zed-industries/zed/issues/5179

Expose cursor shape selection to users. Possibly controversial, since
block cursor seems preserved for vim and terminal. But the heart wants
what it wants?

Release Notes:

- Added a setting for `cursor_shape`. Can be `bar`, `block`,
`underline`, or `hollow`. Default is `bar`.
---
 assets/settings/default.json         | 12 +++++++++++
 crates/editor/src/editor.rs          |  3 ++-
 crates/editor/src/editor_settings.rs |  7 ++++++
 crates/language/src/buffer.rs        |  5 ++++-
 docs/src/configuring-zed.md          | 32 ++++++++++++++++++++++++++++
 5 files changed, 57 insertions(+), 2 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 22dafb2890fb5a..7c0dc831c31fdc 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -111,6 +111,18 @@
   "use_system_path_prompts": true,
   // Whether the cursor blinks in the editor.
   "cursor_blink": true,
+  // Cursor shape for the default editor.
+  //  1. A vertical bar
+  //     "bar"
+  //  2. A block that surrounds the following character
+  //     "block"
+  //  3. An underline that runs along the following character
+  //     "underscore"
+  //  4. A box drawn around the following character
+  //     "hollow"
+  //
+  // Default: bar
+  "cursor_shape": "bar",
   // How to highlight the current line in the editor.
   //
   // 1. Don't highlight the current line:
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index e46b87b0e2ffe9..e583f2d9632db8 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -1904,7 +1904,7 @@ impl Editor {
             linked_editing_range_task: Default::default(),
             pending_rename: Default::default(),
             searchable: true,
-            cursor_shape: Default::default(),
+            cursor_shape: EditorSettings::get_global(cx).cursor_shape,
             current_line_highlight: None,
             autoindent_mode: Some(AutoindentMode::EachLine),
             collapse_matches: false,
@@ -11820,6 +11820,7 @@ impl Editor {
             cx,
         );
         let editor_settings = EditorSettings::get_global(cx);
+        self.cursor_shape = editor_settings.cursor_shape;
         self.scroll_manager.vertical_scroll_margin = editor_settings.vertical_scroll_margin;
         self.show_breadcrumbs = editor_settings.toolbar.breadcrumbs;
 
diff --git a/crates/editor/src/editor_settings.rs b/crates/editor/src/editor_settings.rs
index 2614e4ea303d24..c6c5f111cb384f 100644
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -1,4 +1,5 @@
 use gpui::AppContext;
+use language::CursorShape;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
@@ -6,6 +7,7 @@ use settings::{Settings, SettingsSources};
 #[derive(Deserialize, Clone)]
 pub struct EditorSettings {
     pub cursor_blink: bool,
+    pub cursor_shape: CursorShape,
     pub current_line_highlight: CurrentLineHighlight,
     pub hover_popover_enabled: bool,
     pub show_completions_on_input: bool,
@@ -177,6 +179,11 @@ pub struct EditorSettingsContent {
     ///
     /// Default: true
     pub cursor_blink: Option<bool>,
+    /// Cursor shape for the default editor.
+    /// Can be "bar", "block", "underscore", or "hollow".
+    ///
+    /// Default: bar
+    pub cursor_shape: Option<CursorShape>,
     /// How to highlight the current line in the editor.
     ///
     /// Default: all
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 74080d01622e0d..59b2670dafd84e 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -26,6 +26,8 @@ use gpui::{
 };
 use lsp::LanguageServerId;
 use parking_lot::Mutex;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use settings::WorktreeId;
 use similar::{ChangeTag, TextDiff};
@@ -161,7 +163,8 @@ pub enum IndentKind {
 }
 
 /// The shape of a selection cursor.
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
+#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
 pub enum CursorShape {
     /// A vertical bar
     #[default]
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index d677b08200908c..87cd053f1a0d1b 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -293,6 +293,38 @@ List of `string` values
 
 `boolean` values
 
+## Cursor Shape
+
+- Description: Cursor shape for the default editor.
+- Setting: `cursor_shape`
+- Default: `bar`
+
+**Options**
+
+1. A vertical bar:
+
+```json
+"cursor_shape": "bar"
+```
+
+2. A block that surrounds the following character:
+
+```json
+"cursor_shape": "block"
+```
+
+3. An underline that runs along the following character:
+
+```json
+"cursor_shape": "underline"
+```
+
+4. An box drawn around the following character:
+
+```json
+"cursor_shape": "hollow"
+```
+
 ## Default Dock Anchor
 
 - Description: The default anchor for new docks.

From 83192c29e8affeac98ba29b6850c98f1af9ff993 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 16 Sep 2024 23:16:08 -0400
Subject: [PATCH 118/762] Try and fix tests (#17920)

Tests on main started breaking following
https://github.com/zed-industries/zed/commit/bc5ed1334ff019e026cbf7a6bbad4a8c2c5d68df
from:
- https://github.com/zed-industries/zed/pull/17734

First breakage:
https://github.com/zed-industries/zed/actions/runs/10894059586/job/30230118999
---
 crates/editor/src/editor_tests.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 57471612dbb611..6a8efc5905fbb1 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -4131,7 +4131,7 @@ async fn test_rewrap(cx: &mut TestAppContext) {
                 line_comments: vec!["// ".into(), "/// ".into()],
                 ..LanguageConfig::default()
             },
-            Some(tree_sitter_rust::language()),
+            Some(tree_sitter_rust::LANGUAGE.into()),
         ));
         cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
 

From 1285504b3e85a9b64f993ab7540393efdc4a68f0 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Mon, 16 Sep 2024 21:35:28 -0600
Subject: [PATCH 119/762] Fix panic in wasm extensions (#17922)

Release Notes:

- N/A

Co-authored-by: Peter Tripp <peter@zed.dev>
---
 crates/extension/src/wasm_host/wit/since_v0_1_0.rs | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/crates/extension/src/wasm_host/wit/since_v0_1_0.rs b/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
index 88d860391a477b..50547b6371c697 100644
--- a/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
+++ b/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
@@ -55,16 +55,7 @@ pub type ExtensionHttpResponseStream = Arc<Mutex<::http_client::Response<AsyncBo
 
 pub fn linker() -> &'static Linker<WasmState> {
     static LINKER: OnceLock<Linker<WasmState>> = OnceLock::new();
-    LINKER.get_or_init(|| {
-        super::new_linker(|linker, f| {
-            Extension::add_to_linker(linker, f)?;
-            latest::zed::extension::github::add_to_linker(linker, f)?;
-            latest::zed::extension::nodejs::add_to_linker(linker, f)?;
-            latest::zed::extension::platform::add_to_linker(linker, f)?;
-            latest::zed::extension::slash_command::add_to_linker(linker, f)?;
-            Ok(())
-        })
-    })
+    LINKER.get_or_init(|| super::new_linker(Extension::add_to_linker))
 }
 
 impl From<Command> for latest::Command {

From 4160824b1057fa90c35fdcefd2d2155366b2d8f4 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Mon, 16 Sep 2024 21:55:32 -0600
Subject: [PATCH 120/762] Update Rust crate rodio to 0.19.0 (#17389)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [rodio](https://redirect.github.com/RustAudio/rodio) | dependencies |
minor | `0.17.1` -> `0.19.0` |

---

### Release Notes

<details>
<summary>RustAudio/rodio (rodio)</summary>

###
[`v0.19.0`](https://redirect.github.com/RustAudio/rodio/blob/HEAD/CHANGELOG.md#Version-0190-2024-06-29)

[Compare
Source](https://redirect.github.com/RustAudio/rodio/compare/v0.18.1...v0.19.0)

##### Added

- Adds a new source `track_position`. It keeps track of duration since
the
    beginning of the underlying source.

##### Fixed

- Mp4a with decodable tracks after undecodable tracks now play. This
matches
    VLC's behaviour.

###
[`v0.18.1`](https://redirect.github.com/RustAudio/rodio/blob/HEAD/CHANGELOG.md#Version-0181-2024-05-23)

[Compare
Source](https://redirect.github.com/RustAudio/rodio/compare/v0.18.0...v0.18.1)

##### Fixed

-   Seek no longer hangs if the sink is empty.

###
[`v0.18.0`](https://redirect.github.com/RustAudio/rodio/blob/HEAD/CHANGELOG.md#Version-0180-2024-05-05)

[Compare
Source](https://redirect.github.com/RustAudio/rodio/compare/v0.17.3...v0.18.0)

##### Changed

- `Source` trait is now also implemented for `Box<dyn Source>` and `&mut
Source`
- `fn new_vorbis` is now also available when the `symphonia-vorbis`
feature is enabled

##### Added

- Adds a new method `try_seek` to all sources. It returns either an
error or
seeks to the given position. A few sources are "unsupported" they return
the
    error `Unsupported`.
-   Adds `SpatialSink::clear()` bringing it in line with `Sink`

##### Fixed

- channel upscaling now follows the 'WAVEFORMATEXTENSIBLE' format and no
longer
    repeats the last source channel on all extra output channels.
Stereo content playing on a 5.1 speaker set will now only use the front
left
and front right speaker instead of repeating the right sample on all
speakers
    except the front left one.
- `mp3::is_mp3()` no longer changes the position in the stream when the
stream
    is mp3

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC41OS4yIiwidXBkYXRlZEluVmVyIjoiMzguNTkuMiIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock              | 5 +++--
 crates/audio/Cargo.toml | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 111360b96547bd..b31beee09c62d7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9278,12 +9278,13 @@ dependencies = [
 
 [[package]]
 name = "rodio"
-version = "0.17.3"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b1bb7b48ee48471f55da122c0044fcc7600cfcc85db88240b89cb832935e611"
+checksum = "6006a627c1a38d37f3d3a85c6575418cfe34a5392d60a686d0071e1c8d427acb"
 dependencies = [
  "cpal",
  "hound",
+ "thiserror",
 ]
 
 [[package]]
diff --git a/crates/audio/Cargo.toml b/crates/audio/Cargo.toml
index bfe22de1f07482..9502b58f93274e 100644
--- a/crates/audio/Cargo.toml
+++ b/crates/audio/Cargo.toml
@@ -18,5 +18,5 @@ collections.workspace = true
 derive_more.workspace = true
 gpui.workspace = true
 parking_lot.workspace = true
-rodio = { version = "0.17.1", default-features = false, features = ["wav"] }
+rodio = { version = "0.19.0", default-features = false, features = ["wav"] }
 util.workspace = true

From 7d97855ed7fd7da2626a90baf9a6e7cba4f11439 Mon Sep 17 00:00:00 2001
From: Galen Elias <gelias@gmail.com>
Date: Mon, 16 Sep 2024 21:23:03 -0700
Subject: [PATCH 121/762] Use AppContext for UI font adjustments (#17858)

Appologies if this PR is off base, I'm still not super familiar with the
Zed codebase.

I was trying to integrate with
https://github.com/zed-industries/zed/pull/12940
and found it awkward to hook up global bindings to adjust the UI font
size due to the fact it takes a WindowContext. Looking at the API, it
seemed odd that it took a WindowContext, yet the editor font methods
take an AppContext.

I couldn't find a compelling reason for this to be tied to a
WindowContext, so I personally think it makes sense to switch it.

This does have a behavior change, which hopefully is actually desirable:

Currently, if you have two open and visible Zed windows, and trigger a
UI font adjustment in one, the non-active windows won't update. However,
once you switch focus to the second one it will snap to the new UI font
size. This is inconsistent with adjusting the editor font size, which
applies to all open windows immediately.

Release Notes:

- N/A
---
 crates/theme/src/settings.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/theme/src/settings.rs b/crates/theme/src/settings.rs
index 4d0b4f0215aada..7fa9a870de559b 100644
--- a/crates/theme/src/settings.rs
+++ b/crates/theme/src/settings.rs
@@ -491,13 +491,13 @@ pub fn setup_ui_font(cx: &mut WindowContext) -> gpui::Font {
     ui_font
 }
 
-pub fn get_ui_font_size(cx: &WindowContext) -> Pixels {
+pub fn get_ui_font_size(cx: &AppContext) -> Pixels {
     let ui_font_size = ThemeSettings::get_global(cx).ui_font_size;
     cx.try_global::<AdjustedUiFontSize>()
         .map_or(ui_font_size, |adjusted_size| adjusted_size.0)
 }
 
-pub fn adjust_ui_font_size(cx: &mut WindowContext, f: fn(&mut Pixels)) {
+pub fn adjust_ui_font_size(cx: &mut AppContext, f: fn(&mut Pixels)) {
     let ui_font_size = ThemeSettings::get_global(cx).ui_font_size;
     let mut adjusted_size = cx
         .try_global::<AdjustedUiFontSize>()
@@ -513,7 +513,7 @@ pub fn has_adjusted_ui_font_size(cx: &mut AppContext) -> bool {
     cx.has_global::<AdjustedUiFontSize>()
 }
 
-pub fn reset_ui_font_size(cx: &mut WindowContext) {
+pub fn reset_ui_font_size(cx: &mut AppContext) {
     if cx.has_global::<AdjustedUiFontSize>() {
         cx.remove_global::<AdjustedUiFontSize>();
         cx.refresh();

From d56e3d99b4a0dddbacd4e762c9be83d2f39f48ba Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 17 Sep 2024 10:17:03 +0200
Subject: [PATCH 122/762] rust: Fix looking up `rust-analyzer` in `$PATH` by
 default (#17926)

This is a follow-up to https://github.com/zed-industries/zed/pull/17885,
which is reverted and fixed in this PR.

This PR actually enables the behavior by default.

Release Notes:

- Changed `rust-analyzer` support to lookup `rust-analyzer` binaries by
default in `$PATH`. That changes the default value to something users
requested.
---
 crates/languages/src/rust.rs | 82 ++++++++++++++++++++----------------
 1 file changed, 46 insertions(+), 36 deletions(-)

diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs
index d102276e440c09..456ea8e4492eda 100644
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -38,45 +38,55 @@ impl LspAdapter for RustLspAdapter {
         delegate: &dyn LspAdapterDelegate,
         cx: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
-        let configured_binary = cx.update(|cx| {
-            language_server_settings(delegate, Self::SERVER_NAME, cx).and_then(|s| s.binary.clone())
-        });
-
-        match configured_binary {
-            Ok(Some(BinarySettings {
-                path,
+        let configured_binary = cx
+            .update(|cx| {
+                language_server_settings(delegate, Self::SERVER_NAME, cx)
+                    .and_then(|s| s.binary.clone())
+            })
+            .ok()?;
+
+        let (path, env, arguments) = match configured_binary {
+            // If nothing is configured, or path_lookup explicitly enabled,
+            // we lookup the binary in the path.
+            None
+            | Some(BinarySettings {
+                path: None,
+                path_lookup: Some(true),
+                ..
+            })
+            | Some(BinarySettings {
+                path: None,
+                path_lookup: None,
+                ..
+            }) => {
+                let path = delegate.which(Self::SERVER_NAME.as_ref()).await;
+                let env = delegate.shell_env().await;
+                (path, Some(env), None)
+            }
+            // Otherwise, we use the configured binary.
+            Some(BinarySettings {
+                path: Some(path),
                 arguments,
                 path_lookup,
-            })) => {
-                let (path, env) = match (path, path_lookup) {
-                    (Some(path), lookup) => {
-                        if lookup.is_some() {
-                            log::warn!(
-                                "Both `path` and `path_lookup` are set, ignoring `path_lookup`"
-                            );
-                        }
-                        (Some(path.into()), None)
-                    }
-                    (None, Some(true)) | (None, None) => {
-                        // Try to lookup rust-analyzer in PATH by default.
-                        let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
-                        let env = delegate.shell_env().await;
-                        (Some(path), Some(env))
-                    }
-                    (None, Some(false)) => (None, None),
-                };
-                path.map(|path| LanguageServerBinary {
-                    path,
-                    arguments: arguments
-                        .unwrap_or_default()
-                        .iter()
-                        .map(|arg| arg.into())
-                        .collect(),
-                    env,
-                })
+            }) => {
+                if path_lookup.is_some() {
+                    log::warn!("Both `path` and `path_lookup` are set, ignoring `path_lookup`");
+                }
+                (Some(path.into()), None, arguments)
             }
-            _ => None,
-        }
+
+            _ => (None, None, None),
+        };
+
+        path.map(|path| LanguageServerBinary {
+            path,
+            env,
+            arguments: arguments
+                .unwrap_or_default()
+                .iter()
+                .map(|arg| arg.into())
+                .collect(),
+        })
     }
 
     async fn fetch_latest_server_version(

From 5f0925fb5d26704e37ad943859af2db3ffa57892 Mon Sep 17 00:00:00 2001
From: ClanEver <562211524@qq.com>
Date: Tue, 17 Sep 2024 17:17:29 +0800
Subject: [PATCH 123/762] Add Python venv activation support for Windows and
 PowerShell (#17839)

Release Notes:

- Add Python venv activation support for Windows and PowerShell

Additional:

I discovered a related bug on my Windows system. When first opening the
project, it fails to detect the virtual environment folder `.venv`.
After expanding the .venv folder in the Project Panel, it then becomes
able to detect the virtual environment folder. However, I don't know how
to fix it.
---
 assets/settings/default.json             |  2 +-
 crates/project/src/terminals.rs          | 31 ++++++++++++++++++------
 crates/terminal/src/terminal_settings.rs |  1 +
 3 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 7c0dc831c31fdc..7f8c823210efa3 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -710,7 +710,7 @@
         // to the current working directory. We recommend overriding this
         // in your project's settings, rather than globally.
         "directories": [".env", "env", ".venv", "venv"],
-        // Can also be `csh`, `fish`, and `nushell`
+        // Can also be `csh`, `fish`, `nushell` and `power_shell`
         "activate_script": "default"
       }
     },
diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs
index 6793c028f71795..136842d158604c 100644
--- a/crates/project/src/terminals.rs
+++ b/crates/project/src/terminals.rs
@@ -259,12 +259,16 @@ impl Project {
         cx: &AppContext,
     ) -> Option<PathBuf> {
         let venv_settings = settings.detect_venv.as_option()?;
+        let bin_dir_name = match std::env::consts::OS {
+            "windows" => "Scripts",
+            _ => "bin",
+        };
         venv_settings
             .directories
             .iter()
             .map(|virtual_environment_name| abs_path.join(virtual_environment_name))
             .find(|venv_path| {
-                let bin_path = venv_path.join("bin");
+                let bin_path = venv_path.join(bin_dir_name);
                 self.find_worktree(&bin_path, cx)
                     .and_then(|(worktree, relative_path)| {
                         worktree.read(cx).entry_for_path(&relative_path)
@@ -279,23 +283,36 @@ impl Project {
         settings: &TerminalSettings,
     ) -> Option<String> {
         let venv_settings = settings.detect_venv.as_option()?;
+        let activate_keyword = match venv_settings.activate_script {
+            terminal_settings::ActivateScript::Default => match std::env::consts::OS {
+                "windows" => ".",
+                _ => "source",
+            },
+            terminal_settings::ActivateScript::Nushell => "overlay use",
+            terminal_settings::ActivateScript::PowerShell => ".",
+            _ => "source",
+        };
         let activate_script_name = match venv_settings.activate_script {
             terminal_settings::ActivateScript::Default => "activate",
             terminal_settings::ActivateScript::Csh => "activate.csh",
             terminal_settings::ActivateScript::Fish => "activate.fish",
             terminal_settings::ActivateScript::Nushell => "activate.nu",
+            terminal_settings::ActivateScript::PowerShell => "activate.ps1",
         };
         let path = venv_base_directory
-            .join("bin")
+            .join(match std::env::consts::OS {
+                "windows" => "Scripts",
+                _ => "bin",
+            })
             .join(activate_script_name)
             .to_string_lossy()
             .to_string();
         let quoted = shlex::try_quote(&path).ok()?;
-
-        Some(match venv_settings.activate_script {
-            terminal_settings::ActivateScript::Nushell => format!("overlay use {}\n", quoted),
-            _ => format!("source {}\n", quoted),
-        })
+        let line_ending = match std::env::consts::OS {
+            "windows" => "\r",
+            _ => "\n",
+        };
+        Some(format!("{} {}{}", activate_keyword, quoted, line_ending))
     }
 
     fn activate_python_virtual_environment(
diff --git a/crates/terminal/src/terminal_settings.rs b/crates/terminal/src/terminal_settings.rs
index 6c950526124016..4051caf864d25f 100644
--- a/crates/terminal/src/terminal_settings.rs
+++ b/crates/terminal/src/terminal_settings.rs
@@ -87,6 +87,7 @@ pub enum ActivateScript {
     Csh,
     Fish,
     Nushell,
+    PowerShell,
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]

From c34fc5c6e504bb66bc8973a2c95fc358b613cfea Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 17 Sep 2024 11:47:17 +0200
Subject: [PATCH 124/762] lsp store: Refactor to use shared method to find
 buffer snapshot (#17929)

Came across this code while investigating something else and I think we
should use the same method. As far as I know, it does the same thing,
except that `buffer_snapshot_for_lsp_version` also cleans up the stored
snapshots.

Release Notes:

- N/A
---
 crates/project/src/lsp_store.rs | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index ee02492dd8cfda..fb3d52eb9ebc62 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -6383,21 +6383,16 @@ impl LspStore {
                                 let buffer_id = buffer_to_edit.read(cx).remote_id();
                                 let version = if let Some(buffer_version) = op.text_document.version
                                 {
-                                    this.buffer_snapshots
-                                        .get(&buffer_id)
-                                        .and_then(|server_to_snapshots| {
-                                            let all_snapshots = server_to_snapshots
-                                                .get(&language_server.server_id())?;
-                                            all_snapshots
-                                                .binary_search_by_key(&buffer_version, |snapshot| {
-                                                    snapshot.version
-                                                })
-                                                .ok()
-                                                .and_then(|index| all_snapshots.get(index))
-                                        })
-                                        .map(|lsp_snapshot| lsp_snapshot.snapshot.version())
+                                    this.buffer_snapshot_for_lsp_version(
+                                        &buffer_to_edit,
+                                        language_server.server_id(),
+                                        Some(buffer_version),
+                                        cx,
+                                    )
+                                    .ok()
+                                    .map(|snapshot| snapshot.version)
                                 } else {
-                                    Some(buffer_to_edit.read(cx).saved_version())
+                                    Some(buffer_to_edit.read(cx).saved_version().clone())
                                 };
 
                                 let most_recent_edit = version.and_then(|version| {

From 2165d52d3e97d0477d9769a2c4138b9e6d4b0531 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 17 Sep 2024 14:33:53 +0200
Subject: [PATCH 125/762] project: Update variable and change comment (#17933)

Previous this *was* the `cli_environment`, but now it's the project
environment.

Release Notes:

- N/A
---
 crates/language/src/language_registry.rs | 15 ++++++++-------
 crates/project/src/lsp_store.rs          |  4 ++--
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index 4870c4ed539157..918da4873f8667 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -860,7 +860,7 @@ impl LanguageRegistry {
         adapter: Arc<CachedLspAdapter>,
         root_path: Arc<Path>,
         delegate: Arc<dyn LspAdapterDelegate>,
-        cli_environment: Shared<Task<Option<HashMap<String, String>>>>,
+        project_environment: Shared<Task<Option<HashMap<String, String>>>>,
         cx: &mut AppContext,
     ) -> Option<PendingLanguageServer> {
         let server_id = self.state.write().next_language_server_id();
@@ -881,7 +881,7 @@ impl LanguageRegistry {
         let task = cx.spawn({
             let container_dir = container_dir.clone();
             move |mut cx| async move {
-                let cli_environment = cli_environment.await;
+                let project_environment = project_environment.await;
 
                 let binary_result = adapter
                     .clone()
@@ -892,15 +892,16 @@ impl LanguageRegistry {
 
                 let mut binary = binary_result?;
 
-                // If this Zed project was opened from the CLI and the language server command itself
+                // If we do have a project environment (either by spawning a shell in in the project directory
+                // or by getting it from the CLI) and the language server command itself
                 // doesn't have an environment (which it would have, if it was found in $PATH), then
-                // we pass along the CLI environment that we inherited.
-                if binary.env.is_none() && cli_environment.is_some() {
+                // we use the project environment.
+                if binary.env.is_none() && project_environment.is_some() {
                     log::info!(
-                        "using CLI environment for language server {:?}, id: {server_id}",
+                        "using project environment for language server {:?}, id: {server_id}",
                         adapter.name.0
                     );
-                    binary.env = cli_environment.clone();
+                    binary.env = project_environment.clone();
                 }
 
                 let options = adapter
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index fb3d52eb9ebc62..e1e6001d24b96b 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -4646,7 +4646,7 @@ impl LspStore {
 
         let stderr_capture = Arc::new(Mutex::new(Some(String::new())));
         let lsp_adapter_delegate = ProjectLspAdapterDelegate::for_local(self, worktree_handle, cx);
-        let cli_environment = local.environment.update(cx, |environment, cx| {
+        let project_environment = local.environment.update(cx, |environment, cx| {
             environment.get_environment(Some(worktree_id), Some(worktree_path.clone()), cx)
         });
 
@@ -4656,7 +4656,7 @@ impl LspStore {
             adapter.clone(),
             Arc::clone(&worktree_path),
             lsp_adapter_delegate.clone(),
-            cli_environment,
+            project_environment,
             cx,
         ) {
             Some(pending_server) => pending_server,

From 103f757c114c2712df5f98f05bb64ff1ff9ef2d0 Mon Sep 17 00:00:00 2001
From: Daste <stefankar1000@gmail.com>
Date: Tue, 17 Sep 2024 14:48:05 +0200
Subject: [PATCH 126/762] tab_switcher: Add file and project search icons
 (#17115)

I found tab switcher file icons to be missing. They were mentioned in
the [initial tab switcher
issue](https://github.com/zed-industries/zed/issues/7653), but left to
be added later (mentioned in
https://github.com/zed-industries/zed/pull/7987).

I also noticed that the project search icon went missing, but I'm not
sure if that's intentional. These changes re-introduce it, as it's
provided by the generic `tab_icon()` function.

There's a small difference between the terminal item and everything
else, because terminal's `tab_content` returns a slightly different
layout, which adds a little more space between the icon and text. I'll
look into resolving this withouth changing too much stuff around in the
terminal crate. If you have any ideas on how to do this well, please
comment.

The new `tab_switcher` config section only has a single boolean option -
`show_icons`. It toggles between icons and not icons, but doesn't
disable the terminal icon. Implementing this would probably also require
some refactoring in terminal's `tab_content` function.

Release Notes:

- Added file icons to the tab switcher

Screenshot:

![image](https://github.com/user-attachments/assets/17f3f4a3-1f95-4830-aef1-cda280726385)
---
 crates/diagnostics/src/diagnostics.rs     | 59 ++++++++++++-----------
 crates/tab_switcher/src/tab_switcher.rs   |  3 ++
 crates/terminal_view/src/terminal_view.rs |  2 +-
 3 files changed, 36 insertions(+), 28 deletions(-)

diff --git a/crates/diagnostics/src/diagnostics.rs b/crates/diagnostics/src/diagnostics.rs
index ddf39e0bfa2424..eec4f735ec38e5 100644
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -645,37 +645,42 @@ impl Item for ProjectDiagnosticsEditor {
     }
 
     fn tab_content(&self, params: TabContentParams, _: &WindowContext) -> AnyElement {
-        if self.summary.error_count == 0 && self.summary.warning_count == 0 {
-            Label::new("No problems")
-                .color(params.text_color())
-                .into_any_element()
-        } else {
-            h_flex()
-                .gap_1()
-                .when(self.summary.error_count > 0, |then| {
+        h_flex()
+            .gap_1()
+            .when(
+                self.summary.error_count == 0 && self.summary.warning_count == 0,
+                |then| {
                     then.child(
                         h_flex()
                             .gap_1()
-                            .child(Icon::new(IconName::XCircle).color(Color::Error))
-                            .child(
-                                Label::new(self.summary.error_count.to_string())
-                                    .color(params.text_color()),
-                            ),
+                            .child(Icon::new(IconName::Check).color(Color::Success))
+                            .child(Label::new("No problems").color(params.text_color())),
                     )
-                })
-                .when(self.summary.warning_count > 0, |then| {
-                    then.child(
-                        h_flex()
-                            .gap_1()
-                            .child(Icon::new(IconName::Warning).color(Color::Warning))
-                            .child(
-                                Label::new(self.summary.warning_count.to_string())
-                                    .color(params.text_color()),
-                            ),
-                    )
-                })
-                .into_any_element()
-        }
+                },
+            )
+            .when(self.summary.error_count > 0, |then| {
+                then.child(
+                    h_flex()
+                        .gap_1()
+                        .child(Icon::new(IconName::XCircle).color(Color::Error))
+                        .child(
+                            Label::new(self.summary.error_count.to_string())
+                                .color(params.text_color()),
+                        ),
+                )
+            })
+            .when(self.summary.warning_count > 0, |then| {
+                then.child(
+                    h_flex()
+                        .gap_1()
+                        .child(Icon::new(IconName::Warning).color(Color::Warning))
+                        .child(
+                            Label::new(self.summary.warning_count.to_string())
+                                .color(params.text_color()),
+                        ),
+                )
+            })
+            .into_any_element()
     }
 
     fn telemetry_event_text(&self) -> Option<&'static str> {
diff --git a/crates/tab_switcher/src/tab_switcher.rs b/crates/tab_switcher/src/tab_switcher.rs
index e8966ac5b91769..0b3eaf9e8a5d2a 100644
--- a/crates/tab_switcher/src/tab_switcher.rs
+++ b/crates/tab_switcher/src/tab_switcher.rs
@@ -378,6 +378,9 @@ impl PickerDelegate for TabSwitcherDelegate {
                 .inset(true)
                 .selected(selected)
                 .child(h_flex().w_full().child(label))
+                .when_some(tab_match.item.tab_icon(cx), |el, icon| {
+                    el.start_slot(div().child(icon))
+                })
                 .map(|el| {
                     if self.selected_index == ix {
                         el.end_slot::<AnyElement>(close_button)
diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs
index 1869e33383d177..f19bfa70101ce3 100644
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -1008,7 +1008,7 @@ impl Item for TerminalView {
         };
 
         h_flex()
-            .gap_2()
+            .gap_1()
             .group("term-tab-icon")
             .child(
                 h_flex()

From 4139a9a75862cbb8922a7f74537e09aad5ca1e62 Mon Sep 17 00:00:00 2001
From: iugo <iugogogo@gmail.com>
Date: Tue, 17 Sep 2024 21:23:48 +0800
Subject: [PATCH 127/762] docs: Document usage of deno fmt (#17918)

Clarify in the settings description that the default formatter leverages `deno fmt`. This makes it clearer for users what to expect and how formatting is handled out of the box.

Co-authored-by: Peter Tripp <peter@zed.dev>
---
 docs/src/languages/deno.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/docs/src/languages/deno.md b/docs/src/languages/deno.md
index 5b92acfeeb049b..9ba1526ab0fe97 100644
--- a/docs/src/languages/deno.md
+++ b/docs/src/languages/deno.md
@@ -26,7 +26,8 @@ To use the Deno Language Server with TypeScript and TSX files, you will likely w
         "!typescript-language-server",
         "!vtsls",
         "!eslint"
-      ]
+      ],
+      "formatter": "language_server"
     },
     "TSX": {
       "language_servers": [
@@ -34,7 +35,8 @@ To use the Deno Language Server with TypeScript and TSX files, you will likely w
         "!typescript-language-server",
         "!vtsls",
         "!eslint"
-      ]
+      ],
+      "formatter": "language_server"
     }
   }
 }

From f1d21362fa2b40406c2a71da7b4353d622095ea7 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 17 Sep 2024 15:37:43 +0200
Subject: [PATCH 128/762] editor: Fix cursor_shape regression by not setting it
 to "bar" (#17934)

This fixes the regression introduced here:
https://github.com/zed-industries/zed/pull/17572#issuecomment-2355632615

Essentially: instead of always setting the value when saving settings,
we don't set it by default, but fall back to the default value if it's
not set.

That fixes Vim mode's cursor being overwritten when settings change.

Release Notes:

- N/A
---
 assets/settings/default.json         | 4 ++--
 crates/editor/src/editor.rs          | 8 ++++++--
 crates/editor/src/editor_settings.rs | 4 ++--
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 7f8c823210efa3..35b2ca20f2a44b 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -121,8 +121,8 @@
   //  4. A box drawn around the following character
   //     "hollow"
   //
-  // Default: bar
-  "cursor_shape": "bar",
+  // Default: not set, defaults to "bar"
+  "cursor_shape": null,
   // How to highlight the current line in the editor.
   //
   // 1. Don't highlight the current line:
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index e583f2d9632db8..c3c54e49513d7a 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -1904,7 +1904,9 @@ impl Editor {
             linked_editing_range_task: Default::default(),
             pending_rename: Default::default(),
             searchable: true,
-            cursor_shape: EditorSettings::get_global(cx).cursor_shape,
+            cursor_shape: EditorSettings::get_global(cx)
+                .cursor_shape
+                .unwrap_or_default(),
             current_line_highlight: None,
             autoindent_mode: Some(AutoindentMode::EachLine),
             collapse_matches: false,
@@ -11820,7 +11822,9 @@ impl Editor {
             cx,
         );
         let editor_settings = EditorSettings::get_global(cx);
-        self.cursor_shape = editor_settings.cursor_shape;
+        if let Some(cursor_shape) = editor_settings.cursor_shape {
+            self.cursor_shape = cursor_shape;
+        }
         self.scroll_manager.vertical_scroll_margin = editor_settings.vertical_scroll_margin;
         self.show_breadcrumbs = editor_settings.toolbar.breadcrumbs;
 
diff --git a/crates/editor/src/editor_settings.rs b/crates/editor/src/editor_settings.rs
index c6c5f111cb384f..d651e76c2c2e7d 100644
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -7,7 +7,7 @@ use settings::{Settings, SettingsSources};
 #[derive(Deserialize, Clone)]
 pub struct EditorSettings {
     pub cursor_blink: bool,
-    pub cursor_shape: CursorShape,
+    pub cursor_shape: Option<CursorShape>,
     pub current_line_highlight: CurrentLineHighlight,
     pub hover_popover_enabled: bool,
     pub show_completions_on_input: bool,
@@ -182,7 +182,7 @@ pub struct EditorSettingsContent {
     /// Cursor shape for the default editor.
     /// Can be "bar", "block", "underscore", or "hollow".
     ///
-    /// Default: bar
+    /// Default: None
     pub cursor_shape: Option<CursorShape>,
     /// How to highlight the current line in the editor.
     ///

From c48584fb7964d998b7bfe8f426f60f909db496d4 Mon Sep 17 00:00:00 2001
From: Kevin Wang <kevmo314@gmail.com>
Date: Tue, 17 Sep 2024 07:04:33 -0700
Subject: [PATCH 129/762] supermaven: Fix incorrect offset calculation (#17925)

Fixes a bug in https://github.com/zed-industries/zed/pull/17578 when
computing the offset. Specifically, `offset.add_assign()` should be
incremented on every loop match instead of only when the completion text
is found.

Before:


![image](https://github.com/user-attachments/assets/cc09dbf9-03e8-4453-a1c7-11f838c1d959)

After:


![image](https://github.com/user-attachments/assets/f3513769-d9e1-451f-97dc-b9ad3a57ce3a)

Release Notes:

- Fixed a wrong offset calculation in the Supermaven inline completion
provider.
---
 crates/supermaven/src/supermaven_completion_provider.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/supermaven/src/supermaven_completion_provider.rs b/crates/supermaven/src/supermaven_completion_provider.rs
index 41197717144265..261ce372d9f717 100644
--- a/crates/supermaven/src/supermaven_completion_provider.rs
+++ b/crates/supermaven/src/supermaven_completion_provider.rs
@@ -77,10 +77,10 @@ fn completion_state_from_diff(
                         snapshot.anchor_after(offset),
                         completion_text[i..i + k].into(),
                     ));
-                    offset.add_assign(j);
                 }
                 i += k + 1;
                 j += 1;
+                offset.add_assign(1);
             }
             None => {
                 // there are no more matching completions, so drop the remaining

From a20c0eb62648adb99834c37cfba0961daf771d36 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 17 Sep 2024 10:06:33 -0400
Subject: [PATCH 130/762] Improve error message when docs need fixing with
 Prettier (#17907)

---
 .github/workflows/docs.yml | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index be0f3c5a823524..13fe0411a022ac 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -20,5 +20,11 @@ jobs:
         with:
           version: 9
 
-      - run: pnpm dlx prettier . --check
+      - run: |
+          pnpm dlx prettier . --check || {
+            echo "To fix, run from the root of the zed repo:"
+            echo "  cd docs && pnpm dlx prettier . --write && cd .."
+            false
+          }
+
         working-directory: ./docs

From 54b8232be2013e955e7b7d2a61cc82dc18cea5fa Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Tue, 17 Sep 2024 08:47:08 -0600
Subject: [PATCH 131/762] Introduce a new `/delta` command (#17903)

Release Notes:

- Added a new `/delta` command to re-insert changed files that were
previously included in a context.

---------

Co-authored-by: Roy <roy@anthropic.com>
---
 Cargo.lock                                    |   1 +
 crates/assistant/src/assistant.rs             |   7 +-
 crates/assistant/src/assistant_panel.rs       |  17 +-
 crates/assistant/src/context.rs               |  15 +-
 crates/assistant/src/context/context_tests.rs |   5 +-
 crates/assistant/src/slash_command.rs         |   1 +
 .../src/slash_command/auto_command.rs         |   4 +-
 .../slash_command/context_server_command.rs   |   6 +-
 .../src/slash_command/default_command.rs      |   5 +-
 .../src/slash_command/delta_command.rs        | 109 ++++++++
 .../src/slash_command/diagnostics_command.rs  | 234 +++++-----------
 .../src/slash_command/docs_command.rs         |   5 +-
 .../src/slash_command/fetch_command.rs        |   5 +-
 .../src/slash_command/file_command.rs         | 260 ++++++++----------
 .../src/slash_command/now_command.rs          |   5 +-
 .../src/slash_command/project_command.rs      |   5 +-
 .../src/slash_command/prompt_command.rs       |   5 +-
 .../src/slash_command/search_command.rs       |   3 +
 .../src/slash_command/symbols_command.rs      |   5 +-
 .../src/slash_command/tab_command.rs          |  47 +---
 .../src/slash_command/terminal_command.rs     |   5 +-
 .../src/slash_command/workflow_command.rs     |   5 +-
 crates/assistant_slash_command/Cargo.toml     |   1 +
 .../src/assistant_slash_command.rs            |  13 +-
 .../extension/src/extension_slash_command.rs  |   5 +-
 crates/proto/proto/zed.proto                  |   1 +
 26 files changed, 408 insertions(+), 366 deletions(-)
 create mode 100644 crates/assistant/src/slash_command/delta_command.rs

diff --git a/Cargo.lock b/Cargo.lock
index b31beee09c62d7..6d0f7f54a01770 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -455,6 +455,7 @@ dependencies = [
  "language",
  "parking_lot",
  "serde",
+ "serde_json",
  "workspace",
 ]
 
diff --git a/crates/assistant/src/assistant.rs b/crates/assistant/src/assistant.rs
index 7a73c188ec9dc1..af7f03ebb35264 100644
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -41,9 +41,9 @@ use semantic_index::{CloudEmbeddingProvider, SemanticDb};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings, SettingsStore};
 use slash_command::{
-    auto_command, context_server_command, default_command, diagnostics_command, docs_command,
-    fetch_command, file_command, now_command, project_command, prompt_command, search_command,
-    symbols_command, tab_command, terminal_command, workflow_command,
+    auto_command, context_server_command, default_command, delta_command, diagnostics_command,
+    docs_command, fetch_command, file_command, now_command, project_command, prompt_command,
+    search_command, symbols_command, tab_command, terminal_command, workflow_command,
 };
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -367,6 +367,7 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
     let slash_command_registry = SlashCommandRegistry::global(cx);
 
     slash_command_registry.register_command(file_command::FileSlashCommand, true);
+    slash_command_registry.register_command(delta_command::DeltaSlashCommand, true);
     slash_command_registry.register_command(symbols_command::OutlineSlashCommand, true);
     slash_command_registry.register_command(tab_command::TabSlashCommand, true);
     slash_command_registry.register_command(project_command::ProjectSlashCommand, true);
diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 59f5e81d054c3f..52838b5c77b190 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -1906,7 +1906,22 @@ impl ContextEditor {
         cx: &mut ViewContext<Self>,
     ) {
         if let Some(command) = SlashCommandRegistry::global(cx).command(name) {
-            let output = command.run(arguments, workspace, self.lsp_adapter_delegate.clone(), cx);
+            let context = self.context.read(cx);
+            let sections = context
+                .slash_command_output_sections()
+                .into_iter()
+                .filter(|section| section.is_valid(context.buffer().read(cx)))
+                .cloned()
+                .collect::<Vec<_>>();
+            let snapshot = context.buffer().read(cx).snapshot();
+            let output = command.run(
+                arguments,
+                &sections,
+                snapshot,
+                workspace,
+                self.lsp_adapter_delegate.clone(),
+                cx,
+            );
             self.context.update(cx, |context, cx| {
                 context.insert_command_output(
                     command_range,
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index 38ccddb962d336..d55b1aee088642 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -48,7 +48,7 @@ use std::{
 };
 use telemetry_events::AssistantKind;
 use text::BufferSnapshot;
-use util::{post_inc, TryFutureExt};
+use util::{post_inc, ResultExt, TryFutureExt};
 use uuid::Uuid;
 
 #[derive(Clone, Eq, PartialEq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
@@ -162,6 +162,9 @@ impl ContextOperation {
                                 )?,
                                 icon: section.icon_name.parse()?,
                                 label: section.label.into(),
+                                metadata: section
+                                    .metadata
+                                    .and_then(|metadata| serde_json::from_str(&metadata).log_err()),
                             })
                         })
                         .collect::<Result<Vec<_>>>()?,
@@ -242,6 +245,9 @@ impl ContextOperation {
                                     )),
                                     icon_name: icon_name.to_string(),
                                     label: section.label.to_string(),
+                                    metadata: section.metadata.as_ref().and_then(|metadata| {
+                                        serde_json::to_string(metadata).log_err()
+                                    }),
                                 }
                             })
                             .collect(),
@@ -635,12 +641,13 @@ impl Context {
                 .slash_command_output_sections
                 .iter()
                 .filter_map(|section| {
-                    let range = section.range.to_offset(buffer);
-                    if section.range.start.is_valid(buffer) && !range.is_empty() {
+                    if section.is_valid(buffer) {
+                        let range = section.range.to_offset(buffer);
                         Some(assistant_slash_command::SlashCommandOutputSection {
                             range,
                             icon: section.icon,
                             label: section.label.clone(),
+                            metadata: section.metadata.clone(),
                         })
                     } else {
                         None
@@ -1825,6 +1832,7 @@ impl Context {
                                         ..buffer.anchor_before(start + section.range.end),
                                     icon: section.icon,
                                     label: section.label,
+                                    metadata: section.metadata,
                                 })
                                 .collect::<Vec<_>>();
                             sections.sort_by(|a, b| a.range.cmp(&b.range, buffer));
@@ -2977,6 +2985,7 @@ impl SavedContext {
                             ..buffer.anchor_before(section.range.end),
                         icon: section.icon,
                         label: section.label,
+                        metadata: section.metadata,
                     }
                 })
                 .collect(),
diff --git a/crates/assistant/src/context/context_tests.rs b/crates/assistant/src/context/context_tests.rs
index c851ca7438f5b0..842ac050786344 100644
--- a/crates/assistant/src/context/context_tests.rs
+++ b/crates/assistant/src/context/context_tests.rs
@@ -12,7 +12,7 @@ use assistant_slash_command::{
 use collections::HashSet;
 use fs::FakeFs;
 use gpui::{AppContext, Model, SharedString, Task, TestAppContext, WeakView};
-use language::{Buffer, LanguageRegistry, LspAdapterDelegate};
+use language::{Buffer, BufferSnapshot, LanguageRegistry, LspAdapterDelegate};
 use language_model::{LanguageModelCacheConfiguration, LanguageModelRegistry, Role};
 use parking_lot::Mutex;
 use project::Project;
@@ -1089,6 +1089,7 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
                             range: section_start..section_end,
                             icon: ui::IconName::Ai,
                             label: "section".into(),
+                            metadata: None,
                         });
                     }
 
@@ -1425,6 +1426,8 @@ impl SlashCommand for FakeSlashCommand {
     fn run(
         self: Arc<Self>,
         _arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         _cx: &mut WindowContext,
diff --git a/crates/assistant/src/slash_command.rs b/crates/assistant/src/slash_command.rs
index 387e8231e47842..cf957a15c67d9d 100644
--- a/crates/assistant/src/slash_command.rs
+++ b/crates/assistant/src/slash_command.rs
@@ -22,6 +22,7 @@ use workspace::Workspace;
 pub mod auto_command;
 pub mod context_server_command;
 pub mod default_command;
+pub mod delta_command;
 pub mod diagnostics_command;
 pub mod docs_command;
 pub mod fetch_command;
diff --git a/crates/assistant/src/slash_command/auto_command.rs b/crates/assistant/src/slash_command/auto_command.rs
index cedfc63702b9aa..e1f20c311bd36e 100644
--- a/crates/assistant/src/slash_command/auto_command.rs
+++ b/crates/assistant/src/slash_command/auto_command.rs
@@ -1,7 +1,7 @@
 use super::create_label_for_command;
 use super::{SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Result};
-use assistant_slash_command::ArgumentCompletion;
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use feature_flags::FeatureFlag;
 use futures::StreamExt;
 use gpui::{AppContext, AsyncAppContext, Task, WeakView};
@@ -87,6 +87,8 @@ impl SlashCommand for AutoCommand {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: language::BufferSnapshot,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
diff --git a/crates/assistant/src/slash_command/context_server_command.rs b/crates/assistant/src/slash_command/context_server_command.rs
index 8ae9430a993e16..6b1ae39186d28f 100644
--- a/crates/assistant/src/slash_command/context_server_command.rs
+++ b/crates/assistant/src/slash_command/context_server_command.rs
@@ -9,7 +9,7 @@ use context_servers::{
     protocol::PromptInfo,
 };
 use gpui::{Task, WeakView, WindowContext};
-use language::{CodeLabel, LspAdapterDelegate};
+use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate};
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 use text::LineEnding;
@@ -96,7 +96,6 @@ impl SlashCommand for ContextServerSlashCommand {
                         replace_previous_arguments: false,
                     })
                     .collect();
-
                 Ok(completions)
             })
         } else {
@@ -107,6 +106,8 @@ impl SlashCommand for ContextServerSlashCommand {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -141,6 +142,7 @@ impl SlashCommand for ContextServerSlashCommand {
                                 .description
                                 .unwrap_or(format!("Result from {}", prompt_name)),
                         ),
+                        metadata: None,
                     }],
                     text: prompt,
                     run_commands_in_text: false,
diff --git a/crates/assistant/src/slash_command/default_command.rs b/crates/assistant/src/slash_command/default_command.rs
index 18db87b3228b9c..4199840300a24c 100644
--- a/crates/assistant/src/slash_command/default_command.rs
+++ b/crates/assistant/src/slash_command/default_command.rs
@@ -3,7 +3,7 @@ use crate::prompt_library::PromptStore;
 use anyhow::{anyhow, Result};
 use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use gpui::{Task, WeakView};
-use language::LspAdapterDelegate;
+use language::{BufferSnapshot, LspAdapterDelegate};
 use std::{
     fmt::Write,
     sync::{atomic::AtomicBool, Arc},
@@ -43,6 +43,8 @@ impl SlashCommand for DefaultSlashCommand {
     fn run(
         self: Arc<Self>,
         _arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -70,6 +72,7 @@ impl SlashCommand for DefaultSlashCommand {
                     range: 0..text.len(),
                     icon: IconName::Library,
                     label: "Default".into(),
+                    metadata: None,
                 }],
                 text,
                 run_commands_in_text: true,
diff --git a/crates/assistant/src/slash_command/delta_command.rs b/crates/assistant/src/slash_command/delta_command.rs
new file mode 100644
index 00000000000000..6a66ad3f09aa9a
--- /dev/null
+++ b/crates/assistant/src/slash_command/delta_command.rs
@@ -0,0 +1,109 @@
+use crate::slash_command::file_command::{FileCommandMetadata, FileSlashCommand};
+use anyhow::Result;
+use assistant_slash_command::{
+    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
+};
+use collections::HashSet;
+use futures::future;
+use gpui::{Task, WeakView, WindowContext};
+use language::{BufferSnapshot, LspAdapterDelegate};
+use std::sync::{atomic::AtomicBool, Arc};
+use text::OffsetRangeExt;
+use workspace::Workspace;
+
+pub(crate) struct DeltaSlashCommand;
+
+impl SlashCommand for DeltaSlashCommand {
+    fn name(&self) -> String {
+        "delta".into()
+    }
+
+    fn description(&self) -> String {
+        "re-insert changed files".into()
+    }
+
+    fn menu_text(&self) -> String {
+        "Re-insert Changed Files".into()
+    }
+
+    fn requires_argument(&self) -> bool {
+        false
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        _arguments: &[String],
+        _cancellation_flag: Arc<AtomicBool>,
+        _workspace: Option<WeakView<Workspace>>,
+        _cx: &mut WindowContext,
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        unimplemented!()
+    }
+
+    fn run(
+        self: Arc<Self>,
+        _arguments: &[String],
+        context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        context_buffer: BufferSnapshot,
+        workspace: WeakView<Workspace>,
+        delegate: Option<Arc<dyn LspAdapterDelegate>>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let mut paths = HashSet::default();
+        let mut file_command_old_outputs = Vec::new();
+        let mut file_command_new_outputs = Vec::new();
+        for section in context_slash_command_output_sections.iter().rev() {
+            if let Some(metadata) = section
+                .metadata
+                .as_ref()
+                .and_then(|value| serde_json::from_value::<FileCommandMetadata>(value.clone()).ok())
+            {
+                if paths.insert(metadata.path.clone()) {
+                    file_command_old_outputs.push(
+                        context_buffer
+                            .as_rope()
+                            .slice(section.range.to_offset(&context_buffer)),
+                    );
+                    file_command_new_outputs.push(Arc::new(FileSlashCommand).run(
+                        &[metadata.path.clone()],
+                        context_slash_command_output_sections,
+                        context_buffer.clone(),
+                        workspace.clone(),
+                        delegate.clone(),
+                        cx,
+                    ));
+                }
+            }
+        }
+
+        cx.background_executor().spawn(async move {
+            let mut output = SlashCommandOutput::default();
+
+            let file_command_new_outputs = future::join_all(file_command_new_outputs).await;
+            for (old_text, new_output) in file_command_old_outputs
+                .into_iter()
+                .zip(file_command_new_outputs)
+            {
+                if let Ok(new_output) = new_output {
+                    if let Some(file_command_range) = new_output.sections.first() {
+                        let new_text = &new_output.text[file_command_range.range.clone()];
+                        if old_text.chars().ne(new_text.chars()) {
+                            output.sections.extend(new_output.sections.into_iter().map(
+                                |section| SlashCommandOutputSection {
+                                    range: output.text.len() + section.range.start
+                                        ..output.text.len() + section.range.end,
+                                    icon: section.icon,
+                                    label: section.label,
+                                    metadata: section.metadata,
+                                },
+                            ));
+                            output.text.push_str(&new_output.text);
+                        }
+                    }
+                }
+            }
+
+            Ok(output)
+        })
+    }
+}
diff --git a/crates/assistant/src/slash_command/diagnostics_command.rs b/crates/assistant/src/slash_command/diagnostics_command.rs
index 21058306519787..3f79c016750318 100644
--- a/crates/assistant/src/slash_command/diagnostics_command.rs
+++ b/crates/assistant/src/slash_command/diagnostics_command.rs
@@ -9,10 +9,9 @@ use language::{
 };
 use project::{DiagnosticSummary, PathMatchCandidateSet, Project};
 use rope::Point;
-use std::fmt::Write;
-use std::path::{Path, PathBuf};
 use std::{
-    ops::Range,
+    fmt::Write,
+    path::{Path, PathBuf},
     sync::{atomic::AtomicBool, Arc},
 };
 use ui::prelude::*;
@@ -163,6 +162,8 @@ impl SlashCommand for DiagnosticsSlashCommand {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -175,68 +176,7 @@ impl SlashCommand for DiagnosticsSlashCommand {
 
         let task = collect_diagnostics(workspace.read(cx).project().clone(), options, cx);
 
-        cx.spawn(move |_| async move {
-            let Some((text, sections)) = task.await? else {
-                return Ok(SlashCommandOutput {
-                    sections: vec![SlashCommandOutputSection {
-                        range: 0..1,
-                        icon: IconName::Library,
-                        label: "No Diagnostics".into(),
-                    }],
-                    text: "\n".to_string(),
-                    run_commands_in_text: true,
-                });
-            };
-
-            let sections = sections
-                .into_iter()
-                .map(|(range, placeholder_type)| SlashCommandOutputSection {
-                    range,
-                    icon: match placeholder_type {
-                        PlaceholderType::Root(_, _) => IconName::Warning,
-                        PlaceholderType::File(_) => IconName::File,
-                        PlaceholderType::Diagnostic(DiagnosticType::Error, _) => IconName::XCircle,
-                        PlaceholderType::Diagnostic(DiagnosticType::Warning, _) => {
-                            IconName::Warning
-                        }
-                    },
-                    label: match placeholder_type {
-                        PlaceholderType::Root(summary, source) => {
-                            let mut label = String::new();
-                            label.push_str("Diagnostics");
-                            if let Some(source) = source {
-                                write!(label, " ({})", source).unwrap();
-                            }
-
-                            if summary.error_count > 0 || summary.warning_count > 0 {
-                                label.push(':');
-
-                                if summary.error_count > 0 {
-                                    write!(label, " {} errors", summary.error_count).unwrap();
-                                    if summary.warning_count > 0 {
-                                        label.push_str(",");
-                                    }
-                                }
-
-                                if summary.warning_count > 0 {
-                                    write!(label, " {} warnings", summary.warning_count).unwrap();
-                                }
-                            }
-
-                            label.into()
-                        }
-                        PlaceholderType::File(file_path) => file_path.into(),
-                        PlaceholderType::Diagnostic(_, message) => message.into(),
-                    },
-                })
-                .collect();
-
-            Ok(SlashCommandOutput {
-                text,
-                sections,
-                run_commands_in_text: false,
-            })
-        })
+        cx.spawn(move |_| async move { task.await?.ok_or_else(|| anyhow!("No diagnostics found")) })
     }
 }
 
@@ -277,7 +217,7 @@ fn collect_diagnostics(
     project: Model<Project>,
     options: Options,
     cx: &mut AppContext,
-) -> Task<Result<Option<(String, Vec<(Range<usize>, PlaceholderType)>)>>> {
+) -> Task<Result<Option<SlashCommandOutput>>> {
     let error_source = if let Some(path_matcher) = &options.path_matcher {
         debug_assert_eq!(path_matcher.sources().len(), 1);
         Some(path_matcher.sources().first().cloned().unwrap_or_default())
@@ -318,13 +258,13 @@ fn collect_diagnostics(
         .collect();
 
     cx.spawn(|mut cx| async move {
-        let mut text = String::new();
+        let mut output = SlashCommandOutput::default();
+
         if let Some(error_source) = error_source.as_ref() {
-            writeln!(text, "diagnostics: {}", error_source).unwrap();
+            writeln!(output.text, "diagnostics: {}", error_source).unwrap();
         } else {
-            writeln!(text, "diagnostics").unwrap();
+            writeln!(output.text, "diagnostics").unwrap();
         }
-        let mut sections: Vec<(Range<usize>, PlaceholderType)> = Vec::new();
 
         let mut project_summary = DiagnosticSummary::default();
         for (project_path, path, summary) in diagnostic_summaries {
@@ -341,10 +281,10 @@ fn collect_diagnostics(
                 continue;
             }
 
-            let last_end = text.len();
+            let last_end = output.text.len();
             let file_path = path.to_string_lossy().to_string();
             if !glob_is_exact_file_match {
-                writeln!(&mut text, "{file_path}").unwrap();
+                writeln!(&mut output.text, "{file_path}").unwrap();
             }
 
             if let Some(buffer) = project_handle
@@ -352,75 +292,73 @@ fn collect_diagnostics(
                 .await
                 .log_err()
             {
-                collect_buffer_diagnostics(
-                    &mut text,
-                    &mut sections,
-                    cx.read_model(&buffer, |buffer, _| buffer.snapshot())?,
-                    options.include_warnings,
-                );
+                let snapshot = cx.read_model(&buffer, |buffer, _| buffer.snapshot())?;
+                collect_buffer_diagnostics(&mut output, &snapshot, options.include_warnings);
             }
 
             if !glob_is_exact_file_match {
-                sections.push((
-                    last_end..text.len().saturating_sub(1),
-                    PlaceholderType::File(file_path),
-                ))
+                output.sections.push(SlashCommandOutputSection {
+                    range: last_end..output.text.len().saturating_sub(1),
+                    icon: IconName::File,
+                    label: file_path.into(),
+                    metadata: None,
+                });
             }
         }
 
         // No diagnostics found
-        if sections.is_empty() {
+        if output.sections.is_empty() {
             return Ok(None);
         }
 
-        sections.push((
-            0..text.len(),
-            PlaceholderType::Root(project_summary, error_source),
-        ));
-        Ok(Some((text, sections)))
-    })
-}
-
-pub fn buffer_has_error_diagnostics(snapshot: &BufferSnapshot) -> bool {
-    for (_, group) in snapshot.diagnostic_groups(None) {
-        let entry = &group.entries[group.primary_ix];
-        if entry.diagnostic.severity == DiagnosticSeverity::ERROR {
-            return true;
+        let mut label = String::new();
+        label.push_str("Diagnostics");
+        if let Some(source) = error_source {
+            write!(label, " ({})", source).unwrap();
         }
-    }
-    false
-}
 
-pub fn write_single_file_diagnostics(
-    output: &mut String,
-    path: Option<&Path>,
-    snapshot: &BufferSnapshot,
-) -> bool {
-    if let Some(path) = path {
-        if buffer_has_error_diagnostics(&snapshot) {
-            output.push_str("/diagnostics ");
-            output.push_str(&path.to_string_lossy());
-            return true;
+        if project_summary.error_count > 0 || project_summary.warning_count > 0 {
+            label.push(':');
+
+            if project_summary.error_count > 0 {
+                write!(label, " {} errors", project_summary.error_count).unwrap();
+                if project_summary.warning_count > 0 {
+                    label.push_str(",");
+                }
+            }
+
+            if project_summary.warning_count > 0 {
+                write!(label, " {} warnings", project_summary.warning_count).unwrap();
+            }
         }
-    }
-    false
+
+        output.sections.insert(
+            0,
+            SlashCommandOutputSection {
+                range: 0..output.text.len(),
+                icon: IconName::Warning,
+                label: label.into(),
+                metadata: None,
+            },
+        );
+
+        Ok(Some(output))
+    })
 }
 
-fn collect_buffer_diagnostics(
-    text: &mut String,
-    sections: &mut Vec<(Range<usize>, PlaceholderType)>,
-    snapshot: BufferSnapshot,
+pub fn collect_buffer_diagnostics(
+    output: &mut SlashCommandOutput,
+    snapshot: &BufferSnapshot,
     include_warnings: bool,
 ) {
     for (_, group) in snapshot.diagnostic_groups(None) {
         let entry = &group.entries[group.primary_ix];
-        collect_diagnostic(text, sections, entry, &snapshot, include_warnings)
+        collect_diagnostic(output, entry, &snapshot, include_warnings)
     }
 }
 
 fn collect_diagnostic(
-    text: &mut String,
-    sections: &mut Vec<(Range<usize>, PlaceholderType)>,
+    output: &mut SlashCommandOutput,
     entry: &DiagnosticEntry<Anchor>,
     snapshot: &BufferSnapshot,
     include_warnings: bool,
@@ -428,17 +366,17 @@ fn collect_diagnostic(
     const EXCERPT_EXPANSION_SIZE: u32 = 2;
     const MAX_MESSAGE_LENGTH: usize = 2000;
 
-    let ty = match entry.diagnostic.severity {
+    let (ty, icon) = match entry.diagnostic.severity {
         DiagnosticSeverity::WARNING => {
             if !include_warnings {
                 return;
             }
-            DiagnosticType::Warning
+            ("warning", IconName::Warning)
         }
-        DiagnosticSeverity::ERROR => DiagnosticType::Error,
+        DiagnosticSeverity::ERROR => ("error", IconName::XCircle),
         _ => return,
     };
-    let prev_len = text.len();
+    let prev_len = output.text.len();
 
     let range = entry.range.to_point(snapshot);
     let diagnostic_row_number = range.start.row + 1;
@@ -448,11 +386,11 @@ fn collect_diagnostic(
     let excerpt_range =
         Point::new(start_row, 0).to_offset(&snapshot)..Point::new(end_row, 0).to_offset(&snapshot);
 
-    text.push_str("```");
+    output.text.push_str("```");
     if let Some(language_name) = snapshot.language().map(|l| l.code_fence_block_name()) {
-        text.push_str(&language_name);
+        output.text.push_str(&language_name);
     }
-    text.push('\n');
+    output.text.push('\n');
 
     let mut buffer_text = String::new();
     for chunk in snapshot.text_for_range(excerpt_range) {
@@ -461,46 +399,26 @@ fn collect_diagnostic(
 
     for (i, line) in buffer_text.lines().enumerate() {
         let line_number = start_row + i as u32 + 1;
-        writeln!(text, "{}", line).unwrap();
+        writeln!(output.text, "{}", line).unwrap();
 
         if line_number == diagnostic_row_number {
-            text.push_str("//");
-            let prev_len = text.len();
-            write!(text, " {}: ", ty.as_str()).unwrap();
-            let padding = text.len() - prev_len;
+            output.text.push_str("//");
+            let prev_len = output.text.len();
+            write!(output.text, " {}: ", ty).unwrap();
+            let padding = output.text.len() - prev_len;
 
             let message = util::truncate(&entry.diagnostic.message, MAX_MESSAGE_LENGTH)
                 .replace('\n', format!("\n//{:padding$}", "").as_str());
 
-            writeln!(text, "{message}").unwrap();
+            writeln!(output.text, "{message}").unwrap();
         }
     }
 
-    writeln!(text, "```").unwrap();
-    sections.push((
-        prev_len..text.len().saturating_sub(1),
-        PlaceholderType::Diagnostic(ty, entry.diagnostic.message.clone()),
-    ))
-}
-
-#[derive(Clone)]
-pub enum PlaceholderType {
-    Root(DiagnosticSummary, Option<String>),
-    File(String),
-    Diagnostic(DiagnosticType, String),
-}
-
-#[derive(Copy, Clone)]
-pub enum DiagnosticType {
-    Warning,
-    Error,
-}
-
-impl DiagnosticType {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            DiagnosticType::Warning => "warning",
-            DiagnosticType::Error => "error",
-        }
-    }
+    writeln!(output.text, "```").unwrap();
+    output.sections.push(SlashCommandOutputSection {
+        range: prev_len..output.text.len().saturating_sub(1),
+        icon,
+        label: entry.diagnostic.message.clone().into(),
+        metadata: None,
+    });
 }
diff --git a/crates/assistant/src/slash_command/docs_command.rs b/crates/assistant/src/slash_command/docs_command.rs
index e114cfeab74b31..399ede9d999549 100644
--- a/crates/assistant/src/slash_command/docs_command.rs
+++ b/crates/assistant/src/slash_command/docs_command.rs
@@ -12,7 +12,7 @@ use indexed_docs::{
     DocsDotRsProvider, IndexedDocsRegistry, IndexedDocsStore, LocalRustdocProvider, PackageName,
     ProviderId,
 };
-use language::LspAdapterDelegate;
+use language::{BufferSnapshot, LspAdapterDelegate};
 use project::{Project, ProjectPath};
 use ui::prelude::*;
 use util::{maybe, ResultExt};
@@ -269,6 +269,8 @@ impl SlashCommand for DocsSlashCommand {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -349,6 +351,7 @@ impl SlashCommand for DocsSlashCommand {
                         range,
                         icon: IconName::FileDoc,
                         label: format!("docs ({provider}): {key}",).into(),
+                        metadata: None,
                     })
                     .collect(),
                 run_commands_in_text: false,
diff --git a/crates/assistant/src/slash_command/fetch_command.rs b/crates/assistant/src/slash_command/fetch_command.rs
index 8ecb6de7590663..23d3c884a8ec28 100644
--- a/crates/assistant/src/slash_command/fetch_command.rs
+++ b/crates/assistant/src/slash_command/fetch_command.rs
@@ -11,7 +11,7 @@ use futures::AsyncReadExt;
 use gpui::{Task, WeakView};
 use html_to_markdown::{convert_html_to_markdown, markdown, TagHandler};
 use http_client::{AsyncBody, HttpClient, HttpClientWithUrl};
-use language::LspAdapterDelegate;
+use language::{BufferSnapshot, LspAdapterDelegate};
 use ui::prelude::*;
 use workspace::Workspace;
 
@@ -128,6 +128,8 @@ impl SlashCommand for FetchSlashCommand {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -161,6 +163,7 @@ impl SlashCommand for FetchSlashCommand {
                     range,
                     icon: IconName::AtSign,
                     label: format!("fetch {}", url).into(),
+                    metadata: None,
                 }],
                 run_commands_in_text: false,
             })
diff --git a/crates/assistant/src/slash_command/file_command.rs b/crates/assistant/src/slash_command/file_command.rs
index e5d8f1b2d6bbb2..0df8b5d4e0b83c 100644
--- a/crates/assistant/src/slash_command/file_command.rs
+++ b/crates/assistant/src/slash_command/file_command.rs
@@ -1,10 +1,11 @@
-use super::{diagnostics_command::write_single_file_diagnostics, SlashCommand, SlashCommandOutput};
+use super::{diagnostics_command::collect_buffer_diagnostics, SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Context as _, Result};
 use assistant_slash_command::{AfterCompletion, ArgumentCompletion, SlashCommandOutputSection};
 use fuzzy::PathMatch;
 use gpui::{AppContext, Model, Task, View, WeakView};
 use language::{BufferSnapshot, CodeLabel, HighlightId, LineEnding, LspAdapterDelegate};
 use project::{PathMatchCandidateSet, Project};
+use serde::{Deserialize, Serialize};
 use std::{
     fmt::Write,
     ops::Range,
@@ -175,6 +176,8 @@ impl SlashCommand for FileSlashCommand {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -187,54 +190,15 @@ impl SlashCommand for FileSlashCommand {
             return Task::ready(Err(anyhow!("missing path")));
         };
 
-        let task = collect_files(workspace.read(cx).project().clone(), arguments, cx);
-
-        cx.foreground_executor().spawn(async move {
-            let output = task.await?;
-            Ok(SlashCommandOutput {
-                text: output.completion_text,
-                sections: output
-                    .files
-                    .into_iter()
-                    .map(|file| {
-                        build_entry_output_section(
-                            file.range_in_text,
-                            Some(&file.path),
-                            file.entry_type == EntryType::Directory,
-                            None,
-                        )
-                    })
-                    .collect(),
-                run_commands_in_text: true,
-            })
-        })
+        collect_files(workspace.read(cx).project().clone(), arguments, cx)
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Debug)]
-enum EntryType {
-    File,
-    Directory,
-}
-
-#[derive(Clone, PartialEq, Debug)]
-struct FileCommandOutput {
-    completion_text: String,
-    files: Vec<OutputFile>,
-}
-
-#[derive(Clone, PartialEq, Debug)]
-struct OutputFile {
-    range_in_text: Range<usize>,
-    path: PathBuf,
-    entry_type: EntryType,
-}
-
 fn collect_files(
     project: Model<Project>,
     glob_inputs: &[String],
     cx: &mut AppContext,
-) -> Task<Result<FileCommandOutput>> {
+) -> Task<Result<SlashCommandOutput>> {
     let Ok(matchers) = glob_inputs
         .into_iter()
         .map(|glob_input| {
@@ -254,8 +218,7 @@ fn collect_files(
         .collect::<Vec<_>>();
 
     cx.spawn(|mut cx| async move {
-        let mut text = String::new();
-        let mut ranges = Vec::new();
+        let mut output = SlashCommandOutput::default();
         for snapshot in snapshots {
             let worktree_id = snapshot.id();
             let mut directory_stack: Vec<(Arc<Path>, String, usize)> = Vec::new();
@@ -279,11 +242,12 @@ fn collect_files(
                         break;
                     }
                     let (_, entry_name, start) = directory_stack.pop().unwrap();
-                    ranges.push(OutputFile {
-                        range_in_text: start..text.len().saturating_sub(1),
-                        path: PathBuf::from(entry_name),
-                        entry_type: EntryType::Directory,
-                    });
+                    output.sections.push(build_entry_output_section(
+                        start..output.text.len().saturating_sub(1),
+                        Some(&PathBuf::from(entry_name)),
+                        true,
+                        None,
+                    ));
                 }
 
                 let filename = entry
@@ -315,21 +279,23 @@ fn collect_files(
                         continue;
                     }
                     let prefix_paths = folded_directory_names_stack.drain(..).as_slice().join("/");
-                    let entry_start = text.len();
+                    let entry_start = output.text.len();
                     if prefix_paths.is_empty() {
                         if is_top_level_directory {
-                            text.push_str(&path_including_worktree_name.to_string_lossy());
+                            output
+                                .text
+                                .push_str(&path_including_worktree_name.to_string_lossy());
                             is_top_level_directory = false;
                         } else {
-                            text.push_str(&filename);
+                            output.text.push_str(&filename);
                         }
                         directory_stack.push((entry.path.clone(), filename, entry_start));
                     } else {
                         let entry_name = format!("{}/{}", prefix_paths, &filename);
-                        text.push_str(&entry_name);
+                        output.text.push_str(&entry_name);
                         directory_stack.push((entry.path.clone(), entry_name, entry_start));
                     }
-                    text.push('\n');
+                    output.text.push('\n');
                 } else if entry.is_file() {
                     let Some(open_buffer_task) = project_handle
                         .update(&mut cx, |project, cx| {
@@ -340,28 +306,13 @@ fn collect_files(
                         continue;
                     };
                     if let Some(buffer) = open_buffer_task.await.log_err() {
-                        let buffer_snapshot =
-                            cx.read_model(&buffer, |buffer, _| buffer.snapshot())?;
-                        let prev_len = text.len();
-                        collect_file_content(
-                            &mut text,
-                            &buffer_snapshot,
-                            path_including_worktree_name.to_string_lossy().to_string(),
-                        );
-                        text.push('\n');
-                        if !write_single_file_diagnostics(
-                            &mut text,
+                        let snapshot = buffer.read_with(&cx, |buffer, _| buffer.snapshot())?;
+                        append_buffer_to_output(
+                            &snapshot,
                             Some(&path_including_worktree_name),
-                            &buffer_snapshot,
-                        ) {
-                            text.pop();
-                        }
-                        ranges.push(OutputFile {
-                            range_in_text: prev_len..text.len(),
-                            path: path_including_worktree_name,
-                            entry_type: EntryType::File,
-                        });
-                        text.push('\n');
+                            &mut output,
+                        )
+                        .log_err();
                     }
                 }
             }
@@ -371,42 +322,26 @@ fn collect_files(
                     let mut root_path = PathBuf::new();
                     root_path.push(snapshot.root_name());
                     root_path.push(&dir);
-                    ranges.push(OutputFile {
-                        range_in_text: start..text.len(),
-                        path: root_path,
-                        entry_type: EntryType::Directory,
-                    });
+                    output.sections.push(build_entry_output_section(
+                        start..output.text.len(),
+                        Some(&root_path),
+                        true,
+                        None,
+                    ));
                 } else {
-                    ranges.push(OutputFile {
-                        range_in_text: start..text.len(),
-                        path: PathBuf::from(entry.as_str()),
-                        entry_type: EntryType::Directory,
-                    });
+                    output.sections.push(build_entry_output_section(
+                        start..output.text.len(),
+                        Some(&PathBuf::from(entry.as_str())),
+                        true,
+                        None,
+                    ));
                 }
             }
         }
-        Ok(FileCommandOutput {
-            completion_text: text,
-            files: ranges,
-        })
+        Ok(output)
     })
 }
 
-fn collect_file_content(buffer: &mut String, snapshot: &BufferSnapshot, filename: String) {
-    let mut content = snapshot.text();
-    LineEnding::normalize(&mut content);
-    buffer.reserve(filename.len() + content.len() + 9);
-    buffer.push_str(&codeblock_fence_for_path(
-        Some(&PathBuf::from(filename)),
-        None,
-    ));
-    buffer.push_str(&content);
-    if !buffer.ends_with('\n') {
-        buffer.push('\n');
-    }
-    buffer.push_str("```");
-}
-
 pub fn codeblock_fence_for_path(path: Option<&Path>, row_range: Option<Range<u32>>) -> String {
     let mut text = String::new();
     write!(text, "```").unwrap();
@@ -429,6 +364,11 @@ pub fn codeblock_fence_for_path(path: Option<&Path>, row_range: Option<Range<u32
     text
 }
 
+#[derive(Serialize, Deserialize)]
+pub struct FileCommandMetadata {
+    pub path: String,
+}
+
 pub fn build_entry_output_section(
     range: Range<usize>,
     path: Option<&Path>,
@@ -454,6 +394,16 @@ pub fn build_entry_output_section(
         range,
         icon,
         label: label.into(),
+        metadata: if is_directory {
+            None
+        } else {
+            path.and_then(|path| {
+                serde_json::to_value(FileCommandMetadata {
+                    path: path.to_string_lossy().to_string(),
+                })
+                .ok()
+            })
+        },
     }
 }
 
@@ -539,6 +489,36 @@ mod custom_path_matcher {
     }
 }
 
+pub fn append_buffer_to_output(
+    buffer: &BufferSnapshot,
+    path: Option<&Path>,
+    output: &mut SlashCommandOutput,
+) -> Result<()> {
+    let prev_len = output.text.len();
+
+    let mut content = buffer.text();
+    LineEnding::normalize(&mut content);
+    output.text.push_str(&codeblock_fence_for_path(path, None));
+    output.text.push_str(&content);
+    if !output.text.ends_with('\n') {
+        output.text.push('\n');
+    }
+    output.text.push_str("```");
+    output.text.push('\n');
+
+    let section_ix = output.sections.len();
+    collect_buffer_diagnostics(output, buffer, false);
+
+    output.sections.insert(
+        section_ix,
+        build_entry_output_section(prev_len..output.text.len(), path, false, None),
+    );
+
+    output.text.push('\n');
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod test {
     use fs::FakeFs;
@@ -591,9 +571,9 @@ mod test {
             .await
             .unwrap();
 
-        assert!(result_1.completion_text.starts_with("root/dir"));
+        assert!(result_1.text.starts_with("root/dir"));
         // 4 files + 2 directories
-        assert_eq!(6, result_1.files.len());
+        assert_eq!(result_1.sections.len(), 6);
 
         let result_2 = cx
             .update(|cx| collect_files(project.clone(), &["root/dir/".to_string()], cx))
@@ -607,9 +587,9 @@ mod test {
             .await
             .unwrap();
 
-        assert!(result.completion_text.starts_with("root/dir"));
+        assert!(result.text.starts_with("root/dir"));
         // 5 files + 2 directories
-        assert_eq!(7, result.files.len());
+        assert_eq!(result.sections.len(), 7);
 
         // Ensure that the project lasts until after the last await
         drop(project);
@@ -654,36 +634,27 @@ mod test {
             .unwrap();
 
         // Sanity check
-        assert!(result.completion_text.starts_with("zed/assets/themes\n"));
-        assert_eq!(7, result.files.len());
+        assert!(result.text.starts_with("zed/assets/themes\n"));
+        assert_eq!(result.sections.len(), 7);
 
         // Ensure that full file paths are included in the real output
-        assert!(result
-            .completion_text
-            .contains("zed/assets/themes/andromeda/LICENSE"));
-        assert!(result
-            .completion_text
-            .contains("zed/assets/themes/ayu/LICENSE"));
-        assert!(result
-            .completion_text
-            .contains("zed/assets/themes/summercamp/LICENSE"));
-
-        assert_eq!("summercamp", result.files[5].path.to_string_lossy());
+        assert!(result.text.contains("zed/assets/themes/andromeda/LICENSE"));
+        assert!(result.text.contains("zed/assets/themes/ayu/LICENSE"));
+        assert!(result.text.contains("zed/assets/themes/summercamp/LICENSE"));
+
+        assert_eq!(result.sections[5].label, "summercamp");
 
         // Ensure that things are in descending order, with properly relativized paths
         assert_eq!(
-            "zed/assets/themes/andromeda/LICENSE",
-            result.files[0].path.to_string_lossy()
-        );
-        assert_eq!("andromeda", result.files[1].path.to_string_lossy());
-        assert_eq!(
-            "zed/assets/themes/ayu/LICENSE",
-            result.files[2].path.to_string_lossy()
+            result.sections[0].label,
+            "zed/assets/themes/andromeda/LICENSE"
         );
-        assert_eq!("ayu", result.files[3].path.to_string_lossy());
+        assert_eq!(result.sections[1].label, "andromeda");
+        assert_eq!(result.sections[2].label, "zed/assets/themes/ayu/LICENSE");
+        assert_eq!(result.sections[3].label, "ayu");
         assert_eq!(
-            "zed/assets/themes/summercamp/LICENSE",
-            result.files[4].path.to_string_lossy()
+            result.sections[4].label,
+            "zed/assets/themes/summercamp/LICENSE"
         );
 
         // Ensure that the project lasts until after the last await
@@ -723,27 +694,24 @@ mod test {
             .await
             .unwrap();
 
-        assert!(result.completion_text.starts_with("zed/assets/themes\n"));
-        assert_eq!(
-            "zed/assets/themes/LICENSE",
-            result.files[0].path.to_string_lossy()
-        );
+        assert!(result.text.starts_with("zed/assets/themes\n"));
+        assert_eq!(result.sections[0].label, "zed/assets/themes/LICENSE");
         assert_eq!(
-            "zed/assets/themes/summercamp/LICENSE",
-            result.files[1].path.to_string_lossy()
+            result.sections[1].label,
+            "zed/assets/themes/summercamp/LICENSE"
         );
         assert_eq!(
-            "zed/assets/themes/summercamp/subdir/LICENSE",
-            result.files[2].path.to_string_lossy()
+            result.sections[2].label,
+            "zed/assets/themes/summercamp/subdir/LICENSE"
         );
         assert_eq!(
-            "zed/assets/themes/summercamp/subdir/subsubdir/LICENSE",
-            result.files[3].path.to_string_lossy()
+            result.sections[3].label,
+            "zed/assets/themes/summercamp/subdir/subsubdir/LICENSE"
         );
-        assert_eq!("subsubdir", result.files[4].path.to_string_lossy());
-        assert_eq!("subdir", result.files[5].path.to_string_lossy());
-        assert_eq!("summercamp", result.files[6].path.to_string_lossy());
-        assert_eq!("zed/assets/themes", result.files[7].path.to_string_lossy());
+        assert_eq!(result.sections[4].label, "subsubdir");
+        assert_eq!(result.sections[5].label, "subdir");
+        assert_eq!(result.sections[6].label, "summercamp");
+        assert_eq!(result.sections[7].label, "zed/assets/themes");
 
         // Ensure that the project lasts until after the last await
         drop(project);
diff --git a/crates/assistant/src/slash_command/now_command.rs b/crates/assistant/src/slash_command/now_command.rs
index eb6277a7d92561..eb0ca926f015b6 100644
--- a/crates/assistant/src/slash_command/now_command.rs
+++ b/crates/assistant/src/slash_command/now_command.rs
@@ -7,7 +7,7 @@ use assistant_slash_command::{
 };
 use chrono::Local;
 use gpui::{Task, WeakView};
-use language::LspAdapterDelegate;
+use language::{BufferSnapshot, LspAdapterDelegate};
 use ui::prelude::*;
 use workspace::Workspace;
 
@@ -43,6 +43,8 @@ impl SlashCommand for NowSlashCommand {
     fn run(
         self: Arc<Self>,
         _arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         _cx: &mut WindowContext,
@@ -57,6 +59,7 @@ impl SlashCommand for NowSlashCommand {
                 range,
                 icon: IconName::CountdownTimer,
                 label: now.to_rfc2822().into(),
+                metadata: None,
             }],
             run_commands_in_text: false,
         }))
diff --git a/crates/assistant/src/slash_command/project_command.rs b/crates/assistant/src/slash_command/project_command.rs
index 8182734e7214f8..3e8596d942bf61 100644
--- a/crates/assistant/src/slash_command/project_command.rs
+++ b/crates/assistant/src/slash_command/project_command.rs
@@ -3,7 +3,7 @@ use anyhow::{anyhow, Context, Result};
 use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use fs::Fs;
 use gpui::{AppContext, Model, Task, WeakView};
-use language::LspAdapterDelegate;
+use language::{BufferSnapshot, LspAdapterDelegate};
 use project::{Project, ProjectPath};
 use std::{
     fmt::Write,
@@ -118,6 +118,8 @@ impl SlashCommand for ProjectSlashCommand {
     fn run(
         self: Arc<Self>,
         _arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -140,6 +142,7 @@ impl SlashCommand for ProjectSlashCommand {
                         range,
                         icon: IconName::FileTree,
                         label: "Project".into(),
+                        metadata: None,
                     }],
                     run_commands_in_text: false,
                 })
diff --git a/crates/assistant/src/slash_command/prompt_command.rs b/crates/assistant/src/slash_command/prompt_command.rs
index 4d64bba2edb740..effbcc0f90ce87 100644
--- a/crates/assistant/src/slash_command/prompt_command.rs
+++ b/crates/assistant/src/slash_command/prompt_command.rs
@@ -3,7 +3,7 @@ use crate::prompt_library::PromptStore;
 use anyhow::{anyhow, Context, Result};
 use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use gpui::{Task, WeakView};
-use language::LspAdapterDelegate;
+use language::{BufferSnapshot, LspAdapterDelegate};
 use std::sync::{atomic::AtomicBool, Arc};
 use ui::prelude::*;
 use workspace::Workspace;
@@ -56,6 +56,8 @@ impl SlashCommand for PromptSlashCommand {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -95,6 +97,7 @@ impl SlashCommand for PromptSlashCommand {
                     range,
                     icon: IconName::Library,
                     label: title,
+                    metadata: None,
                 }],
                 run_commands_in_text: true,
             })
diff --git a/crates/assistant/src/slash_command/search_command.rs b/crates/assistant/src/slash_command/search_command.rs
index 3a513ed9ad3784..72d86ec5c54000 100644
--- a/crates/assistant/src/slash_command/search_command.rs
+++ b/crates/assistant/src/slash_command/search_command.rs
@@ -60,6 +60,8 @@ impl SlashCommand for SearchSlashCommand {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: language::BufferSnapshot,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -168,6 +170,7 @@ impl SlashCommand for SearchSlashCommand {
                         range: 0..text.len(),
                         icon: IconName::MagnifyingGlass,
                         label: query,
+                        metadata: None,
                     });
 
                     SlashCommandOutput {
diff --git a/crates/assistant/src/slash_command/symbols_command.rs b/crates/assistant/src/slash_command/symbols_command.rs
index c9582f2882472d..1cf8536c0dbfe7 100644
--- a/crates/assistant/src/slash_command/symbols_command.rs
+++ b/crates/assistant/src/slash_command/symbols_command.rs
@@ -3,7 +3,7 @@ use anyhow::{anyhow, Context as _, Result};
 use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use editor::Editor;
 use gpui::{Task, WeakView};
-use language::LspAdapterDelegate;
+use language::{BufferSnapshot, LspAdapterDelegate};
 use std::sync::Arc;
 use std::{path::Path, sync::atomic::AtomicBool};
 use ui::{IconName, WindowContext};
@@ -41,6 +41,8 @@ impl SlashCommand for OutlineSlashCommand {
     fn run(
         self: Arc<Self>,
         _arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -77,6 +79,7 @@ impl SlashCommand for OutlineSlashCommand {
                         range: 0..outline_text.len(),
                         icon: IconName::ListTree,
                         label: path.to_string_lossy().to_string().into(),
+                        metadata: None,
                     }],
                     text: outline_text,
                     run_commands_in_text: false,
diff --git a/crates/assistant/src/slash_command/tab_command.rs b/crates/assistant/src/slash_command/tab_command.rs
index 1a6884b8538221..bdf8450d43be81 100644
--- a/crates/assistant/src/slash_command/tab_command.rs
+++ b/crates/assistant/src/slash_command/tab_command.rs
@@ -1,21 +1,17 @@
-use super::{
-    diagnostics_command::write_single_file_diagnostics,
-    file_command::{build_entry_output_section, codeblock_fence_for_path},
-    SlashCommand, SlashCommandOutput,
-};
+use super::{file_command::append_buffer_to_output, SlashCommand, SlashCommandOutput};
 use anyhow::{Context, Result};
-use assistant_slash_command::ArgumentCompletion;
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use collections::{HashMap, HashSet};
 use editor::Editor;
 use futures::future::join_all;
 use gpui::{Entity, Task, WeakView};
 use language::{BufferSnapshot, CodeLabel, HighlightId, LspAdapterDelegate};
 use std::{
-    fmt::Write,
     path::PathBuf,
     sync::{atomic::AtomicBool, Arc},
 };
 use ui::{ActiveTheme, WindowContext};
+use util::ResultExt;
 use workspace::Workspace;
 
 pub(crate) struct TabSlashCommand;
@@ -131,6 +127,8 @@ impl SlashCommand for TabSlashCommand {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -144,40 +142,11 @@ impl SlashCommand for TabSlashCommand {
         );
 
         cx.background_executor().spawn(async move {
-            let mut sections = Vec::new();
-            let mut text = String::new();
-            let mut has_diagnostics = false;
+            let mut output = SlashCommandOutput::default();
             for (full_path, buffer, _) in tab_items_search.await? {
-                let section_start_ix = text.len();
-                text.push_str(&codeblock_fence_for_path(full_path.as_deref(), None));
-                for chunk in buffer.as_rope().chunks() {
-                    text.push_str(chunk);
-                }
-                if !text.ends_with('\n') {
-                    text.push('\n');
-                }
-                writeln!(text, "```").unwrap();
-                if write_single_file_diagnostics(&mut text, full_path.as_deref(), &buffer) {
-                    has_diagnostics = true;
-                }
-                if !text.ends_with('\n') {
-                    text.push('\n');
-                }
-
-                let section_end_ix = text.len() - 1;
-                sections.push(build_entry_output_section(
-                    section_start_ix..section_end_ix,
-                    full_path.as_deref(),
-                    false,
-                    None,
-                ));
+                append_buffer_to_output(&buffer, full_path.as_deref(), &mut output).log_err();
             }
-
-            Ok(SlashCommandOutput {
-                text,
-                sections,
-                run_commands_in_text: has_diagnostics,
-            })
+            Ok(output)
         })
     }
 }
diff --git a/crates/assistant/src/slash_command/terminal_command.rs b/crates/assistant/src/slash_command/terminal_command.rs
index 04baabd39669bc..1d0293c235d442 100644
--- a/crates/assistant/src/slash_command/terminal_command.rs
+++ b/crates/assistant/src/slash_command/terminal_command.rs
@@ -6,7 +6,7 @@ use assistant_slash_command::{
     ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
 };
 use gpui::{AppContext, Task, View, WeakView};
-use language::{CodeLabel, LspAdapterDelegate};
+use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate};
 use terminal_view::{terminal_panel::TerminalPanel, TerminalView};
 use ui::prelude::*;
 use workspace::{dock::Panel, Workspace};
@@ -57,6 +57,8 @@ impl SlashCommand for TerminalSlashCommand {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -91,6 +93,7 @@ impl SlashCommand for TerminalSlashCommand {
                 range,
                 icon: IconName::Terminal,
                 label: "Terminal".into(),
+                metadata: None,
             }],
             run_commands_in_text: false,
         }))
diff --git a/crates/assistant/src/slash_command/workflow_command.rs b/crates/assistant/src/slash_command/workflow_command.rs
index f588fe848d5b32..c66dd9bebff144 100644
--- a/crates/assistant/src/slash_command/workflow_command.rs
+++ b/crates/assistant/src/slash_command/workflow_command.rs
@@ -8,7 +8,7 @@ use assistant_slash_command::{
     ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
 };
 use gpui::{Task, WeakView};
-use language::LspAdapterDelegate;
+use language::{BufferSnapshot, LspAdapterDelegate};
 use ui::prelude::*;
 
 use workspace::Workspace;
@@ -53,6 +53,8 @@ impl SlashCommand for WorkflowSlashCommand {
     fn run(
         self: Arc<Self>,
         _arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         _workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -68,6 +70,7 @@ impl SlashCommand for WorkflowSlashCommand {
                     range,
                     icon: IconName::Route,
                     label: "Workflow".into(),
+                    metadata: None,
                 }],
                 run_commands_in_text: false,
             })
diff --git a/crates/assistant_slash_command/Cargo.toml b/crates/assistant_slash_command/Cargo.toml
index 3d764bb0be9d82..a58a84312fc3e2 100644
--- a/crates/assistant_slash_command/Cargo.toml
+++ b/crates/assistant_slash_command/Cargo.toml
@@ -19,4 +19,5 @@ gpui.workspace = true
 language.workspace = true
 parking_lot.workspace = true
 serde.workspace = true
+serde_json.workspace = true
 workspace.workspace = true
diff --git a/crates/assistant_slash_command/src/assistant_slash_command.rs b/crates/assistant_slash_command/src/assistant_slash_command.rs
index c5dece11ca59a8..36e229d49a246d 100644
--- a/crates/assistant_slash_command/src/assistant_slash_command.rs
+++ b/crates/assistant_slash_command/src/assistant_slash_command.rs
@@ -2,7 +2,7 @@ mod slash_command_registry;
 
 use anyhow::Result;
 use gpui::{AnyElement, AppContext, ElementId, SharedString, Task, WeakView, WindowContext};
-use language::{CodeLabel, LspAdapterDelegate};
+use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate, OffsetRangeExt};
 use serde::{Deserialize, Serialize};
 pub use slash_command_registry::*;
 use std::{
@@ -77,6 +77,8 @@ pub trait SlashCommand: 'static + Send + Sync {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        context_buffer: BufferSnapshot,
         workspace: WeakView<Workspace>,
         // TODO: We're just using the `LspAdapterDelegate` here because that is
         // what the extension API is already expecting.
@@ -94,7 +96,7 @@ pub type RenderFoldPlaceholder = Arc<
         + Fn(ElementId, Arc<dyn Fn(&mut WindowContext)>, &mut WindowContext) -> AnyElement,
 >;
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, PartialEq)]
 pub struct SlashCommandOutput {
     pub text: String,
     pub sections: Vec<SlashCommandOutputSection<usize>>,
@@ -106,4 +108,11 @@ pub struct SlashCommandOutputSection<T> {
     pub range: Range<T>,
     pub icon: IconName,
     pub label: SharedString,
+    pub metadata: Option<serde_json::Value>,
+}
+
+impl SlashCommandOutputSection<language::Anchor> {
+    pub fn is_valid(&self, buffer: &language::TextBuffer) -> bool {
+        self.range.start.is_valid(buffer) && !self.range.to_offset(buffer).is_empty()
+    }
 }
diff --git a/crates/extension/src/extension_slash_command.rs b/crates/extension/src/extension_slash_command.rs
index 60b027ef9d0d27..3dfbc4c03d9bb0 100644
--- a/crates/extension/src/extension_slash_command.rs
+++ b/crates/extension/src/extension_slash_command.rs
@@ -6,7 +6,7 @@ use assistant_slash_command::{
 };
 use futures::FutureExt;
 use gpui::{Task, WeakView, WindowContext};
-use language::LspAdapterDelegate;
+use language::{BufferSnapshot, LspAdapterDelegate};
 use ui::prelude::*;
 use wasmtime_wasi::WasiView;
 use workspace::Workspace;
@@ -82,6 +82,8 @@ impl SlashCommand for ExtensionSlashCommand {
     fn run(
         self: Arc<Self>,
         arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
         _workspace: WeakView<Workspace>,
         delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
@@ -121,6 +123,7 @@ impl SlashCommand for ExtensionSlashCommand {
                         range: section.range.into(),
                         icon: IconName::Code,
                         label: section.label.into(),
+                        metadata: None,
                     })
                     .collect(),
                 run_commands_in_text: false,
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index a10b3798a42532..77942c8a94d542 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -2390,6 +2390,7 @@ message SlashCommandOutputSection {
     AnchorRange range = 1;
     string icon_name = 2;
     string label = 3;
+    optional string metadata = 4;
 }
 
 message ContextOperation {

From ddaee2e8dd507d5eab009e789e57c0d4fba6c5bf Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 17 Sep 2024 17:03:10 +0200
Subject: [PATCH 132/762] ssh: Handle BufferSaved ssh message (#17936)

Release Notes:

- N/A

Co-authored-by: Conrad <conrad@zed.dev>
---
 crates/project/src/project.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 14524180ab556d..5d9ac5e8214efb 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -797,9 +797,8 @@ impl Project {
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.settings_observer);
             client.add_model_message_handler(Self::handle_update_worktree);
             client.add_model_message_handler(Self::handle_create_buffer_for_peer);
-            client.add_model_message_handler(BufferStore::handle_update_buffer_file);
-            client.add_model_message_handler(BufferStore::handle_update_diff_base);
             client.add_model_request_handler(BufferStore::handle_update_buffer);
+            BufferStore::init(&client);
             LspStore::init(&client);
             SettingsObserver::init(&client);
 

From ecd183079371d126e2740b4e5b838ce92cd45591 Mon Sep 17 00:00:00 2001
From: Erick Guan <297343+erickguan@users.noreply.github.com>
Date: Tue, 17 Sep 2024 17:19:07 +0200
Subject: [PATCH 133/762] Fix opening file with colon (#17281)

Closes #14100

Release Notes:

- Fixed unable to open file with a colon from Zed CLI

-----

I didn't make change to tests for the first two commits. I changed them
to easily find offending test cases. Behavior changes are in last commit
message.

In the last commit, I changed how `PathWithPosition` should intreprete
file paths. If my assumptions are off, please advise so that I can make
another approach.

I also believe further constraints would be better for
`PathWithPosition`'s intention. But people can make future improvements
to `PathWithPosition`.
---
 crates/util/src/paths.rs | 500 +++++++++++++++++++++++----------------
 1 file changed, 301 insertions(+), 199 deletions(-)

diff --git a/crates/util/src/paths.rs b/crates/util/src/paths.rs
index cd5beedf47b2cb..f4ecfefc52a872 100644
--- a/crates/util/src/paths.rs
+++ b/crates/util/src/paths.rs
@@ -98,10 +98,6 @@ impl<T: AsRef<Path>> PathExt for T {
 /// A delimiter to use in `path_query:row_number:column_number` strings parsing.
 pub const FILE_ROW_COLUMN_DELIMITER: char = ':';
 
-/// Extracts filename and row-column suffixes.
-/// Parenthesis format is used by [MSBuild](https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild-diagnostic-format-for-tasks) compatible tools
-// NOTE: All cases need to have exactly three capture groups for extract(): file_name, row and column.
-// Valid patterns that don't contain row and/or column should have empty groups in their place.
 const ROW_COL_CAPTURE_REGEX: &str = r"(?x)
     ([^\(]+)(?:
         \((\d+),(\d+)\) # filename(row,column)
@@ -109,12 +105,12 @@ const ROW_COL_CAPTURE_REGEX: &str = r"(?x)
         \((\d+)\)()     # filename(row)
     )
     |
-    ([^\:]+)(?:
-        \:(\d+)\:(\d+)  # filename:row:column
+    (.+?)(?:
+        \:+(\d+)\:(\d+)\:*$  # filename:row:column
         |
-        \:(\d+)()       # filename:row
+        \:+(\d+)\:*()$       # filename:row
         |
-        \:()()          # filename:
+        \:*()()$             # filename:
     )";
 
 /// A representation of a path-like string with optional row and column numbers.
@@ -136,9 +132,92 @@ impl PathWithPosition {
             column: None,
         }
     }
+
     /// Parses a string that possibly has `:row:column` or `(row, column)` suffix.
+    /// Parenthesis format is used by [MSBuild](https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild-diagnostic-format-for-tasks) compatible tools
     /// Ignores trailing `:`s, so `test.rs:22:` is parsed as `test.rs:22`.
     /// If the suffix parsing fails, the whole string is parsed as a path.
+    ///
+    /// Be mindful that `test_file:10:1:` is a valid posix filename.
+    /// `PathWithPosition` class assumes that the ending position-like suffix is **not** part of the filename.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use util::paths::PathWithPosition;
+    /// # use std::path::PathBuf;
+    /// assert_eq!(PathWithPosition::parse_str("test_file"), PathWithPosition {
+    ///     path: PathBuf::from("test_file"),
+    ///     row: None,
+    ///     column: None,
+    /// });
+    /// assert_eq!(PathWithPosition::parse_str("test_file:10"), PathWithPosition {
+    ///     path: PathBuf::from("test_file"),
+    ///     row: Some(10),
+    ///     column: None,
+    /// });
+    /// assert_eq!(PathWithPosition::parse_str("test_file.rs"), PathWithPosition {
+    ///     path: PathBuf::from("test_file.rs"),
+    ///     row: None,
+    ///     column: None,
+    /// });
+    /// assert_eq!(PathWithPosition::parse_str("test_file.rs:1"), PathWithPosition {
+    ///     path: PathBuf::from("test_file.rs"),
+    ///     row: Some(1),
+    ///     column: None,
+    /// });
+    /// assert_eq!(PathWithPosition::parse_str("test_file.rs:1:2"), PathWithPosition {
+    ///     path: PathBuf::from("test_file.rs"),
+    ///     row: Some(1),
+    ///     column: Some(2),
+    /// });
+    /// ```
+    ///
+    /// # Expected parsing results when encounter ill-formatted inputs.
+    /// ```
+    /// # use util::paths::PathWithPosition;
+    /// # use std::path::PathBuf;
+    /// assert_eq!(PathWithPosition::parse_str("test_file.rs:a"), PathWithPosition {
+    ///     path: PathBuf::from("test_file.rs:a"),
+    ///     row: None,
+    ///     column: None,
+    /// });
+    /// assert_eq!(PathWithPosition::parse_str("test_file.rs:a:b"), PathWithPosition {
+    ///     path: PathBuf::from("test_file.rs:a:b"),
+    ///     row: None,
+    ///     column: None,
+    /// });
+    /// assert_eq!(PathWithPosition::parse_str("test_file.rs::"), PathWithPosition {
+    ///     path: PathBuf::from("test_file.rs"),
+    ///     row: None,
+    ///     column: None,
+    /// });
+    /// assert_eq!(PathWithPosition::parse_str("test_file.rs::1"), PathWithPosition {
+    ///     path: PathBuf::from("test_file.rs"),
+    ///     row: Some(1),
+    ///     column: None,
+    /// });
+    /// assert_eq!(PathWithPosition::parse_str("test_file.rs:1::"), PathWithPosition {
+    ///     path: PathBuf::from("test_file.rs"),
+    ///     row: Some(1),
+    ///     column: None,
+    /// });
+    /// assert_eq!(PathWithPosition::parse_str("test_file.rs::1:2"), PathWithPosition {
+    ///     path: PathBuf::from("test_file.rs"),
+    ///     row: Some(1),
+    ///     column: Some(2),
+    /// });
+    /// assert_eq!(PathWithPosition::parse_str("test_file.rs:1::2"), PathWithPosition {
+    ///     path: PathBuf::from("test_file.rs:1"),
+    ///     row: Some(2),
+    ///     column: None,
+    /// });
+    /// assert_eq!(PathWithPosition::parse_str("test_file.rs:1:2:3"), PathWithPosition {
+    ///     path: PathBuf::from("test_file.rs:1"),
+    ///     row: Some(2),
+    ///     column: Some(3),
+    /// });
+    /// ```
     pub fn parse_str(s: &str) -> Self {
         let trimmed = s.trim();
         let path = Path::new(trimmed);
@@ -359,206 +438,229 @@ mod tests {
     }
 
     #[test]
-    fn path_with_position_parsing_positive() {
-        let input_and_expected = [
-            (
-                "test_file.rs",
-                PathWithPosition {
-                    path: PathBuf::from("test_file.rs"),
-                    row: None,
-                    column: None,
-                },
-            ),
-            (
-                "test_file.rs:1",
-                PathWithPosition {
-                    path: PathBuf::from("test_file.rs"),
-                    row: Some(1),
-                    column: None,
-                },
-            ),
-            (
-                "test_file.rs:1:2",
-                PathWithPosition {
-                    path: PathBuf::from("test_file.rs"),
-                    row: Some(1),
-                    column: Some(2),
-                },
-            ),
-        ];
+    fn path_with_position_parse_posix_path() {
+        // Test POSIX filename edge cases
+        // Read more at https://en.wikipedia.org/wiki/Filename
+        assert_eq!(
+            PathWithPosition::parse_str(" test_file"),
+            PathWithPosition {
+                path: PathBuf::from("test_file"),
+                row: None,
+                column: None
+            }
+        );
 
-        for (input, expected) in input_and_expected {
-            let actual = PathWithPosition::parse_str(input);
-            assert_eq!(
-                actual, expected,
-                "For positive case input str '{input}', got a parse mismatch"
-            );
-        }
+        assert_eq!(
+            PathWithPosition::parse_str("a:bc:.zip:1"),
+            PathWithPosition {
+                path: PathBuf::from("a:bc:.zip"),
+                row: Some(1),
+                column: None
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("one.second.zip:1"),
+            PathWithPosition {
+                path: PathBuf::from("one.second.zip"),
+                row: Some(1),
+                column: None
+            }
+        );
+
+        // Trim off trailing `:`s for otherwise valid input.
+        assert_eq!(
+            PathWithPosition::parse_str("test_file:10:1:"),
+            PathWithPosition {
+                path: PathBuf::from("test_file"),
+                row: Some(10),
+                column: Some(1)
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("test_file.rs:"),
+            PathWithPosition {
+                path: PathBuf::from("test_file.rs"),
+                row: None,
+                column: None
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("test_file.rs:1:"),
+            PathWithPosition {
+                path: PathBuf::from("test_file.rs"),
+                row: Some(1),
+                column: None
+            }
+        );
     }
 
     #[test]
-    fn path_with_position_parsing_negative() {
-        for (input, row, column) in [
-            ("test_file.rs:a", None, None),
-            ("test_file.rs:a:b", None, None),
-            ("test_file.rs::", None, None),
-            ("test_file.rs::1", None, None),
-            ("test_file.rs:1::", Some(1), None),
-            ("test_file.rs::1:2", None, None),
-            ("test_file.rs:1::2", Some(1), None),
-            ("test_file.rs:1:2:3", Some(1), Some(2)),
-        ] {
-            let actual = PathWithPosition::parse_str(input);
-            assert_eq!(
-                actual,
-                PathWithPosition {
-                    path: PathBuf::from("test_file.rs"),
-                    row,
-                    column,
-                },
-                "For negative case input str '{input}', got a parse mismatch"
-            );
-        }
+    #[cfg(not(target_os = "windows"))]
+    fn path_with_position_parse_posix_path_with_suffix() {
+        assert_eq!(
+            PathWithPosition::parse_str("app-editors:zed-0.143.6:20240710-201212.log:34:"),
+            PathWithPosition {
+                path: PathBuf::from("app-editors:zed-0.143.6:20240710-201212.log"),
+                row: Some(34),
+                column: None,
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("crates/file_finder/src/file_finder.rs:1902:13:"),
+            PathWithPosition {
+                path: PathBuf::from("crates/file_finder/src/file_finder.rs"),
+                row: Some(1902),
+                column: Some(13),
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("crate/utils/src/test:today.log:34"),
+            PathWithPosition {
+                path: PathBuf::from("crate/utils/src/test:today.log"),
+                row: Some(34),
+                column: None,
+            }
+        );
     }
 
-    // Trim off trailing `:`s for otherwise valid input.
     #[test]
-    fn path_with_position_parsing_special() {
-        #[cfg(not(target_os = "windows"))]
-        let input_and_expected = [
-            (
-                "test_file.rs:",
-                PathWithPosition {
-                    path: PathBuf::from("test_file.rs"),
-                    row: None,
-                    column: None,
-                },
-            ),
-            (
-                "test_file.rs:1:",
-                PathWithPosition {
-                    path: PathBuf::from("test_file.rs"),
-                    row: Some(1),
-                    column: None,
-                },
-            ),
-            (
-                "crates/file_finder/src/file_finder.rs:1902:13:",
-                PathWithPosition {
-                    path: PathBuf::from("crates/file_finder/src/file_finder.rs"),
-                    row: Some(1902),
-                    column: Some(13),
-                },
-            ),
-        ];
+    #[cfg(target_os = "windows")]
+    fn path_with_position_parse_windows_path() {
+        assert_eq!(
+            PathWithPosition::parse_str("crates\\utils\\paths.rs"),
+            PathWithPosition {
+                path: PathBuf::from("crates\\utils\\paths.rs"),
+                row: None,
+                column: None
+            }
+        );
 
-        #[cfg(target_os = "windows")]
-        let input_and_expected = [
-            (
-                "test_file.rs:",
-                PathWithPosition {
-                    path: PathBuf::from("test_file.rs"),
-                    row: None,
-                    column: None,
-                },
-            ),
-            (
-                "test_file.rs:1:",
-                PathWithPosition {
-                    path: PathBuf::from("test_file.rs"),
-                    row: Some(1),
-                    column: None,
-                },
-            ),
-            (
-                "\\\\?\\C:\\Users\\someone\\test_file.rs:1902:13:",
-                PathWithPosition {
-                    path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
-                    row: Some(1902),
-                    column: Some(13),
-                },
-            ),
-            (
-                "\\\\?\\C:\\Users\\someone\\test_file.rs:1902:13:15:",
-                PathWithPosition {
-                    path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
-                    row: Some(1902),
-                    column: Some(13),
-                },
-            ),
-            (
-                "\\\\?\\C:\\Users\\someone\\test_file.rs:1902:::15:",
-                PathWithPosition {
-                    path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
-                    row: Some(1902),
-                    column: None,
-                },
-            ),
-            (
-                "\\\\?\\C:\\Users\\someone\\test_file.rs(1902,13):",
-                PathWithPosition {
-                    path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
-                    row: Some(1902),
-                    column: Some(13),
-                },
-            ),
-            (
-                "\\\\?\\C:\\Users\\someone\\test_file.rs(1902):",
-                PathWithPosition {
-                    path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
-                    row: Some(1902),
-                    column: None,
-                },
-            ),
-            (
-                "C:\\Users\\someone\\test_file.rs:1902:13:",
-                PathWithPosition {
-                    path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
-                    row: Some(1902),
-                    column: Some(13),
-                },
-            ),
-            (
-                "crates/utils/paths.rs",
-                PathWithPosition {
-                    path: PathBuf::from("crates\\utils\\paths.rs"),
-                    row: None,
-                    column: None,
-                },
-            ),
-            (
-                "C:\\Users\\someone\\test_file.rs(1902,13):",
-                PathWithPosition {
-                    path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
-                    row: Some(1902),
-                    column: Some(13),
-                },
-            ),
-            (
-                "C:\\Users\\someone\\test_file.rs(1902):",
-                PathWithPosition {
-                    path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
-                    row: Some(1902),
-                    column: None,
-                },
-            ),
-            (
-                "crates/utils/paths.rs:101",
-                PathWithPosition {
-                    path: PathBuf::from("crates\\utils\\paths.rs"),
-                    row: Some(101),
-                    column: None,
-                },
-            ),
-        ];
+        assert_eq!(
+            PathWithPosition::parse_str("C:\\Users\\someone\\test_file.rs"),
+            PathWithPosition {
+                path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
+                row: None,
+                column: None
+            }
+        );
+    }
 
-        for (input, expected) in input_and_expected {
-            let actual = PathWithPosition::parse_str(input);
-            assert_eq!(
-                actual, expected,
-                "For special case input str '{input}', got a parse mismatch"
-            );
-        }
+    #[test]
+    #[cfg(target_os = "windows")]
+    fn path_with_position_parse_windows_path_with_suffix() {
+        assert_eq!(
+            PathWithPosition::parse_str("crates\\utils\\paths.rs:101"),
+            PathWithPosition {
+                path: PathBuf::from("crates\\utils\\paths.rs"),
+                row: Some(101),
+                column: None
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs:1:20"),
+            PathWithPosition {
+                path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
+                row: Some(1),
+                column: Some(20)
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("C:\\Users\\someone\\test_file.rs(1902,13)"),
+            PathWithPosition {
+                path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
+                row: Some(1902),
+                column: Some(13)
+            }
+        );
+
+        // Trim off trailing `:`s for otherwise valid input.
+        assert_eq!(
+            PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs:1902:13:"),
+            PathWithPosition {
+                path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
+                row: Some(1902),
+                column: Some(13)
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs:1902:13:15:"),
+            PathWithPosition {
+                path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs:1902"),
+                row: Some(13),
+                column: Some(15)
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs:1902:::15:"),
+            PathWithPosition {
+                path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs:1902"),
+                row: Some(15),
+                column: None
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs(1902,13):"),
+            PathWithPosition {
+                path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
+                row: Some(1902),
+                column: Some(13),
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("\\\\?\\C:\\Users\\someone\\test_file.rs(1902):"),
+            PathWithPosition {
+                path: PathBuf::from("\\\\?\\C:\\Users\\someone\\test_file.rs"),
+                row: Some(1902),
+                column: None,
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("C:\\Users\\someone\\test_file.rs:1902:13:"),
+            PathWithPosition {
+                path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
+                row: Some(1902),
+                column: Some(13),
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("C:\\Users\\someone\\test_file.rs(1902,13):"),
+            PathWithPosition {
+                path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
+                row: Some(1902),
+                column: Some(13),
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("C:\\Users\\someone\\test_file.rs(1902):"),
+            PathWithPosition {
+                path: PathBuf::from("C:\\Users\\someone\\test_file.rs"),
+                row: Some(1902),
+                column: None,
+            }
+        );
+
+        assert_eq!(
+            PathWithPosition::parse_str("crates/utils/paths.rs:101"),
+            PathWithPosition {
+                path: PathBuf::from("crates\\utils\\paths.rs"),
+                row: Some(101),
+                column: None,
+            }
+        );
     }
 
     #[test]

From 469dfe759c7489ffb1352a74689cb19cae51a84f Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 17 Sep 2024 17:21:20 +0200
Subject: [PATCH 134/762] ssh: Handle `~` in ssh filenames (#17939)

This allows users to open `ssh://user@host/~/my-home-dir-folder`.

Release Notes:

- N/A

Co-authored-by: Conrad <conrad@zed.dev>
---
 crates/project/src/worktree_store.rs | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 8b620de43e0838..07764d4a05ce71 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -182,14 +182,23 @@ impl WorktreeStore {
         visible: bool,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Model<Worktree>, Arc<anyhow::Error>>> {
-        let abs_path = abs_path.as_ref();
-        let root_name = abs_path.file_name().unwrap().to_string_lossy().to_string();
-        let path = abs_path.to_string_lossy().to_string();
+        let mut abs_path = abs_path.as_ref().to_string_lossy().to_string();
+        // If we start with `/~` that means the ssh path was something like `ssh://user@host/~/home-dir-folder/`
+        // in which case want to strip the leading the `/` and expand the tilde.
+        // That's what git does too: https://github.com/libgit2/libgit2/issues/3345#issuecomment-127050850
+        if abs_path.starts_with("/~") {
+            abs_path = shellexpand::tilde(&abs_path[1..]).to_string();
+        }
+        let root_name = PathBuf::from(abs_path.clone())
+            .file_name()
+            .unwrap()
+            .to_string_lossy()
+            .to_string();
         cx.spawn(|this, mut cx| async move {
             let response = client
                 .request(proto::AddWorktree {
                     project_id: SSH_PROJECT_ID,
-                    path: path.clone(),
+                    path: abs_path.clone(),
                 })
                 .await?;
             let worktree = cx.update(|cx| {
@@ -200,7 +209,7 @@ impl WorktreeStore {
                         id: response.worktree_id,
                         root_name,
                         visible,
-                        abs_path: path,
+                        abs_path,
                     },
                     client,
                     cx,

From 10cfaecffaa8c3705085d9faab714121a78e6f3d Mon Sep 17 00:00:00 2001
From: Stanislav Alekseev <43210583+WeetHet@users.noreply.github.com>
Date: Tue, 17 Sep 2024 18:28:03 +0300
Subject: [PATCH 135/762] ocaml: Add Dune language support (#17886)

This uses my fork of the dune tree-sitter grammar to include the
generated files

Release Notes:

- N/A
---
 extensions/ocaml/extension.toml                | 4 ++++
 extensions/ocaml/languages/dune/config.toml    | 8 ++++++++
 extensions/ocaml/languages/dune/highlights.scm | 5 +++++
 extensions/ocaml/languages/dune/injections.scm | 2 ++
 4 files changed, 19 insertions(+)
 create mode 100644 extensions/ocaml/languages/dune/config.toml
 create mode 100644 extensions/ocaml/languages/dune/highlights.scm
 create mode 100644 extensions/ocaml/languages/dune/injections.scm

diff --git a/extensions/ocaml/extension.toml b/extensions/ocaml/extension.toml
index 99f83d126307c2..0523ba83b6b8e8 100644
--- a/extensions/ocaml/extension.toml
+++ b/extensions/ocaml/extension.toml
@@ -19,3 +19,7 @@ path = "grammars/ocaml"
 repository = "https://github.com/tree-sitter/tree-sitter-ocaml"
 commit = "0b12614ded3ec7ed7ab7933a9ba4f695ba4c342e"
 path = "grammars/interface"
+
+[grammars.dune]
+repository = "https://github.com/WHForks/tree-sitter-dune"
+commit = "b3f7882e1b9a1d8811011bf6f0de1c74c9c93949"
diff --git a/extensions/ocaml/languages/dune/config.toml b/extensions/ocaml/languages/dune/config.toml
new file mode 100644
index 00000000000000..332e3f112ea5db
--- /dev/null
+++ b/extensions/ocaml/languages/dune/config.toml
@@ -0,0 +1,8 @@
+name = "Dune"
+grammar = "dune"
+path_suffixes = ["dune", "dune-project"]
+brackets = [
+  { start = "(", end = ")", close = true, newline = true },
+  { start = "\"", end = "\"", close = true, newline = false, not_in = ["string"] }
+]
+tab_size = 2
diff --git a/extensions/ocaml/languages/dune/highlights.scm b/extensions/ocaml/languages/dune/highlights.scm
new file mode 100644
index 00000000000000..e7a21cd2c51c03
--- /dev/null
+++ b/extensions/ocaml/languages/dune/highlights.scm
@@ -0,0 +1,5 @@
+(stanza_name) @function
+(field_name) @property
+(quoted_string) @string
+(multiline_string) @string
+(action_name) @keyword
diff --git a/extensions/ocaml/languages/dune/injections.scm b/extensions/ocaml/languages/dune/injections.scm
new file mode 100644
index 00000000000000..441998290e76df
--- /dev/null
+++ b/extensions/ocaml/languages/dune/injections.scm
@@ -0,0 +1,2 @@
+((ocaml_syntax) @injection.content
+ (#set! injection.language "ocaml"))

From 7c54965b11c096341aeee64a0ed8079890c307d1 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Tue, 17 Sep 2024 17:39:06 +0200
Subject: [PATCH 136/762] docs: Add dark mode (#17940)

Closes https://github.com/zed-industries/zed/issues/17911

This PR enables dark mode on the documentation. This is done without any
special plugins, just pure JavaScript and CSS variables. I may open
fast-follow PRs to fine-tune design and code details that haven't been
super polished yet. For example, when switching to dark mode, the
`class` attribute on the `html` tag would change immediately, whereas
other attributes such as `data-theme` and `data-color-scheme` would
require a full refresh. This seems to be resolved, but not 100%
confident yet.

---

Release Notes:

- Enabled dark mode on the documentation
---
 docs/theme/css/chrome.css    |  47 +++++++++-------
 docs/theme/css/general.css   |  14 ++---
 docs/theme/css/variables.css | 105 ++++++++++++++++++++++++++++++++---
 docs/theme/index.hbs         |  38 ++++++++++---
 docs/theme/page-toc.css      |   2 +-
 docs/theme/plugins.css       |   2 +-
 docs/theme/plugins.js        |  62 +++++++++++++++++++++
 7 files changed, 224 insertions(+), 46 deletions(-)

diff --git a/docs/theme/css/chrome.css b/docs/theme/css/chrome.css
index 7afeabc704ba36..11f16848d70eb4 100644
--- a/docs/theme/css/chrome.css
+++ b/docs/theme/css/chrome.css
@@ -3,7 +3,7 @@
 @import "variables.css";
 
 html {
-  background-color: rgb(246, 245, 240);
+  background-color: var(--bg);
   scrollbar-color: var(--scrollbar) var(--bg);
 }
 #searchresults a,
@@ -58,7 +58,7 @@ a > .hljs {
   height: var(--menu-bar-height);
 }
 #menu-bar.bordered {
-  border-block-end-color: var(--table-border-color);
+  border-block-end-color: var(--divider);
 }
 #menu-bar i,
 #menu-bar .icon-button {
@@ -73,7 +73,7 @@ a > .hljs {
   transition: color 0.5s;
 }
 #menu-bar .icon-button:hover {
-  background-color: hsl(219, 93%, 42%, 0.15);
+  background-color: var(--icon-btn-bg-hover);
 }
 
 @media only screen and (max-width: 420px) {
@@ -116,6 +116,7 @@ a > .hljs {
   align-items: center;
   flex: 1;
   overflow: hidden;
+  filter: var(--logo-brightness);
 }
 .js .menu-title {
   cursor: pointer;
@@ -249,9 +250,10 @@ a:hover > .hljs {
 }
 
 pre {
-  background-color: white;
-  border: 1px rgba(8, 76, 207, 0.3) solid;
-  box-shadow: rgba(8, 76, 207, 0.07) 4px 4px 0px 0px;
+  background-color: var(--pre-bg);
+  border: 1px solid;
+  border-color: var(--pre-border);
+  box-shadow: var(--pre-shadow) 4px 4px 0px 0px;
   position: relative;
 }
 pre > .hljs {
@@ -445,7 +447,8 @@ ul#searchresults span.teaser em {
   overscroll-behavior-y: contain;
   background-color: var(--sidebar-bg);
   color: var(--sidebar-fg);
-  border-right: 1px solid hsl(219, 93%, 42%, 0.15);
+  border-right: 1px solid;
+  border-color: var(--divider);
 }
 [dir="rtl"] .sidebar {
   left: unset;
@@ -606,7 +609,7 @@ ul#searchresults span.teaser em {
   margin: 5px 0px;
 }
 .chapter .spacer {
-  background-color: var(--sidebar-spacer);
+  background-color: var(--divider);
 }
 
 @media (-moz-touch-enabled: 1), (pointer: coarse) {
@@ -628,11 +631,11 @@ ul#searchresults span.teaser em {
 
 .theme-popup {
   position: absolute;
-  left: 10px;
-  top: var(--menu-bar-height);
+  left: 32px;
+  top: calc(var(--menu-bar-height) - 12px);
   z-index: 1000;
   border-radius: 4px;
-  font-size: 0.7em;
+  font-size: 1.4rem;
   color: var(--fg);
   background: var(--theme-popup-bg);
   border: 1px solid var(--theme-popup-border);
@@ -654,7 +657,7 @@ ul#searchresults span.teaser em {
   width: 100%;
   border: 0;
   margin: 0;
-  padding: 2px 20px;
+  padding: 2px 24px;
   line-height: 25px;
   white-space: nowrap;
   text-align: start;
@@ -662,32 +665,36 @@ ul#searchresults span.teaser em {
   color: inherit;
   background: inherit;
   font-size: inherit;
+  font-family: inherit;
 }
 .theme-popup .theme:hover {
   background-color: var(--theme-hover);
 }
 
 .theme-selected::before {
+  font-family: Arial, Helvetica, sans-serif;
+  text-align: center;
   display: inline-block;
   content: "✓";
-  margin-inline-start: -14px;
-  width: 14px;
+  margin-inline-start: -20px;
+  width: 20px;
 }
 
 .download-button {
-  background: hsl(220, 60%, 95%);
-  color: hsl(220, 60%, 30%);
+  background: var(--download-btn-bg);
+  color: var(--download-btn-color);
   padding: 4px 8px;
-  border: 1px solid hsla(220, 60%, 40%, 0.2);
+  border: 1px solid;
+  border-color: var(--download-btn-border);
   font-size: 1.4rem;
   border-radius: 4px;
-  box-shadow: hsla(220, 40%, 60%, 0.1) 0px -2px 0px 0px inset;
+  box-shadow: var(--download-btn-shadow) 0px -2px 0px 0px inset;
   transition: 100ms;
   transition-property: box-shadow, border-color, background-color;
 }
 
 .download-button:hover {
-  background: hsl(220, 60%, 93%);
-  border-color: hsla(220, 60%, 50%, 0.2);
+  background: var(--download-btn-bg);
+  border-color: var(--download-btn-border-hover);
   box-shadow: none;
 }
diff --git a/docs/theme/css/general.css b/docs/theme/css/general.css
index 9a20751f211e74..e6905b47bf485b 100644
--- a/docs/theme/css/general.css
+++ b/docs/theme/css/general.css
@@ -174,10 +174,10 @@ h6:target::before {
 }
 .content a {
   text-decoration: underline;
-  text-decoration-color: hsl(219, 93%, 42%, 0.2);
+  text-decoration-color: var(--link-line-decoration);
 }
 .content a:hover {
-  text-decoration-color: hsl(219, 93%, 42%, 0.5);
+  text-decoration-color: var(--link-line-decoration-hover);
 }
 .content img,
 .content video {
@@ -219,7 +219,7 @@ table thead td {
 }
 table thead th {
   padding: 6px 12px;
-  color: #000;
+  color: var(--full-contrast);
   text-align: left;
   border: 1px var(--table-border-color) solid;
 }
@@ -235,7 +235,7 @@ blockquote {
   margin: auto;
   margin-top: 1rem;
   padding: 1rem 1.25rem;
-  color: #000;
+  color: var(--full-contrast);
   background-color: var(--quote-bg);
   border: 1px solid var(--quote-border);
 }
@@ -315,7 +315,7 @@ kbd {
   font-size: 1.4rem;
   margin: 0.5em 0;
   border-bottom: 1px solid;
-  border-color: var(--border-light);
+  border-color: var(--divider);
 }
 .footnote-definition p {
   display: inline;
@@ -356,6 +356,6 @@ kbd {
 }
 
 code.hljs {
-  color: hsl(221, 13%, 10%) !important;
-  background-color: hsla(221, 93%, 42%, 0.1);
+  color: var(--code-text) !important;
+  background-color: var(--code-bg);
 }
diff --git a/docs/theme/css/variables.css b/docs/theme/css/variables.css
index 481cb5a6c183c2..59f239826472a8 100644
--- a/docs/theme/css/variables.css
+++ b/docs/theme/css/variables.css
@@ -1,6 +1,10 @@
 /* Globals */
 
 :root {
+  --color-scheme: light;
+
+  --logo-brightness: brightness(1);
+
   --sidebar-width: 300px;
   --sidebar-resize-indicator-width: 0px;
   --sidebar-resize-indicator-space: 2px;
@@ -24,18 +28,30 @@
 
   --sidebar-fg: hsl(0, 0%, 0%);
   --sidebar-non-existant: #aaaaaa;
-  --sidebar-active: hsl(219, 93%, 42%);
-  --sidebar-active-bg: hsl(219, 93%, 42%, 0.1);
-  --sidebar-spacer: #f4f4f4;
+  --sidebar-active: hsl(220, 93%, 42%);
+  --sidebar-active-bg: hsl(220, 93%, 42%, 0.1);
 
+  --divider: hsl(220, 93%, 42%, 0.15);
   --scrollbar: #8f8f8f;
 
   --icons: #747474;
   --icons-hover: #000000;
+  --icon-btn-bg-hover: hsl(220, 93%, 42%, 0.15);
 
-  --links: rgb(8, 76, 207);
+  --links: hsl(220, 92%, 42%);
+  --link-line-decoration: hsl(220, 93%, 42%, 0.2);
+  --link-line-decoration-hover: hsl(220, 93%, 42%, 0.5);
+
+  --full-contrast: #000;
 
   --inline-code-color: #301900;
+  --code-text: hsl(220, 13%, 10%);
+  --code-bg: hsl(220, 93%, 42%, 0.1);
+  --keybinding-bg: hsl(0, 0%, 94%);
+
+  --pre-bg: #fff;
+  --pre-border: hsla(220, 93%, 42%, 0.3);
+  --pre-shadow: hsla(220, 93%, 42%, 0.07);
 
   --theme-popup-bg: #fafafa;
   --theme-popup-border: #cccccc;
@@ -48,9 +64,9 @@
   --warning-bg: hsl(42, 100%, 60%, 0.1);
   --warning-icon: hsl(42, 100%, 30%);
 
-  --table-header-bg: hsl(219, 50%, 90%, 0.4);
-  --table-border-color: hsl(219, 93%, 42%, 0.15);
-  --table-alternate-bg: hsl(219, 10%, 90%, 0.4);
+  --table-header-bg: hsl(220, 50%, 90%, 0.4);
+  --table-border-color: hsl(220, 93%, 42%, 0.15);
+  --table-alternate-bg: hsl(220, 10%, 90%, 0.4);
 
   --searchbar-border-color: #aaa;
   --searchbar-bg: #fafafa;
@@ -61,5 +77,78 @@
   --searchresults-li-bg: #e4f2fe;
   --search-mark-bg: #a2cff5;
 
-  --color-scheme: light;
+  --download-btn-bg: hsl(220, 60%, 95%);
+  --download-btn-bg-hover: hsl(220, 60%, 93%);
+  --download-btn-color: hsl(220, 60%, 30%);
+  --download-btn-border: hsla(220, 60%, 40%, 0.2);
+  --download-btn-border-hover: hsla(220, 60%, 50%, 0.2);
+  --download-btn-shadow: hsla(220, 40%, 60%, 0.1);
+}
+
+.dark {
+  --color-scheme: dark;
+
+  --logo-brightness: brightness(2);
+
+  --bg: hsl(220, 13%, 10%);
+  --fg: hsl(220, 14%, 70%);
+  --title-color: hsl(220, 92%, 80%);
+
+  --border: hsl(220, 13%, 20%);
+  --border-light: hsl(220, 13%, 90%);
+  --border-hover: hsl(220, 13%, 40%);
+
+  --sidebar-bg: hsl(220, 13%, 10%);
+  --sidebar-fg: hsl(220, 14%, 71%);
+  --sidebar-non-existant: #505254;
+  --sidebar-active: hsl(220, 92%, 75%);
+  --sidebar-active-bg: hsl(220, 93%, 42%, 0.25);
+
+  --divider: hsl(220, 13%, 20%);
+  --scrollbar: hsl(220, 13%, 30%);
+
+  --icons: hsl(220, 14%, 71%);
+  --icons-hover: hsl(220, 14%, 90%);
+  --icon-btn-bg-hover: hsl(220, 93%, 42%, 0.4);
+
+  --links: hsl(220, 93%, 70%);
+  --link-line-decoration: hsl(220, 92%, 80%, 0.4);
+  --link-line-decoration-hover: hsl(220, 92%, 80%, 0.8);
+  --full-contrast: #fff;
+
+  --inline-code-color: hsl(40, 100%, 80%);
+  --code-text: hsl(220, 13%, 95%);
+  --code-bg: hsl(220, 93%, 50%, 0.2);
+  --keybinding-bg: hsl(0, 0%, 12%);
+
+  --pre-bg: hsl(220, 13%, 5%);
+  --pre-border: hsla(220, 93%, 70%, 0.3);
+  --pre-shadow: hsla(220, 93%, 70%, 0.1);
+
+  --theme-popup-bg: hsl(220, 13%, 15%);
+  --theme-popup-border: hsl(220, 13%, 20%);
+  --theme-hover: hsl(220, 13%, 25%);
+
+  --quote-bg: hsl(220, 13%, 25%, 0.4);
+  --quote-border: hsl(220, 13%, 32%, 0.5);
+
+  --table-border-color: hsl(220, 13%, 30%, 0.5);
+  --table-header-bg: hsl(220, 13%, 25%, 0.5);
+  --table-alternate-bg: hsl(220, 13%, 20%, 0.4);
+
+  --searchbar-border-color: hsl(220, 13%, 30%);
+  --searchbar-bg: hsl(220, 13%, 22%, 0.5);
+  --searchbar-fg: hsl(220, 14%, 71%);
+  --searchbar-shadow-color: hsl(220, 13%, 15%);
+  --searchresults-header-fg: hsl(220, 14%, 60%);
+  --searchresults-border-color: hsl(220, 13%, 30%);
+  --searchresults-li-bg: hsl(220, 13%, 25%);
+  --search-mark-bg: hsl(220, 93%, 60%);
+
+  --download-btn-bg: hsl(220, 90%, 90%, 0.1);
+  --download-btn-bg-hover: hsl(220, 90%, 50%, 0.2);
+  --download-btn-color: hsl(220, 90%, 95%);
+  --download-btn-border: hsla(220, 90%, 80%, 0.2);
+  --download-btn-border-hover: hsla(220, 90%, 80%, 0.4);
+  --download-btn-shadow: hsla(220, 50%, 60%, 0.15);
 }
diff --git a/docs/theme/index.hbs b/docs/theme/index.hbs
index 8976b54bd96014..c4154b46d33b77 100644
--- a/docs/theme/index.hbs
+++ b/docs/theme/index.hbs
@@ -1,5 +1,5 @@
 <!DOCTYPE HTML>
-<html lang="{{ language }}" class="{{ default_theme }}" dir="{{ text_direction }}">
+<html lang="{{ language }}" data-theme="{{ default_theme }}" data-color-scheme="{{ default_theme }}" dir="{{ text_direction }}">
     <head>
         <!-- Book generated using mdBook -->
         <meta charset="UTF-8">
@@ -56,13 +56,15 @@
             var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "{{ preferred_dark_theme }}" : "{{ default_theme }}";
         </script>
 
-        <!-- Set the theme before any content is loaded, prevents flash -->
+        <!-- Support dark mode -->
         <script>
             var theme;
             try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
-            if (theme === null || theme === undefined) { theme = default_theme; }
+            if (theme === null || theme === undefined) {
+                theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+            }
             var html = document.querySelector('html');
-            html.classList.remove('{{ default_theme }}')
+            html.classList.remove('light', 'dark')
             html.classList.add(theme);
             var body = document.querySelector('body');
             body.classList.remove('no-js')
@@ -124,19 +126,19 @@
                 <div id="menu-bar-hover-placeholder"></div>
                 <div id="menu-bar" class="menu-bar sticky">
                     <div class="left-buttons">
+
                         <label id="sidebar-toggle" class="icon-button" for="sidebar-toggle-anchor" title="Toggle Table of Contents" aria-label="Toggle Table of Contents" aria-controls="sidebar">
                             <i class="fa fa-bars"></i>
                         </label>
-                        <button style="display: none;" id="theme-toggle" class="icon-button" type="button" title="Change theme" aria-label="Change theme" aria-haspopup="true" aria-expanded="false" aria-controls="theme-list">
+
+                        <button id="theme-toggle" class="icon-button" type="button" title="Change theme" aria-label="Change theme" aria-haspopup="true" aria-expanded="false" aria-controls="theme-list">
                             <i class="fa fa-paint-brush"></i>
                         </button>
                         <ul id="theme-list" class="theme-popup" aria-label="Themes" role="menu">
                             <li role="none"><button role="menuitem" class="theme" id="light">Light</button></li>
-                            <li role="none"><button role="menuitem" class="theme" id="rust">Rust</button></li>
-                            <li role="none"><button role="menuitem" class="theme" id="coal">Coal</button></li>
-                            <li role="none"><button role="menuitem" class="theme" id="navy">Navy</button></li>
-                            <li role="none"><button role="menuitem" class="theme" id="ayu">Ayu</button></li>
+                            <li role="none"><button role="menuitem" class="theme" id="dark">Dark</button></li>
                         </ul>
+
                         {{#if search_enabled}}
                         <button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
                             <i class="fa fa-search"></i>
@@ -274,6 +276,24 @@
         {{/if}}
         {{/if}}
 
+        <script>
+          (function() {
+            var theme = localStorage.getItem('mdbook-theme');
+            var html = document.querySelector('html');
+            if (theme) {
+              html.setAttribute('data-theme', theme);
+              html.setAttribute('data-color-scheme', theme);
+              html.className = theme;
+            } else {
+              var systemPreference = window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+              html.setAttribute('data-theme', systemPreference);
+              html.setAttribute('data-color-scheme', systemPreference);
+              html.className = systemPreference;
+            }
+          })();
+        </script>
+
+
     </div>
     </body>
 </html>
diff --git a/docs/theme/page-toc.css b/docs/theme/page-toc.css
index dacd61a09b685a..af9b2fbbe1202c 100644
--- a/docs/theme/page-toc.css
+++ b/docs/theme/page-toc.css
@@ -74,6 +74,6 @@
     margin-bottom: 12px;
     padding-left: 12px;
     font-size: 1.4rem;
-    color: #000;
+    color: var(--full-contrast);
   }
 }
diff --git a/docs/theme/plugins.css b/docs/theme/plugins.css
index 9deee5d5baf9ff..9d5d09fe736a96 100644
--- a/docs/theme/plugins.css
+++ b/docs/theme/plugins.css
@@ -1,5 +1,5 @@
 kbd.keybinding {
-  background-color: #f0f0f0;
+  background-color: var(--keybinding-bg);
   padding: 2px 4px;
   border-radius: 3px;
   font-family: monospace;
diff --git a/docs/theme/plugins.js b/docs/theme/plugins.js
index eee842f15a9f44..76a295353f7abc 100644
--- a/docs/theme/plugins.js
+++ b/docs/theme/plugins.js
@@ -48,3 +48,65 @@ console.log("Operating System:", os);
   // Start the process from the body
   walkDOM(document.body);
 })();
+
+function darkModeToggle() {
+  var html = document.documentElement;
+  var themeToggleButton = document.getElementById("theme-toggle");
+  var themePopup = document.getElementById("theme-list");
+  var themePopupButtons = themePopup.querySelectorAll("button");
+
+  function setTheme(theme) {
+    html.setAttribute("data-theme", theme);
+    html.setAttribute("data-color-scheme", theme);
+    html.className = theme;
+    localStorage.setItem("mdbook-theme", theme);
+
+    // Force a repaint to ensure the changes take effect in the client immediately
+    document.body.style.display = "none";
+    document.body.offsetHeight;
+    document.body.style.display = "";
+  }
+
+  themeToggleButton.addEventListener("click", function (event) {
+    event.preventDefault();
+    themePopup.style.display =
+      themePopup.style.display === "block" ? "none" : "block";
+  });
+
+  themePopupButtons.forEach(function (button) {
+    button.addEventListener("click", function () {
+      setTheme(this.id);
+      themePopup.style.display = "none";
+    });
+  });
+
+  document.addEventListener("click", function (event) {
+    if (
+      !themePopup.contains(event.target) &&
+      !themeToggleButton.contains(event.target)
+    ) {
+      themePopup.style.display = "none";
+    }
+  });
+
+  // Set initial theme
+  var currentTheme = localStorage.getItem("mdbook-theme");
+  if (currentTheme) {
+    setTheme(currentTheme);
+  } else {
+    // If no theme is set, use the system's preference
+    var systemPreference = window.matchMedia("(prefers-color-scheme: dark)")
+      .matches
+      ? "dark"
+      : "light";
+    setTheme(systemPreference);
+  }
+
+  // Listen for system's preference changes
+  const darkModeMediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+  darkModeMediaQuery.addEventListener("change", function (e) {
+    if (!localStorage.getItem("mdbook-theme")) {
+      setTheme(e.matches ? "dark" : "light");
+    }
+  });
+}

From d5003e1121045b1c8f505b3ff592630d2e277605 Mon Sep 17 00:00:00 2001
From: VacheDesNeiges <33199153+VacheDesNeiges@users.noreply.github.com>
Date: Tue, 17 Sep 2024 17:40:43 +0200
Subject: [PATCH 137/762] Update C++ Tree-sitter queries (#17471)

Closes #16443

Release Notes:

- Fixed C++ functions being wrongly tagged as variables when called
after two or more scope resolution operators.
- Added a "namespace" tag for highlighting purposes

Before :

![image](https://github.com/user-attachments/assets/743b8407-4e62-4549-9c6a-ed6608ea7e43)
After :

![image](https://github.com/user-attachments/assets/de563621-e722-463c-97a1-a99b925f126e)
---
 crates/languages/src/cpp/highlights.scm | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/crates/languages/src/cpp/highlights.scm b/crates/languages/src/cpp/highlights.scm
index 42d05bde33e0ab..4c9db569285e39 100644
--- a/crates/languages/src/cpp/highlights.scm
+++ b/crates/languages/src/cpp/highlights.scm
@@ -1,10 +1,33 @@
 (identifier) @variable
 (field_identifier) @property
+(namespace_identifier) @namespace
 
 (call_expression
   function: (qualified_identifier
     name: (identifier) @function))
 
+(call_expression
+  (qualified_identifier
+    (identifier) @function.call))
+
+(call_expression
+  (qualified_identifier
+    (qualified_identifier
+      (identifier) @function.call)))
+
+(call_expression
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (identifier) @function.call))))
+
+((qualified_identifier
+  (qualified_identifier
+    (qualified_identifier
+      (qualified_identifier
+        (identifier) @function.call)))) @_parent
+  (#has-ancestor? @_parent call_expression))
+
 (call_expression
   function: (identifier) @function)
 

From e88b48a9c7467aa69a4f7d6dd657bbc1a294e32a Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 17 Sep 2024 11:42:20 -0400
Subject: [PATCH 138/762] ocaml: Fix indentation in files (#17942)

This PR fixes the indentation in the Dune-related files after
https://github.com/zed-industries/zed/pull/17886.

Release Notes:

- N/A
---
 extensions/ocaml/languages/dune/config.toml    | 4 ++--
 extensions/ocaml/languages/dune/injections.scm | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/extensions/ocaml/languages/dune/config.toml b/extensions/ocaml/languages/dune/config.toml
index 332e3f112ea5db..b4f79850b64336 100644
--- a/extensions/ocaml/languages/dune/config.toml
+++ b/extensions/ocaml/languages/dune/config.toml
@@ -2,7 +2,7 @@ name = "Dune"
 grammar = "dune"
 path_suffixes = ["dune", "dune-project"]
 brackets = [
-  { start = "(", end = ")", close = true, newline = true },
-  { start = "\"", end = "\"", close = true, newline = false, not_in = ["string"] }
+    { start = "(", end = ")", close = true, newline = true },
+    { start = "\"", end = "\"", close = true, newline = false, not_in = ["string"] }
 ]
 tab_size = 2
diff --git a/extensions/ocaml/languages/dune/injections.scm b/extensions/ocaml/languages/dune/injections.scm
index 441998290e76df..654b5b2c13967a 100644
--- a/extensions/ocaml/languages/dune/injections.scm
+++ b/extensions/ocaml/languages/dune/injections.scm
@@ -1,2 +1,2 @@
 ((ocaml_syntax) @injection.content
- (#set! injection.language "ocaml"))
+    (#set! injection.language "ocaml"))

From 27f09957c2066f0f4131f5daafb95085e3ce6dbb Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 17 Sep 2024 11:53:52 -0400
Subject: [PATCH 139/762] Improve CSS highlighting for property_name (#17324)

---
 crates/languages/src/css/highlights.scm | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/crates/languages/src/css/highlights.scm b/crates/languages/src/css/highlights.scm
index e271d8583c661b..4ddfe9a418ca70 100644
--- a/crates/languages/src/css/highlights.scm
+++ b/crates/languages/src/css/highlights.scm
@@ -35,10 +35,11 @@
   (class_name)
   (id_name)
   (namespace_name)
-  (property_name)
   (feature_name)
 ] @property
 
+(property_name) @constant
+
 (function_name) @function
 
 (
@@ -75,4 +76,17 @@
 [
   ","
   ":"
+  "."
+  "::"
+  ";"
+  "#"
 ] @punctuation.delimiter
+
+[
+  "{"
+  ")"
+  "("
+  "}"
+  "["
+  "]"
+] @punctuation.bracket

From accff826ca842fc8c297fab317f464bc9c695d75 Mon Sep 17 00:00:00 2001
From: Albert Marashi <albert@lumina.earth>
Date: Wed, 18 Sep 2024 01:32:25 +0930
Subject: [PATCH 140/762] svelte: Migrate to
 `tree-sitter-grammars/tree-sitter-svelte` (#17529)

> [!NOTE]
> The https://github.com/tree-sitter-grammars/tree-sitter-svelte
repository seems to be more well maintained, with higher quality code,
and as per https://github.com/zed-extensions/svelte/issues/1 it was
suggested that we swap to this repository for Svelte grammars

- Closes https://github.com/zed-industries/zed/issues/17310
- Closes https://github.com/zed-industries/zed/issues/10893
- Closes https://github.com/zed-industries/zed/issues/12833
- Closes https://github.com/zed-extensions/svelte/issues/1
- Closes https://github.com/zed-industries/zed/issues/14943
- Closes https://github.com/zed-extensions/svelte/issues/2

- Added: buffer/file symbol outlines for `.svelte` (`outlines.scm`)
- Improved: Attribute directives & modifiers in `.svelte` files can be
styled independently.
- Fixed: issue where svelte expression inside quotes failed parsing
- Improved: Svelte components in Markup are styled differently from
tags.
- Added: Support for Svelte 5 syntax (`{#snippet children()}`, `{@render
foo()`)
- Change: Svelte now using
[tree-sitter-grammars/tree-sitter-svelte](https://github.com/tree-sitter-grammars/tree-sitter-svelte)
for language highlighting
- Added: Support for typescript syntax in svelte expressions


![image](https://github.com/user-attachments/assets/49d199ee-7550-49a7-912d-070cf691b029)

![image](https://github.com/user-attachments/assets/848ac5b6-62da-4c42-8e24-b7023504f8af)

Release Notes:

- N/A

---

**tree-sitter-grammar things to improve**
- [ ] snippet functions aren't being treated as JS code
- [ ] we should be able to detect @component comments and treat them as
markdown
- [x] `foo:bar` style/class/prop directives
- [x] `--foo="..."` var fields
- [ ] snippet/if blocks's children may need to be indented a little
further

Will implement some of the rest of these in a separate PR

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 docs/src/languages/svelte.md                  |  23 ++-
 extensions/svelte/extension.toml              |   4 +-
 .../svelte/languages/svelte/brackets.scm      |   7 +
 .../svelte/languages/svelte/config.toml       |  12 +-
 .../svelte/languages/svelte/highlights.scm    | 121 +++++++++++----
 .../svelte/languages/svelte/injections.scm    | 142 ++++++++++--------
 .../svelte/languages/svelte/outline.scm       |  69 +++++++++
 7 files changed, 268 insertions(+), 110 deletions(-)
 create mode 100644 extensions/svelte/languages/svelte/brackets.scm
 create mode 100644 extensions/svelte/languages/svelte/outline.scm

diff --git a/docs/src/languages/svelte.md b/docs/src/languages/svelte.md
index 1c6fd49b3e25ff..157a57d43e1b8f 100644
--- a/docs/src/languages/svelte.md
+++ b/docs/src/languages/svelte.md
@@ -2,16 +2,29 @@
 
 Svelte support is available through the [Svelte extension](https://github.com/zed-industries/zed/tree/main/extensions/svelte).
 
-- Tree Sitter: [Himujjal/tree-sitter-svelte](https://github.com/Himujjal/tree-sitter-svelte)
+- Tree Sitter: [tree-sitter-grammars/tree-sitter-svelte](https://github.com/tree-sitter-grammars/tree-sitter-svelte)
 - Language Server: [sveltejs/language-tools](https://github.com/sveltejs/language-tools)
 
-<!--
-TBD: Rewrite Svelte docs so it doesn't begin with a json block assuming you know what inlayHints are.
--->
+## Extra theme styling configuration
+
+You can modify how certain styles such as directives and modifiers appear in attributes:
+
+```json
+"syntax": {
+  // Styling for directives (e.g., `class:foo` or `on:click`) (the `on` or `class` part of the attribute).
+  "attribute.function": {
+    "color": "#ff0000"
+  },
+  // Styling for modifiers at the end of attributes, e.g. `on:<click|preventDefault|stopPropagation>`
+  "attribute.special": {
+    "color": "#00ff00"
+  }
+}
+```
 
 ## Inlay Hints
 
-Zed sets the following initialization options for inlay Hints:
+Zed sets the following initialization options for inlay hints:
 
 ```json
 "inlayHints": {
diff --git a/extensions/svelte/extension.toml b/extensions/svelte/extension.toml
index 9ca1d6c5daafdb..694fdec2a67c56 100644
--- a/extensions/svelte/extension.toml
+++ b/extensions/svelte/extension.toml
@@ -11,5 +11,5 @@ name = "Svelte Language Server"
 language = "Svelte"
 
 [grammars.svelte]
-repository = "https://github.com/Himujjal/tree-sitter-svelte"
-commit = "b08d070e303d2a385d6d0ab3add500f8fa514443"
+repository = "https://github.com/tree-sitter-grammars/tree-sitter-svelte"
+commit = "3f06f705410683adb17d146b5eca28c62fe81ba6"
diff --git a/extensions/svelte/languages/svelte/brackets.scm b/extensions/svelte/languages/svelte/brackets.scm
new file mode 100644
index 00000000000000..deb34f80a806ff
--- /dev/null
+++ b/extensions/svelte/languages/svelte/brackets.scm
@@ -0,0 +1,7 @@
+("<" @open ">" @close)
+("{" @open "}" @close)
+("'" @open "'" @close)
+("\"" @open "\"" @close)
+("(" @open ")" @close)
+; ("[" @open "]" @close)
+; ("`" @open "`" @close)
diff --git a/extensions/svelte/languages/svelte/config.toml b/extensions/svelte/languages/svelte/config.toml
index 3bab2f29430813..4db968be8c8f64 100644
--- a/extensions/svelte/languages/svelte/config.toml
+++ b/extensions/svelte/languages/svelte/config.toml
@@ -2,16 +2,16 @@ name = "Svelte"
 grammar = "svelte"
 path_suffixes = ["svelte"]
 block_comment = ["<!-- ", " -->"]
-autoclose_before = ";:.,=}])>"
+autoclose_before = ":\"'}]>"
 brackets = [
     { start = "{", end = "}", close = true, newline = true },
+    { start = "<", end = ">", close = true, newline = true, not_in = ["string"] },
     { start = "[", end = "]", close = true, newline = true },
     { start = "(", end = ")", close = true, newline = true },
-    { start = "<", end = ">", close = false, newline = true, not_in = ["string", "comment"] },
-    { start = "\"", end = "\"", close = true, newline = false, not_in = ["string"] },
-    { start = "'", end = "'", close = true, newline = false, not_in = ["string", "comment"] },
-    { start = "`", end = "`", close = true, newline = false, not_in = ["string"] },
-    { start = "/*", end = " */", close = true, newline = false, not_in = ["string", "comment"] },
+    { start = "!--", end = " --", close = true, newline = true },
+    { start = "\"", end = "\"", close = true, newline = true, not_in = ["string"] },
+    { start = "'", end = "'", close = true, newline = true, not_in = ["string"] },
+    { start = "`", end = "`", close = true, newline = true, not_in = ["string"] },
 ]
 scope_opt_in_language_servers = ["tailwindcss-language-server"]
 prettier_parser_name = "svelte"
diff --git a/extensions/svelte/languages/svelte/highlights.scm b/extensions/svelte/languages/svelte/highlights.scm
index 4e317489d832fa..01d8bb8db6531b 100755
--- a/extensions/svelte/languages/svelte/highlights.scm
+++ b/extensions/svelte/languages/svelte/highlights.scm
@@ -1,50 +1,107 @@
-; Special identifiers
-;--------------------
 
-; Treat capitalized tag names as constructors and types
-((tag_name) @type
- (#match? @type "^[A-Z]"))
+; comments
+(comment) @comment
 
-; Regular (lowercase) tag names
-((tag_name) @tag
- (#match? @tag "^[a-z]"))
+; property attribute
+(attribute_directive) @attribute.function
+(attribute_identifier) @attribute
+(attribute_modifier) @attribute.special
 
-; TODO:
-(attribute_name) @property
-(erroneous_end_tag_name) @keyword
-(comment) @comment
+; Style component attributes as @property
+(start_tag
+    (
+        (tag_name) @_tag_name
+        (#match? @_tag_name "^[A-Z]")
+    )
+    (attribute
+        (attribute_name
+            (attribute_identifier) @tag.property
+        )
+    )
+)
 
-[
-  (attribute_value)
-  (quoted_attribute_value)
-] @string
+(self_closing_tag
+    (
+        (tag_name) @_tag_name
+        (#match? @_tag_name "^[A-Z]")
+    )
+    (attribute
+        (attribute_name
+            (attribute_identifier) @tag.property
+        )
+    )
+)
 
-[
-  (text)
-  (raw_text_expr)
-  (raw_text_each)
-] @none
+
+; style elements starting with lowercase letters as tags
+(
+    (tag_name) @tag
+    (#match? @tag "^[a-z]")
+)
+
+; style elements starting with uppercase letters as components (types)
+; Also valid might be to treat them as constructors
+(
+    (tag_name) @tag @tag.component.type.constructor
+    (#match? @tag "^[A-Z]")
+)
 
 [
-  (special_block_keyword)
-  (then)
-  (as)
-] @keyword
+  "<"
+  ">"
+  "</"
+  "/>"
+] @tag.punctuation.bracket
+
 
 [
   "{"
   "}"
 ] @punctuation.bracket
 
-"=" @operator
+[
+    "|"
+] @punctuation.delimiter
+
 
 [
-  "<"
-  ">"
-  "</"
-  "/>"
+  "@"
   "#"
   ":"
   "/"
-  "@"
-] @tag.delimiter
+] @tag.punctuation.special
+
+"=" @operator
+
+
+; Treating (if, each, ...) as a keyword inside of blocks
+; like {#if ...} or {#each ...}
+(block_start_tag
+    tag: _ @tag.keyword
+)
+
+(block_tag
+    tag: _ @tag.keyword
+)
+
+(block_end_tag
+    tag: _ @tag.keyword
+)
+
+(expression_tag
+    tag: _ @tag.keyword
+)
+
+; Style quoted string attribute values
+(quoted_attribute_value) @string
+
+
+; Highlight the `as` keyword in each blocks
+(each_start
+    ("as") @tag.keyword
+)
+
+
+; Highlight the snippet name as a function
+; (e.g. {#snippet foo(bar)}
+(snippet_name) @function
diff --git a/extensions/svelte/languages/svelte/injections.scm b/extensions/svelte/languages/svelte/injections.scm
index 24f9425803e2d4..73d2b9abb1bb6d 100755
--- a/extensions/svelte/languages/svelte/injections.scm
+++ b/extensions/svelte/languages/svelte/injections.scm
@@ -1,74 +1,86 @@
-; injections.scm
-; --------------
+; ; injections.scm
+; ; --------------
 
-; match script tags without a lang tag
-((script_element
-  (start_tag
-    (attribute
-      (attribute_name) @_name)*)
-    (raw_text) @content)
-  (#not-eq? @_name "lang")
-  (#set! "language" "javascript"))
+; Match script tags with a lang attribute
+(script_element
+    (start_tag
+        (attribute
+            (attribute_name) @_attr_name
+            (#eq? @_attr_name "lang")
+            (quoted_attribute_value
+                (attribute_value) @language
+            )
+        )
+    )
+    (raw_text) @content
+)
 
-; match javascript
-((script_element
-  (start_tag
-    (attribute
-      (attribute_name) @_name
-      (quoted_attribute_value (attribute_value) @_value)))
-    (raw_text) @content)
-  (#eq? @_name "lang")
-  (#eq? @_value "js")
-  (#set! "language" "javascript"))
+; Match script tags without a lang attribute
+(script_element
+    (start_tag
+        (attribute
+            (attribute_name) @_attr_name
+        )*
+    )
+    (raw_text) @content
+    (#not-any-of? @_attr_name "lang")
+    (#set! language "javascript")
+)
 
-; match typescript
-((script_element
-  (start_tag
-    (attribute
-      (attribute_name) @_name
-      (quoted_attribute_value (attribute_value) @_value)))
-    (raw_text) @content)
-  (#eq? @_name "lang")
-  (#eq? @_value "ts")
-  (#set! "language" "typescript"))
+; Match the contents of the script's generics="T extends string" as typescript code
+;
+; Disabled for the time-being because tree-sitter is treating the generics
+; attribute as a top-level typescript statement, where `T extends string` is
+; not a valid top-level typescript statement.
+;
+; (script_element
+;     (start_tag
+;         (attribute
+;             (attribute_name) @_attr_name
+;             (#eq? @_attr_name "generics")
+;             (quoted_attribute_value
+;                 (attribute_value) @content
+;             )
+;         )
+;     )
+; 	(#set! language "typescript")
+; )
 
-(style_element
-  (raw_text) @content
-  (#set! "language" "css"))
 
-; match style tags without a lang tag
-((style_element
-  (start_tag
-    (attribute
-      (attribute_name) @_name)*)
-    (raw_text) @content)
-  (#not-eq? @_name "lang")
-  (#set! "language" "css"))
+; Mark everything as typescript because it's
+; a more generic superset of javascript
+; Not sure if it's possible to somehow refer to the
+; script's language attribute here.
+((svelte_raw_text) @content
+    (#set! "language" "ts")
+)
 
-; match css
-((style_element
-  (start_tag
-    (attribute
-      (attribute_name) @_name
-      (quoted_attribute_value (attribute_value) @_value)))
-    (raw_text) @content)
-  (#eq? @_name "lang")
-  (#eq? @_value "css")
-  (#set! "language" "css"))
+; Match style tags with a lang attribute
+(style_element
+    (start_tag
+        (attribute
+            (attribute_name) @_attr_name
+            (#eq? @_attr_name "lang")
+            (quoted_attribute_value
+                (attribute_value) @language
+            )
+        )
+    )
+    (raw_text) @content
+)
 
-; match scss
-((style_element
-  (start_tag
-    (attribute
-      (attribute_name) @_name
-      (quoted_attribute_value (attribute_value) @_value)))
-    (raw_text) @content)
-  (#eq? @_name "lang")
-  (#eq? @_value "scss")
-  (#set! "language" "scss"))
+; Match style tags without a lang attribute
+(style_element
+    (start_tag
+        (attribute
+            (attribute_name) @_attr_name
+        )*
+    )
+    (raw_text) @content
+    (#not-any-of? @_attr_name "lang")
+    (#set! language "css")
+)
 
-((raw_text_expr) @content
-  (#set! "language" "javascript"))
 
-((raw_text_each) @content
-  (#set! "language" "javascript"))
+; Downstream TODO: Style highlighting for `style:background="red"` and `style="background: red"` strings
+; Downstream TODO: Style component comments as markdown
diff --git a/extensions/svelte/languages/svelte/outline.scm b/extensions/svelte/languages/svelte/outline.scm
new file mode 100644
index 00000000000000..8242ada2433de2
--- /dev/null
+++ b/extensions/svelte/languages/svelte/outline.scm
@@ -0,0 +1,69 @@
+
+(script_element
+    (start_tag) @name
+    (raw_text) @context @item
+)
+
+(script_element
+    (end_tag) @name @item
+)
+
+(style_element
+    (start_tag) @name
+    (raw_text) @context
+) @item
+
+
+(document) @item
+
+(comment) @annotation
+
+(if_statement
+    (if_start) @name
+) @item
+
+(else_block
+    (else_start) @name
+) @item
+
+(else_if_block
+    (else_if_start) @name
+) @item
+
+(element
+    (start_tag) @name
+) @item
+
+(element
+    (self_closing_tag) @name
+) @item
+
+
+; (if_end) @name @item
+
+(each_statement
+    (each_start) @name
+) @item
+
+
+(snippet_statement
+    (snippet_start) @name
+) @item
+
+(snippet_end) @name @item
+
+(html_tag) @name @item
+
+(const_tag) @name @item
+
+(await_statement
+    (await_start) @name
+) @item
+
+(then_block
+    (then_start) @name
+) @item
+
+(catch_block
+    (catch_start) @name
+) @item

From 76603a5fc6b27e7ac86b908429134036f1c49984 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 17 Sep 2024 12:13:06 -0400
Subject: [PATCH 141/762] ocaml: Bump to v0.1.0 (#17945)

This PR bumps the OCaml extension to v0.1.0.

Changes:

- https://github.com/zed-industries/zed/pull/16955
- https://github.com/zed-industries/zed/pull/17886

Release Notes:

- N/A
---
 Cargo.lock                      | 2 +-
 extensions/ocaml/Cargo.toml     | 2 +-
 extensions/ocaml/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6d0f7f54a01770..6d6d8e85e6731a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14481,7 +14481,7 @@ dependencies = [
 
 [[package]]
 name = "zed_ocaml"
-version = "0.0.2"
+version = "0.1.0"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/ocaml/Cargo.toml b/extensions/ocaml/Cargo.toml
index 6e07327036e82c..6df98bec4cfb83 100644
--- a/extensions/ocaml/Cargo.toml
+++ b/extensions/ocaml/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_ocaml"
-version = "0.0.2"
+version = "0.1.0"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/ocaml/extension.toml b/extensions/ocaml/extension.toml
index 0523ba83b6b8e8..bff7c380b5523d 100644
--- a/extensions/ocaml/extension.toml
+++ b/extensions/ocaml/extension.toml
@@ -1,7 +1,7 @@
 id = "ocaml"
 name = "OCaml"
 description = "OCaml support."
-version = "0.0.2"
+version = "0.1.0"
 schema_version = 1
 authors = ["Rashid Almheiri <69181766+huwaireb@users.noreply.github.com>"]
 repository = "https://github.com/zed-industries/zed"

From 3d69942f7141c689a8f607aa11f534303560862b Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Tue, 17 Sep 2024 12:34:36 -0400
Subject: [PATCH 142/762] Use dev icons for dev bundles (#17944)

Follow-up of https://github.com/zed-industries/zed/pull/17486/ actually
using the dev icons for dev bundles

Release Notes:

- N/A
---
 crates/zed/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index ad02d4f38879ef..28d2c7f82576d8 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -134,7 +134,7 @@ tree-sitter-rust.workspace = true
 workspace = { workspace = true, features = ["test-support"] }
 
 [package.metadata.bundle-dev]
-icon = ["resources/app-icon-preview@2x.png", "resources/app-icon-preview.png"]
+icon = ["resources/app-icon-dev@2x.png", "resources/app-icon-dev.png"]
 identifier = "dev.zed.Zed-Dev"
 name = "Zed Dev"
 osx_minimum_system_version = "10.15.7"

From 0070635b4de672af2510df73d8bbd2f1c8f92cce Mon Sep 17 00:00:00 2001
From: Albert Marashi <albert@lumina.earth>
Date: Wed, 18 Sep 2024 02:21:31 +0930
Subject: [PATCH 143/762] Styling option for separating terminal view
 background from background color (#17611)

Closes #17313

Release Notes:

- Added theme styling option to separate terminal background view from
terminal background color, for transparent terminal backgrounds
---
 crates/repl/src/outputs/plain.rs             | 2 +-
 crates/terminal_view/src/terminal_element.rs | 6 +++---
 crates/theme/src/default_colors.rs           | 2 ++
 crates/theme/src/one_themes.rs               | 1 +
 crates/theme/src/schema.rs                   | 8 ++++++++
 crates/theme/src/styles/colors.rs            | 5 ++++-
 6 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/crates/repl/src/outputs/plain.rs b/crates/repl/src/outputs/plain.rs
index 5b9960d7b8917d..4bf007b292fec8 100644
--- a/crates/repl/src/outputs/plain.rs
+++ b/crates/repl/src/outputs/plain.rs
@@ -75,7 +75,7 @@ pub fn text_style(cx: &mut WindowContext) -> TextStyle {
         font_size: theme::get_buffer_font_size(cx).into(),
         font_style: FontStyle::Normal,
         line_height: cx.line_height().into(),
-        background_color: Some(theme.colors().terminal_background),
+        background_color: Some(theme.colors().terminal_ansi_background),
         white_space: WhiteSpace::Normal,
         truncate: None,
         // These are going to be overridden per-cell
diff --git a/crates/terminal_view/src/terminal_element.rs b/crates/terminal_view/src/terminal_element.rs
index b3d2b40e742a1e..ce4be0e6797078 100644
--- a/crates/terminal_view/src/terminal_element.rs
+++ b/crates/terminal_view/src/terminal_element.rs
@@ -662,7 +662,7 @@ impl Element for TerminalElement {
                     font_size: font_size.into(),
                     font_style: FontStyle::Normal,
                     line_height: line_height.into(),
-                    background_color: Some(theme.colors().terminal_background),
+                    background_color: Some(theme.colors().terminal_ansi_background),
                     white_space: WhiteSpace::Normal,
                     truncate: None,
                     // These are going to be overridden per-cell
@@ -778,7 +778,7 @@ impl Element for TerminalElement {
                                 &[TextRun {
                                     len,
                                     font: text_style.font(),
-                                    color: theme.colors().terminal_background,
+                                    color: theme.colors().terminal_ansi_background,
                                     background_color: None,
                                     underline: Default::default(),
                                     strikethrough: None,
@@ -1158,7 +1158,7 @@ pub fn convert_color(fg: &terminal::alacritty_terminal::vte::ansi::Color, theme:
             NamedColor::BrightCyan => colors.terminal_ansi_bright_cyan,
             NamedColor::BrightWhite => colors.terminal_ansi_bright_white,
             NamedColor::Foreground => colors.terminal_foreground,
-            NamedColor::Background => colors.terminal_background,
+            NamedColor::Background => colors.terminal_ansi_background,
             NamedColor::Cursor => theme.players().local().cursor,
             NamedColor::DimBlack => colors.terminal_ansi_dim_black,
             NamedColor::DimRed => colors.terminal_ansi_dim_red,
diff --git a/crates/theme/src/default_colors.rs b/crates/theme/src/default_colors.rs
index 48e67a4cc0433e..4def0bb8d74d62 100644
--- a/crates/theme/src/default_colors.rs
+++ b/crates/theme/src/default_colors.rs
@@ -84,6 +84,7 @@ impl ThemeColors {
             terminal_foreground: black().light().step_12(),
             terminal_bright_foreground: black().light().step_11(),
             terminal_dim_foreground: black().light().step_10(),
+            terminal_ansi_background: neutral().light().step_1(),
             terminal_ansi_bright_black: black().light().step_11(),
             terminal_ansi_bright_red: red().light().step_10(),
             terminal_ansi_bright_green: green().light().step_10(),
@@ -179,6 +180,7 @@ impl ThemeColors {
             editor_document_highlight_read_background: neutral().dark_alpha().step_4(),
             editor_document_highlight_write_background: neutral().dark_alpha().step_4(),
             terminal_background: neutral().dark().step_1(),
+            terminal_ansi_background: neutral().dark().step_1(),
             terminal_foreground: white().dark().step_12(),
             terminal_bright_foreground: white().dark().step_11(),
             terminal_dim_foreground: white().dark().step_10(),
diff --git a/crates/theme/src/one_themes.rs b/crates/theme/src/one_themes.rs
index 241344b8f318b6..69e69ce23dc8d1 100644
--- a/crates/theme/src/one_themes.rs
+++ b/crates/theme/src/one_themes.rs
@@ -105,6 +105,7 @@ pub(crate) fn one_dark() -> Theme {
 
                 terminal_background: bg,
                 // todo("Use one colors for terminal")
+                terminal_ansi_background: crate::black().dark().step_12(),
                 terminal_foreground: crate::white().dark().step_12(),
                 terminal_bright_foreground: crate::white().dark().step_11(),
                 terminal_dim_foreground: crate::white().dark().step_10(),
diff --git a/crates/theme/src/schema.rs b/crates/theme/src/schema.rs
index a47dc23a7c2b69..cc62e2976ba364 100644
--- a/crates/theme/src/schema.rs
+++ b/crates/theme/src/schema.rs
@@ -421,6 +421,10 @@ pub struct ThemeColorsContent {
     #[serde(rename = "terminal.foreground")]
     pub terminal_foreground: Option<String>,
 
+    /// Terminal ansi background color.
+    #[serde(rename = "terminal.ansi.background")]
+    pub terminal_ansi_background: Option<String>,
+
     /// Bright terminal foreground color.
     #[serde(rename = "terminal.bright_foreground")]
     pub terminal_bright_foreground: Option<String>,
@@ -792,6 +796,10 @@ impl ThemeColorsContent {
                 .terminal_background
                 .as_ref()
                 .and_then(|color| try_parse_color(color).ok()),
+            terminal_ansi_background: self
+                .terminal_ansi_background
+                .as_ref()
+                .and_then(|color| try_parse_color(color).ok()),
             terminal_foreground: self
                 .terminal_foreground
                 .as_ref()
diff --git a/crates/theme/src/styles/colors.rs b/crates/theme/src/styles/colors.rs
index 349a79ba662794..04aba89a0d5e73 100644
--- a/crates/theme/src/styles/colors.rs
+++ b/crates/theme/src/styles/colors.rs
@@ -175,7 +175,7 @@ pub struct ThemeColors {
     // ===
     // Terminal
     // ===
-    /// Terminal background color.
+    /// Terminal layout background color.
     pub terminal_background: Hsla,
     /// Terminal foreground color.
     pub terminal_foreground: Hsla,
@@ -184,6 +184,9 @@ pub struct ThemeColors {
     /// Dim terminal foreground color.
     pub terminal_dim_foreground: Hsla,
 
+    /// Terminal ansi background color.
+    pub terminal_ansi_background: Hsla,
+
     /// Black ANSI terminal color.
     pub terminal_ansi_black: Hsla,
     /// Bright black ANSI terminal color.

From ac5c35b3df32a0a68e74ed6dbf288bcc7055e050 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 17 Sep 2024 13:26:34 -0400
Subject: [PATCH 144/762] theme: Fix casing of "ANSI" in doc comments (#17952)

This PR fixes the casing of "ANSI" in some doc comments after #17611.

Release Notes:

- N/A
---
 crates/theme/src/schema.rs        | 2 +-
 crates/theme/src/styles/colors.rs | 4 +---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/crates/theme/src/schema.rs b/crates/theme/src/schema.rs
index cc62e2976ba364..0229b1ea98d590 100644
--- a/crates/theme/src/schema.rs
+++ b/crates/theme/src/schema.rs
@@ -421,7 +421,7 @@ pub struct ThemeColorsContent {
     #[serde(rename = "terminal.foreground")]
     pub terminal_foreground: Option<String>,
 
-    /// Terminal ansi background color.
+    /// Terminal ANSI background color.
     #[serde(rename = "terminal.ansi.background")]
     pub terminal_ansi_background: Option<String>,
 
diff --git a/crates/theme/src/styles/colors.rs b/crates/theme/src/styles/colors.rs
index 04aba89a0d5e73..0b37be09923c79 100644
--- a/crates/theme/src/styles/colors.rs
+++ b/crates/theme/src/styles/colors.rs
@@ -183,10 +183,8 @@ pub struct ThemeColors {
     pub terminal_bright_foreground: Hsla,
     /// Dim terminal foreground color.
     pub terminal_dim_foreground: Hsla,
-
-    /// Terminal ansi background color.
+    /// Terminal ANSI background color.
     pub terminal_ansi_background: Hsla,
-
     /// Black ANSI terminal color.
     pub terminal_ansi_black: Hsla,
     /// Bright black ANSI terminal color.

From ee8668ef45378bda7ca7b1f543310c8fcf226725 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 17 Sep 2024 13:33:09 -0400
Subject: [PATCH 145/762] Bind `editor::Rewrap` to `alt-q` (#17953)

This PR adds a keybinding for the `editor: rewrap` command.

It is bound to `alt-q`, by default. In Vim mode, it is bound to `g q`.

Release Notes:

- N/A
---
 assets/keymaps/default-linux.json | 1 +
 assets/keymaps/default-macos.json | 1 +
 assets/keymaps/vim.json           | 1 +
 3 files changed, 3 insertions(+)

diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index bb5673dde6c178..02fc6d8e04da8a 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -56,6 +56,7 @@
       "shift-tab": "editor::TabPrev",
       "ctrl-k": "editor::CutToEndOfLine",
       // "ctrl-t": "editor::Transpose",
+      "alt-q": "editor::Rewrap",
       "ctrl-backspace": "editor::DeleteToPreviousWordStart",
       "ctrl-delete": "editor::DeleteToNextWordEnd",
       "shift-delete": "editor::Cut",
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index 9a0c08c3dcaddc..33536cc9ff9e4b 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -51,6 +51,7 @@
       "shift-tab": "editor::TabPrev",
       "ctrl-k": "editor::CutToEndOfLine",
       "ctrl-t": "editor::Transpose",
+      "alt-q": "editor::Rewrap",
       "cmd-backspace": "editor::DeleteToBeginningOfLine",
       "cmd-delete": "editor::DeleteToEndOfLine",
       "alt-backspace": "editor::DeleteToPreviousWordStart",
diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index 54905b22678cd1..18b38384ef81ce 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -124,6 +124,7 @@
       "g i": "vim::InsertAtPrevious",
       "g ,": "vim::ChangeListNewer",
       "g ;": "vim::ChangeListOlder",
+      "g q": "editor::Rewrap",
       "shift-h": "vim::WindowTop",
       "shift-m": "vim::WindowMiddle",
       "shift-l": "vim::WindowBottom",

From ccfd4b1887e7dc30e839334d86713b671449c55b Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 17 Sep 2024 19:45:29 +0200
Subject: [PATCH 146/762] rust: Test rust-analyzer binary after finding in PATH
 (#17951)

Release Notes:

- N/A

---------

Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>
---
 crates/language/src/language.rs |  1 +
 crates/languages/src/rust.rs    | 23 ++++++++++++++++++++++-
 crates/project/src/lsp_store.rs | 24 ++++++++++++++++++++++++
 3 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index 8cd8c8079d7f0a..7901a49d0021f8 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -285,6 +285,7 @@ pub trait LspAdapterDelegate: Send + Sync {
     async fn which(&self, command: &OsStr) -> Option<PathBuf>;
     async fn shell_env(&self) -> HashMap<String, String>;
     async fn read_text_file(&self, path: PathBuf) -> Result<String>;
+    async fn try_exec(&self, binary: LanguageServerBinary) -> Result<()>;
 }
 
 #[async_trait(?Send)]
diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs
index 456ea8e4492eda..5055bb69c1e6f5 100644
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -61,7 +61,28 @@ impl LspAdapter for RustLspAdapter {
             }) => {
                 let path = delegate.which(Self::SERVER_NAME.as_ref()).await;
                 let env = delegate.shell_env().await;
-                (path, Some(env), None)
+
+                if let Some(path) = path {
+                    // It is surprisingly common for ~/.cargo/bin/rust-analyzer to be a symlink to
+                    // /usr/bin/rust-analyzer that fails when you run it; so we need to test it.
+                    log::info!("found rust-analyzer in PATH. trying to run `rust-analyzer --help`");
+                    match delegate
+                        .try_exec(LanguageServerBinary {
+                            path: path.clone(),
+                            arguments: vec!["--help".into()],
+                            env: Some(env.clone()),
+                        })
+                        .await
+                    {
+                        Ok(()) => (Some(path), Some(env), None),
+                        Err(err) => {
+                            log::error!("failed to run rust-analyzer after detecting it in PATH: binary: {:?}: {:?}", path, err);
+                            (None, None, None)
+                        }
+                    }
+                } else {
+                    (None, None, None)
+                }
             }
             // Otherwise, we use the configured binary.
             Some(BinarySettings {
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index e1e6001d24b96b..2c718a42abbb84 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -7133,6 +7133,30 @@ impl LspAdapterDelegate for ProjectLspAdapterDelegate {
         which::which(command).ok()
     }
 
+    async fn try_exec(&self, command: LanguageServerBinary) -> Result<()> {
+        if self.fs.is_none() {
+            return Ok(());
+        }
+
+        let working_dir = self.worktree_root_path();
+        let output = smol::process::Command::new(&command.path)
+            .args(command.arguments)
+            .envs(command.env.clone().unwrap_or_default())
+            .current_dir(working_dir)
+            .output()
+            .await?;
+
+        if output.status.success() {
+            return Ok(());
+        }
+        Err(anyhow!(
+            "{}, stdout: {:?}, stderr: {:?}",
+            output.status,
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        ))
+    }
+
     fn update_status(
         &self,
         server_name: LanguageServerName,

From 5cdca6d8dd8c2179a85293376e8db324c34b6945 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 17 Sep 2024 13:49:52 -0400
Subject: [PATCH 147/762] multi_buffer: Fix a panic when expanding an excerpt
 with the cursor at the end (#17955)

This PR fixes a panic when expanding an excerpt within a multibuffer
that could occur when the cursor was at the end of the buffer.

You can reproduce this by opening a multibuffer, putting your cursor at
the very end of that buffer, and then expanding the excerpt (Shift +
Enter).

Release Notes:

- Fixed a panic that could occur when expanding an excerpt within a
multibuffer when the cursor was at the end of the excerpt.

Co-authored-by: Antonio <antonio@zed.dev>
---
 crates/multi_buffer/src/multi_buffer.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index f7172ccf08d297..5b6eddd5b16bf1 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -3790,7 +3790,7 @@ impl MultiBufferSnapshot {
         }
     }
 
-    // Returns the locators referenced by the given excerpt ids, sorted by locator.
+    /// Returns the locators referenced by the given excerpt IDs, sorted by locator.
     fn excerpt_locators_for_ids(
         &self,
         ids: impl IntoIterator<Item = ExcerptId>,
@@ -3801,13 +3801,17 @@ impl MultiBufferSnapshot {
 
         while sorted_ids.last() == Some(&ExcerptId::max()) {
             sorted_ids.pop();
-            locators.push(Locator::max());
+            if let Some(mapping) = self.excerpt_ids.last() {
+                locators.push(mapping.locator.clone());
+            }
         }
 
         let mut sorted_ids = sorted_ids.into_iter().dedup().peekable();
         if sorted_ids.peek() == Some(&ExcerptId::min()) {
             sorted_ids.next();
-            locators.push(Locator::min());
+            if let Some(mapping) = self.excerpt_ids.first() {
+                locators.push(mapping.locator.clone());
+            }
         }
 
         let mut cursor = self.excerpt_ids.cursor::<ExcerptId>();

From 345efa4e36dd40a3eaf50ab5d024a06ed4b1f7b9 Mon Sep 17 00:00:00 2001
From: Jason Lee <huacnlee@gmail.com>
Date: Wed, 18 Sep 2024 01:50:36 +0800
Subject: [PATCH 148/762] gpui: Fix img element to render correct SVG color
 (#15488)

Release Notes:

- N/A


It should convert RGBA to BGRA.

> I added an example color svg, that was I make based on [Lucide grip
icon](https://lucide.dev/icons/grip).

## Before

<img width="692" alt="image"
src="https://github.com/user-attachments/assets/5eb03606-76ce-4049-b3ad-8d1084a4fa55">


## After

<img width="695" alt="image"
src="https://github.com/user-attachments/assets/650dd411-2095-4e92-b3fd-8e91c6954aa3">

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 crates/gpui/examples/image/color.svg | 13 +++++++++++++
 crates/gpui/examples/image/image.rs  |  2 +-
 crates/gpui/src/elements/img.rs      |  7 ++++++-
 3 files changed, 20 insertions(+), 2 deletions(-)
 create mode 100644 crates/gpui/examples/image/color.svg

diff --git a/crates/gpui/examples/image/color.svg b/crates/gpui/examples/image/color.svg
new file mode 100644
index 00000000000000..84e9809d09492a
--- /dev/null
+++ b/crates/gpui/examples/image/color.svg
@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="480" height="480" viewBox="0 0 480 480" fill="none"
+    stroke="currentColor" stroke-width="40" stroke-linecap="round" stroke-linejoin="round"
+    class="lucide lucide-grip">
+    <circle cx="240" cy="240" r="50" stroke="#44403c" />
+    <circle cx="100" cy="100" r="20" stroke="#65a30d" />
+    <circle cx="240" cy="100" r="30" stroke="#dc2626" />
+    <circle cx="380" cy="100" r="20" stroke="#d97706" />
+    <circle cx="380" cy="240" r="30" stroke="#06b6d4" />
+    <circle cx="100" cy="240" r="30" stroke="#3b82f6" />
+    <circle cx="240" cy="380" r="30" stroke="#7c3aed" />
+    <circle cx="380" cy="380" r="20" stroke="#c026d3" />
+    <circle cx="100" cy="380" r="20" stroke="#e11d48" />
+</svg>
\ No newline at end of file
diff --git a/crates/gpui/examples/image/image.rs b/crates/gpui/examples/image/image.rs
index cc8e1a686c8a06..ac7af186d30ba0 100644
--- a/crates/gpui/examples/image/image.rs
+++ b/crates/gpui/examples/image/image.rs
@@ -131,7 +131,7 @@ fn main() {
                         PathBuf::from_str("crates/gpui/examples/image/app-icon.png").unwrap(),
                     ),
                     remote_resource: "https://picsum.photos/512/512".into(),
-                    asset_resource: "image/app-icon.png".into(),
+                    asset_resource: "image/color.svg".into(),
                 })
             })
             .unwrap();
diff --git a/crates/gpui/src/elements/img.rs b/crates/gpui/src/elements/img.rs
index 07f5acc95b1bc9..f1e8bb68e3237e 100644
--- a/crates/gpui/src/elements/img.rs
+++ b/crates/gpui/src/elements/img.rs
@@ -408,9 +408,14 @@ impl Asset for ImageAsset {
                     // TODO: Can we make svgs always rescale?
                     svg_renderer.render_pixmap(&bytes, SvgSize::ScaleFactor(1.0))?;
 
-                let buffer =
+                let mut buffer =
                     ImageBuffer::from_raw(pixmap.width(), pixmap.height(), pixmap.take()).unwrap();
 
+                // Convert from RGBA to BGRA.
+                for pixel in buffer.chunks_exact_mut(4) {
+                    pixel.swap(0, 2);
+                }
+
                 RenderImage::new(SmallVec::from_elem(Frame::new(buffer), 1))
             };
 

From 7246a0f39ce1f529d4e041c3316491e96152f1fe Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 17 Sep 2024 13:51:11 -0400
Subject: [PATCH 149/762] macos: Use ~/Library/Caches/Zed instead of
 ~/.cache/zed (#17949)

---
 crates/paths/src/paths.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/paths/src/paths.rs b/crates/paths/src/paths.rs
index b80bef5f2d623e..7f662d0325d1bf 100644
--- a/crates/paths/src/paths.rs
+++ b/crates/paths/src/paths.rs
@@ -59,6 +59,12 @@ pub fn support_dir() -> &'static PathBuf {
 pub fn temp_dir() -> &'static PathBuf {
     static TEMP_DIR: OnceLock<PathBuf> = OnceLock::new();
     TEMP_DIR.get_or_init(|| {
+        if cfg!(target_os = "macos") {
+            return dirs::cache_dir()
+                .expect("failed to determine cachesDirectory directory")
+                .join("Zed");
+        }
+
         if cfg!(target_os = "windows") {
             return dirs::cache_dir()
                 .expect("failed to determine LocalAppData directory")

From e6c4076ef0e59d4cbbdbbecb22ac57c23e6e69c2 Mon Sep 17 00:00:00 2001
From: Richard Feldman <oss@rtfeldman.com>
Date: Tue, 17 Sep 2024 14:07:50 -0400
Subject: [PATCH 150/762] Add cmake to dev build instructions (#17943)

Release Notes:

- N/A
---
 docs/src/development/macos.md   | 6 ++++++
 docs/src/development/windows.md | 1 +
 script/linux                    | 6 ++++++
 3 files changed, 13 insertions(+)

diff --git a/docs/src/development/macos.md b/docs/src/development/macos.md
index 160ae3dd0e4821..1407b0f610dc68 100644
--- a/docs/src/development/macos.md
+++ b/docs/src/development/macos.md
@@ -29,6 +29,12 @@ Clone down the [Zed repository](https://github.com/zed-industries/zed).
   rustup target add wasm32-wasip1
   ```
 
+- Install `cmake` (required by [a dependency](https://docs.rs/wasmtime-c-api-impl/latest/wasmtime_c_api/))
+
+  ```sh
+  brew install cmake
+  ```
+
 ## Backend Dependencies
 
 If you are developing collaborative features of Zed, you'll need to install the dependencies of zed's `collab` server:
diff --git a/docs/src/development/windows.md b/docs/src/development/windows.md
index 600c030931f27f..86eb21965e550e 100644
--- a/docs/src/development/windows.md
+++ b/docs/src/development/windows.md
@@ -22,6 +22,7 @@ Clone down the [Zed repository](https://github.com/zed-industries/zed).
 
 - Install [Visual Studio](https://visualstudio.microsoft.com/downloads/) with the optional component `MSVC v*** - VS YYYY C++ x64/x86 build tools` (`v***` is your VS version and `YYYY` is year when your VS was released)
 - Install Windows 11 or 10 SDK depending on your system, but ensure that at least `Windows 10 SDK version 2104 (10.0.20348.0)` is installed on your machine. You can download it from the [Windows SDK Archive](https://developer.microsoft.com/windows/downloads/windows-sdk/)
+- Install [CMake](https://cmake.org/download)
 
 ## Backend dependencies
 
diff --git a/script/linux b/script/linux
index 051748ad4556e9..d894d33ea80cd7 100755
--- a/script/linux
+++ b/script/linux
@@ -25,6 +25,7 @@ if [[ -n $apt ]]; then
     libvulkan1
     libgit2-dev
     make
+    cmake
     clang
     mold
     jq
@@ -44,6 +45,7 @@ if [[ -n $dnf ]]; then
     gcc
     g++
     clang
+    cmake
     mold
     alsa-lib-devel
     fontconfig-devel
@@ -78,6 +80,7 @@ if [[ -n $zyp ]]; then
     gcc-c++
     clang
     make
+    cmake
     alsa-devel
     fontconfig-devel
     wayland-devel
@@ -99,6 +102,7 @@ if [[ -n $pacman ]]; then
   deps=(
     gcc
     clang
+    cmake
     alsa-lib
     fontconfig
     wayland
@@ -122,6 +126,7 @@ if [[ -n $xbps ]]; then
   deps=(
     gettext-devel
     clang
+    cmake
     jq
     elfutils-devel
     gcc
@@ -148,6 +153,7 @@ if [[ -n $emerge ]]; then
     app-arch/zstd
     dev-libs/openssl
     dev-libs/wayland
+    dev-util/cmake
     media-libs/alsa-lib
     media-libs/fontconfig
     media-libs/vulkan-loader

From fc43b21e787adb365c09abc68bc3c602b842e74f Mon Sep 17 00:00:00 2001
From: ClanEver <562211524@qq.com>
Date: Wed, 18 Sep 2024 02:10:37 +0800
Subject: [PATCH 151/762] ruff: Fix wrong Ruff path on Windows (#17883)

Log:

2024-09-16T22:32:04.7715712+08:00 [ERROR] failed to start language
server "ruff": failed to spawn command. path:
"...\\AppData\\Local\\Zed\\extensions\\work\\ruff\\ruff-0.6.5\\ruff-x86_64-pc-windows-msvc\\ruff"

The right path:
`...\\AppData\\Local\\Zed\\extensions\\work\\ruff\\ruff-0.6.5\\ruff.exe`

Release Notes:

- N/A
---
 extensions/ruff/src/ruff.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/extensions/ruff/src/ruff.rs b/extensions/ruff/src/ruff.rs
index c7c51ec7b9dd68..048c5893ca773d 100644
--- a/extensions/ruff/src/ruff.rs
+++ b/extensions/ruff/src/ruff.rs
@@ -89,7 +89,10 @@ impl RuffExtension {
             .ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
 
         let version_dir = format!("ruff-{}", release.version);
-        let binary_path = format!("{version_dir}/{asset_stem}/ruff");
+        let binary_path = match platform {
+            zed::Os::Windows => format!("{version_dir}/ruff.exe"),
+            _ => format!("{version_dir}/{asset_stem}/ruff"),
+        };
 
         if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
             zed::set_language_server_installation_status(

From ab7a7d3480c9bc553c320911867236a8554ae0ef Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 17 Sep 2024 14:12:11 -0400
Subject: [PATCH 152/762] docs: Mention how to open the Prompt Library (#17957)

---
 docs/src/assistant/prompting.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docs/src/assistant/prompting.md b/docs/src/assistant/prompting.md
index f6f68880ba28ff..0dca671b47b79a 100644
--- a/docs/src/assistant/prompting.md
+++ b/docs/src/assistant/prompting.md
@@ -52,6 +52,8 @@ More on prompt engineering:
 
 Zed allows you to customize the default prompt used in new context editors. Or to be more precise, it uses a series of prompts that are combined to form the default prompt.
 
+To edit prompts, select "Prompt Library" from the menu icon (three horizontal lines) in the upper right hand corner or using the `cmd-k l` keyboard shortcut.
+
 A default prompt might look something like:
 
 ```plaintext

From 869a72bb3f8b3786c92ec89fecc2c0f7cf96baf0 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 17 Sep 2024 14:21:06 -0400
Subject: [PATCH 153/762] ruff: Bump to v0.1.0 (#17960)

This PR bumps the Ruff extension to v0.1.0.

Changes:

- https://github.com/zed-industries/zed/pull/15852
- https://github.com/zed-industries/zed/pull/16955
- https://github.com/zed-industries/zed/pull/17883

Release Notes:

- N/A
---
 Cargo.lock                     | 2 +-
 extensions/ruff/Cargo.toml     | 2 +-
 extensions/ruff/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6d6d8e85e6731a..6eeec558ec9381 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14516,7 +14516,7 @@ dependencies = [
 
 [[package]]
 name = "zed_ruff"
-version = "0.0.2"
+version = "0.1.0"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/ruff/Cargo.toml b/extensions/ruff/Cargo.toml
index 50e0ae3908e0e6..b6c31ebbc86100 100644
--- a/extensions/ruff/Cargo.toml
+++ b/extensions/ruff/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_ruff"
-version = "0.0.2"
+version = "0.1.0"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/ruff/extension.toml b/extensions/ruff/extension.toml
index d622b37c685e05..63929fc1911971 100644
--- a/extensions/ruff/extension.toml
+++ b/extensions/ruff/extension.toml
@@ -1,7 +1,7 @@
 id = "ruff"
 name = "Ruff"
 description = "Support for Ruff, the Python linter and formatter"
-version = "0.0.2"
+version = "0.1.0"
 schema_version = 1
 authors = []
 repository = "https://github.com/zed-industries/zed"

From 447a5d6e6e95c0bbc9fb008cb27de925a1fcf778 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Tue, 17 Sep 2024 11:35:45 -0700
Subject: [PATCH 154/762] Fix the rendering of warning text in our docs
 (#17958)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

cc: @danilo-leal

Before:

<img width="753" alt="Screenshot 2024-09-17 at 10 53 13 AM"
src="https://github.com/user-attachments/assets/43a2ef89-4a90-46d4-9e90-350fdd1b46bb">

After:

<img width="759" alt="Screenshot 2024-09-17 at 10 53 35 AM"
src="https://github.com/user-attachments/assets/49f2a250-d339-4f61-afda-3ed87181b018">

Light mode:

<img width="757" alt="Screenshot 2024-09-17 at 10 54 17 AM"
src="https://github.com/user-attachments/assets/4d425e9b-3f97-44c4-ba86-d84dc7349060">

Release Notes:

- N/A
---
 docs/theme/css/general.css | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/theme/css/general.css b/docs/theme/css/general.css
index e6905b47bf485b..6f086a1052447b 100644
--- a/docs/theme/css/general.css
+++ b/docs/theme/css/general.css
@@ -268,7 +268,7 @@ blockquote .warning:before {
 .warning {
   margin: auto;
   padding: 1rem 1.25rem;
-  color: #000;
+  color: var(--fg);
   background-color: var(--warning-bg);
   border: 1px solid var(--warning-border);
 }

From c28b22d1cfa3326a0336c69236baf63670473398 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 17 Sep 2024 15:08:14 -0400
Subject: [PATCH 155/762] Update typos-cli to v1.24.6. Add
 scripts/check-spelling. Fix typos (#17961)

---
 .github/workflows/ci.yml              | 11 +----------
 crates/collab/src/db/ids.rs           |  2 +-
 crates/editor/src/inlay_hint_cache.rs |  2 +-
 crates/language/src/buffer.rs         |  2 +-
 crates/language/src/buffer_tests.rs   |  2 +-
 crates/picker/src/picker.rs           |  2 +-
 crates/terminal/src/terminal.rs       |  2 +-
 crates/ui/src/components/icon.rs      |  2 +-
 crates/zed/src/reliability.rs         |  2 +-
 script/check-spelling                 | 11 +++++++++++
 10 files changed, 20 insertions(+), 18 deletions(-)
 create mode 100755 script/check-spelling

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 12b7dbd806e144..3ee4c045805dc6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -39,16 +39,7 @@ jobs:
         run: git clean -df
 
       - name: Check spelling
-        run: |
-          if ! cargo install --list | grep "typos-cli v$TYPOS_CLI_VERSION" > /dev/null; then
-            echo "Installing typos-cli@$TYPOS_CLI_VERSION..."
-            cargo install "typos-cli@$TYPOS_CLI_VERSION"
-          else
-            echo "typos-cli@$TYPOS_CLI_VERSION is already installed."
-          fi
-          typos
-        env:
-          TYPOS_CLI_VERSION: "1.23.3"
+        run: script/check-spelling
 
       - name: Run style checks
         uses: ./.github/actions/check_style
diff --git a/crates/collab/src/db/ids.rs b/crates/collab/src/db/ids.rs
index 82ff8a56e5dc2d..1434bc07cf6c37 100644
--- a/crates/collab/src/db/ids.rs
+++ b/crates/collab/src/db/ids.rs
@@ -104,7 +104,7 @@ pub enum ChannelRole {
     /// Admin can read/write and change permissions.
     #[sea_orm(string_value = "admin")]
     Admin,
-    /// Member can read/write, but not change pemissions.
+    /// Member can read/write, but not change permissions.
     #[sea_orm(string_value = "member")]
     #[default]
     Member,
diff --git a/crates/editor/src/inlay_hint_cache.rs b/crates/editor/src/inlay_hint_cache.rs
index ce7ec5a4b098c9..62c5cde9d89f57 100644
--- a/crates/editor/src/inlay_hint_cache.rs
+++ b/crates/editor/src/inlay_hint_cache.rs
@@ -337,7 +337,7 @@ impl InlayHintCache {
     /// If needed, queries LSP for new inlay hints, using the invalidation strategy given.
     /// To reduce inlay hint jumping, attempts to query a visible range of the editor(s) first,
     /// followed by the delayed queries of the same range above and below the visible one.
-    /// This way, concequent refresh invocations are less likely to trigger LSP queries for the invisible ranges.
+    /// This way, subsequent refresh invocations are less likely to trigger LSP queries for the invisible ranges.
     pub(super) fn spawn_hint_refresh(
         &mut self,
         reason_description: &'static str,
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 59b2670dafd84e..76058ffd9bac9a 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -3025,7 +3025,7 @@ impl BufferSnapshot {
                 let mut start = text.len();
                 let end = start + buffer_range.len();
 
-                // When multiple names are captured, then the matcheable text
+                // When multiple names are captured, then the matchable text
                 // includes the whitespace in between the names.
                 if !name_ranges.is_empty() {
                     start -= 1;
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index 5162269f4f6be8..50dea8d2562b00 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -382,7 +382,7 @@ async fn test_normalize_whitespace(cx: &mut gpui::TestAppContext) {
     let buffer = cx.new_model(|cx| Buffer::local(text, cx));
 
     // Spawn a task to format the buffer's whitespace.
-    // Pause so that the foratting task starts running.
+    // Pause so that the formatting task starts running.
     let format = buffer.update(cx, |buffer, cx| buffer.remove_trailing_whitespace(cx));
     smol::future::yield_now().await;
 
diff --git a/crates/picker/src/picker.rs b/crates/picker/src/picker.rs
index dc661d91fbabab..8350be2b20e07d 100644
--- a/crates/picker/src/picker.rs
+++ b/crates/picker/src/picker.rs
@@ -509,7 +509,7 @@ impl<D: PickerDelegate> Picker<D> {
             .on_mouse_up(
                 MouseButton::Right,
                 cx.listener(move |this, event: &MouseUpEvent, cx| {
-                    // We specficially want to use the platform key here, as
+                    // We specifically want to use the platform key here, as
                     // ctrl will already be held down for the tab switcher.
                     this.handle_click(ix, event.modifiers.platform, cx)
                 }),
diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs
index 12a7349af07a93..8f8982f02c4701 100644
--- a/crates/terminal/src/terminal.rs
+++ b/crates/terminal/src/terminal.rs
@@ -1619,7 +1619,7 @@ fn task_summary(task: &TaskState, error_code: Option<i32>) -> (bool, String, Str
 ///   the cursor's `point` is not updated to the new line and column values
 ///
 /// * ??? there could be more consequences, and any further "proper" streaming from the PTY might bug and/or panic.
-///   Still, concequent `append_text_to_term` invocations are possible and display the contents correctly.
+///   Still, subsequent `append_text_to_term` invocations are possible and display the contents correctly.
 ///
 /// Despite the quirks, this is the simplest approach to appending text to the terminal: its alternative, `grid_mut` manipulations,
 /// do not properly set the scrolling state and display odd text after appending; also those manipulations are more tedious and error-prone.
diff --git a/crates/ui/src/components/icon.rs b/crates/ui/src/components/icon.rs
index a71c3e98720917..323181e84156f4 100644
--- a/crates/ui/src/components/icon.rs
+++ b/crates/ui/src/components/icon.rs
@@ -46,7 +46,7 @@ impl RenderOnce for AnyIcon {
 /// The decoration for an icon.
 ///
 /// For example, this can show an indicator, an "x",
-/// or a diagonal strkethrough to indicate something is disabled.
+/// or a diagonal strikethrough to indicate something is disabled.
 #[derive(Debug, PartialEq, Copy, Clone, EnumIter)]
 pub enum IconDecoration {
     Strikethrough,
diff --git a/crates/zed/src/reliability.rs b/crates/zed/src/reliability.rs
index 9731401b3024e0..188cf417f7c38b 100644
--- a/crates/zed/src/reliability.rs
+++ b/crates/zed/src/reliability.rs
@@ -176,7 +176,7 @@ pub fn monitor_main_thread_hangs(
     let background_executor = cx.background_executor();
     let telemetry_settings = *client::TelemetrySettings::get_global(cx);
 
-    // Initialize SIGUSR2 handler to send a backrace to a channel.
+    // Initialize SIGUSR2 handler to send a backtrace to a channel.
     let (backtrace_tx, backtrace_rx) = mpsc::channel();
     static BACKTRACE: Mutex<Vec<backtrace::Frame>> = Mutex::new(Vec::new());
     static BACKTRACE_SENDER: OnceLock<mpsc::Sender<()>> = OnceLock::new();
diff --git a/script/check-spelling b/script/check-spelling
new file mode 100755
index 00000000000000..65c674057f47f7
--- /dev/null
+++ b/script/check-spelling
@@ -0,0 +1,11 @@
+#!/bin/sh
+
+TYPOS_CLI_VERSION=1.24.6
+
+if ! cargo install --list | grep "typos-cli v$TYPOS_CLI_VERSION" > /dev/null; then
+    echo "Installing typos-cli@$TYPOS_CLI_VERSION..."
+    cargo install "typos-cli@$TYPOS_CLI_VERSION"
+else
+    echo "typos-cli@$TYPOS_CLI_VERSION is already installed."
+fi
+typos

From 06a13c298395f543e6e2e1dfd33c7a7ebe37f59e Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 17 Sep 2024 15:33:28 -0400
Subject: [PATCH 156/762] svelte: Bump to v0.2.0 (#17962)

This PR bumps the Svelte extension to v0.2.0.

Changes:

- https://github.com/zed-industries/zed/pull/17529

Release Notes:

- N/A
---
 Cargo.lock                       | 2 +-
 extensions/svelte/Cargo.toml     | 2 +-
 extensions/svelte/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6eeec558ec9381..3b3a370c36154e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14531,7 +14531,7 @@ dependencies = [
 
 [[package]]
 name = "zed_svelte"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/svelte/Cargo.toml b/extensions/svelte/Cargo.toml
index d07d517af66a77..09ad78aec2db8b 100644
--- a/extensions/svelte/Cargo.toml
+++ b/extensions/svelte/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_svelte"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/svelte/extension.toml b/extensions/svelte/extension.toml
index 694fdec2a67c56..a4ecf460a85ad4 100644
--- a/extensions/svelte/extension.toml
+++ b/extensions/svelte/extension.toml
@@ -1,7 +1,7 @@
 id = "svelte"
 name = "Svelte"
 description = "Svelte support"
-version = "0.1.1"
+version = "0.2.0"
 schema_version = 1
 authors = []
 repository = "https://github.com/zed-extensions/svelte"

From d3d3a093b4a757f1e82cd870a7f9e3cbee9ae933 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Tue, 17 Sep 2024 12:44:33 -0700
Subject: [PATCH 157/762] Add an `eval` binary that evaluates our semantic
 index against CodeSearchNet (#17375)

This PR is the beginning of an evaluation framework for our AI features.
Right now, we're evaluating our semantic search feature against the
[CodeSearchNet](https://github.com/github/CodeSearchNet) code search
dataset. This dataset is very limited (for the most part, only 1 known
good search result per repo) but it has surfaced some problems with our
search already.

Release Notes:

- N/A

---------

Co-authored-by: Jason <jason@zed.dev>
Co-authored-by: Jason Mancuso <7891333+jvmncs@users.noreply.github.com>
Co-authored-by: Nathan <nathan@zed.dev>
Co-authored-by: Richard <richard@zed.dev>
---
 .github/workflows/ci.yml                      |  17 +-
 Cargo.lock                                    |  27 +
 Cargo.toml                                    |   1 +
 crates/assistant/src/assistant_panel.rs       |   2 +-
 .../src/slash_command/file_command.rs         |   9 +-
 .../src/slash_command/search_command.rs       |  54 +-
 crates/evals/Cargo.toml                       |  37 +
 crates/evals/LICENSE-GPL                      |   1 +
 crates/evals/build.rs                         |  14 +
 crates/evals/src/eval.rs                      | 631 ++++++++++++++++++
 crates/http_client/src/http_client.rs         |   3 +-
 crates/semantic_index/src/embedding_index.rs  |  89 ++-
 crates/semantic_index/src/project_index.rs    |  17 +-
 crates/semantic_index/src/semantic_index.rs   | 125 ++--
 14 files changed, 882 insertions(+), 145 deletions(-)
 create mode 100644 crates/evals/Cargo.toml
 create mode 120000 crates/evals/LICENSE-GPL
 create mode 100644 crates/evals/build.rs
 create mode 100644 crates/evals/src/eval.rs

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3ee4c045805dc6..c55a3a9907f47f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -101,7 +101,7 @@ jobs:
     timeout-minutes: 60
     name: (Linux) Run Clippy and tests
     runs-on:
-      - hosted-linux-x86-1
+      - buildjet-16vcpu-ubuntu-2204
     steps:
       - name: Add Rust to the PATH
         run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
@@ -111,6 +111,11 @@ jobs:
         with:
           clean: false
 
+      - name: Cache dependencies
+        uses: swatinem/rust-cache@23bce251a8cd2ffc3c1075eaa2367cf899916d84 # v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+
       - name: Install Linux dependencies
         run: ./script/linux
 
@@ -264,7 +269,7 @@ jobs:
     timeout-minutes: 60
     name: Create a Linux bundle
     runs-on:
-      - hosted-linux-x86-1
+      - buildjet-16vcpu-ubuntu-2204
     if: ${{ startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
     needs: [linux_tests]
     env:
@@ -279,9 +284,6 @@ jobs:
       - name: Install Linux dependencies
         run: ./script/linux
 
-      - name: Limit target directory size
-        run: script/clear-target-dir-if-larger-than 100
-
       - name: Determine version and release channel
         if: ${{ startsWith(github.ref, 'refs/tags/v') }}
         run: |
@@ -335,7 +337,7 @@ jobs:
     timeout-minutes: 60
     name: Create arm64 Linux bundle
     runs-on:
-      - hosted-linux-arm-1
+      - buildjet-16vcpu-ubuntu-2204-arm
     if: ${{ startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
     needs: [linux_tests]
     env:
@@ -350,9 +352,6 @@ jobs:
       - name: Install Linux dependencies
         run: ./script/linux
 
-      - name: Limit target directory size
-        run: script/clear-target-dir-if-larger-than 100
-
       - name: Determine version and release channel
         if: ${{ startsWith(github.ref, 'refs/tags/v') }}
         run: |
diff --git a/Cargo.lock b/Cargo.lock
index 3b3a370c36154e..9cff8953932ade 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4000,6 +4000,33 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "evals"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "client",
+ "clock",
+ "collections",
+ "env_logger",
+ "feature_flags",
+ "fs",
+ "git",
+ "gpui",
+ "http_client",
+ "language",
+ "languages",
+ "node_runtime",
+ "open_ai",
+ "project",
+ "semantic_index",
+ "serde",
+ "serde_json",
+ "settings",
+ "smol",
+]
+
 [[package]]
 name = "event-listener"
 version = "2.5.3"
diff --git a/Cargo.toml b/Cargo.toml
index e1af231c7e4fee..eea510edf2e0e9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,6 +27,7 @@ members = [
     "crates/diagnostics",
     "crates/docs_preprocessor",
     "crates/editor",
+    "crates/evals",
     "crates/extension",
     "crates/extension_api",
     "crates/extension_cli",
diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 52838b5c77b190..6eaa86f4a7aff9 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -3282,7 +3282,7 @@ impl ContextEditor {
 
                     let fence = codeblock_fence_for_path(
                         filename.as_deref(),
-                        Some(selection.start.row..selection.end.row),
+                        Some(selection.start.row..=selection.end.row),
                     );
 
                     if let Some((line_comment_prefix, outline_text)) =
diff --git a/crates/assistant/src/slash_command/file_command.rs b/crates/assistant/src/slash_command/file_command.rs
index 0df8b5d4e0b83c..260c6b0e2a0840 100644
--- a/crates/assistant/src/slash_command/file_command.rs
+++ b/crates/assistant/src/slash_command/file_command.rs
@@ -8,7 +8,7 @@ use project::{PathMatchCandidateSet, Project};
 use serde::{Deserialize, Serialize};
 use std::{
     fmt::Write,
-    ops::Range,
+    ops::{Range, RangeInclusive},
     path::{Path, PathBuf},
     sync::{atomic::AtomicBool, Arc},
 };
@@ -342,7 +342,10 @@ fn collect_files(
     })
 }
 
-pub fn codeblock_fence_for_path(path: Option<&Path>, row_range: Option<Range<u32>>) -> String {
+pub fn codeblock_fence_for_path(
+    path: Option<&Path>,
+    row_range: Option<RangeInclusive<u32>>,
+) -> String {
     let mut text = String::new();
     write!(text, "```").unwrap();
 
@@ -357,7 +360,7 @@ pub fn codeblock_fence_for_path(path: Option<&Path>, row_range: Option<Range<u32
     }
 
     if let Some(row_range) = row_range {
-        write!(text, ":{}-{}", row_range.start + 1, row_range.end + 1).unwrap();
+        write!(text, ":{}-{}", row_range.start() + 1, row_range.end() + 1).unwrap();
     }
 
     text.push('\n');
diff --git a/crates/assistant/src/slash_command/search_command.rs b/crates/assistant/src/slash_command/search_command.rs
index 72d86ec5c54000..7e408cad396a45 100644
--- a/crates/assistant/src/slash_command/search_command.rs
+++ b/crates/assistant/src/slash_command/search_command.rs
@@ -8,14 +8,12 @@ use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use feature_flags::FeatureFlag;
 use gpui::{AppContext, Task, WeakView};
 use language::{CodeLabel, LineEnding, LspAdapterDelegate};
-use semantic_index::SemanticDb;
+use semantic_index::{LoadedSearchResult, SemanticDb};
 use std::{
     fmt::Write,
-    path::PathBuf,
     sync::{atomic::AtomicBool, Arc},
 };
 use ui::{prelude::*, IconName};
-use util::ResultExt;
 use workspace::Workspace;
 
 pub(crate) struct SearchSlashCommandFeatureFlag;
@@ -107,52 +105,28 @@ impl SlashCommand for SearchSlashCommand {
                 })?
                 .await?;
 
-            let mut loaded_results = Vec::new();
-            for result in results {
-                let (full_path, file_content) =
-                    result.worktree.read_with(&cx, |worktree, _cx| {
-                        let entry_abs_path = worktree.abs_path().join(&result.path);
-                        let mut entry_full_path = PathBuf::from(worktree.root_name());
-                        entry_full_path.push(&result.path);
-                        let file_content = async {
-                            let entry_abs_path = entry_abs_path;
-                            fs.load(&entry_abs_path).await
-                        };
-                        (entry_full_path, file_content)
-                    })?;
-                if let Some(file_content) = file_content.await.log_err() {
-                    loaded_results.push((result, full_path, file_content));
-                }
-            }
+            let loaded_results = SemanticDb::load_results(results, &fs, &cx).await?;
 
             let output = cx
                 .background_executor()
                 .spawn(async move {
                     let mut text = format!("Search results for {query}:\n");
                     let mut sections = Vec::new();
-                    for (result, full_path, file_content) in loaded_results {
-                        let range_start = result.range.start.min(file_content.len());
-                        let range_end = result.range.end.min(file_content.len());
-
-                        let start_row = file_content[0..range_start].matches('\n').count() as u32;
-                        let end_row = file_content[0..range_end].matches('\n').count() as u32;
-                        let start_line_byte_offset = file_content[0..range_start]
-                            .rfind('\n')
-                            .map(|pos| pos + 1)
-                            .unwrap_or_default();
-                        let end_line_byte_offset = file_content[range_end..]
-                            .find('\n')
-                            .map(|pos| range_end + pos)
-                            .unwrap_or_else(|| file_content.len());
-
+                    for LoadedSearchResult {
+                        path,
+                        range,
+                        full_path,
+                        file_content,
+                        row_range,
+                    } in loaded_results
+                    {
                         let section_start_ix = text.len();
                         text.push_str(&codeblock_fence_for_path(
-                            Some(&result.path),
-                            Some(start_row..end_row),
+                            Some(&path),
+                            Some(row_range.clone()),
                         ));
 
-                        let mut excerpt =
-                            file_content[start_line_byte_offset..end_line_byte_offset].to_string();
+                        let mut excerpt = file_content[range].to_string();
                         LineEnding::normalize(&mut excerpt);
                         text.push_str(&excerpt);
                         writeln!(text, "\n```\n").unwrap();
@@ -161,7 +135,7 @@ impl SlashCommand for SearchSlashCommand {
                             section_start_ix..section_end_ix,
                             Some(&full_path),
                             false,
-                            Some(start_row + 1..end_row + 1),
+                            Some(row_range.start() + 1..row_range.end() + 1),
                         ));
                     }
 
diff --git a/crates/evals/Cargo.toml b/crates/evals/Cargo.toml
new file mode 100644
index 00000000000000..e680e4f5046236
--- /dev/null
+++ b/crates/evals/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "evals"
+description = "Evaluations for Zed's AI features"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[[bin]]
+name = "eval"
+path = "src/eval.rs"
+
+[dependencies]
+clap.workspace = true
+anyhow.workspace = true
+client.workspace = true
+clock.workspace = true
+collections.workspace = true
+env_logger.workspace = true
+feature_flags.workspace = true
+fs.workspace = true
+git.workspace = true
+gpui.workspace = true
+language.workspace = true
+languages.workspace = true
+http_client.workspace = true
+open_ai.workspace = true
+project.workspace = true
+settings.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+smol.workspace = true
+semantic_index.workspace = true
+node_runtime.workspace = true
diff --git a/crates/evals/LICENSE-GPL b/crates/evals/LICENSE-GPL
new file mode 120000
index 00000000000000..89e542f750cd38
--- /dev/null
+++ b/crates/evals/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
\ No newline at end of file
diff --git a/crates/evals/build.rs b/crates/evals/build.rs
new file mode 100644
index 00000000000000..8175d90494c845
--- /dev/null
+++ b/crates/evals/build.rs
@@ -0,0 +1,14 @@
+fn main() {
+    if cfg!(target_os = "macos") {
+        println!("cargo:rustc-env=MACOSX_DEPLOYMENT_TARGET=10.15.7");
+
+        println!("cargo:rerun-if-env-changed=ZED_BUNDLE");
+        if std::env::var("ZED_BUNDLE").ok().as_deref() == Some("true") {
+            // Find WebRTC.framework in the Frameworks folder when running as part of an application bundle.
+            println!("cargo:rustc-link-arg=-Wl,-rpath,@executable_path/../Frameworks");
+        } else {
+            // Find WebRTC.framework as a sibling of the executable when running outside of an application bundle.
+            println!("cargo:rustc-link-arg=-Wl,-rpath,@executable_path");
+        }
+    }
+}
diff --git a/crates/evals/src/eval.rs b/crates/evals/src/eval.rs
new file mode 100644
index 00000000000000..d7e63fafbf8202
--- /dev/null
+++ b/crates/evals/src/eval.rs
@@ -0,0 +1,631 @@
+use ::fs::{Fs, RealFs};
+use anyhow::Result;
+use clap::Parser;
+use client::{Client, UserStore};
+use clock::RealSystemClock;
+use collections::BTreeMap;
+use feature_flags::FeatureFlagAppExt as _;
+use git::GitHostingProviderRegistry;
+use gpui::{AsyncAppContext, BackgroundExecutor, Context, Model};
+use http_client::{HttpClient, Method};
+use language::LanguageRegistry;
+use node_runtime::FakeNodeRuntime;
+use open_ai::OpenAiEmbeddingModel;
+use project::Project;
+use semantic_index::{OpenAiEmbeddingProvider, ProjectIndex, SemanticDb, Status};
+use serde::{Deserialize, Serialize};
+use settings::SettingsStore;
+use smol::channel::bounded;
+use smol::io::AsyncReadExt;
+use smol::Timer;
+use std::ops::RangeInclusive;
+use std::time::Duration;
+use std::{
+    fs,
+    path::Path,
+    process::{exit, Command, Stdio},
+    sync::{
+        atomic::{AtomicUsize, Ordering::SeqCst},
+        Arc,
+    },
+};
+
+const CODESEARCH_NET_DIR: &'static str = "target/datasets/code-search-net";
+const EVAL_REPOS_DIR: &'static str = "target/datasets/eval-repos";
+const EVAL_DB_PATH: &'static str = "target/eval_db";
+const SEARCH_RESULT_LIMIT: usize = 8;
+const SKIP_EVAL_PATH: &'static str = ".skip_eval";
+
+#[derive(clap::Parser)]
+#[command(author, version, about, long_about = None)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(clap::Subcommand)]
+enum Commands {
+    Fetch {},
+    Run {
+        #[arg(long)]
+        repo: Option<String>,
+    },
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+struct EvaluationProject {
+    repo: String,
+    sha: String,
+    queries: Vec<EvaluationQuery>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+struct EvaluationQuery {
+    query: String,
+    expected_results: Vec<EvaluationSearchResult>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
+struct EvaluationSearchResult {
+    file: String,
+    lines: RangeInclusive<u32>,
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+struct EvaluationProjectOutcome {
+    repo: String,
+    sha: String,
+    queries: Vec<EvaluationQueryOutcome>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+struct EvaluationQueryOutcome {
+    repo: String,
+    query: String,
+    expected_results: Vec<EvaluationSearchResult>,
+    actual_results: Vec<EvaluationSearchResult>,
+    covered_file_count: usize,
+    overlapped_result_count: usize,
+    covered_result_count: usize,
+    total_result_count: usize,
+    covered_result_indices: Vec<usize>,
+}
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+    env_logger::init();
+
+    gpui::App::headless().run(move |cx| {
+        let executor = cx.background_executor().clone();
+
+        match cli.command {
+            Commands::Fetch {} => {
+                executor
+                    .clone()
+                    .spawn(async move {
+                        if let Err(err) = fetch_evaluation_resources(&executor).await {
+                            eprintln!("Error: {}", err);
+                            exit(1);
+                        }
+                        exit(0);
+                    })
+                    .detach();
+            }
+            Commands::Run { repo } => {
+                cx.spawn(|mut cx| async move {
+                    if let Err(err) = run_evaluation(repo, &executor, &mut cx).await {
+                        eprintln!("Error: {}", err);
+                        exit(1);
+                    }
+                    exit(0);
+                })
+                .detach();
+            }
+        }
+    });
+
+    Ok(())
+}
+
+async fn fetch_evaluation_resources(executor: &BackgroundExecutor) -> Result<()> {
+    let http_client = http_client::HttpClientWithProxy::new(None, None);
+    fetch_code_search_net_resources(&http_client).await?;
+    fetch_eval_repos(executor, &http_client).await?;
+    Ok(())
+}
+
+async fn fetch_code_search_net_resources(http_client: &dyn HttpClient) -> Result<()> {
+    eprintln!("Fetching CodeSearchNet evaluations...");
+
+    let annotations_url = "https://raw.githubusercontent.com/github/CodeSearchNet/master/resources/annotationStore.csv";
+
+    let dataset_dir = Path::new(CODESEARCH_NET_DIR);
+    fs::create_dir_all(&dataset_dir).expect("failed to create CodeSearchNet directory");
+
+    // Fetch the annotations CSV, which contains the human-annotated search relevances
+    let annotations_path = dataset_dir.join("annotations.csv");
+    let annotations_csv_content = if annotations_path.exists() {
+        fs::read_to_string(&annotations_path).expect("failed to read annotations")
+    } else {
+        let response = http_client
+            .get(annotations_url, Default::default(), true)
+            .await
+            .expect("failed to fetch annotations csv");
+        let mut body = String::new();
+        response
+            .into_body()
+            .read_to_string(&mut body)
+            .await
+            .expect("failed to read annotations.csv response");
+        fs::write(annotations_path, &body).expect("failed to write annotations.csv");
+        body
+    };
+
+    // Parse the annotations CSV. Skip over queries with zero relevance.
+    let rows = annotations_csv_content.lines().filter_map(|line| {
+        let mut values = line.split(',');
+        let _language = values.next()?;
+        let query = values.next()?;
+        let github_url = values.next()?;
+        let score = values.next()?;
+
+        if score == "0" {
+            return None;
+        }
+
+        let url_path = github_url.strip_prefix("https://github.com/")?;
+        let (url_path, hash) = url_path.split_once('#')?;
+        let (repo_name, url_path) = url_path.split_once("/blob/")?;
+        let (sha, file_path) = url_path.split_once('/')?;
+        let line_range = if let Some((start, end)) = hash.split_once('-') {
+            start.strip_prefix("L")?.parse::<u32>().ok()?..=end.strip_prefix("L")?.parse().ok()?
+        } else {
+            let row = hash.strip_prefix("L")?.parse().ok()?;
+            row..=row
+        };
+        Some((repo_name, sha, query, file_path, line_range))
+    });
+
+    // Group the annotations by repo and sha.
+    let mut evaluations_by_repo = BTreeMap::new();
+    for (repo_name, sha, query, file_path, lines) in rows {
+        let evaluation_project = evaluations_by_repo
+            .entry((repo_name, sha))
+            .or_insert_with(|| EvaluationProject {
+                repo: repo_name.to_string(),
+                sha: sha.to_string(),
+                queries: Vec::new(),
+            });
+
+        let ix = evaluation_project
+            .queries
+            .iter()
+            .position(|entry| entry.query == query)
+            .unwrap_or_else(|| {
+                evaluation_project.queries.push(EvaluationQuery {
+                    query: query.to_string(),
+                    expected_results: Vec::new(),
+                });
+                evaluation_project.queries.len() - 1
+            });
+        let results = &mut evaluation_project.queries[ix].expected_results;
+        let result = EvaluationSearchResult {
+            file: file_path.to_string(),
+            lines,
+        };
+        if !results.contains(&result) {
+            results.push(result);
+        }
+    }
+
+    let evaluations = evaluations_by_repo.into_values().collect::<Vec<_>>();
+    let evaluations_path = dataset_dir.join("evaluations.json");
+    fs::write(
+        &evaluations_path,
+        serde_json::to_vec_pretty(&evaluations).unwrap(),
+    )
+    .unwrap();
+
+    eprintln!(
+        "Fetched CodeSearchNet evaluations into {}",
+        evaluations_path.display()
+    );
+
+    Ok(())
+}
+
+async fn run_evaluation(
+    only_repo: Option<String>,
+    executor: &BackgroundExecutor,
+    cx: &mut AsyncAppContext,
+) -> Result<()> {
+    cx.update(|cx| {
+        let mut store = SettingsStore::new(cx);
+        store
+            .set_default_settings(settings::default_settings().as_ref(), cx)
+            .unwrap();
+        cx.set_global(store);
+        client::init_settings(cx);
+        language::init(cx);
+        Project::init_settings(cx);
+        cx.update_flags(false, vec![]);
+    })
+    .unwrap();
+
+    let dataset_dir = Path::new(CODESEARCH_NET_DIR);
+    let evaluations_path = dataset_dir.join("evaluations.json");
+    let repos_dir = Path::new(EVAL_REPOS_DIR);
+    let db_path = Path::new(EVAL_DB_PATH);
+    let http_client = http_client::HttpClientWithProxy::new(None, None);
+    let api_key = std::env::var("OPENAI_API_KEY").unwrap();
+    let git_hosting_provider_registry = Arc::new(GitHostingProviderRegistry::new());
+    let fs = Arc::new(RealFs::new(git_hosting_provider_registry, None)) as Arc<dyn Fs>;
+    let clock = Arc::new(RealSystemClock);
+    let client = cx
+        .update(|cx| {
+            Client::new(
+                clock,
+                Arc::new(http_client::HttpClientWithUrl::new(
+                    "https://zed.dev",
+                    None,
+                    None,
+                )),
+                cx,
+            )
+        })
+        .unwrap();
+    let user_store = cx
+        .new_model(|cx| UserStore::new(client.clone(), cx))
+        .unwrap();
+    let node_runtime = Arc::new(FakeNodeRuntime {});
+
+    let evaluations = fs::read(&evaluations_path).expect("failed to read evaluations.json");
+    let evaluations: Vec<EvaluationProject> = serde_json::from_slice(&evaluations).unwrap();
+
+    let embedding_provider = Arc::new(OpenAiEmbeddingProvider::new(
+        http_client.clone(),
+        OpenAiEmbeddingModel::TextEmbedding3Small,
+        open_ai::OPEN_AI_API_URL.to_string(),
+        api_key,
+    ));
+
+    let language_registry = Arc::new(LanguageRegistry::new(executor.clone()));
+    cx.update(|cx| languages::init(language_registry.clone(), node_runtime.clone(), cx))
+        .unwrap();
+
+    let mut covered_result_count = 0;
+    let mut overlapped_result_count = 0;
+    let mut covered_file_count = 0;
+    let mut total_result_count = 0;
+    eprint!("Running evals.");
+
+    for evaluation_project in evaluations {
+        if only_repo
+            .as_ref()
+            .map_or(false, |only_repo| only_repo != &evaluation_project.repo)
+        {
+            continue;
+        }
+
+        eprint!("\r\x1B[2K");
+        eprint!(
+            "Running evals. {}/{} covered. {}/{} overlapped. {}/{} files captured. Project: {}...",
+            covered_result_count,
+            total_result_count,
+            overlapped_result_count,
+            total_result_count,
+            covered_file_count,
+            total_result_count,
+            evaluation_project.repo
+        );
+
+        let repo_db_path =
+            db_path.join(format!("{}.db", evaluation_project.repo.replace('/', "_")));
+        let mut semantic_index = SemanticDb::new(repo_db_path, embedding_provider.clone(), cx)
+            .await
+            .unwrap();
+
+        let repo_dir = repos_dir.join(&evaluation_project.repo);
+        if !repo_dir.exists() || repo_dir.join(SKIP_EVAL_PATH).exists() {
+            eprintln!("Skipping {}: directory not found", evaluation_project.repo);
+            continue;
+        }
+
+        let project = cx
+            .update(|cx| {
+                Project::local(
+                    client.clone(),
+                    node_runtime.clone(),
+                    user_store.clone(),
+                    language_registry.clone(),
+                    fs.clone(),
+                    None,
+                    cx,
+                )
+            })
+            .unwrap();
+
+        let (worktree, _) = project
+            .update(cx, |project, cx| {
+                project.find_or_create_worktree(repo_dir, true, cx)
+            })?
+            .await?;
+
+        worktree
+            .update(cx, |worktree, _| {
+                worktree.as_local().unwrap().scan_complete()
+            })
+            .unwrap()
+            .await;
+
+        let project_index = cx
+            .update(|cx| semantic_index.create_project_index(project.clone(), cx))
+            .unwrap();
+        wait_for_indexing_complete(&project_index, cx, Some(Duration::from_secs(120))).await;
+
+        for query in evaluation_project.queries {
+            let results = cx
+                .update(|cx| {
+                    let project_index = project_index.read(cx);
+                    project_index.search(query.query.clone(), SEARCH_RESULT_LIMIT, cx)
+                })
+                .unwrap()
+                .await
+                .unwrap();
+
+            let results = SemanticDb::load_results(results, &fs.clone(), &cx)
+                .await
+                .unwrap();
+
+            let mut project_covered_result_count = 0;
+            let mut project_overlapped_result_count = 0;
+            let mut project_covered_file_count = 0;
+            let mut covered_result_indices = Vec::new();
+            for expected_result in &query.expected_results {
+                let mut file_matched = false;
+                let mut range_overlapped = false;
+                let mut range_covered = false;
+
+                for (ix, result) in results.iter().enumerate() {
+                    if result.path.as_ref() == Path::new(&expected_result.file) {
+                        file_matched = true;
+                        let start_matched =
+                            result.row_range.contains(&expected_result.lines.start());
+                        let end_matched = result.row_range.contains(&expected_result.lines.end());
+
+                        if start_matched || end_matched {
+                            range_overlapped = true;
+                        }
+
+                        if start_matched && end_matched {
+                            range_covered = true;
+                            covered_result_indices.push(ix);
+                            break;
+                        }
+                    }
+                }
+
+                if range_covered {
+                    project_covered_result_count += 1
+                };
+                if range_overlapped {
+                    project_overlapped_result_count += 1
+                };
+                if file_matched {
+                    project_covered_file_count += 1
+                };
+            }
+            let outcome_repo = evaluation_project.repo.clone();
+
+            let query_results = EvaluationQueryOutcome {
+                repo: outcome_repo,
+                query: query.query,
+                total_result_count: query.expected_results.len(),
+                covered_result_count: project_covered_result_count,
+                overlapped_result_count: project_overlapped_result_count,
+                covered_file_count: project_covered_file_count,
+                expected_results: query.expected_results,
+                actual_results: results
+                    .iter()
+                    .map(|result| EvaluationSearchResult {
+                        file: result.path.to_string_lossy().to_string(),
+                        lines: result.row_range.clone(),
+                    })
+                    .collect(),
+                covered_result_indices,
+            };
+
+            overlapped_result_count += query_results.overlapped_result_count;
+            covered_result_count += query_results.covered_result_count;
+            covered_file_count += query_results.covered_file_count;
+            total_result_count += query_results.total_result_count;
+
+            println!("{}", serde_json::to_string(&query_results).unwrap());
+        }
+    }
+
+    eprint!(
+        "Running evals. {}/{} covered. {}/{} overlapped. {}/{} files captured.",
+        covered_result_count,
+        total_result_count,
+        overlapped_result_count,
+        total_result_count,
+        covered_file_count,
+        total_result_count,
+    );
+
+    Ok(())
+}
+
+async fn wait_for_indexing_complete(
+    project_index: &Model<ProjectIndex>,
+    cx: &mut AsyncAppContext,
+    timeout: Option<Duration>,
+) {
+    let (tx, rx) = bounded(1);
+    let subscription = cx.update(|cx| {
+        cx.subscribe(project_index, move |_, event, _| {
+            if let Status::Idle = event {
+                let _ = tx.try_send(*event);
+            }
+        })
+    });
+
+    let result = match timeout {
+        Some(timeout_duration) => {
+            smol::future::or(
+                async {
+                    rx.recv().await.map_err(|_| ())?;
+                    Ok(())
+                },
+                async {
+                    Timer::after(timeout_duration).await;
+                    Err(())
+                },
+            )
+            .await
+        }
+        None => rx.recv().await.map(|_| ()).map_err(|_| ()),
+    };
+
+    match result {
+        Ok(_) => (),
+        Err(_) => {
+            if let Some(timeout) = timeout {
+                eprintln!("Timeout: Indexing did not complete within {:?}", timeout);
+            }
+        }
+    }
+
+    drop(subscription);
+}
+
+async fn fetch_eval_repos(
+    executor: &BackgroundExecutor,
+    http_client: &dyn HttpClient,
+) -> Result<()> {
+    let dataset_dir = Path::new(CODESEARCH_NET_DIR);
+    let evaluations_path = dataset_dir.join("evaluations.json");
+    let repos_dir = Path::new(EVAL_REPOS_DIR);
+
+    let evaluations = fs::read(&evaluations_path).expect("failed to read evaluations.json");
+    let evaluations: Vec<EvaluationProject> = serde_json::from_slice(&evaluations).unwrap();
+
+    eprint!("Fetching evaluation repositories...");
+
+    executor
+        .scoped(move |scope| {
+            let done_count = Arc::new(AtomicUsize::new(0));
+            let len = evaluations.len();
+            for chunk in evaluations.chunks(evaluations.len() / 8) {
+                let chunk = chunk.to_vec();
+                let done_count = done_count.clone();
+                scope.spawn(async move {
+                    for EvaluationProject { repo, sha, .. } in chunk {
+                        eprint!(
+                            "\rFetching evaluation repositories ({}/{})...",
+                            done_count.load(SeqCst),
+                            len,
+                        );
+
+                        fetch_eval_repo(repo, sha, repos_dir, http_client).await;
+                        done_count.fetch_add(1, SeqCst);
+                    }
+                });
+            }
+        })
+        .await;
+
+    Ok(())
+}
+
+async fn fetch_eval_repo(
+    repo: String,
+    sha: String,
+    repos_dir: &Path,
+    http_client: &dyn HttpClient,
+) {
+    let Some((owner, repo_name)) = repo.split_once('/') else {
+        return;
+    };
+    let repo_dir = repos_dir.join(owner).join(repo_name);
+    fs::create_dir_all(&repo_dir).unwrap();
+    let skip_eval_path = repo_dir.join(SKIP_EVAL_PATH);
+    if skip_eval_path.exists() {
+        return;
+    }
+    if let Ok(head_content) = fs::read_to_string(&repo_dir.join(".git").join("HEAD")) {
+        if head_content.trim() == sha {
+            return;
+        }
+    }
+    let repo_response = http_client
+        .send(
+            http_client::Request::builder()
+                .method(Method::HEAD)
+                .uri(format!("https://github.com/{}", repo))
+                .body(Default::default())
+                .expect(""),
+        )
+        .await
+        .expect("failed to check github repo");
+    if !repo_response.status().is_success() && !repo_response.status().is_redirection() {
+        fs::write(&skip_eval_path, "").unwrap();
+        eprintln!(
+            "Repo {repo} is no longer public ({:?}). Skipping",
+            repo_response.status()
+        );
+        return;
+    }
+    if !repo_dir.join(".git").exists() {
+        let init_output = Command::new("git")
+            .current_dir(&repo_dir)
+            .args(&["init"])
+            .output()
+            .unwrap();
+        if !init_output.status.success() {
+            eprintln!(
+                "Failed to initialize git repository for {}: {}",
+                repo,
+                String::from_utf8_lossy(&init_output.stderr)
+            );
+            return;
+        }
+    }
+    let url = format!("https://github.com/{}.git", repo);
+    Command::new("git")
+        .current_dir(&repo_dir)
+        .args(&["remote", "add", "-f", "origin", &url])
+        .stdin(Stdio::null())
+        .output()
+        .unwrap();
+    let fetch_output = Command::new("git")
+        .current_dir(&repo_dir)
+        .args(&["fetch", "--depth", "1", "origin", &sha])
+        .stdin(Stdio::null())
+        .output()
+        .unwrap();
+    if !fetch_output.status.success() {
+        eprintln!(
+            "Failed to fetch {} for {}: {}",
+            sha,
+            repo,
+            String::from_utf8_lossy(&fetch_output.stderr)
+        );
+        return;
+    }
+    let checkout_output = Command::new("git")
+        .current_dir(&repo_dir)
+        .args(&["checkout", &sha])
+        .output()
+        .unwrap();
+
+    if !checkout_output.status.success() {
+        eprintln!(
+            "Failed to checkout {} for {}: {}",
+            sha,
+            repo,
+            String::from_utf8_lossy(&checkout_output.stderr)
+        );
+    }
+}
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index 1841a1f394627d..7ea0029d79029f 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -5,6 +5,7 @@ use derive_more::Deref;
 use futures::future::BoxFuture;
 use futures_lite::FutureExt;
 use isahc::config::{Configurable, RedirectPolicy};
+pub use isahc::http;
 pub use isahc::{
     http::{Method, StatusCode, Uri},
     AsyncBody, Error, HttpClient as IsahcHttpClient, Request, Response,
@@ -226,7 +227,7 @@ pub fn client(user_agent: Option<String>, proxy: Option<Uri>) -> Arc<dyn HttpCli
         // those requests use a different http client, because global timeouts
         // of 50 and 60 seconds, respectively, would be very high!
         .connect_timeout(Duration::from_secs(5))
-        .low_speed_timeout(100, Duration::from_secs(5))
+        .low_speed_timeout(100, Duration::from_secs(30))
         .proxy(proxy.clone());
     if let Some(user_agent) = user_agent {
         builder = builder.default_header("User-Agent", user_agent);
diff --git a/crates/semantic_index/src/embedding_index.rs b/crates/semantic_index/src/embedding_index.rs
index dd7c58dc11a760..a418f603197276 100644
--- a/crates/semantic_index/src/embedding_index.rs
+++ b/crates/semantic_index/src/embedding_index.rs
@@ -234,30 +234,25 @@ impl EmbeddingIndex {
                         cx.spawn(async {
                             while let Ok((entry, handle)) = entries.recv().await {
                                 let entry_abs_path = worktree_abs_path.join(&entry.path);
-                                match fs.load(&entry_abs_path).await {
-                                    Ok(text) => {
-                                        let language = language_registry
-                                            .language_for_file_path(&entry.path)
-                                            .await
-                                            .ok();
-                                        let chunked_file = ChunkedFile {
-                                            chunks: chunking::chunk_text(
-                                                &text,
-                                                language.as_ref(),
-                                                &entry.path,
-                                            ),
-                                            handle,
-                                            path: entry.path,
-                                            mtime: entry.mtime,
-                                            text,
-                                        };
-
-                                        if chunked_files_tx.send(chunked_file).await.is_err() {
-                                            return;
-                                        }
-                                    }
-                                    Err(_)=> {
-                                        log::error!("Failed to read contents into a UTF-8 string: {entry_abs_path:?}");
+                                if let Some(text) = fs.load(&entry_abs_path).await.ok() {
+                                    let language = language_registry
+                                        .language_for_file_path(&entry.path)
+                                        .await
+                                        .ok();
+                                    let chunked_file = ChunkedFile {
+                                        chunks: chunking::chunk_text(
+                                            &text,
+                                            language.as_ref(),
+                                            &entry.path,
+                                        ),
+                                        handle,
+                                        path: entry.path,
+                                        mtime: entry.mtime,
+                                        text,
+                                    };
+
+                                    if chunked_files_tx.send(chunked_file).await.is_err() {
+                                        return;
                                     }
                                 }
                             }
@@ -358,33 +353,37 @@ impl EmbeddingIndex {
     fn persist_embeddings(
         &self,
         mut deleted_entry_ranges: channel::Receiver<(Bound<String>, Bound<String>)>,
-        embedded_files: channel::Receiver<(EmbeddedFile, IndexingEntryHandle)>,
+        mut embedded_files: channel::Receiver<(EmbeddedFile, IndexingEntryHandle)>,
         cx: &AppContext,
     ) -> Task<Result<()>> {
         let db_connection = self.db_connection.clone();
         let db = self.db;
-        cx.background_executor().spawn(async move {
-            while let Some(deletion_range) = deleted_entry_ranges.next().await {
-                let mut txn = db_connection.write_txn()?;
-                let start = deletion_range.0.as_ref().map(|start| start.as_str());
-                let end = deletion_range.1.as_ref().map(|end| end.as_str());
-                log::debug!("deleting embeddings in range {:?}", &(start, end));
-                db.delete_range(&mut txn, &(start, end))?;
-                txn.commit()?;
-            }
 
-            let mut embedded_files = embedded_files.chunks_timeout(4096, Duration::from_secs(2));
-            while let Some(embedded_files) = embedded_files.next().await {
-                let mut txn = db_connection.write_txn()?;
-                for (file, _) in &embedded_files {
-                    log::debug!("saving embedding for file {:?}", file.path);
-                    let key = db_key_for_path(&file.path);
-                    db.put(&mut txn, &key, file)?;
+        cx.background_executor().spawn(async move {
+            loop {
+                // Interleave deletions and persists of embedded files
+                futures::select_biased! {
+                    deletion_range = deleted_entry_ranges.next() => {
+                        if let Some(deletion_range) = deletion_range {
+                            let mut txn = db_connection.write_txn()?;
+                            let start = deletion_range.0.as_ref().map(|start| start.as_str());
+                            let end = deletion_range.1.as_ref().map(|end| end.as_str());
+                            log::debug!("deleting embeddings in range {:?}", &(start, end));
+                            db.delete_range(&mut txn, &(start, end))?;
+                            txn.commit()?;
+                        }
+                    },
+                    file = embedded_files.next() => {
+                        if let Some((file, _)) = file {
+                            let mut txn = db_connection.write_txn()?;
+                            log::debug!("saving embedding for file {:?}", file.path);
+                            let key = db_key_for_path(&file.path);
+                            db.put(&mut txn, &key, &file)?;
+                            txn.commit()?;
+                        }
+                    },
+                    complete => break,
                 }
-                txn.commit()?;
-
-                drop(embedded_files);
-                log::debug!("committed");
             }
 
             Ok(())
diff --git a/crates/semantic_index/src/project_index.rs b/crates/semantic_index/src/project_index.rs
index 84a72c1a3d8c61..5c35c93fa943a7 100644
--- a/crates/semantic_index/src/project_index.rs
+++ b/crates/semantic_index/src/project_index.rs
@@ -15,7 +15,14 @@ use log;
 use project::{Project, Worktree, WorktreeId};
 use serde::{Deserialize, Serialize};
 use smol::channel;
-use std::{cmp::Ordering, future::Future, num::NonZeroUsize, ops::Range, path::Path, sync::Arc};
+use std::{
+    cmp::Ordering,
+    future::Future,
+    num::NonZeroUsize,
+    ops::{Range, RangeInclusive},
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 use util::ResultExt;
 
 #[derive(Debug)]
@@ -26,6 +33,14 @@ pub struct SearchResult {
     pub score: f32,
 }
 
+pub struct LoadedSearchResult {
+    pub path: Arc<Path>,
+    pub range: Range<usize>,
+    pub full_path: PathBuf,
+    pub file_content: String,
+    pub row_range: RangeInclusive<u32>,
+}
+
 pub struct WorktreeSearchResult {
     pub worktree_id: WorktreeId,
     pub path: Arc<Path>,
diff --git a/crates/semantic_index/src/semantic_index.rs b/crates/semantic_index/src/semantic_index.rs
index f2b325ead690b3..3435d0a9ca4f79 100644
--- a/crates/semantic_index/src/semantic_index.rs
+++ b/crates/semantic_index/src/semantic_index.rs
@@ -10,14 +10,16 @@ mod worktree_index;
 
 use anyhow::{Context as _, Result};
 use collections::HashMap;
+use fs::Fs;
 use gpui::{AppContext, AsyncAppContext, BorrowAppContext, Context, Global, Model, WeakModel};
 use project::Project;
-use project_index::ProjectIndex;
 use std::{path::PathBuf, sync::Arc};
 use ui::ViewContext;
+use util::ResultExt as _;
 use workspace::Workspace;
 
 pub use embedding::*;
+pub use project_index::{LoadedSearchResult, ProjectIndex, SearchResult, Status};
 pub use project_index_debug_view::ProjectIndexDebugView;
 pub use summary_index::FileSummary;
 
@@ -56,27 +58,7 @@ impl SemanticDb {
 
                     if cx.has_global::<SemanticDb>() {
                         cx.update_global::<SemanticDb, _>(|this, cx| {
-                            let project_index = cx.new_model(|cx| {
-                                ProjectIndex::new(
-                                    project.clone(),
-                                    this.db_connection.clone(),
-                                    this.embedding_provider.clone(),
-                                    cx,
-                                )
-                            });
-
-                            let project_weak = project.downgrade();
-                            this.project_indices
-                                .insert(project_weak.clone(), project_index);
-
-                            cx.on_release(move |_, _, cx| {
-                                if cx.has_global::<SemanticDb>() {
-                                    cx.update_global::<SemanticDb, _>(|this, _| {
-                                        this.project_indices.remove(&project_weak);
-                                    })
-                                }
-                            })
-                            .detach();
+                            this.create_project_index(project, cx);
                         })
                     } else {
                         log::info!("No SemanticDb, skipping project index")
@@ -94,6 +76,50 @@ impl SemanticDb {
         })
     }
 
+    pub async fn load_results(
+        results: Vec<SearchResult>,
+        fs: &Arc<dyn Fs>,
+        cx: &AsyncAppContext,
+    ) -> Result<Vec<LoadedSearchResult>> {
+        let mut loaded_results = Vec::new();
+        for result in results {
+            let (full_path, file_content) = result.worktree.read_with(cx, |worktree, _cx| {
+                let entry_abs_path = worktree.abs_path().join(&result.path);
+                let mut entry_full_path = PathBuf::from(worktree.root_name());
+                entry_full_path.push(&result.path);
+                let file_content = async {
+                    let entry_abs_path = entry_abs_path;
+                    fs.load(&entry_abs_path).await
+                };
+                (entry_full_path, file_content)
+            })?;
+            if let Some(file_content) = file_content.await.log_err() {
+                let range_start = result.range.start.min(file_content.len());
+                let range_end = result.range.end.min(file_content.len());
+
+                let start_row = file_content[0..range_start].matches('\n').count() as u32;
+                let end_row = file_content[0..range_end].matches('\n').count() as u32;
+                let start_line_byte_offset = file_content[0..range_start]
+                    .rfind('\n')
+                    .map(|pos| pos + 1)
+                    .unwrap_or_default();
+                let end_line_byte_offset = file_content[range_end..]
+                    .find('\n')
+                    .map(|pos| range_end + pos)
+                    .unwrap_or_else(|| file_content.len());
+
+                loaded_results.push(LoadedSearchResult {
+                    path: result.path,
+                    range: start_line_byte_offset..end_line_byte_offset,
+                    full_path,
+                    file_content,
+                    row_range: start_row..=end_row,
+                });
+            }
+        }
+        Ok(loaded_results)
+    }
+
     pub fn project_index(
         &mut self,
         project: Model<Project>,
@@ -113,6 +139,36 @@ impl SemanticDb {
             })
         })
     }
+
+    pub fn create_project_index(
+        &mut self,
+        project: Model<Project>,
+        cx: &mut AppContext,
+    ) -> Model<ProjectIndex> {
+        let project_index = cx.new_model(|cx| {
+            ProjectIndex::new(
+                project.clone(),
+                self.db_connection.clone(),
+                self.embedding_provider.clone(),
+                cx,
+            )
+        });
+
+        let project_weak = project.downgrade();
+        self.project_indices
+            .insert(project_weak.clone(), project_index.clone());
+
+        cx.observe_release(&project, move |_, cx| {
+            if cx.has_global::<SemanticDb>() {
+                cx.update_global::<SemanticDb, _>(|this, _| {
+                    this.project_indices.remove(&project_weak);
+                })
+            }
+        })
+        .detach();
+
+        project_index
+    }
 }
 
 #[cfg(test)]
@@ -230,34 +286,13 @@ mod tests {
 
         let project = Project::test(fs, [project_path], cx).await;
 
-        cx.update(|cx| {
+        let project_index = cx.update(|cx| {
             let language_registry = project.read(cx).languages().clone();
             let node_runtime = project.read(cx).node_runtime().unwrap().clone();
             languages::init(language_registry, node_runtime, cx);
-
-            // Manually create and insert the ProjectIndex
-            let project_index = cx.new_model(|cx| {
-                ProjectIndex::new(
-                    project.clone(),
-                    semantic_index.db_connection.clone(),
-                    semantic_index.embedding_provider.clone(),
-                    cx,
-                )
-            });
-            semantic_index
-                .project_indices
-                .insert(project.downgrade(), project_index);
+            semantic_index.create_project_index(project.clone(), cx)
         });
 
-        let project_index = cx
-            .update(|_cx| {
-                semantic_index
-                    .project_indices
-                    .get(&project.downgrade())
-                    .cloned()
-            })
-            .unwrap();
-
         cx.run_until_parked();
         while cx
             .update(|cx| semantic_index.remaining_summaries(&project.downgrade(), cx))

From 8a6c65c63b6b2b8071ad2380ea392e4f51226c8f Mon Sep 17 00:00:00 2001
From: Stanislav Alekseev <43210583+WeetHet@users.noreply.github.com>
Date: Tue, 17 Sep 2024 22:49:12 +0300
Subject: [PATCH 158/762] Allow task context providers to access project env
 (#17964)

Closes #13106

Release Notes:

- Task context providers now have access to the local shell environment,
allowing local rust tool installations to work

Before:
<img width="1136" alt="Screenshot 2024-09-17 at 22 09 38"
src="https://github.com/user-attachments/assets/7d6c5606-4820-4f6f-92d1-c3d314b9ab42">

After:
<img width="1136" alt="Screenshot 2024-09-17 at 22 09 58"
src="https://github.com/user-attachments/assets/a962e607-15f5-44ce-b53e-a0dbe135f2d8">
---
 crates/language/src/task_context.rs  |  1 +
 crates/languages/src/go.rs           |  2 ++
 crates/languages/src/python.rs       |  2 ++
 crates/languages/src/rust.rs         | 31 +++++++++++++++++++++-------
 crates/project/src/project.rs        | 26 ++++++++++++-----------
 crates/project/src/task_inventory.rs |  3 ++-
 6 files changed, 45 insertions(+), 20 deletions(-)

diff --git a/crates/language/src/task_context.rs b/crates/language/src/task_context.rs
index cc3f29558e0fbb..73150eb8e70d5c 100644
--- a/crates/language/src/task_context.rs
+++ b/crates/language/src/task_context.rs
@@ -25,6 +25,7 @@ pub trait ContextProvider: Send + Sync {
         &self,
         _variables: &TaskVariables,
         _location: &Location,
+        _project_env: Option<&HashMap<String, String>>,
         _cx: &mut AppContext,
     ) -> Result<TaskVariables> {
         Ok(TaskVariables::default())
diff --git a/crates/languages/src/go.rs b/crates/languages/src/go.rs
index a83a11fd49ee34..2ddf7796817e81 100644
--- a/crates/languages/src/go.rs
+++ b/crates/languages/src/go.rs
@@ -1,5 +1,6 @@
 use anyhow::{anyhow, Context, Result};
 use async_trait::async_trait;
+use collections::HashMap;
 use futures::StreamExt;
 use gpui::{AppContext, AsyncAppContext, Task};
 use http_client::github::latest_github_release;
@@ -454,6 +455,7 @@ impl ContextProvider for GoContextProvider {
         &self,
         variables: &TaskVariables,
         location: &Location,
+        _: Option<&HashMap<String, String>>,
         cx: &mut gpui::AppContext,
     ) -> Result<TaskVariables> {
         let local_abs_path = location
diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs
index 99018647ead465..ee127c00cca846 100644
--- a/crates/languages/src/python.rs
+++ b/crates/languages/src/python.rs
@@ -1,5 +1,6 @@
 use anyhow::Result;
 use async_trait::async_trait;
+use collections::HashMap;
 use gpui::AppContext;
 use gpui::AsyncAppContext;
 use language::{ContextProvider, LanguageServerName, LspAdapter, LspAdapterDelegate};
@@ -215,6 +216,7 @@ impl ContextProvider for PythonContextProvider {
         &self,
         variables: &task::TaskVariables,
         _location: &project::Location,
+        _: Option<&HashMap<String, String>>,
         _cx: &mut gpui::AppContext,
     ) -> Result<task::TaskVariables> {
         let python_module_name = python_module_name_from_relative_path(
diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs
index 5055bb69c1e6f5..b55f350b9d9187 100644
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -1,6 +1,7 @@
 use anyhow::{anyhow, bail, Context, Result};
 use async_compression::futures::bufread::GzipDecoder;
 use async_trait::async_trait;
+use collections::HashMap;
 use futures::{io::BufReader, StreamExt};
 use gpui::{AppContext, AsyncAppContext};
 use http_client::github::{latest_github_release, GitHubLspBinaryVersion};
@@ -434,6 +435,7 @@ impl ContextProvider for RustContextProvider {
         &self,
         task_variables: &TaskVariables,
         location: &Location,
+        project_env: Option<&HashMap<String, String>>,
         cx: &mut gpui::AppContext,
     ) -> Result<TaskVariables> {
         let local_abs_path = location
@@ -449,8 +451,8 @@ impl ContextProvider for RustContextProvider {
             .is_some();
 
         if is_main_function {
-            if let Some((package_name, bin_name)) =
-                local_abs_path.and_then(package_name_and_bin_name_from_abs_path)
+            if let Some((package_name, bin_name)) = local_abs_path
+                .and_then(|path| package_name_and_bin_name_from_abs_path(path, project_env))
             {
                 return Ok(TaskVariables::from_iter([
                     (RUST_PACKAGE_TASK_VARIABLE.clone(), package_name),
@@ -461,7 +463,7 @@ impl ContextProvider for RustContextProvider {
 
         if let Some(package_name) = local_abs_path
             .and_then(|local_abs_path| local_abs_path.parent())
-            .and_then(human_readable_package_name)
+            .and_then(|path| human_readable_package_name(path, project_env))
         {
             return Ok(TaskVariables::from_iter([(
                 RUST_PACKAGE_TASK_VARIABLE.clone(),
@@ -615,8 +617,15 @@ struct CargoTarget {
     src_path: String,
 }
 
-fn package_name_and_bin_name_from_abs_path(abs_path: &Path) -> Option<(String, String)> {
-    let output = std::process::Command::new("cargo")
+fn package_name_and_bin_name_from_abs_path(
+    abs_path: &Path,
+    project_env: Option<&HashMap<String, String>>,
+) -> Option<(String, String)> {
+    let mut command = std::process::Command::new("cargo");
+    if let Some(envs) = project_env {
+        command.envs(envs);
+    }
+    let output = command
         .current_dir(abs_path.parent()?)
         .arg("metadata")
         .arg("--no-deps")
@@ -654,9 +663,17 @@ fn retrieve_package_id_and_bin_name_from_metadata(
     None
 }
 
-fn human_readable_package_name(package_directory: &Path) -> Option<String> {
+fn human_readable_package_name(
+    package_directory: &Path,
+    project_env: Option<&HashMap<String, String>>,
+) -> Option<String> {
+    let mut command = std::process::Command::new("cargo");
+    if let Some(envs) = project_env {
+        command.envs(envs);
+    }
+
     let pkgid = String::from_utf8(
-        std::process::Command::new("cargo")
+        command
             .current_dir(package_directory)
             .arg("pkgid")
             .output()
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 5d9ac5e8214efb..4318737e3875b8 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -4890,11 +4890,22 @@ impl Project {
             };
 
             cx.spawn(|project, mut cx| async move {
+                let project_env = project
+                    .update(&mut cx, |project, cx| {
+                        let worktree_abs_path = worktree_abs_path.clone();
+                        project.environment.update(cx, |environment, cx| {
+                            environment.get_environment(worktree_id, worktree_abs_path, cx)
+                        })
+                    })
+                    .ok()?
+                    .await;
+
                 let mut task_variables = cx
                     .update(|cx| {
                         combine_task_variables(
                             captured_variables,
                             location,
+                            project_env.as_ref(),
                             BasicContextProvider::new(project.upgrade()?),
                             cx,
                         )
@@ -4905,16 +4916,6 @@ impl Project {
                 // Remove all custom entries starting with _, as they're not intended for use by the end user.
                 task_variables.sweep();
 
-                let project_env = project
-                    .update(&mut cx, |project, cx| {
-                        let worktree_abs_path = worktree_abs_path.clone();
-                        project.environment.update(cx, |environment, cx| {
-                            environment.get_environment(worktree_id, worktree_abs_path, cx)
-                        })
-                    })
-                    .ok()?
-                    .await;
-
                 Some(TaskContext {
                     project_env: project_env.unwrap_or_default(),
                     cwd: worktree_abs_path.map(|p| p.to_path_buf()),
@@ -5111,6 +5112,7 @@ impl Project {
 fn combine_task_variables(
     mut captured_variables: TaskVariables,
     location: Location,
+    project_env: Option<&HashMap<String, String>>,
     baseline: BasicContextProvider,
     cx: &mut AppContext,
 ) -> anyhow::Result<TaskVariables> {
@@ -5120,13 +5122,13 @@ fn combine_task_variables(
         .language()
         .and_then(|language| language.context_provider());
     let baseline = baseline
-        .build_context(&captured_variables, &location, cx)
+        .build_context(&captured_variables, &location, project_env, cx)
         .context("building basic default context")?;
     captured_variables.extend(baseline);
     if let Some(provider) = language_context_provider {
         captured_variables.extend(
             provider
-                .build_context(&captured_variables, &location, cx)
+                .build_context(&captured_variables, &location, project_env, cx)
                 .context("building provider context")?,
         );
     }
diff --git a/crates/project/src/task_inventory.rs b/crates/project/src/task_inventory.rs
index 314903ec5da439..83c9c1f8e58be9 100644
--- a/crates/project/src/task_inventory.rs
+++ b/crates/project/src/task_inventory.rs
@@ -8,7 +8,7 @@ use std::{
 };
 
 use anyhow::Result;
-use collections::{btree_map, BTreeMap, VecDeque};
+use collections::{btree_map, BTreeMap, HashMap, VecDeque};
 use futures::{
     channel::mpsc::{unbounded, UnboundedSender},
     StreamExt,
@@ -543,6 +543,7 @@ impl ContextProvider for BasicContextProvider {
         &self,
         _: &TaskVariables,
         location: &Location,
+        _: Option<&HashMap<String, String>>,
         cx: &mut AppContext,
     ) -> Result<TaskVariables> {
         let buffer = location.buffer.read(cx);

From 7814dd0301c39987d36c8dbee4cd1b5802e315cc Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Tue, 17 Sep 2024 21:50:37 +0200
Subject: [PATCH 159/762] Update Rust crate sysinfo to 0.31.0 (#17733)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [sysinfo](https://redirect.github.com/GuillaumeGomez/sysinfo) |
workspace.dependencies | minor | `0.30.7` -> `0.31.0` |

---

### Release Notes

<details>
<summary>GuillaumeGomez/sysinfo (sysinfo)</summary>

###
[`v0.31.4`](https://redirect.github.com/GuillaumeGomez/sysinfo/blob/HEAD/CHANGELOG.md#0314)

[Compare
Source](https://redirect.github.com/GuillaumeGomez/sysinfo/compare/v0.31.3...v0.31.4)

-   macOS: Force memory cleanup in disk list retrieval.

###
[`v0.31.3`](https://redirect.github.com/GuillaumeGomez/sysinfo/blob/HEAD/CHANGELOG.md#0313)

[Compare
Source](https://redirect.github.com/GuillaumeGomez/sysinfo/compare/v0.31.2...v0.31.3)

-   Raspberry Pi: Fix temperature retrieval.

###
[`v0.31.2`](https://redirect.github.com/GuillaumeGomez/sysinfo/blob/HEAD/CHANGELOG.md#0312)

[Compare
Source](https://redirect.github.com/GuillaumeGomez/sysinfo/compare/v0.31.1...v0.31.2)

-   Remove `bstr` dependency (needed for rustc development).

###
[`v0.31.1`](https://redirect.github.com/GuillaumeGomez/sysinfo/blob/HEAD/CHANGELOG.md#0311)

[Compare
Source](https://redirect.github.com/GuillaumeGomez/sysinfo/compare/v0.31.0...v0.31.1)

-   Downgrade version of `memchr` (needed for rustc development).

###
[`v0.31.0`](https://redirect.github.com/GuillaumeGomez/sysinfo/blob/HEAD/CHANGELOG.md#0310)

[Compare
Source](https://redirect.github.com/GuillaumeGomez/sysinfo/compare/v0.30.13...v0.31.0)

-   Split crate in features to only enable what you need.
- Remove `System::refresh_process`, `System::refresh_process_specifics`
and `System::refresh_pids`
    methods.
- Add new argument of type `ProcessesToUpdate` to
`System::refresh_processes` and `System::refresh_processes_specifics`
methods.
-   Add new `NetworkData::ip_networks` method.
-   Add new `System::refresh_cpu_list` method.
-   Global CPU now only contains CPU usage.
-   Rename `TermalSensorType` to `ThermalSensorType`.
-   Process names is now an `OsString`.
-   Remove `System::global_cpu_info`.
-   Add `System::global_cpu_usage`.
- macOS: Fix invalid CPU computation when single processes are refreshed
one after the other.
-   Windows: Fix virtual memory computation.
-   Windows: Fix WoW64 parent process refresh.
-   Linux: Retrieve RSS (Resident Set Size) memory for cgroups.

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC43NC4xIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

---------

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
---
 Cargo.lock                      | 19 ++++---------------
 Cargo.toml                      |  2 +-
 crates/client/src/telemetry.rs  | 10 ++++++++--
 crates/terminal/src/pty_info.rs | 15 ++++++++++-----
 4 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9cff8953932ade..930415440ba0ad 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11085,17 +11085,16 @@ dependencies = [
 
 [[package]]
 name = "sysinfo"
-version = "0.30.13"
+version = "0.31.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a5b4ddaee55fb2bea2bf0e5000747e5f5c0de765e5a5ff87f4cd106439f4bb3"
+checksum = "355dbe4f8799b304b05e1b0f05fc59b2a18d36645cf169607da45bde2f69a1be"
 dependencies = [
- "cfg-if",
  "core-foundation-sys",
  "libc",
+ "memchr",
  "ntapi",
- "once_cell",
  "rayon",
- "windows 0.52.0",
+ "windows 0.54.0",
 ]
 
 [[package]]
@@ -13443,16 +13442,6 @@ dependencies = [
  "windows-targets 0.48.5",
 ]
 
-[[package]]
-name = "windows"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
-dependencies = [
- "windows-core 0.52.0",
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows"
 version = "0.54.0"
diff --git a/Cargo.toml b/Cargo.toml
index eea510edf2e0e9..0b392e02eb7b36 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -416,7 +416,7 @@ strsim = "0.11"
 strum = { version = "0.25.0", features = ["derive"] }
 subtle = "2.5.0"
 sys-locale = "0.3.1"
-sysinfo = "0.30.7"
+sysinfo = "0.31.0"
 tempfile = "3.9.0"
 thiserror = "1.0.29"
 tiktoken-rs = "0.5.9"
diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index 860288038bd9e2..b415cae14c60a2 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -304,7 +304,10 @@ impl Telemetry {
 
                 let refresh_kind = ProcessRefreshKind::new().with_cpu().with_memory();
                 let current_process = Pid::from_u32(std::process::id());
-                system.refresh_process_specifics(current_process, refresh_kind);
+                system.refresh_processes_specifics(
+                    sysinfo::ProcessesToUpdate::Some(&[current_process]),
+                    refresh_kind,
+                );
 
                 // Waiting some amount of time before the first query is important to get a reasonable value
                 // https://docs.rs/sysinfo/0.29.10/sysinfo/trait.ProcessExt.html#tymethod.cpu_usage
@@ -314,7 +317,10 @@ impl Telemetry {
                     smol::Timer::after(DURATION_BETWEEN_SYSTEM_EVENTS).await;
 
                     let current_process = Pid::from_u32(std::process::id());
-                    system.refresh_process_specifics(current_process, refresh_kind);
+                    system.refresh_processes_specifics(
+                        sysinfo::ProcessesToUpdate::Some(&[current_process]),
+                        refresh_kind,
+                    );
                     let Some(process) = system.process(current_process) else {
                         log::error!(
                             "Failed to find own process {current_process:?} in system process table"
diff --git a/crates/terminal/src/pty_info.rs b/crates/terminal/src/pty_info.rs
index 5fc3b05f78f139..559d022fda8a0c 100644
--- a/crates/terminal/src/pty_info.rs
+++ b/crates/terminal/src/pty_info.rs
@@ -98,9 +98,10 @@ impl PtyProcessInfo {
 
     fn refresh(&mut self) -> Option<&Process> {
         let pid = self.pid_getter.pid()?;
-        if self
-            .system
-            .refresh_process_specifics(pid, self.refresh_kind)
+        if self.system.refresh_processes_specifics(
+            sysinfo::ProcessesToUpdate::Some(&[pid]),
+            self.refresh_kind,
+        ) == 1
         {
             self.system.process(pid)
         } else {
@@ -116,9 +117,13 @@ impl PtyProcessInfo {
             .map_or(PathBuf::new(), |p| p.to_owned());
 
         let info = ProcessInfo {
-            name: process.name().to_owned(),
+            name: process.name().to_str()?.to_owned(),
             cwd,
-            argv: process.cmd().to_vec(),
+            argv: process
+                .cmd()
+                .iter()
+                .filter_map(|s| s.to_str().map(ToOwned::to_owned))
+                .collect(),
         };
         self.current = Some(info.clone());
         Some(info)

From 8cc6df573cb5926ce501eb58e3ca898e43142a33 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 17 Sep 2024 14:13:37 -0600
Subject: [PATCH 160/762] SshLspAdapterDelegate (#17965)

Release Notes:

- N/A
---
 crates/assistant/src/assistant_panel.rs      |  20 +-
 crates/languages/src/rust.rs                 |   2 +-
 crates/project/src/lsp_store.rs              | 337 ++++++++++++-------
 crates/proto/proto/zed.proto                 |  28 +-
 crates/proto/src/proto.rs                    |  11 +-
 crates/remote/src/ssh_session.rs             |  19 +-
 crates/remote_server/src/headless_project.rs |   2 +
 crates/remote_server/src/main.rs             |   1 -
 8 files changed, 270 insertions(+), 150 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 6eaa86f4a7aff9..5d06720fe0095b 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -54,7 +54,7 @@ use language_model::{
 use language_model::{LanguageModelImage, LanguageModelToolUse};
 use multi_buffer::MultiBufferRow;
 use picker::{Picker, PickerDelegate};
-use project::lsp_store::ProjectLspAdapterDelegate;
+use project::lsp_store::LocalLspAdapterDelegate;
 use project::{Project, Worktree};
 use search::{buffer_search::DivRegistrar, BufferSearchBar};
 use serde::{Deserialize, Serialize};
@@ -5384,18 +5384,16 @@ fn make_lsp_adapter_delegate(
         let worktree = project
             .worktrees(cx)
             .next()
-            .ok_or_else(|| anyhow!("no worktrees when constructing ProjectLspAdapterDelegate"))?;
-        let fs = if project.is_local() {
-            Some(project.fs().clone())
-        } else {
-            None
-        };
+            .ok_or_else(|| anyhow!("no worktrees when constructing LocalLspAdapterDelegate"))?;
         let http_client = project.client().http_client().clone();
         project.lsp_store().update(cx, |lsp_store, cx| {
-            Ok(
-                ProjectLspAdapterDelegate::new(lsp_store, &worktree, http_client, fs, None, cx)
-                    as Arc<dyn LspAdapterDelegate>,
-            )
+            Ok(LocalLspAdapterDelegate::new(
+                lsp_store,
+                &worktree,
+                http_client,
+                project.fs().clone(),
+                cx,
+            ) as Arc<dyn LspAdapterDelegate>)
         })
     })
 }
diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs
index b55f350b9d9187..a32ffe50f519f1 100644
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -77,7 +77,7 @@ impl LspAdapter for RustLspAdapter {
                     {
                         Ok(()) => (Some(path), Some(env), None),
                         Err(err) => {
-                            log::error!("failed to run rust-analyzer after detecting it in PATH: binary: {:?}: {:?}", path, err);
+                            log::error!("failed to run rust-analyzer after detecting it in PATH: binary: {:?}: {}", path, err);
                             (None, None, None)
                         }
                     }
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 2c718a42abbb84..daacf26c3a4c04 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -2305,8 +2305,7 @@ impl LspStore {
                                 .read(cx)
                                 .worktree_for_id(*worktree_id, cx)?;
                             let state = this.as_local()?.language_servers.get(server_id)?;
-                            let delegate =
-                                ProjectLspAdapterDelegate::for_local(this, &worktree, cx);
+                            let delegate = LocalLspAdapterDelegate::for_local(this, &worktree, cx);
                             match state {
                                 LanguageServerState::Starting(_) => None,
                                 LanguageServerState::Running {
@@ -4368,7 +4367,7 @@ impl LspStore {
         let response = this
             .update(&mut cx, |this, cx| {
                 let worktree = this.worktree_for_id(worktree_id, cx)?;
-                let delegate = ProjectLspAdapterDelegate::for_local(this, &worktree, cx);
+                let delegate = LocalLspAdapterDelegate::for_local(this, &worktree, cx);
                 anyhow::Ok(
                     cx.spawn(|_, _| async move { delegate.which(command.as_os_str()).await }),
                 )
@@ -4389,7 +4388,7 @@ impl LspStore {
         let response = this
             .update(&mut cx, |this, cx| {
                 let worktree = this.worktree_for_id(worktree_id, cx)?;
-                let delegate = ProjectLspAdapterDelegate::for_local(this, &worktree, cx);
+                let delegate = LocalLspAdapterDelegate::for_local(this, &worktree, cx);
                 anyhow::Ok(cx.spawn(|_, _| async move { delegate.shell_env().await }))
             })??
             .await;
@@ -4398,6 +4397,52 @@ impl LspStore {
             env: response.into_iter().collect(),
         })
     }
+    pub async fn handle_try_exec(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::TryExec>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::Ack> {
+        let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
+        let binary = envelope
+            .payload
+            .binary
+            .ok_or_else(|| anyhow!("missing binary"))?;
+        let binary = LanguageServerBinary {
+            path: PathBuf::from(binary.path),
+            env: None,
+            arguments: binary.arguments.into_iter().map(Into::into).collect(),
+        };
+        this.update(&mut cx, |this, cx| {
+            let worktree = this.worktree_for_id(worktree_id, cx)?;
+            let delegate = LocalLspAdapterDelegate::for_local(this, &worktree, cx);
+            anyhow::Ok(cx.spawn(|_, _| async move { delegate.try_exec(binary).await }))
+        })??
+        .await?;
+
+        Ok(proto::Ack {})
+    }
+
+    pub async fn handle_read_text_file(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::ReadTextFile>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::ReadTextFileResponse> {
+        let path = envelope
+            .payload
+            .path
+            .ok_or_else(|| anyhow!("missing path"))?;
+        let worktree_id = WorktreeId::from_proto(path.worktree_id);
+        let path = PathBuf::from(path.path);
+        let response = this
+            .update(&mut cx, |this, cx| {
+                let worktree = this.worktree_for_id(worktree_id, cx)?;
+                let delegate = LocalLspAdapterDelegate::for_local(this, &worktree, cx);
+                anyhow::Ok(cx.spawn(|_, _| async move { delegate.read_text_file(path).await }))
+            })??
+            .await?;
+
+        Ok(proto::ReadTextFileResponse { text: response })
+    }
 
     async fn handle_apply_additional_edits_for_completion(
         this: Model<Self>,
@@ -4535,9 +4580,12 @@ impl LspStore {
     ) {
         let ssh = self.as_ssh().unwrap();
 
-        let delegate =
-            ProjectLspAdapterDelegate::for_ssh(self, worktree, ssh.upstream_client.clone(), cx)
-                as Arc<dyn LspAdapterDelegate>;
+        let delegate = Arc::new(SshLspAdapterDelegate {
+            lsp_store: cx.handle().downgrade(),
+            worktree: worktree.read(cx).snapshot(),
+            upstream_client: ssh.upstream_client.clone(),
+            language_registry: self.languages.clone(),
+        }) as Arc<dyn LspAdapterDelegate>;
 
         // TODO: We should use `adapter` here instead of reaching through the `CachedLspAdapter`.
         let lsp_adapter = adapter.adapter.clone();
@@ -4645,7 +4693,7 @@ impl LspStore {
         let local = self.as_local().unwrap();
 
         let stderr_capture = Arc::new(Mutex::new(Some(String::new())));
-        let lsp_adapter_delegate = ProjectLspAdapterDelegate::for_local(self, worktree_handle, cx);
+        let lsp_adapter_delegate = LocalLspAdapterDelegate::for_local(self, worktree_handle, cx);
         let project_environment = local.environment.update(cx, |environment, cx| {
             environment.get_environment(Some(worktree_id), Some(worktree_path.clone()), cx)
         });
@@ -6938,18 +6986,32 @@ impl LspAdapter for SshLspAdapter {
         None
     }
 }
+pub fn language_server_settings<'a, 'b: 'a>(
+    delegate: &'a dyn LspAdapterDelegate,
+    language: &str,
+    cx: &'b AppContext,
+) -> Option<&'a LspSettings> {
+    ProjectSettings::get(
+        Some(SettingsLocation {
+            worktree_id: delegate.worktree_id(),
+            path: delegate.worktree_root_path(),
+        }),
+        cx,
+    )
+    .lsp
+    .get(language)
+}
 
-pub struct ProjectLspAdapterDelegate {
+pub struct LocalLspAdapterDelegate {
     lsp_store: WeakModel<LspStore>,
     worktree: worktree::Snapshot,
-    fs: Option<Arc<dyn Fs>>,
+    fs: Arc<dyn Fs>,
     http_client: Arc<dyn HttpClient>,
     language_registry: Arc<LanguageRegistry>,
     load_shell_env_task: Shared<Task<Option<HashMap<String, String>>>>,
-    upstream_client: Option<AnyProtoClient>,
 }
 
-impl ProjectLspAdapterDelegate {
+impl LocalLspAdapterDelegate {
     fn for_local(
         lsp_store: &LspStore,
         worktree: &Model<Worktree>,
@@ -6957,45 +7019,37 @@ impl ProjectLspAdapterDelegate {
     ) -> Arc<Self> {
         let local = lsp_store
             .as_local()
-            .expect("ProjectLspAdapterDelegate cannot be constructed on a remote");
+            .expect("LocalLspAdapterDelegate cannot be constructed on a remote");
 
         let http_client = local
             .http_client
             .clone()
             .unwrap_or_else(|| Arc::new(BlockedHttpClient));
 
-        Self::new(
-            lsp_store,
-            worktree,
-            http_client,
-            Some(local.fs.clone()),
-            None,
-            cx,
-        )
-    }
-
-    fn for_ssh(
-        lsp_store: &LspStore,
-        worktree: &Model<Worktree>,
-        upstream_client: AnyProtoClient,
-        cx: &mut ModelContext<LspStore>,
-    ) -> Arc<Self> {
-        Self::new(
-            lsp_store,
-            worktree,
-            Arc::new(BlockedHttpClient),
-            None,
-            Some(upstream_client),
-            cx,
-        )
-    }
+        Self::new(lsp_store, worktree, http_client, local.fs.clone(), cx)
+    }
+
+    // fn for_ssh(
+    //     lsp_store: &LspStore,
+    //     worktree: &Model<Worktree>,
+    //     upstream_client: AnyProtoClient,
+    //     cx: &mut ModelContext<LspStore>,
+    // ) -> Arc<Self> {
+    //     Self::new(
+    //         lsp_store,
+    //         worktree,
+    //         Arc::new(BlockedHttpClient),
+    //         None,
+    //         Some(upstream_client),
+    //         cx,
+    //     )
+    // }
 
     pub fn new(
         lsp_store: &LspStore,
         worktree: &Model<Worktree>,
         http_client: Arc<dyn HttpClient>,
-        fs: Option<Arc<dyn Fs>>,
-        upstream_client: Option<AnyProtoClient>,
+        fs: Arc<dyn Fs>,
         cx: &mut ModelContext<LspStore>,
     ) -> Arc<Self> {
         let worktree_id = worktree.read(cx).id();
@@ -7015,52 +7069,14 @@ impl ProjectLspAdapterDelegate {
             worktree: worktree.read(cx).snapshot(),
             fs,
             http_client,
-            upstream_client,
             language_registry: lsp_store.languages.clone(),
             load_shell_env_task,
         })
     }
 }
 
-struct BlockedHttpClient;
-
-impl HttpClient for BlockedHttpClient {
-    fn send(
-        &self,
-        _req: Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>> {
-        Box::pin(async {
-            Err(std::io::Error::new(
-                std::io::ErrorKind::PermissionDenied,
-                "ssh host blocked http connection",
-            )
-            .into())
-        })
-    }
-
-    fn proxy(&self) -> Option<&Uri> {
-        None
-    }
-}
-
-pub fn language_server_settings<'a, 'b: 'a>(
-    delegate: &'a dyn LspAdapterDelegate,
-    language: &str,
-    cx: &'b AppContext,
-) -> Option<&'a LspSettings> {
-    ProjectSettings::get(
-        Some(SettingsLocation {
-            worktree_id: delegate.worktree_id(),
-            path: delegate.worktree_root_path(),
-        }),
-        cx,
-    )
-    .lsp
-    .get(language)
-}
-
 #[async_trait]
-impl LspAdapterDelegate for ProjectLspAdapterDelegate {
+impl LspAdapterDelegate for LocalLspAdapterDelegate {
     fn show_notification(&self, message: &str, cx: &mut AppContext) {
         self.lsp_store
             .update(cx, |_, cx| {
@@ -7082,42 +7098,12 @@ impl LspAdapterDelegate for ProjectLspAdapterDelegate {
     }
 
     async fn shell_env(&self) -> HashMap<String, String> {
-        if let Some(upstream_client) = &self.upstream_client {
-            use rpc::proto::SSH_PROJECT_ID;
-
-            return upstream_client
-                .request(proto::ShellEnv {
-                    project_id: SSH_PROJECT_ID,
-                    worktree_id: self.worktree_id().to_proto(),
-                })
-                .await
-                .map(|response| response.env.into_iter().collect())
-                .unwrap_or_default();
-        }
-
         let task = self.load_shell_env_task.clone();
         task.await.unwrap_or_default()
     }
 
     #[cfg(not(target_os = "windows"))]
     async fn which(&self, command: &OsStr) -> Option<PathBuf> {
-        if let Some(upstream_client) = &self.upstream_client {
-            use rpc::proto::SSH_PROJECT_ID;
-
-            return upstream_client
-                .request(proto::WhichCommand {
-                    project_id: SSH_PROJECT_ID,
-                    worktree_id: self.worktree_id().to_proto(),
-                    command: command.to_string_lossy().to_string(),
-                })
-                .await
-                .log_err()
-                .and_then(|response| response.path)
-                .map(PathBuf::from);
-        }
-
-        self.fs.as_ref()?;
-
         let worktree_abs_path = self.worktree.abs_path();
         let shell_path = self.shell_env().await.get("PATH").cloned();
         which::which_in(command, shell_path.as_ref(), worktree_abs_path).ok()
@@ -7125,8 +7111,6 @@ impl LspAdapterDelegate for ProjectLspAdapterDelegate {
 
     #[cfg(target_os = "windows")]
     async fn which(&self, command: &OsStr) -> Option<PathBuf> {
-        self.fs.as_ref()?;
-
         // todo(windows) Getting the shell env variables in a current directory on Windows is more complicated than other platforms
         //               there isn't a 'default shell' necessarily. The closest would be the default profile on the windows terminal
         //               SEE: https://learn.microsoft.com/en-us/windows/terminal/customize-settings/startup
@@ -7134,10 +7118,6 @@ impl LspAdapterDelegate for ProjectLspAdapterDelegate {
     }
 
     async fn try_exec(&self, command: LanguageServerBinary) -> Result<()> {
-        if self.fs.is_none() {
-            return Ok(());
-        }
-
         let working_dir = self.worktree_root_path();
         let output = smol::process::Command::new(&command.path)
             .args(command.arguments)
@@ -7170,12 +7150,127 @@ impl LspAdapterDelegate for ProjectLspAdapterDelegate {
         if self.worktree.entry_for_path(&path).is_none() {
             return Err(anyhow!("no such path {path:?}"));
         };
-        if let Some(fs) = &self.fs {
-            let content = fs.load(&path).await?;
-            Ok(content)
-        } else {
-            return Err(anyhow!("cannot open {path:?} on ssh host (yet!)"));
-        }
+        self.fs.load(&path).await
+    }
+}
+
+struct BlockedHttpClient;
+
+impl HttpClient for BlockedHttpClient {
+    fn send(
+        &self,
+        _req: Request<AsyncBody>,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>> {
+        Box::pin(async {
+            Err(std::io::Error::new(
+                std::io::ErrorKind::PermissionDenied,
+                "ssh host blocked http connection",
+            )
+            .into())
+        })
+    }
+
+    fn proxy(&self) -> Option<&Uri> {
+        None
+    }
+}
+
+struct SshLspAdapterDelegate {
+    lsp_store: WeakModel<LspStore>,
+    worktree: worktree::Snapshot,
+    upstream_client: AnyProtoClient,
+    language_registry: Arc<LanguageRegistry>,
+}
+
+#[async_trait]
+impl LspAdapterDelegate for SshLspAdapterDelegate {
+    fn show_notification(&self, message: &str, cx: &mut AppContext) {
+        self.lsp_store
+            .update(cx, |_, cx| {
+                cx.emit(LspStoreEvent::Notification(message.to_owned()))
+            })
+            .ok();
+    }
+
+    fn http_client(&self) -> Arc<dyn HttpClient> {
+        Arc::new(BlockedHttpClient)
+    }
+
+    fn worktree_id(&self) -> WorktreeId {
+        self.worktree.id()
+    }
+
+    fn worktree_root_path(&self) -> &Path {
+        self.worktree.abs_path().as_ref()
+    }
+
+    async fn shell_env(&self) -> HashMap<String, String> {
+        use rpc::proto::SSH_PROJECT_ID;
+
+        self.upstream_client
+            .request(proto::ShellEnv {
+                project_id: SSH_PROJECT_ID,
+                worktree_id: self.worktree_id().to_proto(),
+            })
+            .await
+            .map(|response| response.env.into_iter().collect())
+            .unwrap_or_default()
+    }
+
+    async fn which(&self, command: &OsStr) -> Option<PathBuf> {
+        use rpc::proto::SSH_PROJECT_ID;
+
+        self.upstream_client
+            .request(proto::WhichCommand {
+                project_id: SSH_PROJECT_ID,
+                worktree_id: self.worktree_id().to_proto(),
+                command: command.to_string_lossy().to_string(),
+            })
+            .await
+            .log_err()
+            .and_then(|response| response.path)
+            .map(PathBuf::from)
+    }
+
+    async fn try_exec(&self, command: LanguageServerBinary) -> Result<()> {
+        self.upstream_client
+            .request(proto::TryExec {
+                project_id: rpc::proto::SSH_PROJECT_ID,
+                worktree_id: self.worktree.id().to_proto(),
+                binary: Some(proto::LanguageServerCommand {
+                    path: command.path.to_string_lossy().to_string(),
+                    arguments: command
+                        .arguments
+                        .into_iter()
+                        .map(|s| s.to_string_lossy().to_string())
+                        .collect(),
+                    env: command.env.unwrap_or_default().into_iter().collect(),
+                }),
+            })
+            .await?;
+        Ok(())
+    }
+
+    fn update_status(
+        &self,
+        server_name: LanguageServerName,
+        status: language::LanguageServerBinaryStatus,
+    ) {
+        self.language_registry
+            .update_lsp_status(server_name, status);
+    }
+
+    async fn read_text_file(&self, path: PathBuf) -> Result<String> {
+        self.upstream_client
+            .request(proto::ReadTextFile {
+                project_id: rpc::proto::SSH_PROJECT_ID,
+                path: Some(proto::ProjectPath {
+                    worktree_id: self.worktree.id().to_proto(),
+                    path: path.to_string_lossy().to_string(),
+                }),
+            })
+            .await
+            .map(|r| r.text)
     }
 }
 
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index 77942c8a94d542..a886b2185556f3 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -289,7 +289,11 @@ message Envelope {
         WhichCommandResponse which_command_response = 249;
 
         ShellEnv shell_env = 250;
-        ShellEnvResponse shell_env_response = 251; // current max
+        ShellEnvResponse shell_env_response = 251;
+
+        TryExec try_exec = 252;
+        ReadTextFile read_text_file = 253;
+        ReadTextFileResponse read_text_file_response = 254; // current max
     }
 
     reserved 158 to 161;
@@ -2551,13 +2555,21 @@ message ShellEnvResponse {
     map<string, string> env = 1;
 }
 
-// message RestartLanguageServer {
-
-// }
-// message DestroyLanguageServer {
+message ReadTextFile {
+    uint64 project_id = 1;
+    ProjectPath path = 2;
+}
 
-// }
+message ReadTextFileResponse {
+    string text = 1;
+}
 
-// message LspWorkspaceConfiguration {
+message TryExec {
+    uint64 project_id = 1;
+    uint64 worktree_id = 2;
+    LanguageServerCommand binary = 3;
+}
 
-// }
+message TryExecResponse {
+    string text = 1;
+}
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index a1853ed4a3bb5b..b5a00d16704c41 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -370,6 +370,9 @@ messages!(
     (WhichCommandResponse, Foreground),
     (ShellEnv, Foreground),
     (ShellEnvResponse, Foreground),
+    (TryExec, Foreground),
+    (ReadTextFile, Foreground),
+    (ReadTextFileResponse, Foreground)
 );
 
 request_messages!(
@@ -495,7 +498,9 @@ request_messages!(
     (AddWorktree, AddWorktreeResponse),
     (CreateLanguageServer, Ack),
     (WhichCommand, WhichCommandResponse),
-    (ShellEnv, ShellEnvResponse)
+    (ShellEnv, ShellEnvResponse),
+    (ReadTextFile, ReadTextFileResponse),
+    (TryExec, Ack),
 );
 
 entity_messages!(
@@ -571,7 +576,9 @@ entity_messages!(
     UpdateUserSettings,
     CreateLanguageServer,
     WhichCommand,
-    ShellEnv
+    ShellEnv,
+    TryExec,
+    ReadTextFile
 );
 
 entity_messages!(
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 4762a785dbdcd2..7556b38f3ed0f4 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -15,7 +15,7 @@ use gpui::{AppContext, AsyncAppContext, Model, SemanticVersion};
 use parking_lot::Mutex;
 use rpc::{
     proto::{self, build_typed_envelope, Envelope, EnvelopedMessage, PeerId, RequestMessage},
-    EntityMessageSubscriber, ProtoClient, ProtoMessageHandlerSet,
+    EntityMessageSubscriber, ProtoClient, ProtoMessageHandlerSet, RpcError,
 };
 use smol::{
     fs,
@@ -157,8 +157,9 @@ impl SshSession {
 
         let mut remote_server_child = socket
             .ssh_command(format!(
-                "RUST_LOG={} {:?} run",
+                "RUST_LOG={} RUST_BACKTRACE={} {:?} run",
                 std::env::var("RUST_LOG").unwrap_or_default(),
+                std::env::var("RUST_BACKTRACE").unwrap_or_default(),
                 remote_binary_path,
             ))
             .spawn()
@@ -349,7 +350,7 @@ impl SshSession {
                                 }
                                 Err(error) => {
                                     log::error!(
-                                        "error handling message. type:{type_name}, error:{error:?}",
+                                        "error handling message. type:{type_name}, error:{error}",
                                     );
                                 }
                             }
@@ -371,7 +372,7 @@ impl SshSession {
         payload: T,
     ) -> impl 'static + Future<Output = Result<T::Response>> {
         log::debug!("ssh request start. name:{}", T::NAME);
-        let response = self.request_dynamic(payload.into_envelope(0, None, None), "");
+        let response = self.request_dynamic(payload.into_envelope(0, None, None), T::NAME);
         async move {
             let response = response.await?;
             log::debug!("ssh request finish. name:{}", T::NAME);
@@ -388,7 +389,7 @@ impl SshSession {
     pub fn request_dynamic(
         &self,
         mut envelope: proto::Envelope,
-        _request_type: &'static str,
+        type_name: &'static str,
     ) -> impl 'static + Future<Output = Result<proto::Envelope>> {
         envelope.id = self.next_message_id.fetch_add(1, SeqCst);
         let (tx, rx) = oneshot::channel();
@@ -396,7 +397,13 @@ impl SshSession {
         response_channels_lock.insert(MessageId(envelope.id), tx);
         drop(response_channels_lock);
         self.outgoing_tx.unbounded_send(envelope).ok();
-        async move { Ok(rx.await.context("connection lost")?.0) }
+        async move {
+            let response = rx.await.context("connection lost")?.0;
+            if let Some(proto::envelope::Payload::Error(error)) = &response.payload {
+                return Err(RpcError::from_proto(error, type_name));
+            }
+            Ok(response)
+        }
     }
 
     pub fn send_dynamic(&self, mut envelope: proto::Envelope) -> Result<()> {
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 58f5cb0c203cf1..35d6630c1e11be 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -107,6 +107,8 @@ impl HeadlessProject {
         client.add_model_request_handler(LspStore::handle_create_language_server);
         client.add_model_request_handler(LspStore::handle_which_command);
         client.add_model_request_handler(LspStore::handle_shell_env);
+        client.add_model_request_handler(LspStore::handle_try_exec);
+        client.add_model_request_handler(LspStore::handle_read_text_file);
 
         BufferStore::init(&client);
         WorktreeStore::init(&client);
diff --git a/crates/remote_server/src/main.rs b/crates/remote_server/src/main.rs
index 696022a4561094..908a0a89b6273b 100644
--- a/crates/remote_server/src/main.rs
+++ b/crates/remote_server/src/main.rs
@@ -24,7 +24,6 @@ fn main() {
 
 #[cfg(not(windows))]
 fn main() {
-    env::set_var("RUST_BACKTRACE", "1");
     env_logger::builder()
         .format(|buf, record| {
             serde_json::to_writer(&mut *buf, &LogRecord::new(record))?;

From bdca342cdc2cd4d884d13c2246f0bc89365f3a9a Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 17 Sep 2024 16:28:09 -0400
Subject: [PATCH 161/762] Fix "view release notes" on dev/nightly builds
 (#17967)

---
 crates/auto_update/src/auto_update.rs | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index 8063ff4c40fca3..c0863e41d1aa9c 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -244,19 +244,22 @@ pub fn view_release_notes(_: &ViewReleaseNotes, cx: &mut AppContext) -> Option<(
     let auto_updater = AutoUpdater::get(cx)?;
     let release_channel = ReleaseChannel::try_global(cx)?;
 
-    if matches!(
-        release_channel,
-        ReleaseChannel::Stable | ReleaseChannel::Preview
-    ) {
-        let auto_updater = auto_updater.read(cx);
-        let release_channel = release_channel.dev_name();
-        let current_version = auto_updater.current_version;
-        let url = &auto_updater
-            .http_client
-            .build_url(&format!("/releases/{release_channel}/{current_version}"));
-        cx.open_url(url);
+    match release_channel {
+        ReleaseChannel::Stable | ReleaseChannel::Preview => {
+            let auto_updater = auto_updater.read(cx);
+            let current_version = auto_updater.current_version;
+            let release_channel = release_channel.dev_name();
+            let path = format!("/releases/{release_channel}/{current_version}");
+            let url = &auto_updater.http_client.build_url(&path);
+            cx.open_url(url);
+        }
+        ReleaseChannel::Nightly => {
+            cx.open_url("https://github.com/zed-industries/zed/commits/nightly/");
+        }
+        ReleaseChannel::Dev => {
+            cx.open_url("https://github.com/zed-industries/zed/commits/main/");
+        }
     }
-
     None
 }
 

From 51faf4a1cd8965bf014660a63cc6c18e3e39c5cb Mon Sep 17 00:00:00 2001
From: Marek Fajkus <marek.faj@gmail.com>
Date: Tue, 17 Sep 2024 22:28:52 +0200
Subject: [PATCH 162/762] Add missing cmake dependency to Nix build (#17968)

cmake is required during build of dependecies and thus needs to be
supplied in nativeBuildInputs (dependecies required for build not during
runtime).

This fixes (sandboxed) nix builds of the project.

Release Notes:

- N/A
---
 nix/build.nix | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/nix/build.nix b/nix/build.nix
index cd000e9e918969..4782c9a56fda21 100644
--- a/nix/build.nix
+++ b/nix/build.nix
@@ -28,6 +28,7 @@
   stdenvAdapters,
   nix-gitignore,
   withGLES ? false,
+  cmake,
 }: let
   includeFilter = path: type: let
     baseName = baseNameOf (toString path);
@@ -58,6 +59,7 @@
         pkg-config
         protobuf
         rustPlatform.bindgenHook
+        cmake
       ];
 
       buildInputs = [

From e7912370e66a8da7b7aa5560bb616590f0a9ad91 Mon Sep 17 00:00:00 2001
From: Graham Taylor <gwtaylor@users.noreply.github.com>
Date: Tue, 17 Sep 2024 18:31:06 -0400
Subject: [PATCH 163/762] perplexity: Remove duplicate step and fix numbering
 in README (#17978)

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 extensions/perplexity/README.md | 38 +++++++++++++++++----------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/extensions/perplexity/README.md b/extensions/perplexity/README.md
index 094a876885e97f..405356dc535a36 100644
--- a/extensions/perplexity/README.md
+++ b/extensions/perplexity/README.md
@@ -12,30 +12,32 @@ Open the AI Assistant panel (`cmd-r` or `ctrl-r`) and enter:
 
 ## Development Setup
 
-1. Install the rust toolchain and clone the zed repo:
-```
-curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+1. Install the Rust toolchain and clone the zed repo:
 
-mkdir -p ~/code
-cd ~/code
-git clone https://github.com/zed-industries/zed
-```
+   ```
+   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 
-2. Launch Zed and Open Zed Extensions (`cmd-shift-x` / `ctrl-shift-x`)
-3. Open Zed
-4. Open Zed Extensions (`cmd-shift-x` / `ctrl-shift-x`)
-5. Click "Install Dev Extension"
-6. Navigate to the "extensions/perplexity" folder inside the zed git repo.
-7. Ensure your `PERPLEXITY_API_KEY` environment variable is set (instructions below)
-```sh
-env |grep PERPLEXITY_API_KEY
-```
-8. Quit and relaunch Zed
+   mkdir -p ~/code
+   cd ~/code
+   git clone https://github.com/zed-industries/zed
+   ```
+
+1. Open Zed
+1. Open Zed Extensions (`cmd-shift-x` / `ctrl-shift-x`)
+1. Click "Install Dev Extension"
+1. Navigate to the "extensions/perplexity" folder inside the zed git repo.
+1. Ensure your `PERPLEXITY_API_KEY` environment variable is set (instructions below)
+
+   ```sh
+   env | grep PERPLEXITY_API_KEY
+   ```
+
+1. Quit and relaunch Zed
 
 ## PERPLEXITY_API_KEY
 
 This extension requires a Perplexity API key to be available via the `PERPLEXITY_API_KEY` environment variable.
 
-To onbtain a Perplexity.ai API token, login to your Perplexity.ai account and go [Settings->API](https://www.perplexity.ai/settings/api) and under "API Keys" click "Generate".  This will require you to have [Perplexity Pro](https://www.perplexity.ai/pro) or to buy API credits. By default the extension uses `llama-3.1-sonar-small-128k-online`, currently cheapest model available which is roughly half a penny per request + a penny per 50,000 tokens.  So most requests will cost less than $0.01 USD.
+To onbtain a Perplexity.ai API token, login to your Perplexity.ai account and go [Settings->API](https://www.perplexity.ai/settings/api) and under "API Keys" click "Generate". This will require you to have [Perplexity Pro](https://www.perplexity.ai/pro) or to buy API credits. By default the extension uses `llama-3.1-sonar-small-128k-online`, currently cheapest model available which is roughly half a penny per request + a penny per 50,000 tokens. So most requests will cost less than $0.01 USD.
 
 Take your API key and add it to your environment by adding `export PERPLEXITY_API_KEY="pplx-0123456789abcdef..."` to your `~/.zshrc` or `~/.bashrc`. Reload close and reopen your terminal session. Check with `env |grep PERPLEXITY_API_KEY`.

From db18f7a2b008452a5c64a87735ed9cdd916ebcbd Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 17 Sep 2024 18:32:22 -0400
Subject: [PATCH 164/762] rust: Fix doc comment highlighting (#17976)

This PR fixes an issue where `/` and `!` in Rust doc comments were being
incorrectly highlighted as operators after #17734.

We solve this by removing them from the operators list and using more
scoped queries to highlight them.

Release Notes:

- N/A

---------

Co-authored-by: Max <max@zed.dev>
---
 crates/languages/src/rust/highlights.scm | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/languages/src/rust/highlights.scm b/crates/languages/src/rust/highlights.scm
index 0c3aa7efc7a2a5..8d4bad06e06ea9 100644
--- a/crates/languages/src/rust/highlights.scm
+++ b/crates/languages/src/rust/highlights.scm
@@ -139,7 +139,6 @@
 ] @comment.doc
 
 [
-  "!"
   "!="
   "%"
   "%="
@@ -159,7 +158,6 @@
   ".."
   "..="
   "..."
-  "/"
   "/="
   ":"
   ";"
@@ -183,6 +181,10 @@
   "?"
 ] @operator
 
+; Avoid highlighting these as operators when used in doc comments.
+(unary_expression "!" @operator)
+operator: "/" @operator
+
 (lifetime) @lifetime
 
 (parameter (identifier) @variable.parameter)

From 8e45bf71cae37cbbc99dda67fdce57aed4d2d8fd Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 17 Sep 2024 16:37:56 -0600
Subject: [PATCH 165/762] Refactor prettier (#17977)

In preparation for making formatting work on ssh remotes

Release Notes:

- N/A

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 crates/node_runtime/src/node_runtime.rs       |   49 +
 crates/project/src/lsp_store.rs               |  194 ++-
 ...{prettier_support.rs => prettier_store.rs} | 1122 +++++++++--------
 crates/project/src/project.rs                 |  218 +---
 crates/remote_server/Cargo.toml               |    1 +
 crates/remote_server/src/headless_project.rs  |   14 +-
 6 files changed, 902 insertions(+), 696 deletions(-)
 rename crates/project/src/{prettier_support.rs => prettier_store.rs} (65%)

diff --git a/crates/node_runtime/src/node_runtime.rs b/crates/node_runtime/src/node_runtime.rs
index 73650d73c9d219..4aa65ab6db8049 100644
--- a/crates/node_runtime/src/node_runtime.rs
+++ b/crates/node_runtime/src/node_runtime.rs
@@ -462,3 +462,52 @@ impl NodeRuntime for FakeNodeRuntime {
         unreachable!("Should not install packages {packages:?}")
     }
 }
+
+// TODO: Remove this when headless binary can  run node
+pub struct DummyNodeRuntime;
+
+impl DummyNodeRuntime {
+    pub fn new() -> Arc<dyn NodeRuntime> {
+        Arc::new(Self)
+    }
+}
+
+#[async_trait::async_trait]
+impl NodeRuntime for DummyNodeRuntime {
+    async fn binary_path(&self) -> anyhow::Result<PathBuf> {
+        anyhow::bail!("Dummy Node Runtime")
+    }
+
+    async fn node_environment_path(&self) -> anyhow::Result<OsString> {
+        anyhow::bail!("Dummy node runtime")
+    }
+
+    async fn run_npm_subcommand(
+        &self,
+        _: Option<&Path>,
+        _subcommand: &str,
+        _args: &[&str],
+    ) -> anyhow::Result<Output> {
+        anyhow::bail!("Dummy node runtime")
+    }
+
+    async fn npm_package_latest_version(&self, _name: &str) -> anyhow::Result<String> {
+        anyhow::bail!("Dummy node runtime")
+    }
+
+    async fn npm_package_installed_version(
+        &self,
+        _local_package_directory: &Path,
+        _name: &str,
+    ) -> Result<Option<String>> {
+        anyhow::bail!("Dummy node runtime")
+    }
+
+    async fn npm_install_packages(
+        &self,
+        _: &Path,
+        _packages: &[(&str, &str)],
+    ) -> anyhow::Result<()> {
+        anyhow::bail!("Dummy node runtime")
+    }
+}
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index daacf26c3a4c04..35eb20259c1393 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -3,6 +3,7 @@ use crate::{
     environment::ProjectEnvironment,
     lsp_command::{self, *},
     lsp_ext_command,
+    prettier_store::{self, PrettierStore, PrettierStoreEvent},
     project_settings::{LspSettings, ProjectSettings},
     relativize_path, resolve_path,
     worktree_store::{WorktreeStore, WorktreeStoreEvent},
@@ -101,6 +102,8 @@ pub struct LocalLspStore {
         HashMap<LanguageServerId, HashMap<String, Vec<FileSystemWatcher>>>,
     supplementary_language_servers:
         HashMap<LanguageServerId, (LanguageServerName, Arc<LanguageServer>)>,
+    prettier_store: Model<PrettierStore>,
+    current_lsp_settings: HashMap<Arc<str>, LspSettings>,
     _subscription: gpui::Subscription,
 }
 
@@ -135,6 +138,7 @@ impl RemoteLspStore {}
 
 pub struct SshLspStore {
     upstream_client: AnyProtoClient,
+    current_lsp_settings: HashMap<Arc<str>, LspSettings>,
 }
 
 #[allow(clippy::large_enum_variant)]
@@ -310,9 +314,32 @@ impl LspStore {
         }
     }
 
+    pub fn swap_current_lsp_settings(
+        &mut self,
+        new_settings: HashMap<Arc<str>, LspSettings>,
+    ) -> Option<HashMap<Arc<str>, LspSettings>> {
+        match &mut self.mode {
+            LspStoreMode::Ssh(SshLspStore {
+                current_lsp_settings,
+                ..
+            })
+            | LspStoreMode::Local(LocalLspStore {
+                current_lsp_settings,
+                ..
+            }) => {
+                let ret = mem::take(current_lsp_settings);
+                *current_lsp_settings = new_settings;
+                Some(ret)
+            }
+            LspStoreMode::Remote(_) => None,
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
     pub fn new_local(
         buffer_store: Model<BufferStore>,
         worktree_store: Model<WorktreeStore>,
+        prettier_store: Model<PrettierStore>,
         environment: Model<ProjectEnvironment>,
         languages: Arc<LanguageRegistry>,
         http_client: Option<Arc<dyn HttpClient>>,
@@ -324,6 +351,10 @@ impl LspStore {
             .detach();
         cx.subscribe(&worktree_store, Self::on_worktree_store_event)
             .detach();
+        cx.subscribe(&prettier_store, Self::on_prettier_store_event)
+            .detach();
+        cx.observe_global::<SettingsStore>(Self::on_settings_changed)
+            .detach();
 
         Self {
             mode: LspStoreMode::Local(LocalLspStore {
@@ -332,6 +363,8 @@ impl LspStore {
                 last_workspace_edits_by_language_server: Default::default(),
                 language_server_watched_paths: Default::default(),
                 language_server_watcher_registrations: Default::default(),
+                current_lsp_settings: ProjectSettings::get_global(cx).lsp.clone(),
+                prettier_store,
                 environment,
                 http_client,
                 fs,
@@ -387,9 +420,14 @@ impl LspStore {
             .detach();
         cx.subscribe(&worktree_store, Self::on_worktree_store_event)
             .detach();
+        cx.observe_global::<SettingsStore>(Self::on_settings_changed)
+            .detach();
 
         Self {
-            mode: LspStoreMode::Ssh(SshLspStore { upstream_client }),
+            mode: LspStoreMode::Ssh(SshLspStore {
+                upstream_client,
+                current_lsp_settings: Default::default(),
+            }),
             downstream_client: None,
             project_id,
             buffer_store,
@@ -401,6 +439,7 @@ impl LspStore {
             buffer_snapshots: Default::default(),
             next_diagnostic_group_id: Default::default(),
             diagnostic_summaries: Default::default(),
+
             diagnostics: Default::default(),
             active_entry: None,
             _maintain_workspace_config: Self::maintain_workspace_config(cx),
@@ -498,6 +537,36 @@ impl LspStore {
         }
     }
 
+    fn on_prettier_store_event(
+        &mut self,
+        _: Model<PrettierStore>,
+        event: &PrettierStoreEvent,
+        cx: &mut ModelContext<Self>,
+    ) {
+        match event {
+            PrettierStoreEvent::LanguageServerRemoved(prettier_server_id) => {
+                self.unregister_supplementary_language_server(*prettier_server_id, cx);
+            }
+            PrettierStoreEvent::LanguageServerAdded {
+                new_server_id,
+                name,
+                prettier_server,
+            } => {
+                self.register_supplementary_language_server(
+                    *new_server_id,
+                    name.clone(),
+                    prettier_server.clone(),
+                    cx,
+                );
+            }
+        }
+    }
+
+    // todo!
+    pub fn prettier_store(&self) -> Option<Model<PrettierStore>> {
+        self.as_local().map(|local| local.prettier_store.clone())
+    }
+
     fn on_buffer_event(
         &mut self,
         buffer: Model<Buffer>,
@@ -656,11 +725,29 @@ impl LspStore {
         });
 
         let buffer_file = buffer.read(cx).file().cloned();
+        let settings = language_settings(Some(&new_language), buffer_file.as_ref(), cx).clone();
         let buffer_file = File::from_dyn(buffer_file.as_ref());
 
-        if let Some(file) = buffer_file {
+        let worktree_id = if let Some(file) = buffer_file {
             let worktree = file.worktree.clone();
-            self.start_language_servers(&worktree, new_language.name(), cx)
+            self.start_language_servers(&worktree, new_language.name(), cx);
+
+            Some(worktree.read(cx).id())
+        } else {
+            None
+        };
+
+        if let Some(prettier_plugins) = prettier_store::prettier_plugins_for_language(&settings) {
+            let prettier_store = self.as_local().map(|s| s.prettier_store.clone());
+            if let Some(prettier_store) = prettier_store {
+                prettier_store.update(cx, |prettier_store, cx| {
+                    prettier_store.install_default_prettier(
+                        worktree_id,
+                        prettier_plugins.iter().map(|s| Arc::from(s.as_str())),
+                        cx,
+                    )
+                })
+            }
         }
 
         cx.emit(LspStoreEvent::LanguageDetected {
@@ -799,6 +886,95 @@ impl LspStore {
         Task::ready(Ok(Default::default()))
     }
 
+    fn on_settings_changed(&mut self, cx: &mut ModelContext<Self>) {
+        let mut language_servers_to_start = Vec::new();
+        let mut language_formatters_to_check = Vec::new();
+        for buffer in self.buffer_store.read(cx).buffers() {
+            let buffer = buffer.read(cx);
+            let buffer_file = File::from_dyn(buffer.file());
+            let buffer_language = buffer.language();
+            let settings = language_settings(buffer_language, buffer.file(), cx);
+            if let Some(language) = buffer_language {
+                if settings.enable_language_server {
+                    if let Some(file) = buffer_file {
+                        language_servers_to_start.push((file.worktree.clone(), language.name()));
+                    }
+                }
+                language_formatters_to_check
+                    .push((buffer_file.map(|f| f.worktree_id(cx)), settings.clone()));
+            }
+        }
+
+        let mut language_servers_to_stop = Vec::new();
+        let mut language_servers_to_restart = Vec::new();
+        let languages = self.languages.to_vec();
+
+        let new_lsp_settings = ProjectSettings::get_global(cx).lsp.clone();
+        let Some(current_lsp_settings) = self.swap_current_lsp_settings(new_lsp_settings.clone())
+        else {
+            return;
+        };
+        for (worktree_id, started_lsp_name) in self.started_language_servers() {
+            let language = languages.iter().find_map(|l| {
+                let adapter = self
+                    .languages
+                    .lsp_adapters(&l.name())
+                    .iter()
+                    .find(|adapter| adapter.name == started_lsp_name)?
+                    .clone();
+                Some((l, adapter))
+            });
+            if let Some((language, adapter)) = language {
+                let worktree = self.worktree_for_id(worktree_id, cx).ok();
+                let file = worktree.as_ref().and_then(|tree| {
+                    tree.update(cx, |tree, cx| tree.root_file(cx).map(|f| f as _))
+                });
+                if !language_settings(Some(language), file.as_ref(), cx).enable_language_server {
+                    language_servers_to_stop.push((worktree_id, started_lsp_name.clone()));
+                } else if let Some(worktree) = worktree {
+                    let server_name = &adapter.name.0;
+                    match (
+                        current_lsp_settings.get(server_name),
+                        new_lsp_settings.get(server_name),
+                    ) {
+                        (None, None) => {}
+                        (Some(_), None) | (None, Some(_)) => {
+                            language_servers_to_restart.push((worktree, language.name()));
+                        }
+                        (Some(current_lsp_settings), Some(new_lsp_settings)) => {
+                            if current_lsp_settings != new_lsp_settings {
+                                language_servers_to_restart.push((worktree, language.name()));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        for (worktree_id, adapter_name) in language_servers_to_stop {
+            self.stop_language_server(worktree_id, adapter_name, cx)
+                .detach();
+        }
+
+        if let Some(prettier_store) = self.as_local().map(|s| s.prettier_store.clone()) {
+            prettier_store.update(cx, |prettier_store, cx| {
+                prettier_store.on_settings_changed(language_formatters_to_check, cx)
+            })
+        }
+
+        // Start all the newly-enabled language servers.
+        for (worktree, language) in language_servers_to_start {
+            self.start_language_servers(&worktree, language, cx);
+        }
+
+        // Restart all language servers with changed initialization options.
+        for (worktree, language) in language_servers_to_restart {
+            self.restart_language_servers(worktree, language, cx);
+        }
+
+        cx.notify();
+    }
+
     pub async fn execute_code_actions_on_servers(
         this: &WeakModel<LspStore>,
         adapters_and_servers: &[(Arc<CachedLspAdapter>, Arc<LanguageServer>)],
@@ -2375,7 +2551,7 @@ impl LspStore {
             })
     }
 
-    pub fn remove_worktree(&mut self, id_to_remove: WorktreeId, cx: &mut ModelContext<Self>) {
+    fn remove_worktree(&mut self, id_to_remove: WorktreeId, cx: &mut ModelContext<Self>) {
         self.diagnostics.remove(&id_to_remove);
         self.diagnostic_summaries.remove(&id_to_remove);
 
@@ -2406,6 +2582,12 @@ impl LspStore {
             }
             cx.emit(LspStoreEvent::LanguageServerRemoved(server_id_to_remove));
         }
+
+        if let Some(local) = self.as_local() {
+            local.prettier_store.update(cx, |prettier_store, cx| {
+                prettier_store.remove_worktree(id_to_remove, cx);
+            })
+        }
     }
 
     pub fn shared(
@@ -6117,6 +6299,10 @@ impl LspStore {
 
         let Some(local) = self.as_local() else { return };
 
+        local.prettier_store.update(cx, |prettier_store, cx| {
+            prettier_store.update_prettier_settings(&worktree_handle, changes, cx)
+        });
+
         let worktree_id = worktree_handle.read(cx).id();
         let mut language_server_ids = self
             .language_server_ids
diff --git a/crates/project/src/prettier_support.rs b/crates/project/src/prettier_store.rs
similarity index 65%
rename from crates/project/src/prettier_support.rs
rename to crates/project/src/prettier_store.rs
index e90a1dbdf767f6..29101917fb9aa5 100644
--- a/crates/project/src/prettier_support.rs
+++ b/crates/project/src/prettier_store.rs
@@ -5,444 +5,384 @@ use std::{
 };
 
 use anyhow::{anyhow, Context, Result};
-use collections::HashSet;
+use collections::{HashMap, HashSet};
 use fs::Fs;
 use futures::{
     future::{self, Shared},
+    stream::FuturesUnordered,
     FutureExt,
 };
-use gpui::{AsyncAppContext, Model, ModelContext, Task, WeakModel};
+use gpui::{AsyncAppContext, EventEmitter, Model, ModelContext, Task, WeakModel};
 use language::{
     language_settings::{Formatter, LanguageSettings, SelectedFormatter},
-    Buffer, LanguageServerName, LocalFile,
+    Buffer, LanguageRegistry, LanguageServerName, LocalFile,
 };
 use lsp::{LanguageServer, LanguageServerId};
 use node_runtime::NodeRuntime;
 use paths::default_prettier_dir;
 use prettier::Prettier;
+use smol::stream::StreamExt;
 use util::{ResultExt, TryFutureExt};
 
-use crate::{File, FormatOperation, PathChange, Project, ProjectEntryId, Worktree, WorktreeId};
-
-pub fn prettier_plugins_for_language(
-    language_settings: &LanguageSettings,
-) -> Option<&HashSet<String>> {
-    match &language_settings.formatter {
-        SelectedFormatter::Auto => Some(&language_settings.prettier.plugins),
-
-        SelectedFormatter::List(list) => list
-            .as_ref()
-            .contains(&Formatter::Prettier)
-            .then_some(&language_settings.prettier.plugins),
-    }
-}
-
-pub(super) async fn format_with_prettier(
-    project: &WeakModel<Project>,
-    buffer: &Model<Buffer>,
-    cx: &mut AsyncAppContext,
-) -> Option<Result<FormatOperation>> {
-    let prettier_instance = project
-        .update(cx, |project, cx| {
-            project.prettier_instance_for_buffer(buffer, cx)
-        })
-        .ok()?
-        .await;
-
-    let (prettier_path, prettier_task) = prettier_instance?;
-
-    let prettier_description = match prettier_path.as_ref() {
-        Some(path) => format!("prettier at {path:?}"),
-        None => "default prettier instance".to_string(),
-    };
-
-    match prettier_task.await {
-        Ok(prettier) => {
-            let buffer_path = buffer
-                .update(cx, |buffer, cx| {
-                    File::from_dyn(buffer.file()).map(|file| file.abs_path(cx))
-                })
-                .ok()
-                .flatten();
-
-            let format_result = prettier
-                .format(buffer, buffer_path, cx)
-                .await
-                .map(FormatOperation::Prettier)
-                .with_context(|| format!("{} failed to format buffer", prettier_description));
-
-            Some(format_result)
-        }
-        Err(error) => {
-            project
-                .update(cx, |project, _| {
-                    let instance_to_update = match prettier_path {
-                        Some(prettier_path) => project.prettier_instances.get_mut(&prettier_path),
-                        None => match &mut project.default_prettier.prettier {
-                            PrettierInstallation::NotInstalled { .. } => None,
-                            PrettierInstallation::Installed(instance) => Some(instance),
-                        },
-                    };
-
-                    if let Some(instance) = instance_to_update {
-                        instance.attempt += 1;
-                        instance.prettier = None;
-                    }
-                })
-                .log_err();
-
-            Some(Err(anyhow!(
-                "{} failed to spawn: {error:#}",
-                prettier_description
-            )))
-        }
-    }
-}
+use crate::{
+    worktree_store::WorktreeStore, File, FormatOperation, PathChange, ProjectEntryId, Worktree,
+    WorktreeId,
+};
 
-pub struct DefaultPrettier {
-    prettier: PrettierInstallation,
-    installed_plugins: HashSet<Arc<str>>,
+pub struct PrettierStore {
+    node: Arc<dyn NodeRuntime>,
+    fs: Arc<dyn Fs>,
+    languages: Arc<LanguageRegistry>,
+    worktree_store: Model<WorktreeStore>,
+    default_prettier: DefaultPrettier,
+    prettiers_per_worktree: HashMap<WorktreeId, HashSet<Option<PathBuf>>>,
+    prettier_instances: HashMap<PathBuf, PrettierInstance>,
 }
 
-#[derive(Debug)]
-pub enum PrettierInstallation {
-    NotInstalled {
-        attempts: usize,
-        installation_task: Option<Shared<Task<Result<(), Arc<anyhow::Error>>>>>,
-        not_installed_plugins: HashSet<Arc<str>>,
+pub enum PrettierStoreEvent {
+    LanguageServerRemoved(LanguageServerId),
+    LanguageServerAdded {
+        new_server_id: LanguageServerId,
+        name: LanguageServerName,
+        prettier_server: Arc<LanguageServer>,
     },
-    Installed(PrettierInstance),
 }
 
-pub type PrettierTask = Shared<Task<Result<Arc<Prettier>, Arc<anyhow::Error>>>>;
-
-#[derive(Debug, Clone)]
-pub struct PrettierInstance {
-    attempt: usize,
-    prettier: Option<PrettierTask>,
-}
+impl EventEmitter<PrettierStoreEvent> for PrettierStore {}
 
-impl Default for DefaultPrettier {
-    fn default() -> Self {
+impl PrettierStore {
+    pub fn new(
+        node: Arc<dyn NodeRuntime>,
+        fs: Arc<dyn Fs>,
+        languages: Arc<LanguageRegistry>,
+        worktree_store: Model<WorktreeStore>,
+        _: &mut ModelContext<Self>,
+    ) -> Self {
         Self {
-            prettier: PrettierInstallation::NotInstalled {
-                attempts: 0,
-                installation_task: None,
-                not_installed_plugins: HashSet::default(),
-            },
-            installed_plugins: HashSet::default(),
+            node,
+            fs,
+            languages,
+            worktree_store,
+            default_prettier: DefaultPrettier::default(),
+            prettiers_per_worktree: HashMap::default(),
+            prettier_instances: HashMap::default(),
         }
     }
-}
 
-impl DefaultPrettier {
-    pub fn instance(&self) -> Option<&PrettierInstance> {
-        if let PrettierInstallation::Installed(instance) = &self.prettier {
-            Some(instance)
-        } else {
-            None
+    pub fn remove_worktree(&mut self, id_to_remove: WorktreeId, cx: &mut ModelContext<Self>) {
+        let mut prettier_instances_to_clean = FuturesUnordered::new();
+        if let Some(prettier_paths) = self.prettiers_per_worktree.remove(&id_to_remove) {
+            for path in prettier_paths.iter().flatten() {
+                if let Some(prettier_instance) = self.prettier_instances.remove(path) {
+                    prettier_instances_to_clean.push(async move {
+                        prettier_instance
+                            .server()
+                            .await
+                            .map(|server| server.server_id())
+                    });
+                }
+            }
         }
+        cx.spawn(|prettier_store, mut cx| async move {
+            while let Some(prettier_server_id) = prettier_instances_to_clean.next().await {
+                if let Some(prettier_server_id) = prettier_server_id {
+                    prettier_store
+                        .update(&mut cx, |_, cx| {
+                            cx.emit(PrettierStoreEvent::LanguageServerRemoved(
+                                prettier_server_id,
+                            ));
+                        })
+                        .ok();
+                }
+            }
+        })
+        .detach();
     }
 
-    pub fn prettier_task(
+    fn prettier_instance_for_buffer(
         &mut self,
-        node: &Arc<dyn NodeRuntime>,
-        worktree_id: Option<WorktreeId>,
-        cx: &mut ModelContext<'_, Project>,
-    ) -> Option<Task<anyhow::Result<PrettierTask>>> {
-        match &mut self.prettier {
-            PrettierInstallation::NotInstalled { .. } => {
-                Some(start_default_prettier(Arc::clone(node), worktree_id, cx))
+        buffer: &Model<Buffer>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Option<(Option<PathBuf>, PrettierTask)>> {
+        let buffer = buffer.read(cx);
+        let buffer_file = buffer.file();
+        if buffer.language().is_none() {
+            return Task::ready(None);
+        }
+
+        let node = self.node.clone();
+
+        match File::from_dyn(buffer_file).map(|file| (file.worktree_id(cx), file.abs_path(cx))) {
+            Some((worktree_id, buffer_path)) => {
+                let fs = Arc::clone(&self.fs);
+                let installed_prettiers = self.prettier_instances.keys().cloned().collect();
+                cx.spawn(|lsp_store, mut cx| async move {
+                    match cx
+                        .background_executor()
+                        .spawn(async move {
+                            Prettier::locate_prettier_installation(
+                                fs.as_ref(),
+                                &installed_prettiers,
+                                &buffer_path,
+                            )
+                            .await
+                        })
+                        .await
+                    {
+                        Ok(ControlFlow::Break(())) => None,
+                        Ok(ControlFlow::Continue(None)) => {
+                            let default_instance = lsp_store
+                                .update(&mut cx, |lsp_store, cx| {
+                                    lsp_store
+                                        .prettiers_per_worktree
+                                        .entry(worktree_id)
+                                        .or_default()
+                                        .insert(None);
+                                    lsp_store.default_prettier.prettier_task(
+                                        &node,
+                                        Some(worktree_id),
+                                        cx,
+                                    )
+                                })
+                                .ok()?;
+                            Some((None, default_instance?.log_err().await?))
+                        }
+                        Ok(ControlFlow::Continue(Some(prettier_dir))) => {
+                            lsp_store
+                                .update(&mut cx, |lsp_store, _| {
+                                    lsp_store
+                                        .prettiers_per_worktree
+                                        .entry(worktree_id)
+                                        .or_default()
+                                        .insert(Some(prettier_dir.clone()))
+                                })
+                                .ok()?;
+                            if let Some(prettier_task) = lsp_store
+                                .update(&mut cx, |lsp_store, cx| {
+                                    lsp_store.prettier_instances.get_mut(&prettier_dir).map(
+                                        |existing_instance| {
+                                            existing_instance.prettier_task(
+                                                &node,
+                                                Some(&prettier_dir),
+                                                Some(worktree_id),
+                                                cx,
+                                            )
+                                        },
+                                    )
+                                })
+                                .ok()?
+                            {
+                                log::debug!("Found already started prettier in {prettier_dir:?}");
+                                return Some((Some(prettier_dir), prettier_task?.await.log_err()?));
+                            }
+
+                            log::info!("Found prettier in {prettier_dir:?}, starting.");
+                            let new_prettier_task = lsp_store
+                                .update(&mut cx, |lsp_store, cx| {
+                                    let new_prettier_task = Self::start_prettier(
+                                        node,
+                                        prettier_dir.clone(),
+                                        Some(worktree_id),
+                                        cx,
+                                    );
+                                    lsp_store.prettier_instances.insert(
+                                        prettier_dir.clone(),
+                                        PrettierInstance {
+                                            attempt: 0,
+                                            prettier: Some(new_prettier_task.clone()),
+                                        },
+                                    );
+                                    new_prettier_task
+                                })
+                                .ok()?;
+                            Some((Some(prettier_dir), new_prettier_task))
+                        }
+                        Err(e) => {
+                            log::error!("Failed to determine prettier path for buffer: {e:#}");
+                            None
+                        }
+                    }
+                })
             }
-            PrettierInstallation::Installed(existing_instance) => {
-                existing_instance.prettier_task(node, None, worktree_id, cx)
+            None => {
+                let new_task = self.default_prettier.prettier_task(&node, None, cx);
+                cx.spawn(|_, _| async move { Some((None, new_task?.log_err().await?)) })
             }
         }
     }
-}
 
-impl PrettierInstance {
-    pub fn prettier_task(
-        &mut self,
-        node: &Arc<dyn NodeRuntime>,
-        prettier_dir: Option<&Path>,
+    fn start_prettier(
+        node: Arc<dyn NodeRuntime>,
+        prettier_dir: PathBuf,
         worktree_id: Option<WorktreeId>,
-        cx: &mut ModelContext<'_, Project>,
-    ) -> Option<Task<anyhow::Result<PrettierTask>>> {
-        if self.attempt > prettier::FAIL_THRESHOLD {
-            match prettier_dir {
-                Some(prettier_dir) => log::warn!(
-                    "Prettier from path {prettier_dir:?} exceeded launch threshold, not starting"
-                ),
-                None => log::warn!("Default prettier exceeded launch threshold, not starting"),
-            }
-            return None;
-        }
-        Some(match &self.prettier {
-            Some(prettier_task) => Task::ready(Ok(prettier_task.clone())),
-            None => match prettier_dir {
-                Some(prettier_dir) => {
-                    let new_task = start_prettier(
-                        Arc::clone(node),
-                        prettier_dir.to_path_buf(),
-                        worktree_id,
-                        cx,
-                    );
-                    self.attempt += 1;
-                    self.prettier = Some(new_task.clone());
-                    Task::ready(Ok(new_task))
-                }
-                None => {
-                    self.attempt += 1;
-                    let node = Arc::clone(node);
-                    cx.spawn(|project, mut cx| async move {
-                        project
-                            .update(&mut cx, |_, cx| {
-                                start_default_prettier(node, worktree_id, cx)
-                            })?
-                            .await
-                    })
-                }
-            },
+        cx: &mut ModelContext<Self>,
+    ) -> PrettierTask {
+        cx.spawn(|prettier_store, mut cx| async move {
+            log::info!("Starting prettier at path {prettier_dir:?}");
+            let new_server_id = prettier_store.update(&mut cx, |prettier_store, _| {
+                prettier_store.languages.next_language_server_id()
+            })?;
+
+            let new_prettier = Prettier::start(new_server_id, prettier_dir, node, cx.clone())
+                .await
+                .context("default prettier spawn")
+                .map(Arc::new)
+                .map_err(Arc::new)?;
+            Self::register_new_prettier(
+                &prettier_store,
+                &new_prettier,
+                worktree_id,
+                new_server_id,
+                &mut cx,
+            );
+            Ok(new_prettier)
         })
+        .shared()
     }
 
-    pub async fn server(&self) -> Option<Arc<LanguageServer>> {
-        self.prettier.clone()?.await.ok()?.server().cloned()
-    }
-}
-
-fn start_default_prettier(
-    node: Arc<dyn NodeRuntime>,
-    worktree_id: Option<WorktreeId>,
-    cx: &mut ModelContext<'_, Project>,
-) -> Task<anyhow::Result<PrettierTask>> {
-    cx.spawn(|project, mut cx| async move {
-        let installation_task = project.update(&mut cx, |project, _| {
-            match &project.default_prettier.prettier {
-                PrettierInstallation::NotInstalled {
-                    installation_task, ..
-                } => ControlFlow::Continue(installation_task.clone()),
-                PrettierInstallation::Installed(default_prettier) => {
-                    ControlFlow::Break(default_prettier.clone())
-                }
-            }
-        })?;
-        match installation_task {
-            ControlFlow::Continue(None) => {
-                anyhow::bail!("Default prettier is not installed and cannot be started")
-            }
-            ControlFlow::Continue(Some(installation_task)) => {
-                log::info!("Waiting for default prettier to install");
-                if let Err(e) = installation_task.await {
-                    project.update(&mut cx, |project, _| {
-                        if let PrettierInstallation::NotInstalled {
-                            installation_task,
-                            attempts,
-                            ..
-                        } = &mut project.default_prettier.prettier
-                        {
-                            *installation_task = None;
-                            *attempts += 1;
-                        }
-                    })?;
-                    anyhow::bail!(
-                        "Cannot start default prettier due to its installation failure: {e:#}"
-                    );
+    fn start_default_prettier(
+        node: Arc<dyn NodeRuntime>,
+        worktree_id: Option<WorktreeId>,
+        cx: &mut ModelContext<PrettierStore>,
+    ) -> Task<anyhow::Result<PrettierTask>> {
+        cx.spawn(|prettier_store, mut cx| async move {
+            let installation_task = prettier_store.update(&mut cx, |prettier_store, _| {
+                match &prettier_store.default_prettier.prettier {
+                    PrettierInstallation::NotInstalled {
+                        installation_task, ..
+                    } => ControlFlow::Continue(installation_task.clone()),
+                    PrettierInstallation::Installed(default_prettier) => {
+                        ControlFlow::Break(default_prettier.clone())
+                    }
+                }
+            })?;
+            match installation_task {
+                ControlFlow::Continue(None) => {
+                    anyhow::bail!("Default prettier is not installed and cannot be started")
                 }
-                let new_default_prettier = project.update(&mut cx, |project, cx| {
+                ControlFlow::Continue(Some(installation_task)) => {
+                    log::info!("Waiting for default prettier to install");
+                    if let Err(e) = installation_task.await {
+                        prettier_store.update(&mut cx, |project, _| {
+                            if let PrettierInstallation::NotInstalled {
+                                installation_task,
+                                attempts,
+                                ..
+                            } = &mut project.default_prettier.prettier
+                            {
+                                *installation_task = None;
+                                *attempts += 1;
+                            }
+                        })?;
+                        anyhow::bail!(
+                            "Cannot start default prettier due to its installation failure: {e:#}"
+                        );
+                    }
                     let new_default_prettier =
-                        start_prettier(node, default_prettier_dir().clone(), worktree_id, cx);
-                    project.default_prettier.prettier =
-                        PrettierInstallation::Installed(PrettierInstance {
-                            attempt: 0,
-                            prettier: Some(new_default_prettier.clone()),
-                        });
-                    new_default_prettier
-                })?;
-                Ok(new_default_prettier)
-            }
-            ControlFlow::Break(instance) => match instance.prettier {
-                Some(instance) => Ok(instance),
-                None => {
-                    let new_default_prettier = project.update(&mut cx, |project, cx| {
-                        let new_default_prettier =
-                            start_prettier(node, default_prettier_dir().clone(), worktree_id, cx);
-                        project.default_prettier.prettier =
-                            PrettierInstallation::Installed(PrettierInstance {
-                                attempt: instance.attempt + 1,
-                                prettier: Some(new_default_prettier.clone()),
-                            });
-                        new_default_prettier
-                    })?;
+                        prettier_store.update(&mut cx, |prettier_store, cx| {
+                            let new_default_prettier = Self::start_prettier(
+                                node,
+                                default_prettier_dir().clone(),
+                                worktree_id,
+                                cx,
+                            );
+                            prettier_store.default_prettier.prettier =
+                                PrettierInstallation::Installed(PrettierInstance {
+                                    attempt: 0,
+                                    prettier: Some(new_default_prettier.clone()),
+                                });
+                            new_default_prettier
+                        })?;
                     Ok(new_default_prettier)
                 }
-            },
-        }
-    })
-}
-
-fn start_prettier(
-    node: Arc<dyn NodeRuntime>,
-    prettier_dir: PathBuf,
-    worktree_id: Option<WorktreeId>,
-    cx: &mut ModelContext<'_, Project>,
-) -> PrettierTask {
-    cx.spawn(|project, mut cx| async move {
-        log::info!("Starting prettier at path {prettier_dir:?}");
-        let new_server_id = project.update(&mut cx, |project, _| {
-            project.languages.next_language_server_id()
-        })?;
-
-        let new_prettier = Prettier::start(new_server_id, prettier_dir, node, cx.clone())
-            .await
-            .context("default prettier spawn")
-            .map(Arc::new)
-            .map_err(Arc::new)?;
-        register_new_prettier(&project, &new_prettier, worktree_id, new_server_id, &mut cx);
-        Ok(new_prettier)
-    })
-    .shared()
-}
-
-fn register_new_prettier(
-    project: &WeakModel<Project>,
-    prettier: &Prettier,
-    worktree_id: Option<WorktreeId>,
-    new_server_id: LanguageServerId,
-    cx: &mut AsyncAppContext,
-) {
-    let prettier_dir = prettier.prettier_dir();
-    let is_default = prettier.is_default();
-    if is_default {
-        log::info!("Started default prettier in {prettier_dir:?}");
-    } else {
-        log::info!("Started prettier in {prettier_dir:?}");
+                ControlFlow::Break(instance) => match instance.prettier {
+                    Some(instance) => Ok(instance),
+                    None => {
+                        let new_default_prettier =
+                            prettier_store.update(&mut cx, |prettier_store, cx| {
+                                let new_default_prettier = Self::start_prettier(
+                                    node,
+                                    default_prettier_dir().clone(),
+                                    worktree_id,
+                                    cx,
+                                );
+                                prettier_store.default_prettier.prettier =
+                                    PrettierInstallation::Installed(PrettierInstance {
+                                        attempt: instance.attempt + 1,
+                                        prettier: Some(new_default_prettier.clone()),
+                                    });
+                                new_default_prettier
+                            })?;
+                        Ok(new_default_prettier)
+                    }
+                },
+            }
+        })
     }
-    if let Some(prettier_server) = prettier.server() {
-        project
-            .update(cx, |project, cx| {
-                let name = if is_default {
-                    LanguageServerName(Arc::from("prettier (default)"))
-                } else {
-                    let worktree_path = worktree_id
-                        .and_then(|id| project.worktree_for_id(id, cx))
-                        .map(|worktree| worktree.update(cx, |worktree, _| worktree.abs_path()));
-                    let name = match worktree_path {
-                        Some(worktree_path) => {
-                            if prettier_dir == worktree_path.as_ref() {
-                                let name = prettier_dir
-                                    .file_name()
-                                    .and_then(|name| name.to_str())
-                                    .unwrap_or_default();
-                                format!("prettier ({name})")
-                            } else {
-                                let dir_to_display = prettier_dir
-                                    .strip_prefix(worktree_path.as_ref())
-                                    .ok()
-                                    .unwrap_or(prettier_dir);
-                                format!("prettier ({})", dir_to_display.display())
+
+    fn register_new_prettier(
+        prettier_store: &WeakModel<Self>,
+        prettier: &Prettier,
+        worktree_id: Option<WorktreeId>,
+        new_server_id: LanguageServerId,
+        cx: &mut AsyncAppContext,
+    ) {
+        let prettier_dir = prettier.prettier_dir();
+        let is_default = prettier.is_default();
+        if is_default {
+            log::info!("Started default prettier in {prettier_dir:?}");
+        } else {
+            log::info!("Started prettier in {prettier_dir:?}");
+        }
+        if let Some(prettier_server) = prettier.server() {
+            prettier_store
+                .update(cx, |prettier_store, cx| {
+                    let name = if is_default {
+                        LanguageServerName(Arc::from("prettier (default)"))
+                    } else {
+                        let worktree_path = worktree_id
+                            .and_then(|id| {
+                                prettier_store
+                                    .worktree_store
+                                    .read(cx)
+                                    .worktree_for_id(id, cx)
+                            })
+                            .map(|worktree| worktree.update(cx, |worktree, _| worktree.abs_path()));
+                        let name = match worktree_path {
+                            Some(worktree_path) => {
+                                if prettier_dir == worktree_path.as_ref() {
+                                    let name = prettier_dir
+                                        .file_name()
+                                        .and_then(|name| name.to_str())
+                                        .unwrap_or_default();
+                                    format!("prettier ({name})")
+                                } else {
+                                    let dir_to_display = prettier_dir
+                                        .strip_prefix(worktree_path.as_ref())
+                                        .ok()
+                                        .unwrap_or(prettier_dir);
+                                    format!("prettier ({})", dir_to_display.display())
+                                }
                             }
-                        }
-                        None => format!("prettier ({})", prettier_dir.display()),
+                            None => format!("prettier ({})", prettier_dir.display()),
+                        };
+                        LanguageServerName(Arc::from(name))
                     };
-                    LanguageServerName(Arc::from(name))
-                };
-                project.lsp_store.update(cx, |lsp_store, cx| {
-                    lsp_store.register_supplementary_language_server(
+                    cx.emit(PrettierStoreEvent::LanguageServerAdded {
                         new_server_id,
                         name,
-                        Arc::clone(prettier_server),
-                        cx,
-                    )
-                });
-            })
-            .ok();
-    }
-}
-
-async fn install_prettier_packages(
-    fs: &dyn Fs,
-    plugins_to_install: HashSet<Arc<str>>,
-    node: Arc<dyn NodeRuntime>,
-) -> anyhow::Result<()> {
-    let packages_to_versions = future::try_join_all(
-        plugins_to_install
-            .iter()
-            .chain(Some(&"prettier".into()))
-            .map(|package_name| async {
-                let returned_package_name = package_name.to_string();
-                let latest_version = node
-                    .npm_package_latest_version(package_name)
-                    .await
-                    .with_context(|| {
-                        format!("fetching latest npm version for package {returned_package_name}")
-                    })?;
-                anyhow::Ok((returned_package_name, latest_version))
-            }),
-    )
-    .await
-    .context("fetching latest npm versions")?;
-
-    let default_prettier_dir = default_prettier_dir().as_path();
-    match fs.metadata(default_prettier_dir).await.with_context(|| {
-        format!("fetching FS metadata for default prettier dir {default_prettier_dir:?}")
-    })? {
-        Some(prettier_dir_metadata) => anyhow::ensure!(
-            prettier_dir_metadata.is_dir,
-            "default prettier dir {default_prettier_dir:?} is not a directory"
-        ),
-        None => fs
-            .create_dir(default_prettier_dir)
-            .await
-            .with_context(|| format!("creating default prettier dir {default_prettier_dir:?}"))?,
-    }
-
-    log::info!("Installing default prettier and plugins: {packages_to_versions:?}");
-    let borrowed_packages = packages_to_versions
-        .iter()
-        .map(|(package, version)| (package.as_str(), version.as_str()))
-        .collect::<Vec<_>>();
-    node.npm_install_packages(default_prettier_dir, &borrowed_packages)
-        .await
-        .context("fetching formatter packages")?;
-    anyhow::Ok(())
-}
-
-async fn save_prettier_server_file(fs: &dyn Fs) -> anyhow::Result<()> {
-    let prettier_wrapper_path = default_prettier_dir().join(prettier::PRETTIER_SERVER_FILE);
-    fs.save(
-        &prettier_wrapper_path,
-        &text::Rope::from(prettier::PRETTIER_SERVER_JS),
-        text::LineEnding::Unix,
-    )
-    .await
-    .with_context(|| {
-        format!(
-            "writing {} file at {prettier_wrapper_path:?}",
-            prettier::PRETTIER_SERVER_FILE
-        )
-    })?;
-    Ok(())
-}
-
-async fn should_write_prettier_server_file(fs: &dyn Fs) -> bool {
-    let prettier_wrapper_path = default_prettier_dir().join(prettier::PRETTIER_SERVER_FILE);
-    if !fs.is_file(&prettier_wrapper_path).await {
-        return true;
+                        prettier_server: prettier_server.clone(),
+                    });
+                })
+                .ok();
+        }
     }
-    let Ok(prettier_server_file_contents) = fs.load(&prettier_wrapper_path).await else {
-        return true;
-    };
-    prettier_server_file_contents != prettier::PRETTIER_SERVER_JS
-}
 
-impl Project {
     pub fn update_prettier_settings(
         &self,
         worktree: &Model<Worktree>,
         changes: &[(Arc<Path>, ProjectEntryId, PathChange)],
-        cx: &mut ModelContext<'_, Project>,
+        cx: &mut ModelContext<Self>,
     ) {
         let prettier_config_files = Prettier::CONFIG_FILE_NAMES
             .iter()
@@ -510,122 +450,6 @@ impl Project {
         }
     }
 
-    fn prettier_instance_for_buffer(
-        &mut self,
-        buffer: &Model<Buffer>,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Option<(Option<PathBuf>, PrettierTask)>> {
-        // todo(ssh remote): prettier support
-        if self.is_via_collab() || self.ssh_session.is_some() {
-            return Task::ready(None);
-        }
-        let buffer = buffer.read(cx);
-        let buffer_file = buffer.file();
-        if buffer.language().is_none() {
-            return Task::ready(None);
-        }
-        let Some(node) = self.node.clone() else {
-            return Task::ready(None);
-        };
-        match File::from_dyn(buffer_file).map(|file| (file.worktree_id(cx), file.abs_path(cx))) {
-            Some((worktree_id, buffer_path)) => {
-                let fs = Arc::clone(&self.fs);
-                let installed_prettiers = self.prettier_instances.keys().cloned().collect();
-                cx.spawn(|project, mut cx| async move {
-                    match cx
-                        .background_executor()
-                        .spawn(async move {
-                            Prettier::locate_prettier_installation(
-                                fs.as_ref(),
-                                &installed_prettiers,
-                                &buffer_path,
-                            )
-                            .await
-                        })
-                        .await
-                    {
-                        Ok(ControlFlow::Break(())) => None,
-                        Ok(ControlFlow::Continue(None)) => {
-                            let default_instance = project
-                                .update(&mut cx, |project, cx| {
-                                    project
-                                        .prettiers_per_worktree
-                                        .entry(worktree_id)
-                                        .or_default()
-                                        .insert(None);
-                                    project.default_prettier.prettier_task(
-                                        &node,
-                                        Some(worktree_id),
-                                        cx,
-                                    )
-                                })
-                                .ok()?;
-                            Some((None, default_instance?.log_err().await?))
-                        }
-                        Ok(ControlFlow::Continue(Some(prettier_dir))) => {
-                            project
-                                .update(&mut cx, |project, _| {
-                                    project
-                                        .prettiers_per_worktree
-                                        .entry(worktree_id)
-                                        .or_default()
-                                        .insert(Some(prettier_dir.clone()))
-                                })
-                                .ok()?;
-                            if let Some(prettier_task) = project
-                                .update(&mut cx, |project, cx| {
-                                    project.prettier_instances.get_mut(&prettier_dir).map(
-                                        |existing_instance| {
-                                            existing_instance.prettier_task(
-                                                &node,
-                                                Some(&prettier_dir),
-                                                Some(worktree_id),
-                                                cx,
-                                            )
-                                        },
-                                    )
-                                })
-                                .ok()?
-                            {
-                                log::debug!("Found already started prettier in {prettier_dir:?}");
-                                return Some((Some(prettier_dir), prettier_task?.await.log_err()?));
-                            }
-
-                            log::info!("Found prettier in {prettier_dir:?}, starting.");
-                            let new_prettier_task = project
-                                .update(&mut cx, |project, cx| {
-                                    let new_prettier_task = start_prettier(
-                                        node,
-                                        prettier_dir.clone(),
-                                        Some(worktree_id),
-                                        cx,
-                                    );
-                                    project.prettier_instances.insert(
-                                        prettier_dir.clone(),
-                                        PrettierInstance {
-                                            attempt: 0,
-                                            prettier: Some(new_prettier_task.clone()),
-                                        },
-                                    );
-                                    new_prettier_task
-                                })
-                                .ok()?;
-                            Some((Some(prettier_dir), new_prettier_task))
-                        }
-                        Err(e) => {
-                            log::error!("Failed to determine prettier path for buffer: {e:#}");
-                            None
-                        }
-                    }
-                })
-            }
-            None => {
-                let new_task = self.default_prettier.prettier_task(&node, None, cx);
-                cx.spawn(|_, _| async move { Some((None, new_task?.log_err().await?)) })
-            }
-        }
-    }
-
     pub fn install_default_prettier(
         &mut self,
         worktree: Option<WorktreeId>,
@@ -642,12 +466,13 @@ impl Project {
         }
 
         let mut new_plugins = plugins.collect::<HashSet<_>>();
-        let Some(node) = self.node.as_ref().cloned() else {
-            return;
-        };
+        let node = self.node.clone();
+
         let fs = Arc::clone(&self.fs);
         let locate_prettier_installation = match worktree.and_then(|worktree_id| {
-            self.worktree_for_id(worktree_id, cx)
+            self.worktree_store
+                .read(cx)
+                .worktree_for_id(worktree_id, cx)
                 .map(|worktree| worktree.read(cx).abs_path())
         }) {
             Some(locate_from) => {
@@ -777,4 +602,291 @@ impl Project {
             not_installed_plugins: plugins_to_install,
         };
     }
+
+    pub fn on_settings_changed(
+        &mut self,
+        language_formatters_to_check: Vec<(Option<WorktreeId>, LanguageSettings)>,
+        cx: &mut ModelContext<Self>,
+    ) {
+        let mut prettier_plugins_by_worktree = HashMap::default();
+        for (worktree, language_settings) in language_formatters_to_check {
+            if let Some(plugins) = prettier_plugins_for_language(&language_settings) {
+                prettier_plugins_by_worktree
+                    .entry(worktree)
+                    .or_insert_with(HashSet::default)
+                    .extend(plugins.iter().cloned());
+            }
+        }
+        for (worktree, prettier_plugins) in prettier_plugins_by_worktree {
+            self.install_default_prettier(
+                worktree,
+                prettier_plugins.into_iter().map(Arc::from),
+                cx,
+            );
+        }
+    }
+}
+
+pub fn prettier_plugins_for_language(
+    language_settings: &LanguageSettings,
+) -> Option<&HashSet<String>> {
+    match &language_settings.formatter {
+        SelectedFormatter::Auto => Some(&language_settings.prettier.plugins),
+
+        SelectedFormatter::List(list) => list
+            .as_ref()
+            .contains(&Formatter::Prettier)
+            .then_some(&language_settings.prettier.plugins),
+    }
+}
+
+pub(super) async fn format_with_prettier(
+    prettier_store: &WeakModel<PrettierStore>,
+    buffer: &Model<Buffer>,
+    cx: &mut AsyncAppContext,
+) -> Option<Result<FormatOperation>> {
+    let prettier_instance = prettier_store
+        .update(cx, |prettier_store, cx| {
+            prettier_store.prettier_instance_for_buffer(buffer, cx)
+        })
+        .ok()?
+        .await;
+
+    let (prettier_path, prettier_task) = prettier_instance?;
+
+    let prettier_description = match prettier_path.as_ref() {
+        Some(path) => format!("prettier at {path:?}"),
+        None => "default prettier instance".to_string(),
+    };
+
+    match prettier_task.await {
+        Ok(prettier) => {
+            let buffer_path = buffer
+                .update(cx, |buffer, cx| {
+                    File::from_dyn(buffer.file()).map(|file| file.abs_path(cx))
+                })
+                .ok()
+                .flatten();
+
+            let format_result = prettier
+                .format(buffer, buffer_path, cx)
+                .await
+                .map(FormatOperation::Prettier)
+                .with_context(|| format!("{} failed to format buffer", prettier_description));
+
+            Some(format_result)
+        }
+        Err(error) => {
+            prettier_store
+                .update(cx, |project, _| {
+                    let instance_to_update = match prettier_path {
+                        Some(prettier_path) => project.prettier_instances.get_mut(&prettier_path),
+                        None => match &mut project.default_prettier.prettier {
+                            PrettierInstallation::NotInstalled { .. } => None,
+                            PrettierInstallation::Installed(instance) => Some(instance),
+                        },
+                    };
+
+                    if let Some(instance) = instance_to_update {
+                        instance.attempt += 1;
+                        instance.prettier = None;
+                    }
+                })
+                .log_err();
+
+            Some(Err(anyhow!(
+                "{} failed to spawn: {error:#}",
+                prettier_description
+            )))
+        }
+    }
+}
+
+pub struct DefaultPrettier {
+    prettier: PrettierInstallation,
+    installed_plugins: HashSet<Arc<str>>,
+}
+
+#[derive(Debug)]
+pub enum PrettierInstallation {
+    NotInstalled {
+        attempts: usize,
+        installation_task: Option<Shared<Task<Result<(), Arc<anyhow::Error>>>>>,
+        not_installed_plugins: HashSet<Arc<str>>,
+    },
+    Installed(PrettierInstance),
+}
+
+pub type PrettierTask = Shared<Task<Result<Arc<Prettier>, Arc<anyhow::Error>>>>;
+
+#[derive(Debug, Clone)]
+pub struct PrettierInstance {
+    attempt: usize,
+    prettier: Option<PrettierTask>,
+}
+
+impl Default for DefaultPrettier {
+    fn default() -> Self {
+        Self {
+            prettier: PrettierInstallation::NotInstalled {
+                attempts: 0,
+                installation_task: None,
+                not_installed_plugins: HashSet::default(),
+            },
+            installed_plugins: HashSet::default(),
+        }
+    }
+}
+
+impl DefaultPrettier {
+    pub fn instance(&self) -> Option<&PrettierInstance> {
+        if let PrettierInstallation::Installed(instance) = &self.prettier {
+            Some(instance)
+        } else {
+            None
+        }
+    }
+
+    pub fn prettier_task(
+        &mut self,
+        node: &Arc<dyn NodeRuntime>,
+        worktree_id: Option<WorktreeId>,
+        cx: &mut ModelContext<PrettierStore>,
+    ) -> Option<Task<anyhow::Result<PrettierTask>>> {
+        match &mut self.prettier {
+            PrettierInstallation::NotInstalled { .. } => Some(
+                PrettierStore::start_default_prettier(node.clone(), worktree_id, cx),
+            ),
+            PrettierInstallation::Installed(existing_instance) => {
+                existing_instance.prettier_task(node, None, worktree_id, cx)
+            }
+        }
+    }
+}
+
+impl PrettierInstance {
+    pub fn prettier_task(
+        &mut self,
+        node: &Arc<dyn NodeRuntime>,
+        prettier_dir: Option<&Path>,
+        worktree_id: Option<WorktreeId>,
+        cx: &mut ModelContext<PrettierStore>,
+    ) -> Option<Task<anyhow::Result<PrettierTask>>> {
+        if self.attempt > prettier::FAIL_THRESHOLD {
+            match prettier_dir {
+                Some(prettier_dir) => log::warn!(
+                    "Prettier from path {prettier_dir:?} exceeded launch threshold, not starting"
+                ),
+                None => log::warn!("Default prettier exceeded launch threshold, not starting"),
+            }
+            return None;
+        }
+        Some(match &self.prettier {
+            Some(prettier_task) => Task::ready(Ok(prettier_task.clone())),
+            None => match prettier_dir {
+                Some(prettier_dir) => {
+                    let new_task = PrettierStore::start_prettier(
+                        Arc::clone(node),
+                        prettier_dir.to_path_buf(),
+                        worktree_id,
+                        cx,
+                    );
+                    self.attempt += 1;
+                    self.prettier = Some(new_task.clone());
+                    Task::ready(Ok(new_task))
+                }
+                None => {
+                    self.attempt += 1;
+                    let node = Arc::clone(node);
+                    cx.spawn(|prettier_store, mut cx| async move {
+                        prettier_store
+                            .update(&mut cx, |_, cx| {
+                                PrettierStore::start_default_prettier(node, worktree_id, cx)
+                            })?
+                            .await
+                    })
+                }
+            },
+        })
+    }
+
+    pub async fn server(&self) -> Option<Arc<LanguageServer>> {
+        self.prettier.clone()?.await.ok()?.server().cloned()
+    }
+}
+
+async fn install_prettier_packages(
+    fs: &dyn Fs,
+    plugins_to_install: HashSet<Arc<str>>,
+    node: Arc<dyn NodeRuntime>,
+) -> anyhow::Result<()> {
+    let packages_to_versions = future::try_join_all(
+        plugins_to_install
+            .iter()
+            .chain(Some(&"prettier".into()))
+            .map(|package_name| async {
+                let returned_package_name = package_name.to_string();
+                let latest_version = node
+                    .npm_package_latest_version(package_name)
+                    .await
+                    .with_context(|| {
+                        format!("fetching latest npm version for package {returned_package_name}")
+                    })?;
+                anyhow::Ok((returned_package_name, latest_version))
+            }),
+    )
+    .await
+    .context("fetching latest npm versions")?;
+
+    let default_prettier_dir = default_prettier_dir().as_path();
+    match fs.metadata(default_prettier_dir).await.with_context(|| {
+        format!("fetching FS metadata for default prettier dir {default_prettier_dir:?}")
+    })? {
+        Some(prettier_dir_metadata) => anyhow::ensure!(
+            prettier_dir_metadata.is_dir,
+            "default prettier dir {default_prettier_dir:?} is not a directory"
+        ),
+        None => fs
+            .create_dir(default_prettier_dir)
+            .await
+            .with_context(|| format!("creating default prettier dir {default_prettier_dir:?}"))?,
+    }
+
+    log::info!("Installing default prettier and plugins: {packages_to_versions:?}");
+    let borrowed_packages = packages_to_versions
+        .iter()
+        .map(|(package, version)| (package.as_str(), version.as_str()))
+        .collect::<Vec<_>>();
+    node.npm_install_packages(default_prettier_dir, &borrowed_packages)
+        .await
+        .context("fetching formatter packages")?;
+    anyhow::Ok(())
+}
+
+async fn save_prettier_server_file(fs: &dyn Fs) -> anyhow::Result<()> {
+    let prettier_wrapper_path = default_prettier_dir().join(prettier::PRETTIER_SERVER_FILE);
+    fs.save(
+        &prettier_wrapper_path,
+        &text::Rope::from(prettier::PRETTIER_SERVER_JS),
+        text::LineEnding::Unix,
+    )
+    .await
+    .with_context(|| {
+        format!(
+            "writing {} file at {prettier_wrapper_path:?}",
+            prettier::PRETTIER_SERVER_FILE
+        )
+    })?;
+    Ok(())
+}
+
+async fn should_write_prettier_server_file(fs: &dyn Fs) -> bool {
+    let prettier_wrapper_path = default_prettier_dir().join(prettier::PRETTIER_SERVER_FILE);
+    if !fs.is_file(&prettier_wrapper_path).await {
+        return true;
+    }
+    let Ok(prettier_server_file_contents) = fs.load(&prettier_wrapper_path).await else {
+        return true;
+    };
+    prettier_server_file_contents != prettier::PRETTIER_SERVER_JS
 }
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 4318737e3875b8..f4816cf0cde66f 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -4,7 +4,7 @@ pub mod debounced_delay;
 pub mod lsp_command;
 pub mod lsp_ext_command;
 pub mod lsp_store;
-mod prettier_support;
+pub mod prettier_store;
 pub mod project_settings;
 pub mod search;
 mod task_inventory;
@@ -31,7 +31,6 @@ pub use environment::ProjectEnvironment;
 use futures::{
     channel::mpsc::{self, UnboundedReceiver},
     future::try_join_all,
-    stream::FuturesUnordered,
     AsyncWriteExt, FutureExt, StreamExt,
 };
 
@@ -59,8 +58,8 @@ use lsp_command::*;
 use node_runtime::NodeRuntime;
 use parking_lot::{Mutex, RwLock};
 use paths::{local_tasks_file_relative_path, local_vscode_tasks_file_relative_path};
-use prettier_support::{DefaultPrettier, PrettierInstance};
-use project_settings::{LspSettings, ProjectSettings, SettingsObserver};
+pub use prettier_store::PrettierStore;
+use project_settings::{ProjectSettings, SettingsObserver};
 use remote::SshSession;
 use rpc::{proto::SSH_PROJECT_ID, AnyProtoClient, ErrorCode};
 use search::{SearchInputKind, SearchQuery, SearchResult};
@@ -140,7 +139,6 @@ pub struct Project {
     buffer_ordered_messages_tx: mpsc::UnboundedSender<BufferOrderedMessage>,
     languages: Arc<LanguageRegistry>,
     client: Arc<client::Client>,
-    current_lsp_settings: HashMap<Arc<str>, LspSettings>,
     join_project_response_message_id: u32,
     user_store: Model<UserStore>,
     fs: Arc<dyn Fs>,
@@ -157,9 +155,6 @@ pub struct Project {
     remotely_created_buffers: Arc<Mutex<RemotelyCreatedBuffers>>,
     terminals: Terminals,
     node: Option<Arc<dyn NodeRuntime>>,
-    default_prettier: DefaultPrettier,
-    prettiers_per_worktree: HashMap<WorktreeId, HashSet<Option<PathBuf>>>,
-    prettier_instances: HashMap<PathBuf, PrettierInstance>,
     tasks: Model<Inventory>,
     hosted_project_id: Option<ProjectId>,
     dev_server_project_id: Option<client::DevServerProjectId>,
@@ -634,6 +629,16 @@ impl Project {
             cx.subscribe(&buffer_store, Self::on_buffer_store_event)
                 .detach();
 
+            let prettier_store = cx.new_model(|cx| {
+                PrettierStore::new(
+                    node.clone(),
+                    fs.clone(),
+                    languages.clone(),
+                    worktree_store.clone(),
+                    cx,
+                )
+            });
+
             let settings_observer = cx.new_model(|cx| {
                 SettingsObserver::new_local(fs.clone(), worktree_store.clone(), cx)
             });
@@ -643,6 +648,7 @@ impl Project {
                 LspStore::new_local(
                     buffer_store.clone(),
                     worktree_store.clone(),
+                    prettier_store.clone(),
                     environment.clone(),
                     languages.clone(),
                     Some(client.http_client()),
@@ -658,14 +664,10 @@ impl Project {
                 worktree_store,
                 buffer_store,
                 lsp_store,
-                current_lsp_settings: ProjectSettings::get_global(cx).lsp.clone(),
                 join_project_response_message_id: 0,
                 client_state: ProjectClientState::Local,
                 client_subscriptions: Vec::new(),
-                _subscriptions: vec![
-                    cx.observe_global::<SettingsStore>(Self::on_settings_changed),
-                    cx.on_release(Self::release),
-                ],
+                _subscriptions: vec![cx.on_release(Self::release)],
                 active_entry: None,
                 snippets,
                 languages,
@@ -680,9 +682,6 @@ impl Project {
                     local_handles: Vec::new(),
                 },
                 node: Some(node),
-                default_prettier: DefaultPrettier::default(),
-                prettiers_per_worktree: HashMap::default(),
-                prettier_instances: HashMap::default(),
                 tasks,
                 hosted_project_id: None,
                 dev_server_project_id: None,
@@ -751,14 +750,10 @@ impl Project {
                 worktree_store,
                 buffer_store,
                 lsp_store,
-                current_lsp_settings: ProjectSettings::get_global(cx).lsp.clone(),
                 join_project_response_message_id: 0,
                 client_state: ProjectClientState::Local,
                 client_subscriptions: Vec::new(),
-                _subscriptions: vec![
-                    cx.observe_global::<SettingsStore>(Self::on_settings_changed),
-                    cx.on_release(Self::release),
-                ],
+                _subscriptions: vec![cx.on_release(Self::release)],
                 active_entry: None,
                 snippets,
                 languages,
@@ -773,9 +768,6 @@ impl Project {
                     local_handles: Vec::new(),
                 },
                 node: Some(node),
-                default_prettier: DefaultPrettier::default(),
-                prettiers_per_worktree: HashMap::default(),
-                prettier_instances: HashMap::default(),
                 tasks,
                 hosted_project_id: None,
                 dev_server_project_id: None,
@@ -928,7 +920,6 @@ impl Project {
                 buffer_store: buffer_store.clone(),
                 worktree_store: worktree_store.clone(),
                 lsp_store: lsp_store.clone(),
-                current_lsp_settings: ProjectSettings::get_global(cx).lsp.clone(),
                 active_entry: None,
                 collaborators: Default::default(),
                 join_project_response_message_id: response.message_id,
@@ -954,9 +945,6 @@ impl Project {
                     local_handles: Vec::new(),
                 },
                 node: None,
-                default_prettier: DefaultPrettier::default(),
-                prettiers_per_worktree: HashMap::default(),
-                prettier_instances: HashMap::default(),
                 tasks,
                 hosted_project_id: None,
                 dev_server_project_id: response
@@ -1176,112 +1164,6 @@ impl Project {
         self.worktree_store.clone()
     }
 
-    fn on_settings_changed(&mut self, cx: &mut ModelContext<Self>) {
-        let mut language_servers_to_start = Vec::new();
-        let mut language_formatters_to_check = Vec::new();
-        for buffer in self.buffer_store.read(cx).buffers() {
-            let buffer = buffer.read(cx);
-            let buffer_file = File::from_dyn(buffer.file());
-            let buffer_language = buffer.language();
-            let settings = language_settings(buffer_language, buffer.file(), cx);
-            if let Some(language) = buffer_language {
-                if settings.enable_language_server {
-                    if let Some(file) = buffer_file {
-                        language_servers_to_start.push((file.worktree.clone(), language.name()));
-                    }
-                }
-                language_formatters_to_check
-                    .push((buffer_file.map(|f| f.worktree_id(cx)), settings.clone()));
-            }
-        }
-
-        let mut language_servers_to_stop = Vec::new();
-        let mut language_servers_to_restart = Vec::new();
-        let languages = self.languages.to_vec();
-
-        let new_lsp_settings = ProjectSettings::get_global(cx).lsp.clone();
-        let current_lsp_settings = &self.current_lsp_settings;
-        for (worktree_id, started_lsp_name) in self.lsp_store.read(cx).started_language_servers() {
-            let language = languages.iter().find_map(|l| {
-                let adapter = self
-                    .languages
-                    .lsp_adapters(&l.name())
-                    .iter()
-                    .find(|adapter| adapter.name == started_lsp_name)?
-                    .clone();
-                Some((l, adapter))
-            });
-            if let Some((language, adapter)) = language {
-                let worktree = self.worktree_for_id(worktree_id, cx);
-                let file = worktree.as_ref().and_then(|tree| {
-                    tree.update(cx, |tree, cx| tree.root_file(cx).map(|f| f as _))
-                });
-                if !language_settings(Some(language), file.as_ref(), cx).enable_language_server {
-                    language_servers_to_stop.push((worktree_id, started_lsp_name.clone()));
-                } else if let Some(worktree) = worktree {
-                    let server_name = &adapter.name.0;
-                    match (
-                        current_lsp_settings.get(server_name),
-                        new_lsp_settings.get(server_name),
-                    ) {
-                        (None, None) => {}
-                        (Some(_), None) | (None, Some(_)) => {
-                            language_servers_to_restart.push((worktree, language.name()));
-                        }
-                        (Some(current_lsp_settings), Some(new_lsp_settings)) => {
-                            if current_lsp_settings != new_lsp_settings {
-                                language_servers_to_restart.push((worktree, language.name()));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        self.current_lsp_settings = new_lsp_settings;
-
-        // Stop all newly-disabled language servers.
-        self.lsp_store.update(cx, |lsp_store, cx| {
-            for (worktree_id, adapter_name) in language_servers_to_stop {
-                lsp_store
-                    .stop_language_server(worktree_id, adapter_name, cx)
-                    .detach();
-            }
-        });
-
-        let mut prettier_plugins_by_worktree = HashMap::default();
-        for (worktree, language_settings) in language_formatters_to_check {
-            if let Some(plugins) =
-                prettier_support::prettier_plugins_for_language(&language_settings)
-            {
-                prettier_plugins_by_worktree
-                    .entry(worktree)
-                    .or_insert_with(HashSet::default)
-                    .extend(plugins.iter().cloned());
-            }
-        }
-        for (worktree, prettier_plugins) in prettier_plugins_by_worktree {
-            self.install_default_prettier(
-                worktree,
-                prettier_plugins.into_iter().map(Arc::from),
-                cx,
-            );
-        }
-
-        // Start all the newly-enabled language servers.
-        self.lsp_store.update(cx, |lsp_store, cx| {
-            for (worktree, language) in language_servers_to_start {
-                lsp_store.start_language_servers(&worktree, language, cx);
-            }
-
-            // Restart all language servers with changed initialization options.
-            for (worktree, language) in language_servers_to_restart {
-                lsp_store.restart_language_servers(worktree, language, cx);
-            }
-        });
-
-        cx.notify();
-    }
-
     pub fn buffer_for_id(&self, remote_id: BufferId, cx: &AppContext) -> Option<Model<Buffer>> {
         self.buffer_store.read(cx).get(remote_id)
     }
@@ -2160,24 +2042,10 @@ impl Project {
                 buffer,
                 new_language,
             } => {
-                let Some(new_language) = new_language else {
+                let Some(_) = new_language else {
                     cx.emit(Event::LanguageNotFound(buffer.clone()));
                     return;
                 };
-                let buffer_file = buffer.read(cx).file().cloned();
-                let settings =
-                    language_settings(Some(new_language), buffer_file.as_ref(), cx).clone();
-                let buffer_file = File::from_dyn(buffer_file.as_ref());
-                let worktree = buffer_file.as_ref().map(|f| f.worktree_id(cx));
-                if let Some(prettier_plugins) =
-                    prettier_support::prettier_plugins_for_language(&settings)
-                {
-                    self.install_default_prettier(
-                        worktree,
-                        prettier_plugins.iter().map(|s| Arc::from(s.as_str())),
-                        cx,
-                    );
-                };
             }
             LspStoreEvent::RefreshInlayHints => cx.emit(Event::RefreshInlayHints),
             LspStoreEvent::LanguageServerPrompt(prompt) => {
@@ -2253,7 +2121,6 @@ impl Project {
                 worktree::Event::UpdatedEntries(changes) => {
                     if is_local {
                         this.update_local_worktree_settings(&worktree, changes, cx);
-                        this.update_prettier_settings(&worktree, changes, cx);
                     }
 
                     cx.emit(Event::WorktreeUpdatedEntries(
@@ -2300,37 +2167,6 @@ impl Project {
             return;
         }
 
-        let mut prettier_instances_to_clean = FuturesUnordered::new();
-        if let Some(prettier_paths) = self.prettiers_per_worktree.remove(&id_to_remove) {
-            for path in prettier_paths.iter().flatten() {
-                if let Some(prettier_instance) = self.prettier_instances.remove(path) {
-                    prettier_instances_to_clean.push(async move {
-                        prettier_instance
-                            .server()
-                            .await
-                            .map(|server| server.server_id())
-                    });
-                }
-            }
-        }
-        cx.spawn(|project, mut cx| async move {
-            while let Some(prettier_server_id) = prettier_instances_to_clean.next().await {
-                if let Some(prettier_server_id) = prettier_server_id {
-                    project
-                        .update(&mut cx, |project, cx| {
-                            project.lsp_store.update(cx, |lsp_store, cx| {
-                                lsp_store.unregister_supplementary_language_server(
-                                    prettier_server_id,
-                                    cx,
-                                );
-                            });
-                        })
-                        .ok();
-                }
-            }
-        })
-        .detach();
-
         self.task_inventory().update(cx, |inventory, _| {
             inventory.remove_worktree_sources(id_to_remove);
         });
@@ -3059,11 +2895,21 @@ impl Project {
                     None
                 }
             }
-            Formatter::Prettier => prettier_support::format_with_prettier(&project, buffer, cx)
-                .await
-                .transpose()
-                .ok()
-                .flatten(),
+            Formatter::Prettier => {
+                let prettier = project.update(cx, |project, cx| {
+                    project
+                        .lsp_store
+                        .read(cx)
+                        .prettier_store()
+                        .unwrap()
+                        .downgrade()
+                })?;
+                prettier_store::format_with_prettier(&prettier, buffer, cx)
+                    .await
+                    .transpose()
+                    .ok()
+                    .flatten()
+            }
             Formatter::External { command, arguments } => {
                 let buffer_abs_path = buffer_abs_path.as_ref().map(|path| path.as_path());
                 Self::format_via_external_command(buffer, buffer_abs_path, command, arguments, cx)
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index f5efa21bd0fb6a..ed12b41167cc23 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -26,6 +26,7 @@ env_logger.workspace = true
 fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
+node_runtime.workspace = true
 log.workspace = true
 project.workspace = true
 remote.workspace = true
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 35d6630c1e11be..ec26bddfc3e7ab 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -2,12 +2,13 @@ use anyhow::{anyhow, Result};
 use fs::Fs;
 use gpui::{AppContext, AsyncAppContext, Context, Model, ModelContext};
 use language::{proto::serialize_operation, Buffer, BufferEvent, LanguageRegistry};
+use node_runtime::DummyNodeRuntime;
 use project::{
     buffer_store::{BufferStore, BufferStoreEvent},
     project_settings::SettingsObserver,
     search::SearchQuery,
     worktree_store::WorktreeStore,
-    LspStore, LspStoreEvent, ProjectPath, WorktreeId,
+    LspStore, LspStoreEvent, PrettierStore, ProjectPath, WorktreeId,
 };
 use remote::SshSession;
 use rpc::{
@@ -54,6 +55,16 @@ impl HeadlessProject {
             buffer_store.shared(SSH_PROJECT_ID, session.clone().into(), cx);
             buffer_store
         });
+        let prettier_store = cx.new_model(|cx| {
+            PrettierStore::new(
+                DummyNodeRuntime::new(),
+                fs.clone(),
+                languages.clone(),
+                worktree_store.clone(),
+                cx,
+            )
+        });
+
         let settings_observer = cx.new_model(|cx| {
             let mut observer = SettingsObserver::new_local(fs.clone(), worktree_store.clone(), cx);
             observer.shared(SSH_PROJECT_ID, session.clone().into(), cx);
@@ -64,6 +75,7 @@ impl HeadlessProject {
             let mut lsp_store = LspStore::new_local(
                 buffer_store.clone(),
                 worktree_store.clone(),
+                prettier_store.clone(),
                 environment,
                 languages.clone(),
                 None,

From 56f9e4c7b3834826c01a75f0a883e594a8482d90 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Tue, 17 Sep 2024 15:39:44 -0700
Subject: [PATCH 166/762] Remove visible 'TBD' from docs (#17979)

Release Notes:

- N/A
---
 docs/src/extensions/languages.md | 2 ++
 docs/src/key-bindings.md         | 2 ++
 docs/src/languages/javascript.md | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/docs/src/extensions/languages.md b/docs/src/extensions/languages.md
index 90de3f658d831a..c00328530322b2 100644
--- a/docs/src/extensions/languages.md
+++ b/docs/src/extensions/languages.md
@@ -284,7 +284,9 @@ The `@run` capture specifies where the run button should appear in the editor. O
 | @run    | Captures the script name                               |
 | @script | Also captures the script name (for different purposes) |
 
+<!--
 TBD: `#set! tag`
+-->
 
 ## Language Servers
 
diff --git a/docs/src/key-bindings.md b/docs/src/key-bindings.md
index 989e101e7d9fbd..b35c894071bbf1 100644
--- a/docs/src/key-bindings.md
+++ b/docs/src/key-bindings.md
@@ -177,8 +177,10 @@ See the [tasks documentation](tasks.md#custom-keybindings-for-tasks) for more.
 
 #### Global
 
+<!--
 TBD: Update these to reflect current bindings
 TBD: Add Column with Linux shortcuts
+-->
 
 | **Command**               | **Target**   | **Default Shortcut**    |
 | ------------------------- | ------------ | ----------------------- |
diff --git a/docs/src/languages/javascript.md b/docs/src/languages/javascript.md
index 0e642527e08f46..8fb84881ada0f8 100644
--- a/docs/src/languages/javascript.md
+++ b/docs/src/languages/javascript.md
@@ -26,6 +26,7 @@ For example, if you have Prettier installed and on your `PATH`, you can use it t
 }
 ```
 
+<!--
 ## JSX
 
 TBD: Mention JSX
@@ -35,6 +36,7 @@ TBD: Mention JSX
 TBD: Document JSDoc support in Zed.
 
 - Tree Sitter: [tree-sitter/tree-sitter-jsdoc](https://github.com/tree-sitter/tree-sitter-jsdoc)
+-->
 
 ## ESLint
 

From fbb402ef12b0e61bc02db7a1715d0a36df1b94a7 Mon Sep 17 00:00:00 2001
From: Junkui Zhang <364772080@qq.com>
Date: Wed, 18 Sep 2024 06:45:08 +0800
Subject: [PATCH 167/762] windows: Remove the use of `DispatcherQueue` and fix
 `FileSaveDialog` unresponsive issue (#17946)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes #17069, closes #12410


With the help of @kennykerr (Creator of C++/WinRT and the crate
`windows-rs`, Engineer on the Windows team at Microsoft) and @riverar
(Windows Development expert), we discovered that this bug only occurs
when an IME with a candidate window, such as Microsoft Pinyin IME, is
active. In this case, the `FileSaveDialog` becomes unresponsive—while
the dialog itself appears to be functioning, it doesn't accept any mouse
or keyboard input.

After a period of debugging and testing, I found that this issue only
arises when using `DispatcherQueue` to dispatch runnables on the UI
thread. After @kennykerr’s further investigation, Kenny identified that
this is a bug with `DispatcherQueue`, and he recommended to avoid using
`DispatcherQueue`. Given the uncertainty about whether Microsoft will
address this bug in the foreseeable future, I have removed the use of
`DispatcherQueue`.

Co-authored-by: Kenny <kenny@kennykerr.ca>

Release Notes:

- N/A

---------

Co-authored-by: Kenny <kenny@kennykerr.ca>
---
 Cargo.toml                                    |  2 +-
 crates/gpui/Cargo.toml                        |  4 +-
 .../gpui/src/platform/windows/dispatcher.rs   | 57 ++++--------
 crates/gpui/src/platform/windows/events.rs    |  3 +
 crates/gpui/src/platform/windows/platform.rs  | 90 ++++++++++++++-----
 crates/gpui/src/platform/windows/window.rs    | 19 ++--
 6 files changed, 104 insertions(+), 71 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 0b392e02eb7b36..ec3138179b1c5a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -490,7 +490,6 @@ features = [
     "implement",
     "Foundation_Numerics",
     "Storage",
-    "System",
     "System_Threading",
     "UI_ViewManagement",
     "Wdk_System_SystemServices",
@@ -521,6 +520,7 @@ features = [
     "Win32_UI_Input_Ime",
     "Win32_UI_Input_KeyboardAndMouse",
     "Win32_UI_Shell",
+    "Win32_UI_Shell_Common",
     "Win32_UI_WindowsAndMessaging",
 ]
 
diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml
index 09b546fc3266d2..d0d75b73e97a7d 100644
--- a/crates/gpui/Cargo.toml
+++ b/crates/gpui/Cargo.toml
@@ -50,7 +50,7 @@ parking = "2.0.0"
 parking_lot.workspace = true
 postage.workspace = true
 profiling.workspace = true
-rand = { optional = true, workspace = true}
+rand = { optional = true, workspace = true }
 raw-window-handle = "0.6"
 refineable.workspace = true
 resvg = { version = "0.41.0", default-features = false }
@@ -110,6 +110,7 @@ blade-graphics.workspace = true
 blade-macros.workspace = true
 blade-util.workspace = true
 bytemuck = "1"
+flume = "0.11"
 
 [target.'cfg(target_os = "linux")'.dependencies]
 as-raw-xcb-connection = "1"
@@ -117,7 +118,6 @@ ashpd.workspace = true
 calloop = "0.13.0"
 calloop-wayland-source = "0.3.0"
 cosmic-text = { git = "https://github.com/pop-os/cosmic-text", rev = "542b20c" }
-flume = "0.11"
 wayland-backend = { version = "0.3.3", features = ["client_system", "dlopen"] }
 wayland-client = { version = "0.31.2" }
 wayland-cursor = "0.31.1"
diff --git a/crates/gpui/src/platform/windows/dispatcher.rs b/crates/gpui/src/platform/windows/dispatcher.rs
index abe40d2c2e34db..575e844051d9b7 100644
--- a/crates/gpui/src/platform/windows/dispatcher.rs
+++ b/crates/gpui/src/platform/windows/dispatcher.rs
@@ -3,51 +3,39 @@ use std::{
     time::Duration,
 };
 
+use anyhow::Context;
 use async_task::Runnable;
+use flume::Sender;
 use parking::Parker;
 use parking_lot::Mutex;
 use util::ResultExt;
 use windows::{
     Foundation::TimeSpan,
-    System::{
-        DispatcherQueue, DispatcherQueueController, DispatcherQueueHandler,
-        Threading::{
-            ThreadPool, ThreadPoolTimer, TimerElapsedHandler, WorkItemHandler, WorkItemOptions,
-            WorkItemPriority,
-        },
-    },
-    Win32::System::WinRT::{
-        CreateDispatcherQueueController, DispatcherQueueOptions, DQTAT_COM_NONE,
-        DQTYPE_THREAD_CURRENT,
+    System::Threading::{
+        ThreadPool, ThreadPoolTimer, TimerElapsedHandler, WorkItemHandler, WorkItemOptions,
+        WorkItemPriority,
     },
+    Win32::{Foundation::HANDLE, System::Threading::SetEvent},
 };
 
-use crate::{PlatformDispatcher, TaskLabel};
+use crate::{PlatformDispatcher, SafeHandle, TaskLabel};
 
 pub(crate) struct WindowsDispatcher {
-    controller: DispatcherQueueController,
-    main_queue: DispatcherQueue,
+    main_sender: Sender<Runnable>,
+    dispatch_event: SafeHandle,
     parker: Mutex<Parker>,
     main_thread_id: ThreadId,
 }
 
 impl WindowsDispatcher {
-    pub(crate) fn new() -> Self {
-        let controller = unsafe {
-            let options = DispatcherQueueOptions {
-                dwSize: std::mem::size_of::<DispatcherQueueOptions>() as u32,
-                threadType: DQTYPE_THREAD_CURRENT,
-                apartmentType: DQTAT_COM_NONE,
-            };
-            CreateDispatcherQueueController(options).unwrap()
-        };
-        let main_queue = controller.DispatcherQueue().unwrap();
+    pub(crate) fn new(main_sender: Sender<Runnable>, dispatch_event: HANDLE) -> Self {
+        let dispatch_event = dispatch_event.into();
         let parker = Mutex::new(Parker::new());
         let main_thread_id = current().id();
 
         WindowsDispatcher {
-            controller,
-            main_queue,
+            main_sender,
+            dispatch_event,
             parker,
             main_thread_id,
         }
@@ -86,12 +74,6 @@ impl WindowsDispatcher {
     }
 }
 
-impl Drop for WindowsDispatcher {
-    fn drop(&mut self) {
-        self.controller.ShutdownQueueAsync().log_err();
-    }
-}
-
 impl PlatformDispatcher for WindowsDispatcher {
     fn is_main_thread(&self) -> bool {
         current().id() == self.main_thread_id
@@ -105,14 +87,11 @@ impl PlatformDispatcher for WindowsDispatcher {
     }
 
     fn dispatch_on_main_thread(&self, runnable: Runnable) {
-        let handler = {
-            let mut task_wrapper = Some(runnable);
-            DispatcherQueueHandler::new(move || {
-                task_wrapper.take().unwrap().run();
-                Ok(())
-            })
-        };
-        self.main_queue.TryEnqueue(&handler).log_err();
+        self.main_sender
+            .send(runnable)
+            .context("Dispatch on main thread failed")
+            .log_err();
+        unsafe { SetEvent(*self.dispatch_event).log_err() };
     }
 
     fn dispatch_after(&self, duration: Duration, runnable: Runnable) {
diff --git a/crates/gpui/src/platform/windows/events.rs b/crates/gpui/src/platform/windows/events.rs
index 0d55142ae9f338..b62f51f6d9b94e 100644
--- a/crates/gpui/src/platform/windows/events.rs
+++ b/crates/gpui/src/platform/windows/events.rs
@@ -177,6 +177,9 @@ fn handle_timer_msg(
     state_ptr: Rc<WindowsWindowStatePtr>,
 ) -> Option<isize> {
     if wparam.0 == SIZE_MOVE_LOOP_TIMER_ID {
+        for runnable in state_ptr.main_receiver.drain() {
+            runnable.run();
+        }
         handle_paint_msg(handle, state_ptr)
     } else {
         None
diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs
index 934d9336d2f6c2..d9f08c2247adf0 100644
--- a/crates/gpui/src/platform/windows/platform.rs
+++ b/crates/gpui/src/platform/windows/platform.rs
@@ -8,6 +8,7 @@ use std::{
 
 use ::util::ResultExt;
 use anyhow::{anyhow, Context, Result};
+use async_task::Runnable;
 use futures::channel::oneshot::{self, Receiver};
 use itertools::Itertools;
 use parking_lot::RwLock;
@@ -46,6 +47,8 @@ pub(crate) struct WindowsPlatform {
     raw_window_handles: RwLock<SmallVec<[HWND; 4]>>,
     // The below members will never change throughout the entire lifecycle of the app.
     icon: HICON,
+    main_receiver: flume::Receiver<Runnable>,
+    dispatch_event: HANDLE,
     background_executor: BackgroundExecutor,
     foreground_executor: ForegroundExecutor,
     text_system: Arc<DirectWriteTextSystem>,
@@ -89,7 +92,9 @@ impl WindowsPlatform {
         unsafe {
             OleInitialize(None).expect("unable to initialize Windows OLE");
         }
-        let dispatcher = Arc::new(WindowsDispatcher::new());
+        let (main_sender, main_receiver) = flume::unbounded::<Runnable>();
+        let dispatch_event = unsafe { CreateEventW(None, false, false, None) }.unwrap();
+        let dispatcher = Arc::new(WindowsDispatcher::new(main_sender, dispatch_event));
         let background_executor = BackgroundExecutor::new(dispatcher.clone());
         let foreground_executor = ForegroundExecutor::new(dispatcher);
         let bitmap_factory = ManuallyDrop::new(unsafe {
@@ -113,6 +118,8 @@ impl WindowsPlatform {
             state,
             raw_window_handles,
             icon,
+            main_receiver,
+            dispatch_event,
             background_executor,
             foreground_executor,
             text_system,
@@ -176,6 +183,24 @@ impl WindowsPlatform {
 
         lock.is_empty()
     }
+
+    #[inline]
+    fn run_foreground_tasks(&self) {
+        for runnable in self.main_receiver.drain() {
+            runnable.run();
+        }
+    }
+
+    fn generate_creation_info(&self) -> WindowCreationInfo {
+        WindowCreationInfo {
+            icon: self.icon,
+            executor: self.foreground_executor.clone(),
+            current_cursor: self.state.borrow().current_cursor,
+            windows_version: self.windows_version,
+            validation_number: self.validation_number,
+            main_receiver: self.main_receiver.clone(),
+        }
+    }
 }
 
 impl Platform for WindowsPlatform {
@@ -197,16 +222,21 @@ impl Platform for WindowsPlatform {
         begin_vsync(*vsync_event);
         'a: loop {
             let wait_result = unsafe {
-                MsgWaitForMultipleObjects(Some(&[*vsync_event]), false, INFINITE, QS_ALLINPUT)
+                MsgWaitForMultipleObjects(
+                    Some(&[*vsync_event, self.dispatch_event]),
+                    false,
+                    INFINITE,
+                    QS_ALLINPUT,
+                )
             };
 
             match wait_result {
                 // compositor clock ticked so we should draw a frame
-                WAIT_EVENT(0) => {
-                    self.redraw_all();
-                }
+                WAIT_EVENT(0) => self.redraw_all(),
+                // foreground tasks are dispatched
+                WAIT_EVENT(1) => self.run_foreground_tasks(),
                 // Windows thread messages are posted
-                WAIT_EVENT(1) => {
+                WAIT_EVENT(2) => {
                     let mut msg = MSG::default();
                     unsafe {
                         while PeekMessageW(&mut msg, None, 0, 0, PM_REMOVE).as_bool() {
@@ -230,6 +260,8 @@ impl Platform for WindowsPlatform {
                             }
                         }
                     }
+                    // foreground tasks may have been queued in the message handlers
+                    self.run_foreground_tasks();
                 }
                 _ => {
                     log::error!("Something went wrong while waiting {:?}", wait_result);
@@ -319,17 +351,7 @@ impl Platform for WindowsPlatform {
         handle: AnyWindowHandle,
         options: WindowParams,
     ) -> Result<Box<dyn PlatformWindow>> {
-        let lock = self.state.borrow();
-        let window = WindowsWindow::new(
-            handle,
-            options,
-            self.icon,
-            self.foreground_executor.clone(),
-            lock.current_cursor,
-            self.windows_version,
-            self.validation_number,
-        )?;
-        drop(lock);
+        let window = WindowsWindow::new(handle, options, self.generate_creation_info())?;
         let handle = window.get_raw_handle();
         self.raw_window_handles.write().push(handle);
 
@@ -558,6 +580,15 @@ impl Drop for WindowsPlatform {
     }
 }
 
+pub(crate) struct WindowCreationInfo {
+    pub(crate) icon: HICON,
+    pub(crate) executor: ForegroundExecutor,
+    pub(crate) current_cursor: HCURSOR,
+    pub(crate) windows_version: WindowsVersion,
+    pub(crate) validation_number: usize,
+    pub(crate) main_receiver: flume::Receiver<Runnable>,
+}
+
 fn open_target(target: &str) {
     unsafe {
         let ret = ShellExecuteW(
@@ -631,22 +662,33 @@ fn file_open_dialog(options: PathPromptOptions) -> Result<Option<Vec<PathBuf>>>
 
 fn file_save_dialog(directory: PathBuf) -> Result<Option<PathBuf>> {
     let dialog: IFileSaveDialog = unsafe { CoCreateInstance(&FileSaveDialog, None, CLSCTX_ALL)? };
-    if let Some(full_path) = directory.canonicalize().log_err() {
-        let full_path = full_path.to_string_lossy().to_string();
-        if !full_path.is_empty() {
-            let path_item: IShellItem =
-                unsafe { SHCreateItemFromParsingName(&HSTRING::from(&full_path), None)? };
-            unsafe { dialog.SetFolder(&path_item).log_err() };
+    if !directory.to_string_lossy().is_empty() {
+        if let Some(full_path) = directory.canonicalize().log_err() {
+            let full_path = full_path.to_string_lossy().to_string();
+            if !full_path.is_empty() {
+                let path_item: IShellItem =
+                    unsafe { SHCreateItemFromParsingName(&HSTRING::from(&full_path), None)? };
+                unsafe { dialog.SetFolder(&path_item).log_err() };
+            }
         }
     }
     unsafe {
+        dialog.SetFileTypes(&[Common::COMDLG_FILTERSPEC {
+            pszName: windows::core::w!("All files"),
+            pszSpec: windows::core::w!("*.*"),
+        }])?;
         if dialog.Show(None).is_err() {
             // User cancelled
             return Ok(None);
         }
     }
     let shell_item = unsafe { dialog.GetResult()? };
-    let file_path_string = unsafe { shell_item.GetDisplayName(SIGDN_FILESYSPATH)?.to_string()? };
+    let file_path_string = unsafe {
+        let pwstr = shell_item.GetDisplayName(SIGDN_FILESYSPATH)?;
+        let string = pwstr.to_string()?;
+        CoTaskMemFree(Some(pwstr.0 as _));
+        string
+    };
     Ok(Some(PathBuf::from(file_path_string)))
 }
 
diff --git a/crates/gpui/src/platform/windows/window.rs b/crates/gpui/src/platform/windows/window.rs
index 1a059491a2a4ad..e2cfb38afd4dfc 100644
--- a/crates/gpui/src/platform/windows/window.rs
+++ b/crates/gpui/src/platform/windows/window.rs
@@ -12,6 +12,7 @@ use std::{
 
 use ::util::ResultExt;
 use anyhow::{Context, Result};
+use async_task::Runnable;
 use futures::channel::oneshot::{self, Receiver};
 use itertools::Itertools;
 use raw_window_handle as rwh;
@@ -63,6 +64,7 @@ pub(crate) struct WindowsWindowStatePtr {
     pub(crate) executor: ForegroundExecutor,
     pub(crate) windows_version: WindowsVersion,
     pub(crate) validation_number: usize,
+    pub(crate) main_receiver: flume::Receiver<Runnable>,
 }
 
 impl WindowsWindowState {
@@ -226,6 +228,7 @@ impl WindowsWindowStatePtr {
             executor: context.executor.clone(),
             windows_version: context.windows_version,
             validation_number: context.validation_number,
+            main_receiver: context.main_receiver.clone(),
         }))
     }
 }
@@ -253,18 +256,23 @@ struct WindowCreateContext {
     current_cursor: HCURSOR,
     windows_version: WindowsVersion,
     validation_number: usize,
+    main_receiver: flume::Receiver<Runnable>,
 }
 
 impl WindowsWindow {
     pub(crate) fn new(
         handle: AnyWindowHandle,
         params: WindowParams,
-        icon: HICON,
-        executor: ForegroundExecutor,
-        current_cursor: HCURSOR,
-        windows_version: WindowsVersion,
-        validation_number: usize,
+        creation_info: WindowCreationInfo,
     ) -> Result<Self> {
+        let WindowCreationInfo {
+            icon,
+            executor,
+            current_cursor,
+            windows_version,
+            validation_number,
+            main_receiver,
+        } = creation_info;
         let classname = register_wnd_class(icon);
         let hide_title_bar = params
             .titlebar
@@ -305,6 +313,7 @@ impl WindowsWindow {
             current_cursor,
             windows_version,
             validation_number,
+            main_receiver,
         };
         let lpparam = Some(&context as *const _ as *const _);
         let creation_result = unsafe {

From 4d074fc737db71ff10b4cf1e68f4b70e092124b6 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 17 Sep 2024 19:20:45 -0400
Subject: [PATCH 168/762] editor: Fix rewrap with a non-empty selection
 (#17980)

This PR fixes an issue where rewrapping would not occur with a non-empty
selection.

It is only the expansion to neighboring lines that needs to be gated by
an empty selection.

Release Notes:

- N/A
---
 crates/editor/src/editor.rs       | 30 ++++++++++++++--------------
 crates/editor/src/editor_tests.rs | 33 +++++++++++++++++++++++++++++++
 2 files changed, 48 insertions(+), 15 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index c3c54e49513d7a..61a59665c15e3e 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -6736,22 +6736,22 @@ impl Editor {
 
             let mut line_prefix = indent_size.chars().collect::<String>();
 
-            if selection.is_empty() {
-                if let Some(comment_prefix) =
-                    buffer
-                        .language_scope_at(selection.head())
-                        .and_then(|language| {
-                            language
-                                .line_comment_prefixes()
-                                .iter()
-                                .find(|prefix| buffer.contains_str_at(indent_end, prefix))
-                                .cloned()
-                        })
-                {
-                    line_prefix.push_str(&comment_prefix);
-                    should_rewrap = true;
-                }
+            if let Some(comment_prefix) =
+                buffer
+                    .language_scope_at(selection.head())
+                    .and_then(|language| {
+                        language
+                            .line_comment_prefixes()
+                            .iter()
+                            .find(|prefix| buffer.contains_str_at(indent_end, prefix))
+                            .cloned()
+                    })
+            {
+                line_prefix.push_str(&comment_prefix);
+                should_rewrap = true;
+            }
 
+            if selection.is_empty() {
                 'expand_upwards: while start_row > 0 {
                     let prev_row = start_row - 1;
                     if buffer.contains_str_at(Point::new(prev_row, 0), &line_prefix)
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 6a8efc5905fbb1..e11b38ba59680d 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -4017,6 +4017,39 @@ async fn test_rewrap(cx: &mut TestAppContext) {
         cx.assert_editor_state(wrapped_text);
     }
 
+    // Test that rewrapping works inside of a selection
+    {
+        let language = Arc::new(Language::new(
+            LanguageConfig {
+                line_comments: vec!["// ".into()],
+                ..LanguageConfig::default()
+            },
+            None,
+        ));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
+
+        let unwrapped_text = indoc! {"
+            «// Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus auctor, eu lacinia sapien scelerisque. Vivamus sit amet neque et quam tincidunt hendrerit. Praesent semper egestas tellus id dignissim. Pellentesque odio lectus, iaculis ac volutpat et, blandit quis urna. Sed vestibulum nisi sit amet nisl venenatis tempus. Donec molestie blandit quam, et porta nunc laoreet in. Integer sit amet scelerisque nisi. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras egestas porta metus, eu viverra ipsum efficitur quis. Donec luctus eros turpis, id vulputate turpis porttitor id. Aliquam id accumsan eros.ˇ»
+        "};
+
+        let wrapped_text = indoc! {"
+            // Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit
+            // purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus
+            // auctor, eu lacinia sapien scelerisque. Vivamus sit amet neque et quam
+            // tincidunt hendrerit. Praesent semper egestas tellus id dignissim.
+            // Pellentesque odio lectus, iaculis ac volutpat et, blandit quis urna. Sed
+            // vestibulum nisi sit amet nisl venenatis tempus. Donec molestie blandit quam,
+            // et porta nunc laoreet in. Integer sit amet scelerisque nisi. Lorem ipsum
+            // dolor sit amet, consectetur adipiscing elit. Cras egestas porta metus, eu
+            // viverra ipsum efficitur quis. Donec luctus eros turpis, id vulputate turpis
+            // porttitor id. Aliquam id accumsan eros.ˇ
+        "};
+
+        cx.set_state(unwrapped_text);
+        cx.update_editor(|e, cx| e.rewrap(&Rewrap, cx));
+        cx.assert_editor_state(wrapped_text);
+    }
+
     // Test that cursors that expand to the same region are collapsed.
     {
         let language = Arc::new(Language::new(

From 2e72fd210a93aaaf5a4a1ad9fd04a046fd1f394e Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Tue, 17 Sep 2024 19:43:59 -0600
Subject: [PATCH 169/762] Replace Default trait bound with a zero function on
 Summary/Dimension (#17975)

This lets us provide a context when constructing the zero value. We need
it so we can require anchors to be associated with a buffer id, which
we're doing as part of simplifying the multibuffer API.

Release Notes:

- N/A

Co-authored-by: Nathan <nathan@zed.dev>
---
 crates/channel/src/channel_chat.rs            |  30 ++--
 crates/editor/src/display_map.rs              |   5 +-
 crates/editor/src/display_map/block_map.rs    |  38 +++--
 crates/editor/src/display_map/crease_map.rs   |  41 +++--
 crates/editor/src/display_map/fold_map.rs     |  79 +++++++---
 crates/editor/src/display_map/inlay_map.rs    |  47 ++++--
 crates/editor/src/display_map/wrap_map.rs     |  44 ++++--
 crates/editor/src/git/blame.rs                |  14 +-
 crates/git/src/diff.rs                        |  46 +++---
 crates/gpui/src/elements/list.rs              |  34 +++--
 crates/language/src/buffer.rs                 |  10 +-
 crates/language/src/diagnostic_set.rs         |   8 +-
 crates/language/src/syntax_map.rs             |  39 +++--
 .../src/syntax_map/syntax_map_tests.rs        |  16 +-
 crates/multi_buffer/src/multi_buffer.rs       | 142 +++++++++++-------
 .../notifications/src/notification_store.rs   |  21 ++-
 crates/project/src/lsp_store.rs               |   8 +-
 crates/rope/src/rope.rs                       |  66 +++++---
 crates/rope/src/unclipped.rs                  |   4 +
 crates/sum_tree/src/cursor.rs                 |  36 +++--
 crates/sum_tree/src/sum_tree.rs               | 125 +++++++++------
 crates/sum_tree/src/tree_map.rs               |  22 ++-
 crates/text/src/anchor.rs                     |   2 +-
 crates/text/src/locator.rs                    |   4 +
 crates/text/src/operation_queue.rs            |  12 +-
 crates/text/src/text.rs                       |  94 ++++++++----
 crates/text/src/undo_map.rs                   |   9 +-
 crates/worktree/src/worktree.rs               |  59 ++++++--
 28 files changed, 706 insertions(+), 349 deletions(-)

diff --git a/crates/channel/src/channel_chat.rs b/crates/channel/src/channel_chat.rs
index 286eb46a916004..1a9e46db0460a9 100644
--- a/crates/channel/src/channel_chat.rs
+++ b/crates/channel/src/channel_chat.rs
@@ -332,7 +332,7 @@ impl ChannelChat {
                 .update(&mut cx, |chat, cx| {
                     if let Some(first_id) = chat.first_loaded_message_id() {
                         if first_id <= message_id {
-                            let mut cursor = chat.messages.cursor::<(ChannelMessageId, Count)>();
+                            let mut cursor = chat.messages.cursor::<(ChannelMessageId, Count)>(&());
                             let message_id = ChannelMessageId::Saved(message_id);
                             cursor.seek(&message_id, Bias::Left, &());
                             return ControlFlow::Break(
@@ -498,7 +498,7 @@ impl ChannelChat {
     }
 
     pub fn message(&self, ix: usize) -> &ChannelMessage {
-        let mut cursor = self.messages.cursor::<Count>();
+        let mut cursor = self.messages.cursor::<Count>(&());
         cursor.seek(&Count(ix), Bias::Right, &());
         cursor.item().unwrap()
     }
@@ -515,13 +515,13 @@ impl ChannelChat {
     }
 
     pub fn messages_in_range(&self, range: Range<usize>) -> impl Iterator<Item = &ChannelMessage> {
-        let mut cursor = self.messages.cursor::<Count>();
+        let mut cursor = self.messages.cursor::<Count>(&());
         cursor.seek(&Count(range.start), Bias::Right, &());
         cursor.take(range.len())
     }
 
     pub fn pending_messages(&self) -> impl Iterator<Item = &ChannelMessage> {
-        let mut cursor = self.messages.cursor::<ChannelMessageId>();
+        let mut cursor = self.messages.cursor::<ChannelMessageId>(&());
         cursor.seek(&ChannelMessageId::Pending(0), Bias::Left, &());
         cursor
     }
@@ -589,11 +589,11 @@ impl ChannelChat {
     fn insert_messages(&mut self, messages: SumTree<ChannelMessage>, cx: &mut ModelContext<Self>) {
         if let Some((first_message, last_message)) = messages.first().zip(messages.last()) {
             let nonces = messages
-                .cursor::<()>()
+                .cursor::<()>(&())
                 .map(|m| m.nonce)
                 .collect::<HashSet<_>>();
 
-            let mut old_cursor = self.messages.cursor::<(ChannelMessageId, Count)>();
+            let mut old_cursor = self.messages.cursor::<(ChannelMessageId, Count)>(&());
             let mut new_messages = old_cursor.slice(&first_message.id, Bias::Left, &());
             let start_ix = old_cursor.start().1 .0;
             let removed_messages = old_cursor.slice(&last_message.id, Bias::Right, &());
@@ -646,7 +646,7 @@ impl ChannelChat {
     }
 
     fn message_removed(&mut self, id: u64, cx: &mut ModelContext<Self>) {
-        let mut cursor = self.messages.cursor::<ChannelMessageId>();
+        let mut cursor = self.messages.cursor::<ChannelMessageId>(&());
         let mut messages = cursor.slice(&ChannelMessageId::Saved(id), Bias::Left, &());
         if let Some(item) = cursor.item() {
             if item.id == ChannelMessageId::Saved(id) {
@@ -685,7 +685,7 @@ impl ChannelChat {
         edited_at: Option<OffsetDateTime>,
         cx: &mut ModelContext<Self>,
     ) {
-        let mut cursor = self.messages.cursor::<ChannelMessageId>();
+        let mut cursor = self.messages.cursor::<ChannelMessageId>(&());
         let mut messages = cursor.slice(&id, Bias::Left, &());
         let ix = messages.summary().count;
 
@@ -716,7 +716,7 @@ async fn messages_from_proto(
     cx: &mut AsyncAppContext,
 ) -> Result<SumTree<ChannelMessage>> {
     let messages = ChannelMessage::from_proto_vec(proto_messages, user_store, cx).await?;
-    let mut result = SumTree::new();
+    let mut result = SumTree::default();
     result.extend(messages, &());
     Ok(result)
 }
@@ -825,6 +825,10 @@ impl Default for ChannelMessageId {
 impl sum_tree::Summary for ChannelMessageSummary {
     type Context = ();
 
+    fn zero(_cx: &Self::Context) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &()) {
         self.max_id = summary.max_id;
         self.count += summary.count;
@@ -832,6 +836,10 @@ impl sum_tree::Summary for ChannelMessageSummary {
 }
 
 impl<'a> sum_tree::Dimension<'a, ChannelMessageSummary> for ChannelMessageId {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ChannelMessageSummary, _: &()) {
         debug_assert!(summary.max_id > *self);
         *self = summary.max_id;
@@ -839,6 +847,10 @@ impl<'a> sum_tree::Dimension<'a, ChannelMessageSummary> for ChannelMessageId {
 }
 
 impl<'a> sum_tree::Dimension<'a, ChannelMessageSummary> for Count {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ChannelMessageSummary, _: &()) {
         self.0 += summary.count;
     }
diff --git a/crates/editor/src/display_map.rs b/crates/editor/src/display_map.rs
index 86ea7ee3fabf95..790a0a6a1eba78 100644
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -127,7 +127,9 @@ impl DisplayMap {
         let buffer_subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
 
         let tab_size = Self::tab_size(&buffer, cx);
-        let (inlay_map, snapshot) = InlayMap::new(buffer.read(cx).snapshot(cx));
+        let buffer_snapshot = buffer.read(cx).snapshot(cx);
+        let crease_map = CreaseMap::new(&buffer_snapshot);
+        let (inlay_map, snapshot) = InlayMap::new(buffer_snapshot);
         let (fold_map, snapshot) = FoldMap::new(snapshot);
         let (tab_map, snapshot) = TabMap::new(snapshot, tab_size);
         let (wrap_map, snapshot) = WrapMap::new(snapshot, font, font_size, wrap_width, cx);
@@ -138,7 +140,6 @@ impl DisplayMap {
             excerpt_header_height,
             excerpt_footer_height,
         );
-        let crease_map = CreaseMap::default();
 
         cx.observe(&wrap_map, |_, _, cx| cx.notify()).detach();
 
diff --git a/crates/editor/src/display_map/block_map.rs b/crates/editor/src/display_map/block_map.rs
index 28e0b9d7af3709..3a298832dee5ef 100644
--- a/crates/editor/src/display_map/block_map.rs
+++ b/crates/editor/src/display_map/block_map.rs
@@ -389,10 +389,10 @@ impl BlockMap {
         }
 
         let mut transforms = self.transforms.borrow_mut();
-        let mut new_transforms = SumTree::new();
+        let mut new_transforms = SumTree::default();
         let old_row_count = transforms.summary().input_rows;
         let new_row_count = wrap_snapshot.max_point().row() + 1;
-        let mut cursor = transforms.cursor::<WrapRow>();
+        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();
@@ -757,7 +757,7 @@ impl<'a> BlockMapReader<'a> {
                 .unwrap_or(self.wrap_snapshot.max_point().row() + 1),
         );
 
-        let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>();
+        let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&());
         cursor.seek(&start_wrap_row, Bias::Left, &());
         while let Some(transform) = cursor.item() {
             if cursor.start().0 > end_wrap_row {
@@ -950,7 +950,7 @@ impl BlockSnapshot {
         highlights: Highlights<'a>,
     ) -> BlockChunks<'a> {
         let max_output_row = cmp::min(rows.end, self.transforms.summary().output_rows);
-        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
+        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
         let input_end = {
             cursor.seek(&BlockRow(rows.end), Bias::Right, &());
             let overshoot = if cursor
@@ -990,7 +990,7 @@ impl BlockSnapshot {
     }
 
     pub(super) fn buffer_rows(&self, start_row: BlockRow) -> BlockBufferRows {
-        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
+        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
         cursor.seek(&start_row, Bias::Right, &());
         let (output_start, input_start) = cursor.start();
         let overshoot = if cursor.item().map_or(false, |t| t.is_isomorphic()) {
@@ -1008,7 +1008,7 @@ impl BlockSnapshot {
     }
 
     pub fn blocks_in_range(&self, rows: Range<u32>) -> impl Iterator<Item = (u32, &Block)> {
-        let mut cursor = self.transforms.cursor::<BlockRow>();
+        let mut cursor = self.transforms.cursor::<BlockRow>(&());
         cursor.seek(&BlockRow(rows.start), Bias::Left, &());
         while cursor.start().0 < rows.start && cursor.end(&()).0 <= rows.start {
             cursor.next(&());
@@ -1050,7 +1050,7 @@ impl BlockSnapshot {
                 let wrap_point = self
                     .wrap_snapshot
                     .make_wrap_point(excerpt_range.start, Bias::Left);
-                let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>();
+                let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&());
                 cursor.seek(&WrapRow(wrap_point.row()), Bias::Left, &());
                 while let Some(transform) = cursor.item() {
                     if let Some(block) = transform.block.as_ref() {
@@ -1072,7 +1072,7 @@ impl BlockSnapshot {
                     .wrap_snapshot
                     .make_wrap_point(excerpt_range.end, Bias::Left);
 
-                let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>();
+                let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&());
                 cursor.seek(&WrapRow(wrap_point.row()), Bias::Left, &());
                 while let Some(transform) = cursor.item() {
                     if let Some(block) = transform.block.as_ref() {
@@ -1102,7 +1102,7 @@ impl BlockSnapshot {
     }
 
     pub(super) fn line_len(&self, row: BlockRow) -> u32 {
-        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
+        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
         cursor.seek(&BlockRow(row.0), Bias::Right, &());
         if let Some(transform) = cursor.item() {
             let (output_start, input_start) = cursor.start();
@@ -1118,13 +1118,13 @@ impl BlockSnapshot {
     }
 
     pub(super) fn is_block_line(&self, row: BlockRow) -> bool {
-        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
+        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
         cursor.seek(&row, Bias::Right, &());
         cursor.item().map_or(false, |t| t.block.is_some())
     }
 
     pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint {
-        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
+        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
         cursor.seek(&BlockRow(point.row), Bias::Right, &());
 
         let max_input_row = WrapRow(self.transforms.summary().input_rows);
@@ -1172,7 +1172,7 @@ impl BlockSnapshot {
     }
 
     pub fn to_block_point(&self, wrap_point: WrapPoint) -> BlockPoint {
-        let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>();
+        let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&());
         cursor.seek(&WrapRow(wrap_point.row()), Bias::Right, &());
         if let Some(transform) = cursor.item() {
             debug_assert!(transform.is_isomorphic());
@@ -1188,7 +1188,7 @@ impl BlockSnapshot {
     }
 
     pub fn to_wrap_point(&self, block_point: BlockPoint) -> WrapPoint {
-        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
+        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
         cursor.seek(&BlockRow(block_point.row), Bias::Right, &());
         if let Some(transform) = cursor.item() {
             match transform.block.as_ref().map(|b| b.disposition()) {
@@ -1368,6 +1368,10 @@ impl sum_tree::Item for Transform {
 impl sum_tree::Summary for TransformSummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &()) {
         self.input_rows += summary.input_rows;
         self.output_rows += summary.output_rows;
@@ -1375,12 +1379,20 @@ impl sum_tree::Summary for TransformSummary {
 }
 
 impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapRow {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
         self.0 += 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.0 += summary.output_rows;
     }
diff --git a/crates/editor/src/display_map/crease_map.rs b/crates/editor/src/display_map/crease_map.rs
index 10ee125b3237ac..bfc9c7d1a4ffbf 100644
--- a/crates/editor/src/display_map/crease_map.rs
+++ b/crates/editor/src/display_map/crease_map.rs
@@ -12,19 +12,34 @@ use crate::FoldPlaceholder;
 #[derive(Copy, Clone, Default, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
 pub struct CreaseId(usize);
 
-#[derive(Default)]
 pub struct CreaseMap {
     snapshot: CreaseSnapshot,
     next_id: CreaseId,
     id_to_range: HashMap<CreaseId, Range<Anchor>>,
 }
 
-#[derive(Clone, Default)]
+impl CreaseMap {
+    pub fn new(snapshot: &MultiBufferSnapshot) -> Self {
+        CreaseMap {
+            snapshot: CreaseSnapshot::new(snapshot),
+            next_id: CreaseId::default(),
+            id_to_range: HashMap::default(),
+        }
+    }
+}
+
+#[derive(Clone)]
 pub struct CreaseSnapshot {
     creases: SumTree<CreaseItem>,
 }
 
 impl CreaseSnapshot {
+    pub fn new(snapshot: &MultiBufferSnapshot) -> Self {
+        CreaseSnapshot {
+            creases: SumTree::new(snapshot),
+        }
+    }
+
     /// Returns the first Crease starting on the specified buffer row.
     pub fn query_row<'a>(
         &'a self,
@@ -32,7 +47,7 @@ impl CreaseSnapshot {
         snapshot: &'a MultiBufferSnapshot,
     ) -> Option<&'a Crease> {
         let start = snapshot.anchor_before(Point::new(row.0, 0));
-        let mut cursor = self.creases.cursor::<ItemSummary>();
+        let mut cursor = self.creases.cursor::<ItemSummary>(snapshot);
         cursor.seek(&start, Bias::Left, snapshot);
         while let Some(item) = cursor.item() {
             match Ord::cmp(&item.crease.range.start.to_point(snapshot).row, &row.0) {
@@ -56,7 +71,7 @@ impl CreaseSnapshot {
         snapshot: &'a MultiBufferSnapshot,
     ) -> impl '_ + Iterator<Item = &'a Crease> {
         let start = snapshot.anchor_before(Point::new(range.start.0, 0));
-        let mut cursor = self.creases.cursor::<ItemSummary>();
+        let mut cursor = self.creases.cursor::<ItemSummary>(snapshot);
         cursor.seek(&start, Bias::Left, snapshot);
 
         std::iter::from_fn(move || {
@@ -79,7 +94,7 @@ impl CreaseSnapshot {
         &self,
         snapshot: &MultiBufferSnapshot,
     ) -> Vec<(CreaseId, Range<Point>)> {
-        let mut cursor = self.creases.cursor::<ItemSummary>();
+        let mut cursor = self.creases.cursor::<ItemSummary>(snapshot);
         let mut results = Vec::new();
 
         cursor.next(snapshot);
@@ -194,8 +209,8 @@ impl CreaseMap {
     ) -> Vec<CreaseId> {
         let mut new_ids = Vec::new();
         self.snapshot.creases = {
-            let mut new_creases = SumTree::new();
-            let mut cursor = self.snapshot.creases.cursor::<ItemSummary>();
+            let mut new_creases = SumTree::new(snapshot);
+            let mut cursor = self.snapshot.creases.cursor::<ItemSummary>(snapshot);
             for crease in creases {
                 new_creases.append(cursor.slice(&crease.range, Bias::Left, snapshot), snapshot);
 
@@ -227,8 +242,8 @@ impl CreaseMap {
         });
 
         self.snapshot.creases = {
-            let mut new_creases = SumTree::new();
-            let mut cursor = self.snapshot.creases.cursor::<ItemSummary>();
+            let mut new_creases = SumTree::new(snapshot);
+            let mut cursor = self.snapshot.creases.cursor::<ItemSummary>(snapshot);
 
             for (id, range) in removals {
                 new_creases.append(cursor.slice(&range, Bias::Left, snapshot), snapshot);
@@ -264,6 +279,10 @@ impl Default for ItemSummary {
 impl sum_tree::Summary for ItemSummary {
     type Context = MultiBufferSnapshot;
 
+    fn zero(_cx: &Self::Context) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, other: &Self, _snapshot: &MultiBufferSnapshot) {
         self.range = other.range.clone();
     }
@@ -303,7 +322,7 @@ mod test {
         let text = "line1\nline2\nline3\nline4\nline5";
         let buffer = MultiBuffer::build_simple(text, cx);
         let snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
-        let mut crease_map = CreaseMap::default();
+        let mut crease_map = CreaseMap::new(&buffer.read(cx).read(cx));
 
         // Insert creases
         let creases = [
@@ -350,7 +369,7 @@ mod test {
         let text = "line1\nline2\nline3\nline4\nline5\nline6\nline7";
         let buffer = MultiBuffer::build_simple(text, cx);
         let snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
-        let mut crease_map = CreaseMap::default();
+        let mut crease_map = CreaseMap::new(&snapshot);
 
         let creases = [
             Crease::new(
diff --git a/crates/editor/src/display_map/fold_map.rs b/crates/editor/src/display_map/fold_map.rs
index 486fe4b2e5d40b..37983030b8e1a7 100644
--- a/crates/editor/src/display_map/fold_map.rs
+++ b/crates/editor/src/display_map/fold_map.rs
@@ -79,7 +79,7 @@ impl FoldPoint {
     }
 
     pub fn to_inlay_point(self, snapshot: &FoldSnapshot) -> InlayPoint {
-        let mut cursor = snapshot.transforms.cursor::<(FoldPoint, InlayPoint)>();
+        let mut cursor = snapshot.transforms.cursor::<(FoldPoint, InlayPoint)>(&());
         cursor.seek(&self, Bias::Right, &());
         let overshoot = self.0 - cursor.start().0 .0;
         InlayPoint(cursor.start().1 .0 + overshoot)
@@ -88,7 +88,7 @@ impl FoldPoint {
     pub fn to_offset(self, snapshot: &FoldSnapshot) -> FoldOffset {
         let mut cursor = snapshot
             .transforms
-            .cursor::<(FoldPoint, TransformSummary)>();
+            .cursor::<(FoldPoint, TransformSummary)>(&());
         cursor.seek(&self, Bias::Right, &());
         let overshoot = self.0 - cursor.start().1.output.lines;
         let mut offset = cursor.start().1.output.len;
@@ -105,6 +105,10 @@ impl FoldPoint {
 }
 
 impl<'a> sum_tree::Dimension<'a, TransformSummary> for FoldPoint {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
         self.0 += &summary.output.lines;
     }
@@ -154,8 +158,8 @@ impl<'a> FoldMapWriter<'a> {
         folds.sort_unstable_by(|a, b| sum_tree::SeekTarget::cmp(&a.range, &b.range, buffer));
 
         self.0.snapshot.folds = {
-            let mut new_tree = SumTree::new();
-            let mut cursor = self.0.snapshot.folds.cursor::<FoldRange>();
+            let mut new_tree = SumTree::new(buffer);
+            let mut cursor = self.0.snapshot.folds.cursor::<FoldRange>(buffer);
             for fold in folds {
                 new_tree.append(cursor.slice(&fold.range, Bias::Right, buffer), buffer);
                 new_tree.push(fold, buffer);
@@ -202,8 +206,8 @@ impl<'a> FoldMapWriter<'a> {
         fold_ixs_to_delete.dedup();
 
         self.0.snapshot.folds = {
-            let mut cursor = self.0.snapshot.folds.cursor::<usize>();
-            let mut folds = SumTree::new();
+            let mut cursor = self.0.snapshot.folds.cursor::<usize>(buffer);
+            let mut folds = SumTree::new(buffer);
             for fold_ix in fold_ixs_to_delete {
                 folds.append(cursor.slice(&fold_ix, Bias::Right, buffer), buffer);
                 cursor.next(buffer);
@@ -230,7 +234,7 @@ impl FoldMap {
     pub(crate) fn new(inlay_snapshot: InlaySnapshot) -> (Self, FoldSnapshot) {
         let this = Self {
             snapshot: FoldSnapshot {
-                folds: Default::default(),
+                folds: SumTree::new(&inlay_snapshot.buffer),
                 transforms: SumTree::from_item(
                     Transform {
                         summary: TransformSummary {
@@ -314,8 +318,8 @@ impl FoldMap {
         } else {
             let mut inlay_edits_iter = inlay_edits.iter().cloned().peekable();
 
-            let mut new_transforms = SumTree::<Transform>::new();
-            let mut cursor = self.snapshot.transforms.cursor::<InlayOffset>();
+            let mut new_transforms = SumTree::<Transform>::default();
+            let mut cursor = self.snapshot.transforms.cursor::<InlayOffset>(&());
             cursor.seek(&InlayOffset(0), Bias::Right, &());
 
             while let Some(mut edit) = inlay_edits_iter.next() {
@@ -367,7 +371,10 @@ impl FoldMap {
                 let anchor = inlay_snapshot
                     .buffer
                     .anchor_before(inlay_snapshot.to_buffer_offset(edit.new.start));
-                let mut folds_cursor = self.snapshot.folds.cursor::<FoldRange>();
+                let mut folds_cursor = self
+                    .snapshot
+                    .folds
+                    .cursor::<FoldRange>(&inlay_snapshot.buffer);
                 folds_cursor.seek(
                     &FoldRange(anchor..Anchor::max()),
                     Bias::Left,
@@ -470,8 +477,8 @@ impl FoldMap {
                 let mut old_transforms = self
                     .snapshot
                     .transforms
-                    .cursor::<(InlayOffset, FoldOffset)>();
-                let mut new_transforms = new_transforms.cursor::<(InlayOffset, FoldOffset)>();
+                    .cursor::<(InlayOffset, FoldOffset)>(&());
+                let mut new_transforms = new_transforms.cursor::<(InlayOffset, FoldOffset)>(&());
 
                 for mut edit in inlay_edits {
                     old_transforms.seek(&edit.old.start, Bias::Left, &());
@@ -545,7 +552,7 @@ impl FoldSnapshot {
     pub fn text_summary_for_range(&self, range: Range<FoldPoint>) -> TextSummary {
         let mut summary = TextSummary::default();
 
-        let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>();
+        let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>(&());
         cursor.seek(&range.start, Bias::Right, &());
         if let Some(transform) = cursor.item() {
             let start_in_transform = range.start.0 - cursor.start().0 .0;
@@ -594,7 +601,7 @@ impl FoldSnapshot {
     }
 
     pub fn to_fold_point(&self, point: InlayPoint, bias: Bias) -> FoldPoint {
-        let mut cursor = self.transforms.cursor::<(InlayPoint, FoldPoint)>();
+        let mut cursor = self.transforms.cursor::<(InlayPoint, FoldPoint)>(&());
         cursor.seek(&point, Bias::Right, &());
         if cursor.item().map_or(false, |t| t.is_fold()) {
             if bias == Bias::Left || point == cursor.start().0 {
@@ -631,7 +638,7 @@ impl FoldSnapshot {
         }
 
         let fold_point = FoldPoint::new(start_row, 0);
-        let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>();
+        let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>(&());
         cursor.seek(&fold_point, Bias::Left, &());
 
         let overshoot = fold_point.0 - cursor.start().0 .0;
@@ -672,7 +679,7 @@ impl FoldSnapshot {
     {
         let buffer_offset = offset.to_offset(&self.inlay_snapshot.buffer);
         let inlay_offset = self.inlay_snapshot.to_inlay_offset(buffer_offset);
-        let mut cursor = self.transforms.cursor::<InlayOffset>();
+        let mut cursor = self.transforms.cursor::<InlayOffset>(&());
         cursor.seek(&inlay_offset, Bias::Right, &());
         cursor.item().map_or(false, |t| t.placeholder.is_some())
     }
@@ -681,7 +688,7 @@ impl FoldSnapshot {
         let mut inlay_point = self
             .inlay_snapshot
             .to_inlay_point(Point::new(buffer_row.0, 0));
-        let mut cursor = self.transforms.cursor::<InlayPoint>();
+        let mut cursor = self.transforms.cursor::<InlayPoint>(&());
         cursor.seek(&inlay_point, Bias::Right, &());
         loop {
             match cursor.item() {
@@ -711,7 +718,7 @@ impl FoldSnapshot {
         language_aware: bool,
         highlights: Highlights<'a>,
     ) -> FoldChunks<'a> {
-        let mut transform_cursor = self.transforms.cursor::<(FoldOffset, InlayOffset)>();
+        let mut transform_cursor = self.transforms.cursor::<(FoldOffset, InlayOffset)>(&());
         transform_cursor.seek(&range.start, Bias::Right, &());
 
         let inlay_start = {
@@ -766,7 +773,7 @@ impl FoldSnapshot {
     }
 
     pub fn clip_point(&self, point: FoldPoint, bias: Bias) -> FoldPoint {
-        let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>();
+        let mut cursor = self.transforms.cursor::<(FoldPoint, InlayPoint)>(&());
         cursor.seek(&point, Bias::Right, &());
         if let Some(transform) = cursor.item() {
             let transform_start = cursor.start().0 .0;
@@ -826,7 +833,7 @@ where
     let buffer = &inlay_snapshot.buffer;
     let start = buffer.anchor_before(range.start.to_offset(buffer));
     let end = buffer.anchor_after(range.end.to_offset(buffer));
-    let mut cursor = folds.filter::<_, usize>(move |summary| {
+    let mut cursor = folds.filter::<_, usize>(buffer, move |summary| {
         let start_cmp = start.cmp(&summary.max_end, buffer);
         let end_cmp = end.cmp(&summary.min_start, buffer);
 
@@ -945,6 +952,10 @@ impl sum_tree::Item for Transform {
 impl sum_tree::Summary for TransformSummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, other: &Self, _: &()) {
         self.input += &other.input;
         self.output += &other.output;
@@ -1028,6 +1039,10 @@ impl Default for FoldSummary {
 impl sum_tree::Summary for FoldSummary {
     type Context = MultiBufferSnapshot;
 
+    fn zero(_cx: &MultiBufferSnapshot) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
         if other.min_start.cmp(&self.min_start, buffer) == Ordering::Less {
             self.min_start = other.min_start;
@@ -1052,6 +1067,10 @@ impl sum_tree::Summary for FoldSummary {
 }
 
 impl<'a> sum_tree::Dimension<'a, FoldSummary> for FoldRange {
+    fn zero(_cx: &MultiBufferSnapshot) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a FoldSummary, _: &MultiBufferSnapshot) {
         self.0.start = summary.start;
         self.0.end = summary.end;
@@ -1065,6 +1084,10 @@ impl<'a> sum_tree::SeekTarget<'a, FoldSummary, FoldRange> for FoldRange {
 }
 
 impl<'a> sum_tree::Dimension<'a, FoldSummary> for usize {
+    fn zero(_cx: &MultiBufferSnapshot) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a FoldSummary, _: &MultiBufferSnapshot) {
         *self += summary.count;
     }
@@ -1196,7 +1219,7 @@ impl FoldOffset {
     pub fn to_point(self, snapshot: &FoldSnapshot) -> FoldPoint {
         let mut cursor = snapshot
             .transforms
-            .cursor::<(FoldOffset, TransformSummary)>();
+            .cursor::<(FoldOffset, TransformSummary)>(&());
         cursor.seek(&self, Bias::Right, &());
         let overshoot = if cursor.item().map_or(true, |t| t.is_fold()) {
             Point::new(0, (self.0 - cursor.start().0 .0) as u32)
@@ -1210,7 +1233,7 @@ impl FoldOffset {
 
     #[cfg(test)]
     pub fn to_inlay_offset(self, snapshot: &FoldSnapshot) -> InlayOffset {
-        let mut cursor = snapshot.transforms.cursor::<(FoldOffset, InlayOffset)>();
+        let mut cursor = snapshot.transforms.cursor::<(FoldOffset, InlayOffset)>(&());
         cursor.seek(&self, Bias::Right, &());
         let overshoot = self.0 - cursor.start().0 .0;
         InlayOffset(cursor.start().1 .0 + overshoot)
@@ -1240,18 +1263,30 @@ impl Sub for FoldOffset {
 }
 
 impl<'a> sum_tree::Dimension<'a, TransformSummary> for FoldOffset {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
         self.0 += &summary.output.len;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, TransformSummary> for InlayPoint {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
         self.0 += &summary.input.lines;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, TransformSummary> for InlayOffset {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
         self.0 += &summary.input.len;
     }
diff --git a/crates/editor/src/display_map/inlay_map.rs b/crates/editor/src/display_map/inlay_map.rs
index b6ab2cdd28feea..712db45e3f61a7 100644
--- a/crates/editor/src/display_map/inlay_map.rs
+++ b/crates/editor/src/display_map/inlay_map.rs
@@ -97,6 +97,10 @@ struct TransformSummary {
 impl sum_tree::Summary for TransformSummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, other: &Self, _: &()) {
         self.input += &other.input;
         self.output += &other.output;
@@ -137,6 +141,10 @@ impl SubAssign for InlayOffset {
 }
 
 impl<'a> sum_tree::Dimension<'a, TransformSummary> for InlayOffset {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
         self.0 += &summary.output.len;
     }
@@ -162,18 +170,30 @@ impl Sub for InlayPoint {
 }
 
 impl<'a> sum_tree::Dimension<'a, TransformSummary> for InlayPoint {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
         self.0 += &summary.output.lines;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, TransformSummary> for usize {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
         *self += &summary.input.len;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, TransformSummary> for Point {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
         *self += &summary.input.lines;
     }
@@ -475,8 +495,8 @@ impl InlayMap {
             (snapshot.clone(), Vec::new())
         } else {
             let mut inlay_edits = Patch::default();
-            let mut new_transforms = SumTree::new();
-            let mut cursor = snapshot.transforms.cursor::<(usize, InlayOffset)>();
+            let mut new_transforms = SumTree::default();
+            let mut cursor = snapshot.transforms.cursor::<(usize, InlayOffset)>(&());
             let mut buffer_edits_iter = buffer_edits.iter().peekable();
             while let Some(buffer_edit) = buffer_edits_iter.next() {
                 new_transforms.append(cursor.slice(&buffer_edit.old.start, Bias::Left, &()), &());
@@ -693,7 +713,7 @@ impl InlaySnapshot {
     pub fn to_point(&self, offset: InlayOffset) -> InlayPoint {
         let mut cursor = self
             .transforms
-            .cursor::<(InlayOffset, (InlayPoint, usize))>();
+            .cursor::<(InlayOffset, (InlayPoint, usize))>(&());
         cursor.seek(&offset, Bias::Right, &());
         let overshoot = offset.0 - cursor.start().0 .0;
         match cursor.item() {
@@ -723,7 +743,7 @@ impl InlaySnapshot {
     pub fn to_offset(&self, point: InlayPoint) -> InlayOffset {
         let mut cursor = self
             .transforms
-            .cursor::<(InlayPoint, (InlayOffset, Point))>();
+            .cursor::<(InlayPoint, (InlayOffset, Point))>(&());
         cursor.seek(&point, Bias::Right, &());
         let overshoot = point.0 - cursor.start().0 .0;
         match cursor.item() {
@@ -741,9 +761,8 @@ impl InlaySnapshot {
             None => self.len(),
         }
     }
-
     pub fn to_buffer_point(&self, point: InlayPoint) -> Point {
-        let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>();
+        let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>(&());
         cursor.seek(&point, Bias::Right, &());
         match cursor.item() {
             Some(Transform::Isomorphic(_)) => {
@@ -754,9 +773,8 @@ impl InlaySnapshot {
             None => self.buffer.max_point(),
         }
     }
-
     pub fn to_buffer_offset(&self, offset: InlayOffset) -> usize {
-        let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>();
+        let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>(&());
         cursor.seek(&offset, Bias::Right, &());
         match cursor.item() {
             Some(Transform::Isomorphic(_)) => {
@@ -769,7 +787,7 @@ impl InlaySnapshot {
     }
 
     pub fn to_inlay_offset(&self, offset: usize) -> InlayOffset {
-        let mut cursor = self.transforms.cursor::<(usize, InlayOffset)>();
+        let mut cursor = self.transforms.cursor::<(usize, InlayOffset)>(&());
         cursor.seek(&offset, Bias::Left, &());
         loop {
             match cursor.item() {
@@ -801,9 +819,8 @@ impl InlaySnapshot {
             }
         }
     }
-
     pub fn to_inlay_point(&self, point: Point) -> InlayPoint {
-        let mut cursor = self.transforms.cursor::<(Point, InlayPoint)>();
+        let mut cursor = self.transforms.cursor::<(Point, InlayPoint)>(&());
         cursor.seek(&point, Bias::Left, &());
         loop {
             match cursor.item() {
@@ -837,7 +854,7 @@ impl InlaySnapshot {
     }
 
     pub fn clip_point(&self, mut point: InlayPoint, mut bias: Bias) -> InlayPoint {
-        let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>();
+        let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>(&());
         cursor.seek(&point, Bias::Left, &());
         loop {
             match cursor.item() {
@@ -934,7 +951,7 @@ impl InlaySnapshot {
     pub fn text_summary_for_range(&self, range: Range<InlayOffset>) -> TextSummary {
         let mut summary = TextSummary::default();
 
-        let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>();
+        let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>(&());
         cursor.seek(&range.start, Bias::Right, &());
 
         let overshoot = range.start.0 - cursor.start().0 .0;
@@ -982,7 +999,7 @@ impl InlaySnapshot {
     }
 
     pub fn buffer_rows(&self, row: u32) -> InlayBufferRows<'_> {
-        let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>();
+        let mut cursor = self.transforms.cursor::<(InlayPoint, Point)>(&());
         let inlay_point = InlayPoint::new(row, 0);
         cursor.seek(&inlay_point, Bias::Left, &());
 
@@ -1024,7 +1041,7 @@ impl InlaySnapshot {
         language_aware: bool,
         highlights: Highlights<'a>,
     ) -> InlayChunks<'a> {
-        let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>();
+        let mut cursor = self.transforms.cursor::<(InlayOffset, usize)>(&());
         cursor.seek(&range.start, Bias::Right, &());
 
         let mut highlight_endpoints = Vec::new();
diff --git a/crates/editor/src/display_map/wrap_map.rs b/crates/editor/src/display_map/wrap_map.rs
index 08b2ae0c645bcd..564bba2158030e 100644
--- a/crates/editor/src/display_map/wrap_map.rs
+++ b/crates/editor/src/display_map/wrap_map.rs
@@ -204,7 +204,7 @@ impl WrapMap {
             }
         } else {
             let old_rows = self.snapshot.transforms.summary().output.lines.row + 1;
-            self.snapshot.transforms = SumTree::new();
+            self.snapshot.transforms = SumTree::default();
             let summary = self.snapshot.tab_snapshot.text_summary();
             if !summary.lines.is_zero() {
                 self.snapshot
@@ -303,7 +303,7 @@ impl WrapMap {
 
 impl WrapSnapshot {
     fn new(tab_snapshot: TabSnapshot) -> Self {
-        let mut transforms = SumTree::new();
+        let mut transforms = SumTree::default();
         let extent = tab_snapshot.text_summary();
         if !extent.lines.is_zero() {
             transforms.push(Transform::isomorphic(extent), &());
@@ -324,7 +324,7 @@ impl WrapSnapshot {
         if tab_edits.is_empty() {
             new_transforms = self.transforms.clone();
         } else {
-            let mut old_cursor = self.transforms.cursor::<TabPoint>();
+            let mut old_cursor = self.transforms.cursor::<TabPoint>(&());
 
             let mut tab_edits_iter = tab_edits.iter().peekable();
             new_transforms =
@@ -424,7 +424,7 @@ impl WrapSnapshot {
             new_transforms = self.transforms.clone();
         } else {
             let mut row_edits = row_edits.into_iter().peekable();
-            let mut old_cursor = self.transforms.cursor::<TabPoint>();
+            let mut old_cursor = self.transforms.cursor::<TabPoint>(&());
 
             new_transforms = old_cursor.slice(
                 &TabPoint::new(row_edits.peek().unwrap().old_rows.start, 0),
@@ -537,8 +537,8 @@ impl WrapSnapshot {
 
     fn compute_edits(&self, tab_edits: &[TabEdit], new_snapshot: &WrapSnapshot) -> Patch<u32> {
         let mut wrap_edits = Vec::new();
-        let mut old_cursor = self.transforms.cursor::<TransformSummary>();
-        let mut new_cursor = new_snapshot.transforms.cursor::<TransformSummary>();
+        let mut old_cursor = self.transforms.cursor::<TransformSummary>(&());
+        let mut new_cursor = new_snapshot.transforms.cursor::<TransformSummary>(&());
         for mut tab_edit in tab_edits.iter().cloned() {
             tab_edit.old.start.0.column = 0;
             tab_edit.old.end.0 += Point::new(1, 0);
@@ -579,7 +579,7 @@ impl WrapSnapshot {
     ) -> WrapChunks<'a> {
         let output_start = WrapPoint::new(rows.start, 0);
         let output_end = WrapPoint::new(rows.end, 0);
-        let mut transforms = self.transforms.cursor::<(WrapPoint, TabPoint)>();
+        let mut transforms = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
         transforms.seek(&output_start, Bias::Right, &());
         let mut input_start = TabPoint(transforms.start().1 .0);
         if transforms.item().map_or(false, |t| t.is_isomorphic()) {
@@ -606,7 +606,7 @@ impl WrapSnapshot {
     }
 
     pub fn line_len(&self, row: u32) -> u32 {
-        let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>();
+        let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
         cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Left, &());
         if cursor
             .item()
@@ -626,7 +626,7 @@ impl WrapSnapshot {
     }
 
     pub fn soft_wrap_indent(&self, row: u32) -> Option<u32> {
-        let mut cursor = self.transforms.cursor::<WrapPoint>();
+        let mut cursor = self.transforms.cursor::<WrapPoint>(&());
         cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Right, &());
         cursor.item().and_then(|transform| {
             if transform.is_isomorphic() {
@@ -642,7 +642,7 @@ impl WrapSnapshot {
     }
 
     pub fn buffer_rows(&self, start_row: u32) -> WrapBufferRows {
-        let mut transforms = self.transforms.cursor::<(WrapPoint, TabPoint)>();
+        let mut transforms = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
         transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left, &());
         let mut input_row = transforms.start().1.row();
         if transforms.item().map_or(false, |t| t.is_isomorphic()) {
@@ -662,7 +662,7 @@ impl WrapSnapshot {
     }
 
     pub fn to_tab_point(&self, point: WrapPoint) -> TabPoint {
-        let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>();
+        let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
         cursor.seek(&point, Bias::Right, &());
         let mut tab_point = cursor.start().1 .0;
         if cursor.item().map_or(false, |t| t.is_isomorphic()) {
@@ -680,14 +680,14 @@ impl WrapSnapshot {
     }
 
     pub fn tab_point_to_wrap_point(&self, point: TabPoint) -> WrapPoint {
-        let mut cursor = self.transforms.cursor::<(TabPoint, WrapPoint)>();
+        let mut cursor = self.transforms.cursor::<(TabPoint, WrapPoint)>(&());
         cursor.seek(&point, Bias::Right, &());
         WrapPoint(cursor.start().1 .0 + (point.0 - cursor.start().0 .0))
     }
 
     pub fn clip_point(&self, mut point: WrapPoint, bias: Bias) -> WrapPoint {
         if bias == Bias::Left {
-            let mut cursor = self.transforms.cursor::<WrapPoint>();
+            let mut cursor = self.transforms.cursor::<WrapPoint>(&());
             cursor.seek(&point, Bias::Right, &());
             if cursor.item().map_or(false, |t| !t.is_isomorphic()) {
                 point = *cursor.start();
@@ -705,7 +705,7 @@ impl WrapSnapshot {
 
         *point.column_mut() = 0;
 
-        let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>();
+        let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
         cursor.seek(&point, Bias::Right, &());
         if cursor.item().is_none() {
             cursor.prev(&());
@@ -725,7 +725,7 @@ impl WrapSnapshot {
     pub fn next_row_boundary(&self, mut point: WrapPoint) -> Option<u32> {
         point.0 += Point::new(1, 0);
 
-        let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>();
+        let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
         cursor.seek(&point, Bias::Right, &());
         while let Some(transform) = cursor.item() {
             if transform.is_isomorphic() && cursor.start().1.column() == 0 {
@@ -747,7 +747,7 @@ impl WrapSnapshot {
             );
 
             {
-                let mut transforms = self.transforms.cursor::<()>().peekable();
+                let mut transforms = self.transforms.cursor::<()>(&()).peekable();
                 while let Some(transform) = transforms.next() {
                     if let Some(next_transform) = transforms.peek() {
                         assert!(transform.is_isomorphic() != next_transform.is_isomorphic());
@@ -982,6 +982,10 @@ impl WrapPoint {
 impl sum_tree::Summary for TransformSummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, other: &Self, _: &()) {
         self.input += &other.input;
         self.output += &other.output;
@@ -989,6 +993,10 @@ impl sum_tree::Summary for TransformSummary {
 }
 
 impl<'a> sum_tree::Dimension<'a, TransformSummary> for TabPoint {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
         self.0 += summary.input.lines;
     }
@@ -1001,6 +1009,10 @@ impl<'a> sum_tree::SeekTarget<'a, TransformSummary, TransformSummary> for TabPoi
 }
 
 impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapPoint {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
         self.0 += summary.output.lines;
     }
diff --git a/crates/editor/src/git/blame.rs b/crates/editor/src/git/blame.rs
index 00531ee88649a5..775cbcc379e128 100644
--- a/crates/editor/src/git/blame.rs
+++ b/crates/editor/src/git/blame.rs
@@ -37,12 +37,20 @@ impl sum_tree::Item for GitBlameEntry {
 impl sum_tree::Summary for GitBlameEntrySummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _cx: &()) {
         self.rows += summary.rows;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, GitBlameEntrySummary> for u32 {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a GitBlameEntrySummary, _cx: &()) {
         *self += summary.rows;
     }
@@ -191,7 +199,7 @@ impl GitBlame {
     ) -> impl 'a + Iterator<Item = Option<BlameEntry>> {
         self.sync(cx);
 
-        let mut cursor = self.entries.cursor::<u32>();
+        let mut cursor = self.entries.cursor::<u32>(&());
         rows.into_iter().map(move |row| {
             let row = row?;
             cursor.seek_forward(&row.0, Bias::Right, &());
@@ -249,8 +257,8 @@ impl GitBlame {
             })
             .peekable();
 
-        let mut new_entries = SumTree::new();
-        let mut cursor = self.entries.cursor::<u32>();
+        let mut new_entries = SumTree::default();
+        let mut cursor = self.entries.cursor::<u32>(&());
 
         while let Some(mut edit) = row_edits.next() {
             while let Some(next_edit) = row_edits.peek() {
diff --git a/crates/git/src/diff.rs b/crates/git/src/diff.rs
index eedef199dc3798..8cc7ee186350c5 100644
--- a/crates/git/src/diff.rs
+++ b/crates/git/src/diff.rs
@@ -48,6 +48,10 @@ pub struct DiffHunkSummary {
 impl sum_tree::Summary for DiffHunkSummary {
     type Context = text::BufferSnapshot;
 
+    fn zero(_cx: &Self::Context) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
         self.buffer_range.start = self
             .buffer_range
@@ -63,17 +67,11 @@ pub struct BufferDiff {
     tree: SumTree<DiffHunk<Anchor>>,
 }
 
-impl Default for BufferDiff {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl BufferDiff {
-    pub fn new() -> BufferDiff {
+    pub fn new(buffer: &BufferSnapshot) -> BufferDiff {
         BufferDiff {
             last_buffer_version: None,
-            tree: SumTree::new(),
+            tree: SumTree::new(buffer),
         }
     }
 
@@ -97,11 +95,13 @@ impl BufferDiff {
         range: Range<Anchor>,
         buffer: &'a BufferSnapshot,
     ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
-        let mut cursor = self.tree.filter::<_, DiffHunkSummary>(move |summary| {
-            let before_start = summary.buffer_range.end.cmp(&range.start, buffer).is_lt();
-            let after_end = summary.buffer_range.start.cmp(&range.end, buffer).is_gt();
-            !before_start && !after_end
-        });
+        let mut cursor = self
+            .tree
+            .filter::<_, DiffHunkSummary>(buffer, move |summary| {
+                let before_start = summary.buffer_range.end.cmp(&range.start, buffer).is_lt();
+                let after_end = summary.buffer_range.start.cmp(&range.end, buffer).is_gt();
+                !before_start && !after_end
+            });
 
         let anchor_iter = std::iter::from_fn(move || {
             cursor.next(buffer);
@@ -142,11 +142,13 @@ impl BufferDiff {
         range: Range<Anchor>,
         buffer: &'a BufferSnapshot,
     ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
-        let mut cursor = self.tree.filter::<_, DiffHunkSummary>(move |summary| {
-            let before_start = summary.buffer_range.end.cmp(&range.start, buffer).is_lt();
-            let after_end = summary.buffer_range.start.cmp(&range.end, buffer).is_gt();
-            !before_start && !after_end
-        });
+        let mut cursor = self
+            .tree
+            .filter::<_, DiffHunkSummary>(buffer, move |summary| {
+                let before_start = summary.buffer_range.end.cmp(&range.start, buffer).is_lt();
+                let after_end = summary.buffer_range.start.cmp(&range.end, buffer).is_gt();
+                !before_start && !after_end
+            });
 
         std::iter::from_fn(move || {
             cursor.prev(buffer);
@@ -171,11 +173,11 @@ impl BufferDiff {
     #[cfg(test)]
     fn clear(&mut self, buffer: &text::BufferSnapshot) {
         self.last_buffer_version = Some(buffer.version().clone());
-        self.tree = SumTree::new();
+        self.tree = SumTree::new(buffer);
     }
 
     pub async fn update(&mut self, diff_base: &Rope, buffer: &text::BufferSnapshot) {
-        let mut tree = SumTree::new();
+        let mut tree = SumTree::new(buffer);
 
         let diff_base_text = diff_base.to_string();
         let buffer_text = buffer.as_rope().to_string();
@@ -351,7 +353,7 @@ mod tests {
         .unindent();
 
         let mut buffer = Buffer::new(0, BufferId::new(1).unwrap(), buffer_text);
-        let mut diff = BufferDiff::new();
+        let mut diff = BufferDiff::new(&buffer);
         smol::block_on(diff.update(&diff_base_rope, &buffer));
         assert_hunks(
             diff.hunks(&buffer),
@@ -412,7 +414,7 @@ mod tests {
         .unindent();
 
         let buffer = Buffer::new(0, BufferId::new(1).unwrap(), buffer_text);
-        let mut diff = BufferDiff::new();
+        let mut diff = BufferDiff::new(&buffer);
         smol::block_on(diff.update(&diff_base_rope, &buffer));
         assert_eq!(diff.hunks(&buffer).count(), 8);
 
diff --git a/crates/gpui/src/elements/list.rs b/crates/gpui/src/elements/list.rs
index bea8270fa5524e..d03392867b5ee2 100644
--- a/crates/gpui/src/elements/list.rs
+++ b/crates/gpui/src/elements/list.rs
@@ -181,7 +181,7 @@ impl ListState {
             last_layout_bounds: None,
             last_padding: None,
             render_item: Box::new(render_item),
-            items: SumTree::new(),
+            items: SumTree::default(),
             logical_scroll_top: None,
             alignment,
             overdraw,
@@ -228,7 +228,7 @@ impl ListState {
     ) {
         let state = &mut *self.0.borrow_mut();
 
-        let mut old_items = state.items.cursor::<Count>();
+        let mut old_items = state.items.cursor::<Count>(&());
         let mut new_items = old_items.slice(&Count(old_range.start), Bias::Right, &());
         old_items.seek_forward(&Count(old_range.end), Bias::Right, &());
 
@@ -297,7 +297,7 @@ impl ListState {
             scroll_top.item_ix = ix;
             scroll_top.offset_in_item = px(0.);
         } else {
-            let mut cursor = state.items.cursor::<ListItemSummary>();
+            let mut cursor = state.items.cursor::<ListItemSummary>(&());
             cursor.seek(&Count(ix + 1), Bias::Right, &());
             let bottom = cursor.start().height + padding.top;
             let goal_top = px(0.).max(bottom - height + padding.bottom);
@@ -326,7 +326,7 @@ impl ListState {
             return None;
         }
 
-        let mut cursor = state.items.cursor::<(Count, Height)>();
+        let mut cursor = state.items.cursor::<(Count, Height)>(&());
         cursor.seek(&Count(scroll_top.item_ix), Bias::Right, &());
 
         let scroll_top = cursor.start().1 .0 + scroll_top.offset_in_item;
@@ -348,7 +348,7 @@ impl ListState {
 
 impl StateInner {
     fn visible_range(&self, height: Pixels, scroll_top: &ListOffset) -> Range<usize> {
-        let mut cursor = self.items.cursor::<ListItemSummary>();
+        let mut cursor = self.items.cursor::<ListItemSummary>(&());
         cursor.seek(&Count(scroll_top.item_ix), Bias::Right, &());
         let start_y = cursor.start().height + scroll_top.offset_in_item;
         cursor.seek_forward(&Height(start_y + height), Bias::Left, &());
@@ -378,7 +378,7 @@ impl StateInner {
         if self.alignment == ListAlignment::Bottom && new_scroll_top == scroll_max {
             self.logical_scroll_top = None;
         } else {
-            let mut cursor = self.items.cursor::<ListItemSummary>();
+            let mut cursor = self.items.cursor::<ListItemSummary>(&());
             cursor.seek(&Height(new_scroll_top), Bias::Right, &());
             let item_ix = cursor.start().count;
             let offset_in_item = new_scroll_top - cursor.start().height;
@@ -418,7 +418,7 @@ impl StateInner {
     }
 
     fn scroll_top(&self, logical_scroll_top: &ListOffset) -> Pixels {
-        let mut cursor = self.items.cursor::<ListItemSummary>();
+        let mut cursor = self.items.cursor::<ListItemSummary>(&());
         cursor.seek(&Count(logical_scroll_top.item_ix), Bias::Right, &());
         cursor.start().height + logical_scroll_top.offset_in_item
     }
@@ -445,7 +445,7 @@ impl StateInner {
             AvailableSpace::MinContent,
         );
 
-        let mut cursor = old_items.cursor::<Count>();
+        let mut cursor = old_items.cursor::<Count>(&());
 
         // Render items after the scroll top, including those in the trailing overdraw
         cursor.seek(&Count(scroll_top.item_ix), Bias::Right, &());
@@ -560,7 +560,7 @@ impl StateInner {
         }
 
         let measured_range = cursor.start().0..(cursor.start().0 + measured_items.len());
-        let mut cursor = old_items.cursor::<Count>();
+        let mut cursor = old_items.cursor::<Count>(&());
         let mut new_items = cursor.slice(&Count(measured_range.start), Bias::Right, &());
         new_items.extend(measured_items, &());
         cursor.seek(&Count(measured_range.end), Bias::Right, &());
@@ -573,7 +573,7 @@ impl StateInner {
         if !rendered_focused_item {
             let mut cursor = self
                 .items
-                .filter::<_, Count>(|summary| summary.has_focus_handles);
+                .filter::<_, Count>(&(), |summary| summary.has_focus_handles);
             cursor.next(&());
             while let Some(item) = cursor.item() {
                 if item.contains_focused(cx) {
@@ -629,7 +629,7 @@ impl StateInner {
                                     offset_in_item: autoscroll_bounds.top() - item_origin.y,
                                 });
                             } else if autoscroll_bounds.bottom() > bounds.bottom() {
-                                let mut cursor = self.items.cursor::<Count>();
+                                let mut cursor = self.items.cursor::<Count>(&());
                                 cursor.seek(&Count(item.index), Bias::Right, &());
                                 let mut height = bounds.size.height - padding.top - padding.bottom;
 
@@ -883,6 +883,10 @@ impl sum_tree::Item for ListItem {
 impl sum_tree::Summary for ListItemSummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &()) {
         self.count += summary.count;
         self.rendered_count += summary.rendered_count;
@@ -893,12 +897,20 @@ impl sum_tree::Summary for ListItemSummary {
 }
 
 impl<'a> sum_tree::Dimension<'a, ListItemSummary> for Count {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ListItemSummary, _: &()) {
         self.0 += summary.count;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, ListItemSummary> for Height {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ListItemSummary, _: &()) {
         self.0 += summary.height;
     }
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 76058ffd9bac9a..43fe1565acb796 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -722,7 +722,9 @@ impl Buffer {
         capability: Capability,
     ) -> Self {
         let saved_mtime = file.as_ref().and_then(|file| file.mtime());
-
+        let snapshot = buffer.snapshot();
+        let git_diff = git::diff::BufferDiff::new(&snapshot);
+        let syntax_map = Mutex::new(SyntaxMap::new(&snapshot));
         Self {
             saved_mtime,
             saved_version: buffer.version(),
@@ -739,10 +741,10 @@ impl Buffer {
                 })
                 .map(Rope::from),
             diff_base_version: 0,
-            git_diff: git::diff::BufferDiff::new(),
+            git_diff,
             file,
             capability,
-            syntax_map: Mutex::new(SyntaxMap::new()),
+            syntax_map,
             parsing_in_background: false,
             non_text_state_update_count: 0,
             sync_parse_timeout: Duration::from_millis(1),
@@ -809,7 +811,7 @@ impl Buffer {
     /// Assign a language to the buffer.
     pub fn set_language(&mut self, language: Option<Arc<Language>>, cx: &mut ModelContext<Self>) {
         self.non_text_state_update_count += 1;
-        self.syntax_map.lock().clear();
+        self.syntax_map.lock().clear(&self.text);
         self.language = language;
         self.reparse(cx);
         cx.emit(BufferEvent::LanguageChanged);
diff --git a/crates/language/src/diagnostic_set.rs b/crates/language/src/diagnostic_set.rs
index bc53778d97fb50..c35659d9bbd4d1 100644
--- a/crates/language/src/diagnostic_set.rs
+++ b/crates/language/src/diagnostic_set.rs
@@ -15,7 +15,7 @@ use text::{Anchor, FromAnchor, PointUtf16, ToOffset};
 /// The diagnostics are stored in a [`SumTree`], which allows this struct
 /// to be cheaply copied, and allows for efficient retrieval of the
 /// diagnostics that intersect a given range of the buffer.
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug)]
 pub struct DiagnosticSet {
     diagnostics: SumTree<DiagnosticEntry<Anchor>>,
 }
@@ -135,7 +135,7 @@ impl DiagnosticSet {
     {
         let end_bias = if inclusive { Bias::Right } else { Bias::Left };
         let range = buffer.anchor_before(range.start)..buffer.anchor_at(range.end, end_bias);
-        let mut cursor = self.diagnostics.filter::<_, ()>({
+        let mut cursor = self.diagnostics.filter::<_, ()>(buffer, {
             move |summary: &Summary| {
                 let start_cmp = range.start.cmp(&summary.max_end, buffer);
                 let end_cmp = range.end.cmp(&summary.min_start, buffer);
@@ -261,6 +261,10 @@ impl Default for Summary {
 impl sum_tree::Summary for Summary {
     type Context = text::BufferSnapshot;
 
+    fn zero(_cx: &Self::Context) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
         if other.min_start.cmp(&self.min_start, buffer).is_lt() {
             self.min_start = other.min_start;
diff --git a/crates/language/src/syntax_map.rs b/crates/language/src/syntax_map.rs
index 0cdc166570face..daae54fb4da62a 100644
--- a/crates/language/src/syntax_map.rs
+++ b/crates/language/src/syntax_map.rs
@@ -18,13 +18,12 @@ use sum_tree::{Bias, SeekTarget, SumTree};
 use text::{Anchor, BufferSnapshot, OffsetRangeExt, Point, Rope, ToOffset, ToPoint};
 use tree_sitter::{Node, Query, QueryCapture, QueryCaptures, QueryCursor, QueryMatches, Tree};
 
-#[derive(Default)]
 pub struct SyntaxMap {
     snapshot: SyntaxSnapshot,
     language_registry: Option<Arc<LanguageRegistry>>,
 }
 
-#[derive(Clone, Default)]
+#[derive(Clone)]
 pub struct SyntaxSnapshot {
     layers: SumTree<SyntaxLayerEntry>,
     parsed_version: clock::Global,
@@ -212,8 +211,11 @@ struct ByteChunks<'a>(text::Chunks<'a>);
 pub(crate) struct QueryCursorHandle(Option<QueryCursor>);
 
 impl SyntaxMap {
-    pub fn new() -> Self {
-        Self::default()
+    pub fn new(text: &BufferSnapshot) -> Self {
+        Self {
+            snapshot: SyntaxSnapshot::new(text),
+            language_registry: None,
+        }
     }
 
     pub fn set_language_registry(&mut self, registry: Arc<LanguageRegistry>) {
@@ -242,12 +244,21 @@ impl SyntaxMap {
         self.snapshot = snapshot;
     }
 
-    pub fn clear(&mut self) {
-        self.snapshot = SyntaxSnapshot::default();
+    pub fn clear(&mut self, text: &BufferSnapshot) {
+        self.snapshot = SyntaxSnapshot::new(text);
     }
 }
 
 impl SyntaxSnapshot {
+    fn new(text: &BufferSnapshot) -> Self {
+        Self {
+            layers: SumTree::new(text),
+            parsed_version: clock::Global::default(),
+            interpolated_version: clock::Global::default(),
+            language_registry_version: 0,
+        }
+    }
+
     pub fn is_empty(&self) -> bool {
         self.layers.is_empty()
     }
@@ -262,10 +273,10 @@ impl SyntaxSnapshot {
             return;
         }
 
-        let mut layers = SumTree::new();
+        let mut layers = SumTree::new(text);
         let mut first_edit_ix_for_depth = 0;
         let mut prev_depth = 0;
-        let mut cursor = self.layers.cursor::<SyntaxLayerSummary>();
+        let mut cursor = self.layers.cursor::<SyntaxLayerSummary>(text);
         cursor.next(text);
 
         'outer: loop {
@@ -388,7 +399,7 @@ impl SyntaxSnapshot {
                 let mut resolved_injection_ranges = Vec::new();
                 let mut cursor = self
                     .layers
-                    .filter::<_, ()>(|summary| summary.contains_unknown_injections);
+                    .filter::<_, ()>(text, |summary| summary.contains_unknown_injections);
                 cursor.next(text);
                 while let Some(layer) = cursor.item() {
                     let SyntaxLayerContent::Pending { language_name } = &layer.content else {
@@ -430,9 +441,9 @@ impl SyntaxSnapshot {
         log::trace!("reparse. invalidated ranges:{:?}", invalidated_ranges);
 
         let max_depth = self.layers.summary().max_depth;
-        let mut cursor = self.layers.cursor::<SyntaxLayerSummary>();
+        let mut cursor = self.layers.cursor::<SyntaxLayerSummary>(text);
         cursor.next(text);
-        let mut layers = SumTree::new();
+        let mut layers = SumTree::new(text);
 
         let mut changed_regions = ChangeRegionSet::default();
         let mut queue = BinaryHeap::new();
@@ -823,7 +834,7 @@ impl SyntaxSnapshot {
         let start = buffer.anchor_before(start_offset);
         let end = buffer.anchor_after(end_offset);
 
-        let mut cursor = self.layers.filter::<_, ()>(move |summary| {
+        let mut cursor = self.layers.filter::<_, ()>(buffer, move |summary| {
             if summary.max_depth > summary.min_depth {
                 true
             } else {
@@ -1666,6 +1677,10 @@ impl Default for SyntaxLayerSummary {
 impl sum_tree::Summary for SyntaxLayerSummary {
     type Context = BufferSnapshot;
 
+    fn zero(_cx: &BufferSnapshot) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
         if other.max_depth > self.max_depth {
             self.max_depth = other.max_depth;
diff --git a/crates/language/src/syntax_map/syntax_map_tests.rs b/crates/language/src/syntax_map/syntax_map_tests.rs
index 6f42252da56cfd..f6d27bcbd21943 100644
--- a/crates/language/src/syntax_map/syntax_map_tests.rs
+++ b/crates/language/src/syntax_map/syntax_map_tests.rs
@@ -103,7 +103,7 @@ fn test_syntax_map_layers_for_range(cx: &mut AppContext) {
         .unindent(),
     );
 
-    let mut syntax_map = SyntaxMap::new();
+    let mut syntax_map = SyntaxMap::new(&buffer);
     syntax_map.set_language_registry(registry.clone());
     syntax_map.reparse(language.clone(), &buffer);
 
@@ -202,7 +202,7 @@ fn test_dynamic_language_injection(cx: &mut AppContext) {
         .unindent(),
     );
 
-    let mut syntax_map = SyntaxMap::new();
+    let mut syntax_map = SyntaxMap::new(&buffer);
     syntax_map.set_language_registry(registry.clone());
     syntax_map.reparse(markdown.clone(), &buffer);
     syntax_map.reparse(markdown_inline.clone(), &buffer);
@@ -897,11 +897,11 @@ fn test_random_edits(
 
     let mut buffer = Buffer::new(0, BufferId::new(1).unwrap(), text);
 
-    let mut syntax_map = SyntaxMap::new();
+    let mut syntax_map = SyntaxMap::new(&buffer);
     syntax_map.set_language_registry(registry.clone());
     syntax_map.reparse(language.clone(), &buffer);
 
-    let mut reference_syntax_map = SyntaxMap::new();
+    let mut reference_syntax_map = SyntaxMap::new(&buffer);
     reference_syntax_map.set_language_registry(registry.clone());
 
     log::info!("initial text:\n{}", buffer.text());
@@ -918,7 +918,7 @@ fn test_random_edits(
 
         syntax_map.reparse(language.clone(), &buffer);
 
-        reference_syntax_map.clear();
+        reference_syntax_map.clear(&buffer);
         reference_syntax_map.reparse(language.clone(), &buffer);
     }
 
@@ -931,7 +931,7 @@ fn test_random_edits(
         syntax_map.interpolate(&buffer);
         syntax_map.reparse(language.clone(), &buffer);
 
-        reference_syntax_map.clear();
+        reference_syntax_map.clear(&buffer);
         reference_syntax_map.reparse(language.clone(), &buffer);
         assert_eq!(
             syntax_map.layers(&buffer).len(),
@@ -1082,7 +1082,7 @@ fn test_edit_sequence(
         .unwrap();
     let mut buffer = Buffer::new(0, BufferId::new(1).unwrap(), Default::default());
 
-    let mut mutated_syntax_map = SyntaxMap::new();
+    let mut mutated_syntax_map = SyntaxMap::new(&buffer);
     mutated_syntax_map.set_language_registry(registry.clone());
     mutated_syntax_map.reparse(language.clone(), &buffer);
 
@@ -1097,7 +1097,7 @@ fn test_edit_sequence(
 
         // Create a second syntax map from scratch
         log::info!("fresh parse {i}: {marked_string:?}");
-        let mut reference_syntax_map = SyntaxMap::new();
+        let mut reference_syntax_map = SyntaxMap::new(&buffer);
         reference_syntax_map.set_language_registry(registry.clone());
         reference_syntax_map.reparse(language.clone(), &buffer);
 
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index 5b6eddd5b16bf1..9dee092dea9f29 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -561,7 +561,7 @@ impl MultiBuffer {
         }
         let mut buffer_edits: HashMap<BufferId, Vec<BufferEdit>> = Default::default();
         let mut edited_excerpt_ids = Vec::new();
-        let mut cursor = snapshot.excerpts.cursor::<usize>();
+        let mut cursor = snapshot.excerpts.cursor::<usize>(&());
         for (ix, (range, new_text)) in edits.enumerate() {
             let new_text: Arc<str> = new_text.into();
             let original_indent_column = original_indent_columns.get(ix).copied().unwrap_or(0);
@@ -841,7 +841,7 @@ impl MultiBuffer {
         let mut ranges = Vec::new();
         let snapshot = self.read(cx);
         let buffers = self.buffers.borrow();
-        let mut cursor = snapshot.excerpts.cursor::<ExcerptSummary>();
+        let mut cursor = snapshot.excerpts.cursor::<ExcerptSummary>(&());
 
         for (buffer_id, buffer_transaction) in &transaction.buffer_transactions {
             let Some(buffer_state) = buffers.get(buffer_id) else {
@@ -957,7 +957,7 @@ impl MultiBuffer {
         let mut selections_by_buffer: HashMap<BufferId, Vec<Selection<text::Anchor>>> =
             Default::default();
         let snapshot = self.read(cx);
-        let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>();
+        let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>(&());
         for selection in selections {
             let start_locator = snapshot.excerpt_locator_for_id(selection.start.excerpt_id);
             let end_locator = snapshot.excerpt_locator_for_id(selection.end.excerpt_id);
@@ -1281,7 +1281,7 @@ impl MultiBuffer {
 
         let mut prev_locator = snapshot.excerpt_locator_for_id(prev_excerpt_id).clone();
         let mut new_excerpt_ids = mem::take(&mut snapshot.excerpt_ids);
-        let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>();
+        let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>(&());
         let mut new_excerpts = cursor.slice(&prev_locator, Bias::Right, &());
         prev_locator = cursor.start().unwrap_or(Locator::min_ref()).clone();
 
@@ -1388,7 +1388,7 @@ impl MultiBuffer {
         let mut excerpts = Vec::new();
         let snapshot = self.read(cx);
         let buffers = self.buffers.borrow();
-        let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>();
+        let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>(&());
         for locator in buffers
             .get(&buffer.read(cx).remote_id())
             .map(|state| &state.excerpts)
@@ -1432,7 +1432,7 @@ impl MultiBuffer {
         let snapshot = self.read(cx);
         let position = position.to_offset(&snapshot);
 
-        let mut cursor = snapshot.excerpts.cursor::<usize>();
+        let mut cursor = snapshot.excerpts.cursor::<usize>(&());
         cursor.seek(&position, Bias::Right, &());
         cursor
             .item()
@@ -1459,7 +1459,7 @@ impl MultiBuffer {
     ) -> Option<(Model<Buffer>, usize, ExcerptId)> {
         let snapshot = self.read(cx);
         let offset = point.to_offset(&snapshot);
-        let mut cursor = snapshot.excerpts.cursor::<usize>();
+        let mut cursor = snapshot.excerpts.cursor::<usize>(&());
         cursor.seek(&offset, Bias::Right, &());
         if cursor.item().is_none() {
             cursor.prev(&());
@@ -1482,7 +1482,7 @@ impl MultiBuffer {
     ) -> Option<(Model<Buffer>, Point, ExcerptId)> {
         let snapshot = self.read(cx);
         let point = point.to_point(&snapshot);
-        let mut cursor = snapshot.excerpts.cursor::<Point>();
+        let mut cursor = snapshot.excerpts.cursor::<Point>(&());
         cursor.seek(&point, Bias::Right, &());
         if cursor.item().is_none() {
             cursor.prev(&());
@@ -1507,7 +1507,7 @@ impl MultiBuffer {
         let end = range.end.to_offset(&snapshot);
 
         let mut result = Vec::new();
-        let mut cursor = snapshot.excerpts.cursor::<usize>();
+        let mut cursor = snapshot.excerpts.cursor::<usize>(&());
         cursor.seek(&start, Bias::Right, &());
         if cursor.item().is_none() {
             cursor.prev(&());
@@ -1546,8 +1546,8 @@ impl MultiBuffer {
 
         let mut buffers = self.buffers.borrow_mut();
         let mut snapshot = self.snapshot.borrow_mut();
-        let mut new_excerpts = SumTree::new();
-        let mut cursor = snapshot.excerpts.cursor::<(Option<&Locator>, usize)>();
+        let mut new_excerpts = SumTree::default();
+        let mut cursor = snapshot.excerpts.cursor::<(Option<&Locator>, usize)>(&());
         let mut edits = Vec::new();
         let mut excerpt_ids = ids.iter().copied().peekable();
 
@@ -1801,8 +1801,8 @@ impl MultiBuffer {
         let ids = ids.into_iter().collect::<Vec<_>>();
         let snapshot = self.snapshot(cx);
         let locators = snapshot.excerpt_locators_for_ids(ids.iter().copied());
-        let mut new_excerpts = SumTree::new();
-        let mut cursor = snapshot.excerpts.cursor::<(Option<&Locator>, usize)>();
+        let mut new_excerpts = SumTree::default();
+        let mut cursor = snapshot.excerpts.cursor::<(Option<&Locator>, usize)>(&());
         let mut edits = Vec::<Edit<usize>>::new();
 
         for locator in &locators {
@@ -1927,8 +1927,8 @@ impl MultiBuffer {
         excerpts_to_edit.sort_unstable_by_key(|(locator, _, _)| *locator);
 
         let mut edits = Vec::new();
-        let mut new_excerpts = SumTree::new();
-        let mut cursor = snapshot.excerpts.cursor::<(Option<&Locator>, usize)>();
+        let mut new_excerpts = SumTree::default();
+        let mut cursor = snapshot.excerpts.cursor::<(Option<&Locator>, usize)>(&());
 
         for (locator, buffer, buffer_edited) in excerpts_to_edit {
             new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &());
@@ -2230,7 +2230,7 @@ impl MultiBufferSnapshot {
 
     pub fn reversed_chars_at<T: ToOffset>(&self, position: T) -> impl Iterator<Item = char> + '_ {
         let mut offset = position.to_offset(self);
-        let mut cursor = self.excerpts.cursor::<usize>();
+        let mut cursor = self.excerpts.cursor::<usize>(&());
         cursor.seek(&offset, Bias::Left, &());
         let mut excerpt_chunks = cursor.item().map(|excerpt| {
             let end_before_footer = cursor.start() + excerpt.text_summary.len;
@@ -2357,7 +2357,7 @@ impl MultiBufferSnapshot {
             return buffer.clip_offset(offset, bias);
         }
 
-        let mut cursor = self.excerpts.cursor::<usize>();
+        let mut cursor = self.excerpts.cursor::<usize>(&());
         cursor.seek(&offset, Bias::Right, &());
         let overshoot = if let Some(excerpt) = cursor.item() {
             let excerpt_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
@@ -2376,7 +2376,7 @@ impl MultiBufferSnapshot {
             return buffer.clip_point(point, bias);
         }
 
-        let mut cursor = self.excerpts.cursor::<Point>();
+        let mut cursor = self.excerpts.cursor::<Point>(&());
         cursor.seek(&point, Bias::Right, &());
         let overshoot = if let Some(excerpt) = cursor.item() {
             let excerpt_start = excerpt.range.context.start.to_point(&excerpt.buffer);
@@ -2395,7 +2395,7 @@ impl MultiBufferSnapshot {
             return buffer.clip_offset_utf16(offset, bias);
         }
 
-        let mut cursor = self.excerpts.cursor::<OffsetUtf16>();
+        let mut cursor = self.excerpts.cursor::<OffsetUtf16>(&());
         cursor.seek(&offset, Bias::Right, &());
         let overshoot = if let Some(excerpt) = cursor.item() {
             let excerpt_start = excerpt.range.context.start.to_offset_utf16(&excerpt.buffer);
@@ -2414,7 +2414,7 @@ impl MultiBufferSnapshot {
             return buffer.clip_point_utf16(point, bias);
         }
 
-        let mut cursor = self.excerpts.cursor::<PointUtf16>();
+        let mut cursor = self.excerpts.cursor::<PointUtf16>(&());
         cursor.seek(&point.0, Bias::Right, &());
         let overshoot = if let Some(excerpt) = cursor.item() {
             let excerpt_start = excerpt
@@ -2432,7 +2432,7 @@ impl MultiBufferSnapshot {
 
     pub fn bytes_in_range<T: ToOffset>(&self, range: Range<T>) -> MultiBufferBytes {
         let range = range.start.to_offset(self)..range.end.to_offset(self);
-        let mut excerpts = self.excerpts.cursor::<usize>();
+        let mut excerpts = self.excerpts.cursor::<usize>(&());
         excerpts.seek(&range.start, Bias::Right, &());
 
         let mut chunk = &[][..];
@@ -2457,7 +2457,7 @@ impl MultiBufferSnapshot {
         range: Range<T>,
     ) -> ReversedMultiBufferBytes {
         let range = range.start.to_offset(self)..range.end.to_offset(self);
-        let mut excerpts = self.excerpts.cursor::<usize>();
+        let mut excerpts = self.excerpts.cursor::<usize>(&());
         excerpts.seek(&range.end, Bias::Left, &());
 
         let mut chunk = &[][..];
@@ -2482,7 +2482,7 @@ impl MultiBufferSnapshot {
     pub fn buffer_rows(&self, start_row: MultiBufferRow) -> MultiBufferRows {
         let mut result = MultiBufferRows {
             buffer_row_range: 0..0,
-            excerpts: self.excerpts.cursor(),
+            excerpts: self.excerpts.cursor(&()),
         };
         result.seek(start_row);
         result
@@ -2492,7 +2492,7 @@ impl MultiBufferSnapshot {
         let range = range.start.to_offset(self)..range.end.to_offset(self);
         let mut chunks = MultiBufferChunks {
             range: range.clone(),
-            excerpts: self.excerpts.cursor(),
+            excerpts: self.excerpts.cursor(&()),
             excerpt_chunks: None,
             language_aware,
         };
@@ -2505,7 +2505,7 @@ impl MultiBufferSnapshot {
             return buffer.offset_to_point(offset);
         }
 
-        let mut cursor = self.excerpts.cursor::<(usize, Point)>();
+        let mut cursor = self.excerpts.cursor::<(usize, Point)>(&());
         cursor.seek(&offset, Bias::Right, &());
         if let Some(excerpt) = cursor.item() {
             let (start_offset, start_point) = cursor.start();
@@ -2526,7 +2526,7 @@ impl MultiBufferSnapshot {
             return buffer.offset_to_point_utf16(offset);
         }
 
-        let mut cursor = self.excerpts.cursor::<(usize, PointUtf16)>();
+        let mut cursor = self.excerpts.cursor::<(usize, PointUtf16)>(&());
         cursor.seek(&offset, Bias::Right, &());
         if let Some(excerpt) = cursor.item() {
             let (start_offset, start_point) = cursor.start();
@@ -2547,7 +2547,7 @@ impl MultiBufferSnapshot {
             return buffer.point_to_point_utf16(point);
         }
 
-        let mut cursor = self.excerpts.cursor::<(Point, PointUtf16)>();
+        let mut cursor = self.excerpts.cursor::<(Point, PointUtf16)>(&());
         cursor.seek(&point, Bias::Right, &());
         if let Some(excerpt) = cursor.item() {
             let (start_offset, start_point) = cursor.start();
@@ -2569,7 +2569,7 @@ impl MultiBufferSnapshot {
             return buffer.point_to_offset(point);
         }
 
-        let mut cursor = self.excerpts.cursor::<(Point, usize)>();
+        let mut cursor = self.excerpts.cursor::<(Point, usize)>(&());
         cursor.seek(&point, Bias::Right, &());
         if let Some(excerpt) = cursor.item() {
             let (start_point, start_offset) = cursor.start();
@@ -2590,7 +2590,7 @@ impl MultiBufferSnapshot {
             return buffer.offset_utf16_to_offset(offset_utf16);
         }
 
-        let mut cursor = self.excerpts.cursor::<(OffsetUtf16, usize)>();
+        let mut cursor = self.excerpts.cursor::<(OffsetUtf16, usize)>(&());
         cursor.seek(&offset_utf16, Bias::Right, &());
         if let Some(excerpt) = cursor.item() {
             let (start_offset_utf16, start_offset) = cursor.start();
@@ -2612,7 +2612,7 @@ impl MultiBufferSnapshot {
             return buffer.offset_to_offset_utf16(offset);
         }
 
-        let mut cursor = self.excerpts.cursor::<(usize, OffsetUtf16)>();
+        let mut cursor = self.excerpts.cursor::<(usize, OffsetUtf16)>(&());
         cursor.seek(&offset, Bias::Right, &());
         if let Some(excerpt) = cursor.item() {
             let (start_offset, start_offset_utf16) = cursor.start();
@@ -2636,7 +2636,7 @@ impl MultiBufferSnapshot {
             return buffer.point_utf16_to_offset(point);
         }
 
-        let mut cursor = self.excerpts.cursor::<(PointUtf16, usize)>();
+        let mut cursor = self.excerpts.cursor::<(PointUtf16, usize)>(&());
         cursor.seek(&point, Bias::Right, &());
         if let Some(excerpt) = cursor.item() {
             let (start_point, start_offset) = cursor.start();
@@ -2659,7 +2659,7 @@ impl MultiBufferSnapshot {
         point: T,
     ) -> Option<(&BufferSnapshot, usize)> {
         let offset = point.to_offset(self);
-        let mut cursor = self.excerpts.cursor::<usize>();
+        let mut cursor = self.excerpts.cursor::<usize>(&());
         cursor.seek(&offset, Bias::Right, &());
         if cursor.item().is_none() {
             cursor.prev(&());
@@ -2680,7 +2680,7 @@ impl MultiBufferSnapshot {
         let mut result = BTreeMap::new();
 
         let mut rows_for_excerpt = Vec::new();
-        let mut cursor = self.excerpts.cursor::<Point>();
+        let mut cursor = self.excerpts.cursor::<Point>(&());
         let mut rows = rows.into_iter().peekable();
         let mut prev_row = u32::MAX;
         let mut prev_language_indent_size = IndentSize::default();
@@ -2769,7 +2769,7 @@ impl MultiBufferSnapshot {
         &self,
         row: MultiBufferRow,
     ) -> Option<(&BufferSnapshot, Range<Point>)> {
-        let mut cursor = self.excerpts.cursor::<Point>();
+        let mut cursor = self.excerpts.cursor::<Point>(&());
         let point = Point::new(row.0, 0);
         cursor.seek(&point, Bias::Right, &());
         if cursor.item().is_none() && *cursor.start() == point {
@@ -2803,9 +2803,9 @@ impl MultiBufferSnapshot {
         D: TextDimension,
         O: ToOffset,
     {
-        let mut summary = D::default();
+        let mut summary = D::zero(&());
         let mut range = range.start.to_offset(self)..range.end.to_offset(self);
-        let mut cursor = self.excerpts.cursor::<usize>();
+        let mut cursor = self.excerpts.cursor::<usize>(&());
         cursor.seek(&range.start, Bias::Right, &());
         if let Some(excerpt) = cursor.item() {
             let mut end_before_newline = cursor.end(&());
@@ -2856,7 +2856,7 @@ impl MultiBufferSnapshot {
     where
         D: TextDimension + Ord + Sub<D, Output = D>,
     {
-        let mut cursor = self.excerpts.cursor::<ExcerptSummary>();
+        let mut cursor = self.excerpts.cursor::<ExcerptSummary>(&());
         let locator = self.excerpt_locator_for_id(anchor.excerpt_id);
 
         cursor.seek(locator, Bias::Left, &());
@@ -2894,7 +2894,7 @@ impl MultiBufferSnapshot {
         }
 
         let mut anchors = anchors.into_iter().peekable();
-        let mut cursor = self.excerpts.cursor::<ExcerptSummary>();
+        let mut cursor = self.excerpts.cursor::<ExcerptSummary>(&());
         let mut summaries = Vec::new();
         while let Some(anchor) = anchors.peek() {
             let excerpt_id = anchor.excerpt_id;
@@ -2949,7 +2949,7 @@ impl MultiBufferSnapshot {
         I: 'a + IntoIterator<Item = &'a Anchor>,
     {
         let mut anchors = anchors.into_iter().enumerate().peekable();
-        let mut cursor = self.excerpts.cursor::<Option<&Locator>>();
+        let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
         cursor.next(&());
 
         let mut result = Vec::new();
@@ -3064,7 +3064,7 @@ impl MultiBufferSnapshot {
             };
         }
 
-        let mut cursor = self.excerpts.cursor::<(usize, Option<ExcerptId>)>();
+        let mut cursor = self.excerpts.cursor::<(usize, Option<ExcerptId>)>(&());
         cursor.seek(&offset, Bias::Right, &());
         if cursor.item().is_none() && offset == cursor.start().0 && bias == Bias::Left {
             cursor.prev(&());
@@ -3099,7 +3099,7 @@ impl MultiBufferSnapshot {
         text_anchor: text::Anchor,
     ) -> Option<Anchor> {
         let locator = self.excerpt_locator_for_id(excerpt_id);
-        let mut cursor = self.excerpts.cursor::<Option<&Locator>>();
+        let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
         cursor.seek(locator, Bias::Left, &());
         if let Some(excerpt) = cursor.item() {
             if excerpt.id == excerpt_id {
@@ -3139,7 +3139,7 @@ impl MultiBufferSnapshot {
     ) -> impl Iterator<Item = (&Excerpt, usize)> + '_ {
         let range = range.start.to_offset(self)..range.end.to_offset(self);
 
-        let mut cursor = self.excerpts.cursor::<usize>();
+        let mut cursor = self.excerpts.cursor::<usize>(&());
         cursor.seek(&range.start, Bias::Right, &());
         cursor.prev(&());
 
@@ -3183,7 +3183,7 @@ impl MultiBufferSnapshot {
         };
         let bounds = (start, end);
 
-        let mut cursor = self.excerpts.cursor::<(usize, Point)>();
+        let mut cursor = self.excerpts.cursor::<(usize, Point)>(&());
         cursor.seek(&start_offset, Bias::Right, &());
         if cursor.item().is_none() {
             cursor.prev(&());
@@ -3550,7 +3550,7 @@ impl MultiBufferSnapshot {
         &self,
         row_range: Range<MultiBufferRow>,
     ) -> impl Iterator<Item = DiffHunk<MultiBufferRow>> + '_ {
-        let mut cursor = self.excerpts.cursor::<Point>();
+        let mut cursor = self.excerpts.cursor::<Point>(&());
 
         cursor.seek(&Point::new(row_range.end.0, 0), Bias::Left, &());
         if cursor.item().is_none() {
@@ -3617,7 +3617,7 @@ impl MultiBufferSnapshot {
         &self,
         row_range: Range<MultiBufferRow>,
     ) -> impl Iterator<Item = DiffHunk<MultiBufferRow>> + '_ {
-        let mut cursor = self.excerpts.cursor::<Point>();
+        let mut cursor = self.excerpts.cursor::<Point>(&());
 
         cursor.seek(&Point::new(row_range.start.0, 0), Bias::Left, &());
 
@@ -3779,7 +3779,7 @@ impl MultiBufferSnapshot {
         } else if id == ExcerptId::max() {
             Locator::max_ref()
         } else {
-            let mut cursor = self.excerpt_ids.cursor::<ExcerptId>();
+            let mut cursor = self.excerpt_ids.cursor::<ExcerptId>(&());
             cursor.seek(&id, Bias::Left, &());
             if let Some(entry) = cursor.item() {
                 if entry.id == id {
@@ -3814,7 +3814,7 @@ impl MultiBufferSnapshot {
             }
         }
 
-        let mut cursor = self.excerpt_ids.cursor::<ExcerptId>();
+        let mut cursor = self.excerpt_ids.cursor::<ExcerptId>(&());
         for id in sorted_ids {
             if cursor.seek_forward(&id, Bias::Left, &()) {
                 locators.push(cursor.item().unwrap().locator.clone());
@@ -3839,7 +3839,7 @@ impl MultiBufferSnapshot {
         &'a self,
         excerpt_id: ExcerptId,
     ) -> Option<Range<T>> {
-        let mut cursor = self.excerpts.cursor::<(Option<&Locator>, T)>();
+        let mut cursor = self.excerpts.cursor::<(Option<&Locator>, T)>(&());
         let locator = self.excerpt_locator_for_id(excerpt_id);
         if cursor.seek(&Some(locator), Bias::Left, &()) {
             let start = cursor.start().1.clone();
@@ -3851,7 +3851,7 @@ impl MultiBufferSnapshot {
     }
 
     fn excerpt(&self, excerpt_id: ExcerptId) -> Option<&Excerpt> {
-        let mut cursor = self.excerpts.cursor::<Option<&Locator>>();
+        let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
         let locator = self.excerpt_locator_for_id(excerpt_id);
         cursor.seek(&Some(locator), Bias::Left, &());
         if let Some(excerpt) = cursor.item() {
@@ -3866,7 +3866,7 @@ impl MultiBufferSnapshot {
     pub fn excerpt_containing<T: ToOffset>(&self, range: Range<T>) -> Option<MultiBufferExcerpt> {
         let range = range.start.to_offset(self)..range.end.to_offset(self);
 
-        let mut cursor = self.excerpts.cursor::<usize>();
+        let mut cursor = self.excerpts.cursor::<usize>(&());
         cursor.seek(&range.start, Bias::Right, &());
         let start_excerpt = cursor.item()?;
 
@@ -3891,7 +3891,7 @@ impl MultiBufferSnapshot {
         I: IntoIterator<Item = Range<Anchor>> + 'a,
     {
         let mut ranges = ranges.into_iter().map(|range| range.to_offset(self));
-        let mut cursor = self.excerpts.cursor::<usize>();
+        let mut cursor = self.excerpts.cursor::<usize>(&());
         cursor.next(&());
         let mut current_range = ranges.next();
         iter::from_fn(move || {
@@ -3943,7 +3943,7 @@ impl MultiBufferSnapshot {
         ranges: impl IntoIterator<Item = Range<Anchor>>,
     ) -> impl Iterator<Item = (ExcerptId, &BufferSnapshot, Range<usize>)> {
         let mut ranges = ranges.into_iter().map(|range| range.to_offset(self));
-        let mut cursor = self.excerpts.cursor::<usize>();
+        let mut cursor = self.excerpts.cursor::<usize>(&());
         cursor.next(&());
         let mut current_range = ranges.next();
         iter::from_fn(move || {
@@ -3980,7 +3980,7 @@ impl MultiBufferSnapshot {
         range: &'a Range<Anchor>,
         include_local: bool,
     ) -> impl 'a + Iterator<Item = (ReplicaId, bool, CursorShape, Selection<Anchor>)> {
-        let mut cursor = self.excerpts.cursor::<ExcerptSummary>();
+        let mut cursor = self.excerpts.cursor::<ExcerptSummary>(&());
         let start_locator = self.excerpt_locator_for_id(range.start.excerpt_id);
         let end_locator = self.excerpt_locator_for_id(range.end.excerpt_id);
         cursor.seek(start_locator, Bias::Left, &());
@@ -4519,6 +4519,10 @@ impl sum_tree::KeyedItem for ExcerptIdMapping {
 impl sum_tree::Summary for ExcerptId {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, other: &Self, _: &()) {
         *self = *other;
     }
@@ -4527,6 +4531,10 @@ impl sum_tree::Summary for ExcerptId {
 impl sum_tree::Summary for ExcerptSummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &()) {
         debug_assert!(summary.excerpt_locator > self.excerpt_locator);
         self.excerpt_locator = summary.excerpt_locator.clone();
@@ -4536,12 +4544,20 @@ impl sum_tree::Summary for ExcerptSummary {
 }
 
 impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for TextSummary {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
         *self += &summary.text;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for usize {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
         *self += summary.text.len;
     }
@@ -4566,30 +4582,50 @@ impl<'a> sum_tree::SeekTarget<'a, ExcerptSummary, ExcerptSummary> for Locator {
 }
 
 impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for OffsetUtf16 {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
         *self += summary.text.len_utf16;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Point {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
         *self += summary.text.lines;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for PointUtf16 {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
         *self += summary.text.lines_utf16()
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Option<&'a Locator> {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
         *self = Some(&summary.excerpt_locator);
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Option<ExcerptId> {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
         *self = Some(summary.excerpt_id);
     }
diff --git a/crates/notifications/src/notification_store.rs b/crates/notifications/src/notification_store.rs
index e01b99d472223f..48fcb5dfbb830a 100644
--- a/crates/notifications/src/notification_store.rs
+++ b/crates/notifications/src/notification_store.rs
@@ -137,13 +137,12 @@ impl NotificationStore {
             return None;
         }
         let ix = count - 1 - ix;
-        let mut cursor = self.notifications.cursor::<Count>();
+        let mut cursor = self.notifications.cursor::<Count>(&());
         cursor.seek(&Count(ix), Bias::Right, &());
         cursor.item()
     }
-
     pub fn notification_for_id(&self, id: u64) -> Option<&NotificationEntry> {
-        let mut cursor = self.notifications.cursor::<NotificationId>();
+        let mut cursor = self.notifications.cursor::<NotificationId>(&());
         cursor.seek(&NotificationId(id), Bias::Left, &());
         if let Some(item) = cursor.item() {
             if item.id == id {
@@ -372,8 +371,8 @@ impl NotificationStore {
         is_new: bool,
         cx: &mut ModelContext<'_, NotificationStore>,
     ) {
-        let mut cursor = self.notifications.cursor::<(NotificationId, Count)>();
-        let mut new_notifications = SumTree::new();
+        let mut cursor = self.notifications.cursor::<(NotificationId, Count)>(&());
+        let mut new_notifications = SumTree::default();
         let mut old_range = 0..0;
 
         for (i, (id, new_notification)) in notifications.into_iter().enumerate() {
@@ -468,6 +467,10 @@ impl sum_tree::Item for NotificationEntry {
 impl sum_tree::Summary for NotificationSummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &()) {
         self.max_id = self.max_id.max(summary.max_id);
         self.count += summary.count;
@@ -476,6 +479,10 @@ impl sum_tree::Summary for NotificationSummary {
 }
 
 impl<'a> sum_tree::Dimension<'a, NotificationSummary> for NotificationId {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &NotificationSummary, _: &()) {
         debug_assert!(summary.max_id > self.0);
         self.0 = summary.max_id;
@@ -483,6 +490,10 @@ impl<'a> sum_tree::Dimension<'a, NotificationSummary> for NotificationId {
 }
 
 impl<'a> sum_tree::Dimension<'a, NotificationSummary> for Count {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &NotificationSummary, _: &()) {
         self.0 += summary.count;
     }
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 35eb20259c1393..24852afd702e18 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -2753,7 +2753,7 @@ impl LspStore {
             if let Some(language) = buffer.language().cloned() {
                 for adapter in self.languages.lsp_adapters(&language.name()) {
                     if let Some(server_id) = ids.get(&(worktree_id, adapter.name.clone())) {
-                        buffer.update_diagnostics(*server_id, Default::default(), cx);
+                        buffer.update_diagnostics(*server_id, DiagnosticSet::new([], buffer), cx);
                     }
                 }
             }
@@ -5149,7 +5149,11 @@ impl LspStore {
                 self.buffer_store.update(cx, |buffer_store, cx| {
                     for buffer in buffer_store.buffers() {
                         buffer.update(cx, |buffer, cx| {
-                            buffer.update_diagnostics(server_id, Default::default(), cx);
+                            buffer.update_diagnostics(
+                                server_id,
+                                DiagnosticSet::new([], buffer),
+                                cx,
+                            );
                         });
                     }
                 });
diff --git a/crates/rope/src/rope.rs b/crates/rope/src/rope.rs
index 00ffbfa9ebcde7..56fe7fc0544471 100644
--- a/crates/rope/src/rope.rs
+++ b/crates/rope/src/rope.rs
@@ -36,7 +36,7 @@ impl Rope {
     }
 
     pub fn append(&mut self, rope: Rope) {
-        let mut chunks = rope.chunks.cursor::<()>();
+        let mut chunks = rope.chunks.cursor::<()>(&());
         chunks.next(&());
         if let Some(chunk) = chunks.item() {
             if self.chunks.last().map_or(false, |c| c.0.len() < CHUNK_BASE)
@@ -175,7 +175,7 @@ impl Rope {
         {
             // Ensure all chunks except maybe the last one are not underflowing.
             // Allow some wiggle room for multibyte characters at chunk boundaries.
-            let mut chunks = self.chunks.cursor::<()>().peekable();
+            let mut chunks = self.chunks.cursor::<()>(&()).peekable();
             while let Some(chunk) = chunks.next() {
                 if chunks.peek().is_some() {
                     assert!(chunk.0.len() + 3 >= CHUNK_BASE);
@@ -245,7 +245,7 @@ impl Rope {
         if offset >= self.summary().len {
             return self.summary().len_utf16;
         }
-        let mut cursor = self.chunks.cursor::<(usize, OffsetUtf16)>();
+        let mut cursor = self.chunks.cursor::<(usize, OffsetUtf16)>(&());
         cursor.seek(&offset, Bias::Left, &());
         let overshoot = offset - cursor.start().0;
         cursor.start().1
@@ -258,7 +258,7 @@ impl Rope {
         if offset >= self.summary().len_utf16 {
             return self.summary().len;
         }
-        let mut cursor = self.chunks.cursor::<(OffsetUtf16, usize)>();
+        let mut cursor = self.chunks.cursor::<(OffsetUtf16, usize)>(&());
         cursor.seek(&offset, Bias::Left, &());
         let overshoot = offset - cursor.start().0;
         cursor.start().1
@@ -271,7 +271,7 @@ impl Rope {
         if offset >= self.summary().len {
             return self.summary().lines;
         }
-        let mut cursor = self.chunks.cursor::<(usize, Point)>();
+        let mut cursor = self.chunks.cursor::<(usize, Point)>(&());
         cursor.seek(&offset, Bias::Left, &());
         let overshoot = offset - cursor.start().0;
         cursor.start().1
@@ -284,7 +284,7 @@ impl Rope {
         if offset >= self.summary().len {
             return self.summary().lines_utf16();
         }
-        let mut cursor = self.chunks.cursor::<(usize, PointUtf16)>();
+        let mut cursor = self.chunks.cursor::<(usize, PointUtf16)>(&());
         cursor.seek(&offset, Bias::Left, &());
         let overshoot = offset - cursor.start().0;
         cursor.start().1
@@ -297,7 +297,7 @@ impl Rope {
         if point >= self.summary().lines {
             return self.summary().lines_utf16();
         }
-        let mut cursor = self.chunks.cursor::<(Point, PointUtf16)>();
+        let mut cursor = self.chunks.cursor::<(Point, PointUtf16)>(&());
         cursor.seek(&point, Bias::Left, &());
         let overshoot = point - cursor.start().0;
         cursor.start().1
@@ -310,7 +310,7 @@ impl Rope {
         if point >= self.summary().lines {
             return self.summary().len;
         }
-        let mut cursor = self.chunks.cursor::<(Point, usize)>();
+        let mut cursor = self.chunks.cursor::<(Point, usize)>(&());
         cursor.seek(&point, Bias::Left, &());
         let overshoot = point - cursor.start().0;
         cursor.start().1
@@ -331,7 +331,7 @@ impl Rope {
         if point >= self.summary().lines_utf16() {
             return self.summary().len;
         }
-        let mut cursor = self.chunks.cursor::<(PointUtf16, usize)>();
+        let mut cursor = self.chunks.cursor::<(PointUtf16, usize)>(&());
         cursor.seek(&point, Bias::Left, &());
         let overshoot = point - cursor.start().0;
         cursor.start().1
@@ -344,7 +344,7 @@ impl Rope {
         if point.0 >= self.summary().lines_utf16() {
             return self.summary().lines;
         }
-        let mut cursor = self.chunks.cursor::<(PointUtf16, Point)>();
+        let mut cursor = self.chunks.cursor::<(PointUtf16, Point)>(&());
         cursor.seek(&point.0, Bias::Left, &());
         let overshoot = Unclipped(point.0 - cursor.start().0);
         cursor.start().1
@@ -354,7 +354,7 @@ impl Rope {
     }
 
     pub fn clip_offset(&self, mut offset: usize, bias: Bias) -> usize {
-        let mut cursor = self.chunks.cursor::<usize>();
+        let mut cursor = self.chunks.cursor::<usize>(&());
         cursor.seek(&offset, Bias::Left, &());
         if let Some(chunk) = cursor.item() {
             let mut ix = offset - cursor.start();
@@ -377,7 +377,7 @@ impl Rope {
     }
 
     pub fn clip_offset_utf16(&self, offset: OffsetUtf16, bias: Bias) -> OffsetUtf16 {
-        let mut cursor = self.chunks.cursor::<OffsetUtf16>();
+        let mut cursor = self.chunks.cursor::<OffsetUtf16>(&());
         cursor.seek(&offset, Bias::Right, &());
         if let Some(chunk) = cursor.item() {
             let overshoot = offset - cursor.start();
@@ -388,7 +388,7 @@ impl Rope {
     }
 
     pub fn clip_point(&self, point: Point, bias: Bias) -> Point {
-        let mut cursor = self.chunks.cursor::<Point>();
+        let mut cursor = self.chunks.cursor::<Point>(&());
         cursor.seek(&point, Bias::Right, &());
         if let Some(chunk) = cursor.item() {
             let overshoot = point - cursor.start();
@@ -399,7 +399,7 @@ impl Rope {
     }
 
     pub fn clip_point_utf16(&self, point: Unclipped<PointUtf16>, bias: Bias) -> PointUtf16 {
-        let mut cursor = self.chunks.cursor::<PointUtf16>();
+        let mut cursor = self.chunks.cursor::<PointUtf16>(&());
         cursor.seek(&point.0, Bias::Right, &());
         if let Some(chunk) = cursor.item() {
             let overshoot = Unclipped(point.0 - cursor.start());
@@ -472,7 +472,7 @@ pub struct Cursor<'a> {
 
 impl<'a> Cursor<'a> {
     pub fn new(rope: &'a Rope, offset: usize) -> Self {
-        let mut chunks = rope.chunks.cursor();
+        let mut chunks = rope.chunks.cursor(&());
         chunks.seek(&offset, Bias::Right, &());
         Self {
             rope,
@@ -521,7 +521,7 @@ impl<'a> Cursor<'a> {
     pub fn summary<D: TextDimension>(&mut self, end_offset: usize) -> D {
         debug_assert!(end_offset >= self.offset);
 
-        let mut summary = D::default();
+        let mut summary = D::zero(&());
         if let Some(start_chunk) = self.chunks.item() {
             let start_ix = self.offset - self.chunks.start();
             let end_ix = cmp::min(end_offset, self.chunks.end(&())) - self.chunks.start();
@@ -563,7 +563,7 @@ pub struct Chunks<'a> {
 
 impl<'a> Chunks<'a> {
     pub fn new(rope: &'a Rope, range: Range<usize>, reversed: bool) -> Self {
-        let mut chunks = rope.chunks.cursor();
+        let mut chunks = rope.chunks.cursor(&());
         let offset = if reversed {
             chunks.seek(&range.end, Bias::Left, &());
             range.end
@@ -774,7 +774,7 @@ pub struct Bytes<'a> {
 
 impl<'a> Bytes<'a> {
     pub fn new(rope: &'a Rope, range: Range<usize>, reversed: bool) -> Self {
-        let mut chunks = rope.chunks.cursor();
+        let mut chunks = rope.chunks.cursor(&());
         if reversed {
             chunks.seek(&range.end, Bias::Left, &());
         } else {
@@ -1180,6 +1180,10 @@ impl<'a> From<&'a str> for ChunkSummary {
 impl sum_tree::Summary for ChunkSummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &()) {
         self.text += &summary.text;
     }
@@ -1263,6 +1267,10 @@ impl<'a> From<&'a str> for TextSummary {
 impl sum_tree::Summary for TextSummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &Self::Context) {
         *self += summary;
     }
@@ -1333,6 +1341,10 @@ impl<D1: TextDimension, D2: TextDimension> TextDimension for (D1, D2) {
 }
 
 impl<'a> sum_tree::Dimension<'a, ChunkSummary> for TextSummary {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ChunkSummary, _: &()) {
         *self += &summary.text;
     }
@@ -1349,6 +1361,10 @@ impl TextDimension for TextSummary {
 }
 
 impl<'a> sum_tree::Dimension<'a, ChunkSummary> for usize {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ChunkSummary, _: &()) {
         *self += summary.text.len;
     }
@@ -1365,6 +1381,10 @@ impl TextDimension for usize {
 }
 
 impl<'a> sum_tree::Dimension<'a, ChunkSummary> for OffsetUtf16 {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ChunkSummary, _: &()) {
         *self += summary.text.len_utf16;
     }
@@ -1381,6 +1401,10 @@ impl TextDimension for OffsetUtf16 {
 }
 
 impl<'a> sum_tree::Dimension<'a, ChunkSummary> for Point {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ChunkSummary, _: &()) {
         *self += summary.text.lines;
     }
@@ -1397,6 +1421,10 @@ impl TextDimension for Point {
 }
 
 impl<'a> sum_tree::Dimension<'a, ChunkSummary> for PointUtf16 {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a ChunkSummary, _: &()) {
         *self += summary.text.lines_utf16();
     }
@@ -1890,7 +1918,7 @@ mod tests {
     impl Rope {
         fn text(&self) -> String {
             let mut text = String::new();
-            for chunk in self.chunks.cursor::<()>() {
+            for chunk in self.chunks.cursor::<()>(&()) {
                 text.push_str(&chunk.0);
             }
             text
diff --git a/crates/rope/src/unclipped.rs b/crates/rope/src/unclipped.rs
index 937cbca0534d0e..b3427e2cb98bb2 100644
--- a/crates/rope/src/unclipped.rs
+++ b/crates/rope/src/unclipped.rs
@@ -13,6 +13,10 @@ impl<T> From<T> for Unclipped<T> {
 impl<'a, T: sum_tree::Dimension<'a, ChunkSummary>> sum_tree::Dimension<'a, ChunkSummary>
     for Unclipped<T>
 {
+    fn zero(_: &()) -> Self {
+        Self(T::zero(&()))
+    }
+
     fn add_summary(&mut self, summary: &'a ChunkSummary, _: &()) {
         self.0.add_summary(summary, &());
     }
diff --git a/crates/sum_tree/src/cursor.rs b/crates/sum_tree/src/cursor.rs
index 452930f942bb97..6da43a8de5ce39 100644
--- a/crates/sum_tree/src/cursor.rs
+++ b/crates/sum_tree/src/cursor.rs
@@ -28,21 +28,21 @@ where
     T: Item,
     D: Dimension<'a, T::Summary>,
 {
-    pub fn new(tree: &'a SumTree<T>) -> Self {
+    pub fn new(tree: &'a SumTree<T>, cx: &<T::Summary as Summary>::Context) -> Self {
         Self {
             tree,
             stack: ArrayVec::new(),
-            position: D::default(),
+            position: D::zero(cx),
             did_seek: false,
             at_end: tree.is_empty(),
         }
     }
 
-    fn reset(&mut self) {
+    fn reset(&mut self, cx: &<T::Summary as Summary>::Context) {
         self.did_seek = false;
         self.at_end = self.tree.is_empty();
         self.stack.truncate(0);
-        self.position = D::default();
+        self.position = D::zero(cx);
     }
 
     pub fn start(&self) -> &D {
@@ -192,7 +192,7 @@ where
         }
 
         if self.at_end {
-            self.position = D::default();
+            self.position = D::zero(cx);
             self.at_end = self.tree.is_empty();
             if !self.tree.is_empty() {
                 self.stack.push(StackEntry {
@@ -208,7 +208,7 @@ where
             if let Some(StackEntry { position, .. }) = self.stack.iter().rev().nth(1) {
                 self.position = position.clone();
             } else {
-                self.position = D::default();
+                self.position = D::zero(cx);
             }
 
             let entry = self.stack.last_mut().unwrap();
@@ -232,7 +232,7 @@ where
                     if descending {
                         let tree = &child_trees[entry.index];
                         self.stack.push(StackEntry {
-                            position: D::default(),
+                            position: D::zero(cx),
                             tree,
                             index: tree.0.child_summaries().len() - 1,
                         })
@@ -264,7 +264,7 @@ where
                 self.stack.push(StackEntry {
                     tree: self.tree,
                     index: 0,
-                    position: D::default(),
+                    position: D::zero(cx),
                 });
                 descend = true;
             }
@@ -364,7 +364,7 @@ where
     where
         Target: SeekTarget<'a, T::Summary, D>,
     {
-        self.reset();
+        self.reset(cx);
         self.seek_internal(pos, bias, &mut (), cx)
     }
 
@@ -392,10 +392,10 @@ where
         Target: SeekTarget<'a, T::Summary, D>,
     {
         let mut slice = SliceSeekAggregate {
-            tree: SumTree::new(),
+            tree: SumTree::new(cx),
             leaf_items: ArrayVec::new(),
             leaf_item_summaries: ArrayVec::new(),
-            leaf_summary: T::Summary::default(),
+            leaf_summary: <T::Summary as Summary>::zero(cx),
         };
         self.seek_internal(end, bias, &mut slice, cx);
         slice.tree
@@ -417,7 +417,7 @@ where
         Target: SeekTarget<'a, T::Summary, D>,
         Output: Dimension<'a, T::Summary>,
     {
-        let mut summary = SummarySeekAggregate(Output::default());
+        let mut summary = SummarySeekAggregate(Output::zero(cx));
         self.seek_internal(end, bias, &mut summary, cx);
         summary.0
     }
@@ -443,7 +443,7 @@ where
             self.stack.push(StackEntry {
                 tree: self.tree,
                 index: 0,
-                position: Default::default(),
+                position: D::zero(cx),
             });
         }
 
@@ -633,8 +633,12 @@ where
     T: Item,
     D: Dimension<'a, T::Summary>,
 {
-    pub fn new(tree: &'a SumTree<T>, filter_node: F) -> Self {
-        let cursor = tree.cursor::<D>();
+    pub fn new(
+        tree: &'a SumTree<T>,
+        cx: &<T::Summary as Summary>::Context,
+        filter_node: F,
+    ) -> Self {
+        let cursor = tree.cursor::<D>(cx);
         Self {
             cursor,
             filter_node,
@@ -727,7 +731,7 @@ impl<'a, T: Item> SeekAggregate<'a, T> for SliceSeekAggregate<T> {
     fn end_leaf(&mut self, cx: &<T::Summary as Summary>::Context) {
         self.tree.append(
             SumTree(Arc::new(Node::Leaf {
-                summary: mem::take(&mut self.leaf_summary),
+                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),
             })),
diff --git a/crates/sum_tree/src/sum_tree.rs b/crates/sum_tree/src/sum_tree.rs
index 8a8027408f3014..ca351d67cea76f 100644
--- a/crates/sum_tree/src/sum_tree.rs
+++ b/crates/sum_tree/src/sum_tree.rs
@@ -34,9 +34,11 @@ pub trait KeyedItem: Item {
 ///
 /// Each Summary type can have multiple [`Dimensions`] that it measures,
 /// which can be used to navigate the tree
-pub trait Summary: Default + Clone + fmt::Debug {
+pub trait Summary: Clone + fmt::Debug {
     type Context;
 
+    fn zero(cx: &Self::Context) -> Self;
+
     fn add_summary(&mut self, summary: &Self, cx: &Self::Context);
 }
 
@@ -47,17 +49,23 @@ pub trait Summary: Default + Clone + fmt::Debug {
 /// # Example:
 /// Zed's rope has a `TextSummary` type that summarizes lines, characters, and bytes.
 /// Each of these are different dimensions we may want to seek to
-pub trait Dimension<'a, S: Summary>: Clone + fmt::Debug + Default {
-    fn add_summary(&mut self, _summary: &'a S, _: &S::Context);
+pub trait Dimension<'a, S: Summary>: Clone + fmt::Debug {
+    fn zero(cx: &S::Context) -> Self;
+
+    fn add_summary(&mut self, summary: &'a S, cx: &S::Context);
 
     fn from_summary(summary: &'a S, cx: &S::Context) -> Self {
-        let mut dimension = Self::default();
+        let mut dimension = Self::zero(cx);
         dimension.add_summary(summary, cx);
         dimension
     }
 }
 
 impl<'a, T: Summary> Dimension<'a, T> for T {
+    fn zero(cx: &T::Context) -> Self {
+        Summary::zero(cx)
+    }
+
     fn add_summary(&mut self, summary: &'a T, cx: &T::Context) {
         Summary::add_summary(self, summary, cx);
     }
@@ -74,10 +82,18 @@ impl<'a, S: Summary, D: Dimension<'a, S> + Ord> SeekTarget<'a, S, D> for D {
 }
 
 impl<'a, T: Summary> Dimension<'a, T> for () {
+    fn zero(_: &T::Context) -> Self {
+        ()
+    }
+
     fn add_summary(&mut self, _: &'a T, _: &T::Context) {}
 }
 
 impl<'a, T: Summary, D1: Dimension<'a, T>, D2: Dimension<'a, T>> Dimension<'a, T> for (D1, D2) {
+    fn zero(cx: &T::Context) -> Self {
+        (D1::zero(cx), D2::zero(cx))
+    }
+
     fn add_summary(&mut self, summary: &'a T, cx: &T::Context) {
         self.0.add_summary(summary, cx);
         self.1.add_summary(summary, cx);
@@ -161,16 +177,16 @@ impl Bias {
 pub struct SumTree<T: Item>(Arc<Node<T>>);
 
 impl<T: Item> SumTree<T> {
-    pub fn new() -> Self {
+    pub fn new(cx: &<T::Summary as Summary>::Context) -> Self {
         SumTree(Arc::new(Node::Leaf {
-            summary: T::Summary::default(),
+            summary: <T::Summary as Summary>::zero(cx),
             items: ArrayVec::new(),
             item_summaries: ArrayVec::new(),
         }))
     }
 
     pub fn from_item(item: T, cx: &<T::Summary as Summary>::Context) -> Self {
-        let mut tree = Self::new();
+        let mut tree = Self::new(cx);
         tree.push(item, cx);
         tree
     }
@@ -206,7 +222,7 @@ impl<T: Item> SumTree<T> {
             let mut current_parent_node = None;
             for child_node in nodes.drain(..) {
                 let parent_node = current_parent_node.get_or_insert_with(|| Node::Internal {
-                    summary: T::Summary::default(),
+                    summary: <T::Summary as Summary>::zero(cx),
                     height,
                     child_summaries: ArrayVec::new(),
                     child_trees: ArrayVec::new(),
@@ -234,7 +250,7 @@ impl<T: Item> SumTree<T> {
         }
 
         if nodes.is_empty() {
-            Self::new()
+            Self::new(cx)
         } else {
             debug_assert_eq!(nodes.len(), 1);
             Self(Arc::new(nodes.pop().unwrap()))
@@ -296,7 +312,7 @@ impl<T: Item> SumTree<T> {
         }
 
         if nodes.is_empty() {
-            Self::new()
+            Self::new(cx)
         } else {
             debug_assert_eq!(nodes.len(), 1);
             nodes.pop().unwrap()
@@ -306,7 +322,7 @@ impl<T: Item> SumTree<T> {
     #[allow(unused)]
     pub fn items(&self, cx: &<T::Summary as Summary>::Context) -> Vec<T> {
         let mut items = Vec::new();
-        let mut cursor = self.cursor::<()>();
+        let mut cursor = self.cursor::<()>(cx);
         cursor.next(cx);
         while let Some(item) = cursor.item() {
             items.push(item.clone());
@@ -319,21 +335,25 @@ impl<T: Item> SumTree<T> {
         Iter::new(self)
     }
 
-    pub fn cursor<'a, S>(&'a self) -> Cursor<T, S>
+    pub fn cursor<'a, S>(&'a self, cx: &<T::Summary as Summary>::Context) -> Cursor<T, S>
     where
         S: Dimension<'a, T::Summary>,
     {
-        Cursor::new(self)
+        Cursor::new(self, cx)
     }
 
     /// Note: If the summary type requires a non `()` context, then the filter cursor
     /// that is returned cannot be used with Rust's iterators.
-    pub fn filter<'a, F, U>(&'a self, filter_node: F) -> FilterCursor<F, T, U>
+    pub fn filter<'a, F, U>(
+        &'a self,
+        cx: &<T::Summary as Summary>::Context,
+        filter_node: F,
+    ) -> FilterCursor<F, T, U>
     where
         F: FnMut(&T::Summary) -> bool,
         U: Dimension<'a, T::Summary>,
     {
-        FilterCursor::new(self, filter_node)
+        FilterCursor::new(self, cx, filter_node)
     }
 
     #[allow(dead_code)]
@@ -389,7 +409,7 @@ impl<T: Item> SumTree<T> {
         &'a self,
         cx: &<T::Summary as Summary>::Context,
     ) -> D {
-        let mut extent = D::default();
+        let mut extent = D::zero(cx);
         match self.0.as_ref() {
             Node::Internal { summary, .. } | Node::Leaf { summary, .. } => {
                 extent.add_summary(summary, cx);
@@ -636,7 +656,7 @@ impl<T: KeyedItem> SumTree<T> {
     ) -> Option<T> {
         let mut replaced = None;
         *self = {
-            let mut cursor = self.cursor::<T::Key>();
+            let mut cursor = self.cursor::<T::Key>(cx);
             let mut new_tree = cursor.slice(&item.key(), Bias::Left, cx);
             if let Some(cursor_item) = cursor.item() {
                 if cursor_item.key() == item.key() {
@@ -654,7 +674,7 @@ impl<T: KeyedItem> SumTree<T> {
     pub fn remove(&mut self, key: &T::Key, cx: &<T::Summary as Summary>::Context) -> Option<T> {
         let mut removed = None;
         *self = {
-            let mut cursor = self.cursor::<T::Key>();
+            let mut cursor = self.cursor::<T::Key>(cx);
             let mut new_tree = cursor.slice(key, Bias::Left, cx);
             if let Some(item) = cursor.item() {
                 if item.key() == *key {
@@ -681,11 +701,11 @@ impl<T: KeyedItem> SumTree<T> {
         edits.sort_unstable_by_key(|item| item.key());
 
         *self = {
-            let mut cursor = self.cursor::<T::Key>();
-            let mut new_tree = SumTree::new();
+            let mut cursor = self.cursor::<T::Key>(cx);
+            let mut new_tree = SumTree::new(cx);
             let mut buffered_items = Vec::new();
 
-            cursor.seek(&T::Key::default(), Bias::Left, cx);
+            cursor.seek(&T::Key::zero(cx), Bias::Left, cx);
             for edit in edits {
                 let new_key = edit.key();
                 let mut old_item = cursor.item();
@@ -724,7 +744,7 @@ impl<T: KeyedItem> SumTree<T> {
     }
 
     pub fn get(&self, key: &T::Key, cx: &<T::Summary as Summary>::Context) -> Option<&T> {
-        let mut cursor = self.cursor::<T::Key>();
+        let mut cursor = self.cursor::<T::Key>(cx);
         if cursor.seek(key, Bias::Left, cx) {
             cursor.item()
         } else {
@@ -733,9 +753,13 @@ impl<T: KeyedItem> SumTree<T> {
     }
 }
 
-impl<T: Item> Default for SumTree<T> {
+impl<T, S> Default for SumTree<T>
+where
+    T: Item<Summary = S>,
+    S: Summary<Context = ()>,
+{
     fn default() -> Self {
-        Self::new()
+        Self::new(&())
     }
 }
 
@@ -824,7 +848,7 @@ where
     T: 'a + Summary,
     I: Iterator<Item = &'a T>,
 {
-    let mut sum = T::default();
+    let mut sum = T::zero(cx);
     for value in iter {
         sum.add_summary(value, cx);
     }
@@ -846,10 +870,10 @@ mod tests {
 
     #[test]
     fn test_extend_and_push_tree() {
-        let mut tree1 = SumTree::new();
+        let mut tree1 = SumTree::default();
         tree1.extend(0..20, &());
 
-        let mut tree2 = SumTree::new();
+        let mut tree2 = SumTree::default();
         tree2.extend(50..100, &());
 
         tree1.append(tree2, &());
@@ -877,7 +901,7 @@ mod tests {
             let mut rng = StdRng::seed_from_u64(seed);
 
             let rng = &mut rng;
-            let mut tree = SumTree::<u8>::new();
+            let mut tree = SumTree::<u8>::default();
             let count = rng.gen_range(0..10);
             if rng.gen() {
                 tree.extend(rng.sample_iter(distributions::Standard).take(count), &());
@@ -903,7 +927,7 @@ mod tests {
                 reference_items.splice(splice_start..splice_end, new_items.clone());
 
                 tree = {
-                    let mut cursor = tree.cursor::<Count>();
+                    let mut cursor = tree.cursor::<Count>(&());
                     let mut new_tree = cursor.slice(&Count(splice_start), Bias::Right, &());
                     if rng.gen() {
                         new_tree.extend(new_items, &());
@@ -918,12 +942,13 @@ mod tests {
                 assert_eq!(tree.items(&()), reference_items);
                 assert_eq!(
                     tree.iter().collect::<Vec<_>>(),
-                    tree.cursor::<()>().collect::<Vec<_>>()
+                    tree.cursor::<()>(&()).collect::<Vec<_>>()
                 );
 
                 log::info!("tree items: {:?}", tree.items(&()));
 
-                let mut filter_cursor = tree.filter::<_, Count>(|summary| summary.contains_even);
+                let mut filter_cursor =
+                    tree.filter::<_, Count>(&(), |summary| summary.contains_even);
                 let expected_filtered_items = tree
                     .items(&())
                     .into_iter()
@@ -964,7 +989,7 @@ mod tests {
                 assert_eq!(filter_cursor.item(), None);
 
                 let mut before_start = false;
-                let mut cursor = tree.cursor::<Count>();
+                let mut cursor = tree.cursor::<Count>(&());
                 let start_pos = rng.gen_range(0..=reference_items.len());
                 cursor.seek(&Count(start_pos), Bias::Right, &());
                 let mut pos = rng.gen_range(start_pos..=reference_items.len());
@@ -1015,7 +1040,7 @@ mod tests {
                 let start_bias = if rng.gen() { Bias::Left } else { Bias::Right };
                 let end_bias = if rng.gen() { Bias::Left } else { Bias::Right };
 
-                let mut cursor = tree.cursor::<Count>();
+                let mut cursor = tree.cursor::<Count>(&());
                 cursor.seek(&Count(start), start_bias, &());
                 let slice = cursor.slice(&Count(end), end_bias, &());
 
@@ -1030,8 +1055,8 @@ mod tests {
     #[test]
     fn test_cursor() {
         // Empty tree
-        let tree = SumTree::<u8>::new();
-        let mut cursor = tree.cursor::<IntegersSummary>();
+        let tree = SumTree::<u8>::default();
+        let mut cursor = tree.cursor::<IntegersSummary>(&());
         assert_eq!(
             cursor.slice(&Count(0), Bias::Right, &()).items(&()),
             Vec::<u8>::new()
@@ -1052,9 +1077,9 @@ mod tests {
         assert_eq!(cursor.start().sum, 0);
 
         // Single-element tree
-        let mut tree = SumTree::<u8>::new();
+        let mut tree = SumTree::<u8>::default();
         tree.extend(vec![1], &());
-        let mut cursor = tree.cursor::<IntegersSummary>();
+        let mut cursor = tree.cursor::<IntegersSummary>(&());
         assert_eq!(
             cursor.slice(&Count(0), Bias::Right, &()).items(&()),
             Vec::<u8>::new()
@@ -1076,7 +1101,7 @@ mod tests {
         assert_eq!(cursor.next_item(), None);
         assert_eq!(cursor.start().sum, 0);
 
-        let mut cursor = tree.cursor::<IntegersSummary>();
+        let mut cursor = tree.cursor::<IntegersSummary>(&());
         assert_eq!(cursor.slice(&Count(1), Bias::Right, &()).items(&()), [1]);
         assert_eq!(cursor.item(), None);
         assert_eq!(cursor.prev_item(), Some(&1));
@@ -1096,9 +1121,9 @@ mod tests {
         assert_eq!(cursor.start().sum, 1);
 
         // Multiple-element tree
-        let mut tree = SumTree::new();
+        let mut tree = SumTree::default();
         tree.extend(vec![1, 2, 3, 4, 5, 6], &());
-        let mut cursor = tree.cursor::<IntegersSummary>();
+        let mut cursor = tree.cursor::<IntegersSummary>(&());
 
         assert_eq!(cursor.slice(&Count(2), Bias::Right, &()).items(&()), [1, 2]);
         assert_eq!(cursor.item(), Some(&3));
@@ -1179,7 +1204,7 @@ mod tests {
         assert_eq!(cursor.next_item(), Some(&2));
         assert_eq!(cursor.start().sum, 0);
 
-        let mut cursor = tree.cursor::<IntegersSummary>();
+        let mut cursor = tree.cursor::<IntegersSummary>(&());
         assert_eq!(
             cursor
                 .slice(&tree.extent::<Count>(&()), Bias::Right, &())
@@ -1227,7 +1252,7 @@ mod tests {
 
     #[test]
     fn test_edit() {
-        let mut tree = SumTree::<u8>::new();
+        let mut tree = SumTree::<u8>::default();
 
         let removed = tree.edit(vec![Edit::Insert(1), Edit::Insert(2), Edit::Insert(0)], &());
         assert_eq!(tree.items(&()), vec![0, 1, 2]);
@@ -1305,6 +1330,10 @@ mod tests {
     impl Summary for IntegersSummary {
         type Context = ();
 
+        fn zero(_cx: &()) -> Self {
+            Default::default()
+        }
+
         fn add_summary(&mut self, other: &Self, _: &()) {
             self.count += other.count;
             self.sum += other.sum;
@@ -1314,12 +1343,20 @@ mod tests {
     }
 
     impl<'a> Dimension<'a, IntegersSummary> for u8 {
+        fn zero(_cx: &()) -> Self {
+            Default::default()
+        }
+
         fn add_summary(&mut self, summary: &IntegersSummary, _: &()) {
             *self = summary.max;
         }
     }
 
     impl<'a> Dimension<'a, IntegersSummary> for Count {
+        fn zero(_cx: &()) -> Self {
+            Default::default()
+        }
+
         fn add_summary(&mut self, summary: &IntegersSummary, _: &()) {
             self.0 += summary.count;
         }
@@ -1332,6 +1369,10 @@ mod tests {
     }
 
     impl<'a> Dimension<'a, IntegersSummary> for Sum {
+        fn zero(_cx: &()) -> Self {
+            Default::default()
+        }
+
         fn add_summary(&mut self, summary: &IntegersSummary, _: &()) {
             self.0 += summary.sum;
         }
diff --git a/crates/sum_tree/src/tree_map.rs b/crates/sum_tree/src/tree_map.rs
index 53bb0a807c23df..72465b1a99cabd 100644
--- a/crates/sum_tree/src/tree_map.rs
+++ b/crates/sum_tree/src/tree_map.rs
@@ -53,7 +53,7 @@ impl<K: Clone + Debug + Ord, V: Clone + Debug> TreeMap<K, V> {
     }
 
     pub fn get(&self, key: &K) -> Option<&V> {
-        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>();
+        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(&());
         cursor.seek(&MapKeyRef(Some(key)), Bias::Left, &());
         if let Some(item) = cursor.item() {
             if Some(key) == item.key().0.as_ref() {
@@ -72,7 +72,7 @@ impl<K: Clone + Debug + Ord, V: Clone + Debug> TreeMap<K, V> {
 
     pub fn remove(&mut self, key: &K) -> Option<V> {
         let mut removed = None;
-        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>();
+        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 {
@@ -88,7 +88,7 @@ impl<K: Clone + Debug + Ord, V: Clone + Debug> TreeMap<K, V> {
     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 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(&()), &());
@@ -98,7 +98,7 @@ impl<K: Clone + Debug + Ord, V: Clone + Debug> TreeMap<K, V> {
 
     /// 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 mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(&());
         let key = MapKeyRef(Some(key));
         cursor.seek(&key, Bias::Right, &());
         cursor.prev(&());
@@ -106,7 +106,7 @@ impl<K: Clone + Debug + Ord, V: Clone + Debug> TreeMap<K, V> {
     }
 
     pub fn iter_from<'a>(&'a self, from: &'a K) -> impl Iterator<Item = (&K, &V)> + '_ {
-        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>();
+        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(&());
         let from_key = MapKeyRef(Some(from));
         cursor.seek(&from_key, Bias::Left, &());
 
@@ -117,7 +117,7 @@ impl<K: Clone + Debug + Ord, V: Clone + Debug> TreeMap<K, V> {
     where
         F: FnOnce(&mut V) -> T,
     {
-        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>();
+        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;
@@ -136,7 +136,7 @@ impl<K: Clone + Debug + Ord, V: Clone + Debug> TreeMap<K, V> {
     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>>();
+        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(&());
         cursor.next(&());
         while let Some(item) = cursor.item() {
             if predicate(&item.key, &item.value) {
@@ -247,6 +247,10 @@ where
 {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &()) {
         *self = summary.clone()
     }
@@ -256,6 +260,10 @@ impl<'a, K> Dimension<'a, MapKey<K>> for MapKeyRef<'a, K>
 where
     K: Clone + Debug + Ord,
 {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a MapKey<K>, _: &()) {
         self.0 = summary.0.as_ref();
     }
diff --git a/crates/text/src/anchor.rs b/crates/text/src/anchor.rs
index ee833326f58099..3bc5889caeb700 100644
--- a/crates/text/src/anchor.rs
+++ b/crates/text/src/anchor.rs
@@ -100,7 +100,7 @@ impl Anchor {
             false
         } else {
             let fragment_id = buffer.fragment_id_for_anchor(self);
-            let mut fragment_cursor = buffer.fragments.cursor::<(Option<&Locator>, usize)>();
+            let mut fragment_cursor = buffer.fragments.cursor::<(Option<&Locator>, usize)>(&None);
             fragment_cursor.seek(&Some(fragment_id), Bias::Left, &None);
             fragment_cursor
                 .item()
diff --git a/crates/text/src/locator.rs b/crates/text/src/locator.rs
index 83d57016c5d753..7afc16f5815496 100644
--- a/crates/text/src/locator.rs
+++ b/crates/text/src/locator.rs
@@ -85,6 +85,10 @@ impl sum_tree::KeyedItem for Locator {
 impl sum_tree::Summary for Locator {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &()) {
         self.assign(summary);
     }
diff --git a/crates/text/src/operation_queue.rs b/crates/text/src/operation_queue.rs
index 063f05066570f6..c7964f62674ca5 100644
--- a/crates/text/src/operation_queue.rs
+++ b/crates/text/src/operation_queue.rs
@@ -34,7 +34,7 @@ impl<T: Operation> Default for OperationQueue<T> {
 
 impl<T: Operation> OperationQueue<T> {
     pub fn new() -> Self {
-        OperationQueue(SumTree::new())
+        OperationQueue(SumTree::default())
     }
 
     pub fn len(&self) -> usize {
@@ -58,7 +58,7 @@ impl<T: Operation> OperationQueue<T> {
 
     pub fn drain(&mut self) -> Self {
         let clone = self.clone();
-        self.0 = SumTree::new();
+        self.0 = SumTree::default();
         clone
     }
 
@@ -70,6 +70,10 @@ impl<T: Operation> OperationQueue<T> {
 impl Summary for OperationSummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, other: &Self, _: &()) {
         assert!(self.key < other.key);
         self.key = other.key;
@@ -90,6 +94,10 @@ impl<'a> Add<&'a Self> for OperationSummary {
 }
 
 impl<'a> Dimension<'a, OperationSummary> for OperationKey {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &OperationSummary, _: &()) {
         assert!(*self <= summary.key);
         *self = summary.key;
diff --git a/crates/text/src/text.rs b/crates/text/src/text.rs
index b17748c6d067aa..9630ec5b80334c 100644
--- a/crates/text/src/text.rs
+++ b/crates/text/src/text.rs
@@ -492,6 +492,10 @@ struct FragmentTextSummary {
 }
 
 impl<'a> sum_tree::Dimension<'a, FragmentSummary> for FragmentTextSummary {
+    fn zero(_: &Option<clock::Global>) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a FragmentSummary, _: &Option<clock::Global>) {
         self.visible += summary.text.visible;
         self.deleted += summary.text.deleted;
@@ -654,8 +658,8 @@ impl Buffer {
         normalized: Rope,
     ) -> Buffer {
         let history = History::new(normalized);
-        let mut fragments = SumTree::new();
-        let mut insertions = SumTree::new();
+        let mut fragments = SumTree::new(&None);
+        let mut insertions = SumTree::default();
 
         let mut lamport_clock = clock::Lamport::new(replica_id);
         let mut version = clock::Global::new();
@@ -772,7 +776,7 @@ impl Buffer {
 
         let mut new_ropes =
             RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0));
-        let mut old_fragments = self.fragments.cursor::<FragmentTextSummary>();
+        let mut old_fragments = self.fragments.cursor::<FragmentTextSummary>(&None);
         let mut new_fragments =
             old_fragments.slice(&edits.peek().unwrap().0.start, Bias::Right, &None);
         new_ropes.append(new_fragments.summary().text);
@@ -992,7 +996,7 @@ impl Buffer {
         let mut insertion_offset = 0;
         let mut new_ropes =
             RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0));
-        let mut old_fragments = self.fragments.cursor::<(VersionedFullOffset, usize)>();
+        let mut old_fragments = self.fragments.cursor::<(VersionedFullOffset, usize)>(&cx);
         let mut new_fragments = old_fragments.slice(
             &VersionedFullOffset::Offset(ranges[0].start),
             Bias::Left,
@@ -1185,7 +1189,7 @@ impl Buffer {
 
         // Get all of the fragments corresponding to these insertion slices.
         let mut fragment_ids = Vec::new();
-        let mut insertions_cursor = self.insertions.cursor::<InsertionFragmentKey>();
+        let mut insertions_cursor = self.insertions.cursor::<InsertionFragmentKey>(&());
         for insertion_slice in &insertion_slices {
             if insertion_slice.insertion_id != insertions_cursor.start().timestamp
                 || insertion_slice.range.start > insertions_cursor.start().split_offset
@@ -1217,8 +1221,8 @@ impl Buffer {
         self.snapshot.undo_map.insert(undo);
 
         let mut edits = Patch::default();
-        let mut old_fragments = self.fragments.cursor::<(Option<&Locator>, usize)>();
-        let mut new_fragments = SumTree::new();
+        let mut old_fragments = self.fragments.cursor::<(Option<&Locator>, usize)>(&None);
+        let mut new_fragments = SumTree::new(&None);
         let mut new_ropes =
             RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0));
 
@@ -1455,7 +1459,7 @@ impl Buffer {
         D: TextDimension,
     {
         // get fragment ranges
-        let mut cursor = self.fragments.cursor::<(Option<&Locator>, usize)>();
+        let mut cursor = self.fragments.cursor::<(Option<&Locator>, usize)>(&None);
         let offset_ranges = self
             .fragment_ids_for_edits(transaction.edit_ids.iter())
             .into_iter()
@@ -1485,7 +1489,7 @@ impl Buffer {
             });
 
         // convert to the desired text dimension.
-        let mut position = D::default();
+        let mut position = D::zero(&());
         let mut rope_cursor = self.visible_text.cursor(0);
         disjoint_ranges.map(move |range| {
             position.add_assign(&rope_cursor.summary(range.start));
@@ -1665,8 +1669,8 @@ impl Buffer {
             );
         }
 
-        let mut cursor = self.snapshot.fragments.cursor::<Option<&Locator>>();
-        for insertion_fragment in self.snapshot.insertions.cursor::<()>() {
+        let mut cursor = self.snapshot.fragments.cursor::<Option<&Locator>>(&None);
+        for insertion_fragment in self.snapshot.insertions.cursor::<()>(&()) {
             cursor.seek(&Some(&insertion_fragment.fragment_id), Bias::Left, &None);
             let fragment = cursor.item().unwrap();
             assert_eq!(insertion_fragment.fragment_id, fragment.id);
@@ -1783,7 +1787,7 @@ impl BufferSnapshot {
 
         let mut cursor = self
             .fragments
-            .filter::<_, FragmentTextSummary>(move |summary| {
+            .filter::<_, FragmentTextSummary>(&None, move |summary| {
                 !version.observed_all(&summary.max_version)
             });
         cursor.next(&None);
@@ -2110,14 +2114,14 @@ impl BufferSnapshot {
         A: 'a + IntoIterator<Item = (&'a Anchor, T)>,
     {
         let anchors = anchors.into_iter();
-        let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>();
-        let mut fragment_cursor = self.fragments.cursor::<(Option<&Locator>, usize)>();
+        let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>(&());
+        let mut fragment_cursor = self.fragments.cursor::<(Option<&Locator>, usize)>(&None);
         let mut text_cursor = self.visible_text.cursor(0);
-        let mut position = D::default();
+        let mut position = D::zero(&());
 
         anchors.map(move |(anchor, payload)| {
             if *anchor == Anchor::MIN {
-                return (D::default(), payload);
+                return (D::zero(&()), payload);
             } else if *anchor == Anchor::MAX {
                 return (D::from_text_summary(&self.visible_text.summary()), payload);
             }
@@ -2159,7 +2163,7 @@ impl BufferSnapshot {
         D: TextDimension,
     {
         if *anchor == Anchor::MIN {
-            D::default()
+            D::zero(&())
         } else if *anchor == Anchor::MAX {
             D::from_text_summary(&self.visible_text.summary())
         } else {
@@ -2167,7 +2171,7 @@ impl BufferSnapshot {
                 timestamp: anchor.timestamp,
                 split_offset: anchor.offset,
             };
-            let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>();
+            let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>(&());
             insertion_cursor.seek(&anchor_key, anchor.bias, &());
             if let Some(insertion) = insertion_cursor.item() {
                 let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key);
@@ -2192,7 +2196,7 @@ impl BufferSnapshot {
                 );
             };
 
-            let mut fragment_cursor = self.fragments.cursor::<(Option<&Locator>, usize)>();
+            let mut fragment_cursor = self.fragments.cursor::<(Option<&Locator>, usize)>(&None);
             fragment_cursor.seek(&Some(&insertion.fragment_id), Bias::Left, &None);
             let fragment = fragment_cursor.item().unwrap();
             let mut fragment_offset = fragment_cursor.start().1;
@@ -2213,7 +2217,7 @@ impl BufferSnapshot {
                 timestamp: anchor.timestamp,
                 split_offset: anchor.offset,
             };
-            let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>();
+            let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>(&());
             insertion_cursor.seek(&anchor_key, anchor.bias, &());
             if let Some(insertion) = insertion_cursor.item() {
                 let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key);
@@ -2263,7 +2267,7 @@ impl BufferSnapshot {
         } else if bias == Bias::Right && offset == self.len() {
             Anchor::MAX
         } else {
-            let mut fragment_cursor = self.fragments.cursor::<usize>();
+            let mut fragment_cursor = self.fragments.cursor::<usize>(&None);
             fragment_cursor.seek(&offset, bias, &None);
             let fragment = fragment_cursor.item().unwrap();
             let overshoot = offset - *fragment_cursor.start();
@@ -2341,15 +2345,15 @@ impl BufferSnapshot {
         let fragments_cursor = if *since == self.version {
             None
         } else {
-            let mut cursor = self
-                .fragments
-                .filter(move |summary| !since.observed_all(&summary.max_version));
+            let mut cursor = self.fragments.filter(&None, move |summary| {
+                !since.observed_all(&summary.max_version)
+            });
             cursor.next(&None);
             Some(cursor)
         };
         let mut cursor = self
             .fragments
-            .cursor::<(Option<&Locator>, FragmentTextSummary)>();
+            .cursor::<(Option<&Locator>, FragmentTextSummary)>(&None);
 
         let start_fragment_id = self.fragment_id_for_anchor(&range.start);
         cursor.seek(&Some(start_fragment_id), Bias::Left, &None);
@@ -2371,8 +2375,8 @@ impl BufferSnapshot {
             fragments_cursor,
             undos: &self.undo_map,
             since,
-            old_end: Default::default(),
-            new_end: Default::default(),
+            old_end: D::zero(&()),
+            new_end: D::zero(&()),
             range: (start_fragment_id, range.start.offset)..(end_fragment_id, range.end.offset),
             buffer_id: self.remote_id,
         }
@@ -2382,9 +2386,9 @@ impl BufferSnapshot {
         if *since != self.version {
             let start_fragment_id = self.fragment_id_for_anchor(&range.start);
             let end_fragment_id = self.fragment_id_for_anchor(&range.end);
-            let mut cursor = self
-                .fragments
-                .filter::<_, usize>(move |summary| !since.observed_all(&summary.max_version));
+            let mut cursor = self.fragments.filter::<_, usize>(&None, move |summary| {
+                !since.observed_all(&summary.max_version)
+            });
             cursor.next(&None);
             while let Some(fragment) = cursor.item() {
                 if fragment.id > *end_fragment_id {
@@ -2405,9 +2409,9 @@ impl BufferSnapshot {
 
     pub fn has_edits_since(&self, since: &clock::Global) -> bool {
         if *since != self.version {
-            let mut cursor = self
-                .fragments
-                .filter::<_, usize>(move |summary| !since.observed_all(&summary.max_version));
+            let mut cursor = self.fragments.filter::<_, usize>(&None, move |summary| {
+                !since.observed_all(&summary.max_version)
+            });
             cursor.next(&None);
             while let Some(fragment) = cursor.item() {
                 let was_visible = fragment.was_visible(since, &self.undo_map);
@@ -2644,6 +2648,10 @@ impl sum_tree::Item for Fragment {
 impl sum_tree::Summary for FragmentSummary {
     type Context = Option<clock::Global>;
 
+    fn zero(_cx: &Self::Context) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, other: &Self, _: &Self::Context) {
         self.max_id.assign(&other.max_id);
         self.text.visible += &other.text.visible;
@@ -2704,6 +2712,10 @@ impl InsertionFragment {
 impl sum_tree::Summary for InsertionFragmentKey {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &()) {
         *self = *summary;
     }
@@ -2736,18 +2748,30 @@ impl ops::Sub for FullOffset {
 }
 
 impl<'a> sum_tree::Dimension<'a, FragmentSummary> for usize {
+    fn zero(_: &Option<clock::Global>) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &FragmentSummary, _: &Option<clock::Global>) {
         *self += summary.text.visible;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, FragmentSummary> for FullOffset {
+    fn zero(_: &Option<clock::Global>) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &FragmentSummary, _: &Option<clock::Global>) {
         self.0 += summary.text.visible + summary.text.deleted;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, FragmentSummary> for Option<&'a Locator> {
+    fn zero(_: &Option<clock::Global>) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a FragmentSummary, _: &Option<clock::Global>) {
         *self = Some(&summary.max_id);
     }
@@ -2786,6 +2810,10 @@ impl Default for VersionedFullOffset {
 }
 
 impl<'a> sum_tree::Dimension<'a, FragmentSummary> for VersionedFullOffset {
+    fn zero(_cx: &Option<clock::Global>) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a FragmentSummary, cx: &Option<clock::Global>) {
         if let Self::Offset(offset) = self {
             let version = cx.as_ref().unwrap();
diff --git a/crates/text/src/undo_map.rs b/crates/text/src/undo_map.rs
index f95809c02e2472..4e670fd456068d 100644
--- a/crates/text/src/undo_map.rs
+++ b/crates/text/src/undo_map.rs
@@ -33,6 +33,10 @@ struct UndoMapKey {
 impl sum_tree::Summary for UndoMapKey {
     type Context = ();
 
+    fn zero(_cx: &Self::Context) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &Self::Context) {
         *self = cmp::max(*self, *summary);
     }
@@ -62,9 +66,8 @@ impl UndoMap {
     pub fn is_undone(&self, edit_id: clock::Lamport) -> bool {
         self.undo_count(edit_id) % 2 == 1
     }
-
     pub fn was_undone(&self, edit_id: clock::Lamport, version: &clock::Global) -> bool {
-        let mut cursor = self.0.cursor::<UndoMapKey>();
+        let mut cursor = self.0.cursor::<UndoMapKey>(&());
         cursor.seek(
             &UndoMapKey {
                 edit_id,
@@ -89,7 +92,7 @@ impl UndoMap {
     }
 
     pub fn undo_count(&self, edit_id: clock::Lamport) -> u32 {
-        let mut cursor = self.0.cursor::<UndoMapKey>();
+        let mut cursor = self.0.cursor::<UndoMapKey>(&());
         cursor.seek(
             &UndoMapKey {
                 edit_id,
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index 776c01c49c2868..d8555b71a4f67c 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -2049,7 +2049,7 @@ impl Snapshot {
     fn delete_entry(&mut self, entry_id: ProjectEntryId) -> Option<Arc<Path>> {
         let removed_entry = self.entries_by_id.remove(&entry_id, &())?;
         self.entries_by_path = {
-            let mut cursor = self.entries_by_path.cursor::<TraversalProgress>();
+            let mut cursor = self.entries_by_path.cursor::<TraversalProgress>(&());
             let mut new_entries_by_path =
                 cursor.slice(&TraversalTarget::Path(&removed_entry.path), Bias::Left, &());
             while let Some(entry) = cursor.item() {
@@ -2192,7 +2192,7 @@ impl Snapshot {
         include_ignored: bool,
         start_offset: usize,
     ) -> Traversal {
-        let mut cursor = self.entries_by_path.cursor();
+        let mut cursor = self.entries_by_path.cursor(&());
         cursor.seek(
             &TraversalTarget::Count {
                 count: start_offset,
@@ -2302,7 +2302,7 @@ impl Snapshot {
     pub fn propagate_git_statuses(&self, result: &mut [Entry]) {
         let mut cursor = self
             .entries_by_path
-            .cursor::<(TraversalProgress, GitStatuses)>();
+            .cursor::<(TraversalProgress, GitStatuses)>(&());
         let mut entry_stack = Vec::<(usize, GitStatuses)>::new();
 
         let mut result_ix = 0;
@@ -2358,13 +2358,13 @@ impl Snapshot {
     pub fn paths(&self) -> impl Iterator<Item = &Arc<Path>> {
         let empty_path = Path::new("");
         self.entries_by_path
-            .cursor::<()>()
+            .cursor::<()>(&())
             .filter(move |entry| entry.path.as_ref() != empty_path)
             .map(|entry| &entry.path)
     }
 
     pub fn child_entries<'a>(&'a self, parent_path: &'a Path) -> ChildEntriesIter<'a> {
-        let mut cursor = self.entries_by_path.cursor();
+        let mut cursor = self.entries_by_path.cursor(&());
         cursor.seek(&TraversalTarget::Path(parent_path), Bias::Right, &());
         let traversal = Traversal {
             cursor,
@@ -2581,7 +2581,7 @@ impl LocalSnapshot {
     #[cfg(test)]
     pub(crate) fn expanded_entries(&self) -> impl Iterator<Item = &Entry> {
         self.entries_by_path
-            .cursor::<()>()
+            .cursor::<()>(&())
             .filter(|entry| entry.kind == EntryKind::Dir && (entry.is_external || entry.is_ignored))
     }
 
@@ -2591,11 +2591,11 @@ impl LocalSnapshot {
 
         assert_eq!(
             self.entries_by_path
-                .cursor::<()>()
+                .cursor::<()>(&())
                 .map(|e| (&e.path, e.id))
                 .collect::<Vec<_>>(),
             self.entries_by_id
-                .cursor::<()>()
+                .cursor::<()>(&())
                 .map(|e| (&e.path, e.id))
                 .collect::<collections::BTreeSet<_>>()
                 .into_iter()
@@ -2605,7 +2605,7 @@ impl LocalSnapshot {
 
         let mut files = self.files(true, 0);
         let mut visible_files = self.files(false, 0);
-        for entry in self.entries_by_path.cursor::<()>() {
+        for entry in self.entries_by_path.cursor::<()>(&()) {
             if entry.is_file() {
                 assert_eq!(files.next().unwrap().inode, entry.inode);
                 if !entry.is_ignored && !entry.is_external {
@@ -2633,7 +2633,7 @@ impl LocalSnapshot {
 
         let dfs_paths_via_iter = self
             .entries_by_path
-            .cursor::<()>()
+            .cursor::<()>(&())
             .map(|e| e.path.as_ref())
             .collect::<Vec<_>>();
         assert_eq!(bfs_paths, dfs_paths_via_iter);
@@ -2679,7 +2679,7 @@ impl LocalSnapshot {
     #[cfg(test)]
     pub fn entries_without_ids(&self, include_ignored: bool) -> Vec<(&Path, u64, bool)> {
         let mut paths = Vec::new();
-        for entry in self.entries_by_path.cursor::<()>() {
+        for entry in self.entries_by_path.cursor::<()>(&()) {
             if include_ignored || !entry.is_ignored {
                 paths.push((entry.path.as_ref(), entry.inode, entry.is_ignored));
             }
@@ -2839,7 +2839,10 @@ impl BackgroundScannerState {
         let mut new_entries;
         let removed_entries;
         {
-            let mut cursor = self.snapshot.entries_by_path.cursor::<TraversalProgress>();
+            let mut cursor = self
+                .snapshot
+                .entries_by_path
+                .cursor::<TraversalProgress>(&());
             new_entries = cursor.slice(&TraversalTarget::Path(path), Bias::Left, &());
             removed_entries = cursor.slice(&TraversalTarget::PathSuccessor(path), Bias::Left, &());
             new_entries.append(cursor.suffix(&()), &());
@@ -2847,7 +2850,7 @@ impl BackgroundScannerState {
         self.snapshot.entries_by_path = new_entries;
 
         let mut removed_ids = Vec::with_capacity(removed_entries.summary().count);
-        for entry in removed_entries.cursor::<()>() {
+        for entry in removed_entries.cursor::<()>(&()) {
             match self.removed_entries.entry(entry.inode) {
                 hash_map::Entry::Occupied(mut e) => {
                     let prev_removed_entry = e.get_mut();
@@ -3403,6 +3406,10 @@ impl Default for EntrySummary {
 impl sum_tree::Summary for EntrySummary {
     type Context = ();
 
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, rhs: &Self, _: &()) {
         self.max_path = rhs.max_path.clone();
         self.count += rhs.count;
@@ -3445,12 +3452,20 @@ struct PathEntrySummary {
 impl sum_tree::Summary for PathEntrySummary {
     type Context = ();
 
+    fn zero(_cx: &Self::Context) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &Self, _: &Self::Context) {
         self.max_id = summary.max_id;
     }
 }
 
 impl<'a> sum_tree::Dimension<'a, PathEntrySummary> for ProjectEntryId {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a PathEntrySummary, _: &()) {
         *self = summary.max_id;
     }
@@ -3466,6 +3481,10 @@ impl Default for PathKey {
 }
 
 impl<'a> sum_tree::Dimension<'a, EntrySummary> for PathKey {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a EntrySummary, _: &()) {
         self.0 = summary.max_path.clone();
     }
@@ -4629,8 +4648,8 @@ impl BackgroundScanner {
         // Identify which paths have changed. Use the known set of changed
         // parent paths to optimize the search.
         let mut changes = Vec::new();
-        let mut old_paths = old_snapshot.entries_by_path.cursor::<PathKey>();
-        let mut new_paths = new_snapshot.entries_by_path.cursor::<PathKey>();
+        let mut old_paths = old_snapshot.entries_by_path.cursor::<PathKey>(&());
+        let mut new_paths = new_snapshot.entries_by_path.cursor::<PathKey>(&());
         let mut last_newly_loaded_dir_path = None;
         old_paths.next(&());
         new_paths.next(&());
@@ -4981,6 +5000,10 @@ impl<'a> TraversalProgress<'a> {
 }
 
 impl<'a> sum_tree::Dimension<'a, EntrySummary> for TraversalProgress<'a> {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a EntrySummary, _: &()) {
         self.max_path = summary.max_path.as_ref();
         self.count += summary.count;
@@ -5030,6 +5053,10 @@ impl Sub for GitStatuses {
 }
 
 impl<'a> sum_tree::Dimension<'a, EntrySummary> for GitStatuses {
+    fn zero(_cx: &()) -> Self {
+        Default::default()
+    }
+
     fn add_summary(&mut self, summary: &'a EntrySummary, _: &()) {
         *self += summary.statuses
     }
@@ -5050,7 +5077,7 @@ impl<'a> Traversal<'a> {
         include_ignored: bool,
         start_path: &Path,
     ) -> Self {
-        let mut cursor = entries.cursor();
+        let mut cursor = entries.cursor(&());
         cursor.seek(&TraversalTarget::Path(start_path), Bias::Left, &());
         let mut traversal = Self {
             cursor,

From 8e30229ec974722fd08daac9509eca27a93a00b4 Mon Sep 17 00:00:00 2001
From: jvmncs <7891333+jvmncs@users.noreply.github.com>
Date: Tue, 17 Sep 2024 22:09:59 -0400
Subject: [PATCH 170/762] Fix nix shell (#17982)

Recently `cmake` was added as a build-time dependency to the wasm
runtime. This adds that dependency to our nix shell env.

Release Notes:

- N/A
---
 flake.lock    | 29 ++++++++++++-----------------
 flake.nix     |  5 +----
 nix/shell.nix |  1 +
 3 files changed, 14 insertions(+), 21 deletions(-)

diff --git a/flake.lock b/flake.lock
index f996e1e5776458..2b421a9efb8b99 100644
--- a/flake.lock
+++ b/flake.lock
@@ -1,17 +1,12 @@
 {
   "nodes": {
     "crane": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
       "locked": {
-        "lastModified": 1724537630,
-        "narHash": "sha256-gpqINM71zp3kw5XYwUXa84ZtPnCmLLnByuFoYesT1bY=",
+        "lastModified": 1725409566,
+        "narHash": "sha256-PrtLmqhM6UtJP7v7IGyzjBFhbG4eOAHT6LPYOFmYfbk=",
         "owner": "ipetkov",
         "repo": "crane",
-        "rev": "3e08f4b1fc9aaede5dd511d8f5f4ef27501e49b0",
+        "rev": "7e4586bad4e3f8f97a9271def747cf58c4b68f3c",
         "type": "github"
       },
       "original": {
@@ -28,11 +23,11 @@
         "rust-analyzer-src": "rust-analyzer-src"
       },
       "locked": {
-        "lastModified": 1724740262,
-        "narHash": "sha256-cpFasbzOTlwLi4fNas6hDznVUdCJn/lMLxi7MAMG6hg=",
+        "lastModified": 1726554553,
+        "narHash": "sha256-xakDhIS1c1VgJc/NMOLj05yBsTdlXKMEYz6wC8Hdshc=",
         "owner": "nix-community",
         "repo": "fenix",
-        "rev": "703efdd9b5c6a7d5824afa348a24fbbf8ff226be",
+        "rev": "1f59d7585aa06d2c327960d397bea4067d8fee98",
         "type": "github"
       },
       "original": {
@@ -58,11 +53,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1724479785,
-        "narHash": "sha256-pP3Azj5d6M5nmG68Fu4JqZmdGt4S4vqI5f8te+E/FTw=",
+        "lastModified": 1726463316,
+        "narHash": "sha256-gI9kkaH0ZjakJOKrdjaI/VbaMEo9qBbSUl93DnU7f4c=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "d0e1602ddde669d5beb01aec49d71a51937ed7be",
+        "rev": "99dc8785f6a0adac95f5e2ab05cc2e1bf666d172",
         "type": "github"
       },
       "original": {
@@ -83,11 +78,11 @@
     "rust-analyzer-src": {
       "flake": false,
       "locked": {
-        "lastModified": 1724666781,
-        "narHash": "sha256-nOQDgjTDlWe0/+Ptf3o2p6UrznQFHnXBHRV1ZAsSpe8=",
+        "lastModified": 1726443025,
+        "narHash": "sha256-nCmG4NJpwI0IoIlYlwtDwVA49yuspA2E6OhfCOmiArQ=",
         "owner": "rust-lang",
         "repo": "rust-analyzer",
-        "rev": "095926ea6f008477a15a2ec6b0b8797e2e5be0e5",
+        "rev": "94b526fc86eaa0e90fb4d54a5ba6313aa1e9b269",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index 23631996abd5ae..7d1410ac7c20b7 100644
--- a/flake.nix
+++ b/flake.nix
@@ -7,10 +7,7 @@
       url = "github:nix-community/fenix";
       inputs.nixpkgs.follows = "nixpkgs";
     };
-    crane = {
-      url = "github:ipetkov/crane";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
+    crane.url = "github:ipetkov/crane";
     flake-compat.url = "github:edolstra/flake-compat";
   };
 
diff --git a/nix/shell.nix b/nix/shell.nix
index 34682ab1d5f8d0..03e298e132f9b0 100644
--- a/nix/shell.nix
+++ b/nix/shell.nix
@@ -26,6 +26,7 @@ in
       nativeBuildInputs = with pkgs; [
         clang
         curl
+        cmake
         perl
         pkg-config
         protobuf

From 2699fa8d4a10eb38445e0c5979dfb56a2193f949 Mon Sep 17 00:00:00 2001
From: Junkui Zhang <364772080@qq.com>
Date: Wed, 18 Sep 2024 11:59:19 +0800
Subject: [PATCH 171/762] windows: Fix `tailwind-language-server` (#17778)

Closes #17741

I'm not sure why, but ever since `tailwind` was upgraded to `0.24`,
there have been occasional errors indicating that the `.ps1` file could
not be found. After reviewing the `.ps1` script, it appears that it
simply starts the server using `node`. This PR directly using the method
from the script to start the server with `node`.


Co-authored-by: Anay <me@anayparaswani.dev>


Release Notes:

- N/A

---------

Co-authored-by: Anay <me@anayparaswani.dev>
---
 crates/languages/src/tailwind.rs | 34 +++++++-------------------------
 1 file changed, 7 insertions(+), 27 deletions(-)

diff --git a/crates/languages/src/tailwind.rs b/crates/languages/src/tailwind.rs
index 524e4ce84611bc..9a053dbd8739ce 100644
--- a/crates/languages/src/tailwind.rs
+++ b/crates/languages/src/tailwind.rs
@@ -18,20 +18,15 @@ use std::{
 use util::{maybe, ResultExt};
 
 #[cfg(target_os = "windows")]
-const SERVER_PATH: &str = "node_modules/.bin/tailwindcss-language-server.ps1";
+const SERVER_PATH: &str =
+    "node_modules/@tailwindcss/language-server/bin/tailwindcss-language-server";
 #[cfg(not(target_os = "windows"))]
 const SERVER_PATH: &str = "node_modules/.bin/tailwindcss-language-server";
 
-#[cfg(not(target_os = "windows"))]
 fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
     vec![server_path.into(), "--stdio".into()]
 }
 
-#[cfg(target_os = "windows")]
-fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
-    vec!["-File".into(), server_path.into(), "--stdio".into()]
-}
-
 pub struct TailwindLspAdapter {
     node: Arc<dyn NodeRuntime>,
 }
@@ -114,26 +109,11 @@ impl LspAdapter for TailwindLspAdapter {
                 .await?;
         }
 
-        #[cfg(target_os = "windows")]
-        {
-            let env_path = self.node.node_environment_path().await?;
-            let mut env = HashMap::default();
-            env.insert("PATH".to_string(), env_path.to_string_lossy().to_string());
-
-            Ok(LanguageServerBinary {
-                path: "powershell.exe".into(),
-                env: Some(env),
-                arguments: server_binary_arguments(&server_path),
-            })
-        }
-        #[cfg(not(target_os = "windows"))]
-        {
-            Ok(LanguageServerBinary {
-                path: self.node.binary_path().await?,
-                env: None,
-                arguments: server_binary_arguments(&server_path),
-            })
-        }
+        Ok(LanguageServerBinary {
+            path: self.node.binary_path().await?,
+            env: None,
+            arguments: server_binary_arguments(&server_path),
+        })
     }
 
     async fn cached_server_binary(

From d4e10dfba3bc88c6476605a9efbd7f5c5be45a8a Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 18 Sep 2024 10:04:02 +0200
Subject: [PATCH 172/762] docs: Update rust-analyzer docs (#17988)

Release Notes:

- N/A
---
 docs/src/languages/rust.md | 182 ++++++++++++++++++-------------------
 1 file changed, 91 insertions(+), 91 deletions(-)

diff --git a/docs/src/languages/rust.md b/docs/src/languages/rust.md
index 026b522898cf07..233c378dae06d3 100644
--- a/docs/src/languages/rust.md
+++ b/docs/src/languages/rust.md
@@ -13,37 +13,29 @@ TBD: Provide explicit examples not just `....`
 
 ## Inlay Hints
 
-The following configuration can be used to enable inlay hints for rust:
+The following configuration can be used to change the inlay hint settings for `rust-analyzer` in Rust:
 
 ```json
-"inlayHints": {
-  "maxLength": null,
-  "lifetimeElisionHints": {
-  "useParameterNames": true,
-    "enable": "skip_trivial"
-  },
-  "closureReturnTypeHints": {
-    "enable": "always"
-  }
-}
-```
-
-to make the language server send back inlay hints when Zed has them enabled in the settings.
-
-Use
-
-```json
-"lsp": {
-  "rust-analyzer": {
-    "initialization_options": {
-      ....
+{
+  "lsp": {
+    "rust-analyzer": {
+      "initialization_options": {
+        "inlayHints": {
+          "maxLength": null,
+          "lifetimeElisionHints": {
+            "enable": "skip_trivial"
+            "useParameterNames": true,
+          },
+          "closureReturnTypeHints": {
+            "enable": "always"
+          }
+        }
+      }
     }
   }
 }
 ```
 
-to override these settings.
-
 See [Inlay Hints](https://rust-analyzer.github.io/manual.html#inlay-hints) in the Rust Analyzer Manual for more information.
 
 ## Target directory
@@ -70,35 +62,39 @@ A `true` setting will set the target directory to `target/rust-analyzer`. You ca
 
 You can configure which `rust-analyzer` binary Zed should use.
 
-To use a binary in a custom location, add the following to your `settings.json`:
+By default, Zed will try to find a `rust-analyzer` in your `$PATH` and try to use that. If that binary successfully executes `rust-analyzer --help`, it's used. Otherwise, Zed will fall back to installing its own `rust-analyzer` version and using that.
+
+If you want to disable Zed looking for a `rust-analyzer` binary, you can set `path_lookup` to `false` in your `settings.json`:
 
 ```json
 {
   "lsp": {
     "rust-analyzer": {
       "binary": {
-        "path": "/Users/example/bin/rust-analyzer",
-        "args": []
+        "path_lookup": false
       }
     }
   }
 }
 ```
 
-To use a binary that is on your `$PATH`, add the following to your `settings.json`:
+If you want to use a binary in a custom location, you can specify a `path` and optional `args`:
 
 ```json
 {
   "lsp": {
     "rust-analyzer": {
       "binary": {
-        "path_lookup": true
+        "path": "/Users/example/bin/rust-analyzer",
+        "args": []
       }
     }
   }
 }
 ```
 
+This `"path"` has to be an absolute path.
+
 ## More server configuration
 
 <!--
@@ -138,30 +134,32 @@ Check on save feature is responsible for returning part of the diagnostics based
 Consider more `rust-analyzer.cargo.` and `rust-analyzer.check.` and `rust-analyzer.diagnostics.` settings from the manual for more fine-grained configuration.
 Here's a snippet for Zed settings.json (the language server will restart automatically after the `lsp.rust-analyzer` section is edited and saved):
 
-```json5
-"lsp": {
+```json
+{
+  "lsp": {
     "rust-analyzer": {
-        "initialization_options": {
-            // get more cargo-less diagnostics from rust-analyzer,
-            // which might include false-positives (those can be turned off by their names)
-            "diagnostics": {
-                "experimental": {
-                    "enable": true
-                }
-            },
-            // To disable the checking entirely
-            // (ignores all cargo and check settings below)
-            "checkOnSave": false,
-            // To check the `lib` target only.
-            "cargo": {
-                "allTargets": false
-            },
-            // Use `-p` instead of `--workspace` for cargo check
-            "check": {
-              "workspace": false
-            }
+      "initialization_options": {
+        // get more cargo-less diagnostics from rust-analyzer,
+        // which might include false-positives (those can be turned off by their names)
+        "diagnostics": {
+          "experimental": {
+            "enable": true
+          }
+        },
+        // To disable the checking entirely
+        // (ignores all cargo and check settings below)
+        "checkOnSave": false,
+        // To check the `lib` target only.
+        "cargo": {
+          "allTargets": false
+        },
+        // Use `-p` instead of `--workspace` for cargo check
+        "check": {
+          "workspace": false
         }
+      }
     }
+  }
 }
 ```
 
@@ -170,50 +168,52 @@ Here's a snippet for Zed settings.json (the language server will restart automat
 There's a way get custom completion items from rust-analyzer, that will transform the code according to the snippet body:
 
 ```json
-"lsp": {
+{
+  "lsp": {
     "rust-analyzer": {
-        "initialization_options": {
-            "completion": {
-                "snippets": {
-                    "custom": {
-                        "Arc::new": {
-                            "postfix": "arc",
-                            "body": ["Arc::new(${receiver})"],
-                            "requires": "std::sync::Arc",
-                            "scope": "expr"
-                        },
-                        "Some": {
-                            "postfix": "some",
-                            "body": ["Some(${receiver})"],
-                            "scope": "expr"
-                        },
-                        "Ok": {
-                            "postfix": "ok",
-                            "body": ["Ok(${receiver})"],
-                            "scope": "expr"
-                        },
-                        "Rc::new": {
-                            "postfix": "rc",
-                            "body": ["Rc::new(${receiver})"],
-                            "requires": "std::rc::Rc",
-                            "scope": "expr"
-                        },
-                        "Box::pin": {
-                            "postfix": "boxpin",
-                            "body": ["Box::pin(${receiver})"],
-                            "requires": "std::boxed::Box",
-                            "scope": "expr"
-                        },
-                        "vec!": {
-                            "postfix": "vec",
-                            "body": ["vec![${receiver}]"],
-                            "description": "vec![]",
-                            "scope": "expr"
-                        }
-                    }
-                }
+      "initialization_options": {
+        "completion": {
+          "snippets": {
+            "custom": {
+              "Arc::new": {
+                "postfix": "arc",
+                "body": ["Arc::new(${receiver})"],
+                "requires": "std::sync::Arc",
+                "scope": "expr"
+              },
+              "Some": {
+                "postfix": "some",
+                "body": ["Some(${receiver})"],
+                "scope": "expr"
+              },
+              "Ok": {
+                "postfix": "ok",
+                "body": ["Ok(${receiver})"],
+                "scope": "expr"
+              },
+              "Rc::new": {
+                "postfix": "rc",
+                "body": ["Rc::new(${receiver})"],
+                "requires": "std::rc::Rc",
+                "scope": "expr"
+              },
+              "Box::pin": {
+                "postfix": "boxpin",
+                "body": ["Box::pin(${receiver})"],
+                "requires": "std::boxed::Box",
+                "scope": "expr"
+              },
+              "vec!": {
+                "postfix": "vec",
+                "body": ["vec![${receiver}]"],
+                "description": "vec![]",
+                "scope": "expr"
+              }
             }
+          }
         }
+      }
     }
+  }
 }
 ```

From 550ceec549519e564e52c3d4f02f88ebad531236 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 18 Sep 2024 10:04:13 +0200
Subject: [PATCH 173/762] docs: Update Ruby docs to provide more complete
 examples (#17987)

Closes #17917

Release Notes:

- N/A
---
 docs/src/languages/ruby.md | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/docs/src/languages/ruby.md b/docs/src/languages/ruby.md
index 6385de9c963050..47466a35cdb304 100644
--- a/docs/src/languages/ruby.md
+++ b/docs/src/languages/ruby.md
@@ -138,15 +138,21 @@ Ruby LSP uses pull-based diagnostics which Zed doesn't support yet. We can tell
 
 ```json
 {
+  "languages": {
+    "Ruby": {
+      "language_servers": ["ruby-lsp", "!solargraph", "..."],
+    },
+  },
   "lsp": {
     "ruby-lsp": {
       "initialization_options": {
         "enabledFeatures": {
-          "diagnostics": false
-        }
-      }
-    }
-  }
+          // This disables diagnostics
+          "diagnostics": false,
+        },
+      },
+    },
+  },
 }
 ```
 
@@ -164,11 +170,24 @@ Rubocop has unsafe autocorrection disabled by default. We can tell Zed to enable
 
 ```json
 {
+  "languages": {
+    "Ruby": {
+      // Use ruby-lsp as the primary language server and rubocop as the secondary.
+      "language_servers": ["ruby-lsp", "rubocop", "!solargraph", "..."]
+    }
+  },
   "lsp": {
     "rubocop": {
       "initialization_options": {
         "safeAutocorrect": false
       }
+    },
+    "ruby-lsp": {
+      "initialization_options": {
+        "enabledFeatures": {
+          "diagnostics": false
+        }
+      }
     }
   }
 }

From aae26ee33de912aa0a5193a3d9d86ae5d4856723 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 18 Sep 2024 12:34:10 +0200
Subject: [PATCH 174/762] go: Fix tasks when running tests/benchs in packages
 (#17998)

Turns out that #17645 reintroduced another regression and didn't catch
all the regressions in #17108.

Releases Notes:

- Fixed Go tasks not working properly when running tests or benchmarks
in subfolders/packages.

Co-authored-by: Piotr <piotr@zed.dev>
---
 crates/languages/src/go.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/crates/languages/src/go.rs b/crates/languages/src/go.rs
index 2ddf7796817e81..a103c4783cffad 100644
--- a/crates/languages/src/go.rs
+++ b/crates/languages/src/go.rs
@@ -519,7 +519,6 @@ impl ContextProvider for GoContextProvider {
                 command: "go".into(),
                 args: vec![
                     "test".into(),
-                    GO_PACKAGE_TASK_VARIABLE.template_value(),
                     "-run".into(),
                     format!("^{}\\$", VariableName::Symbol.template_value(),),
                 ],
@@ -530,7 +529,7 @@ impl ContextProvider for GoContextProvider {
             TaskTemplate {
                 label: format!("go test {}", GO_PACKAGE_TASK_VARIABLE.template_value()),
                 command: "go".into(),
-                args: vec!["test".into(), GO_PACKAGE_TASK_VARIABLE.template_value()],
+                args: vec!["test".into()],
                 cwd: package_cwd.clone(),
                 ..TaskTemplate::default()
             },
@@ -572,7 +571,6 @@ impl ContextProvider for GoContextProvider {
                 command: "go".into(),
                 args: vec![
                     "test".into(),
-                    GO_PACKAGE_TASK_VARIABLE.template_value(),
                     "-benchmem".into(),
                     "-run=^$".into(),
                     "-bench".into(),

From f68f4ab9825d6a3f22b9fd05e648af1a311bd7d6 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 18 Sep 2024 12:34:39 +0200
Subject: [PATCH 175/762] docs: Add tweaks to the REPL page (#18000)

Just capitalizing some things, making sure URLs are clickable links, and
using the note blockquote callout when appropriate.

Release Notes:

- N/A
---
 docs/src/languages/ruby.md | 14 +++++++-------
 docs/src/repl.md           | 10 +++++-----
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/docs/src/languages/ruby.md b/docs/src/languages/ruby.md
index 47466a35cdb304..e8bec34a71caa3 100644
--- a/docs/src/languages/ruby.md
+++ b/docs/src/languages/ruby.md
@@ -140,19 +140,19 @@ Ruby LSP uses pull-based diagnostics which Zed doesn't support yet. We can tell
 {
   "languages": {
     "Ruby": {
-      "language_servers": ["ruby-lsp", "!solargraph", "..."],
-    },
+      "language_servers": ["ruby-lsp", "!solargraph", "..."]
+    }
   },
   "lsp": {
     "ruby-lsp": {
       "initialization_options": {
         "enabledFeatures": {
           // This disables diagnostics
-          "diagnostics": false,
-        },
-      },
-    },
-  },
+          "diagnostics": false
+        }
+      }
+    }
+  }
 }
 ```
 
diff --git a/docs/src/repl.md b/docs/src/repl.md
index 3d5d441e79a2ec..9c14ff925fd59b 100644
--- a/docs/src/repl.md
+++ b/docs/src/repl.md
@@ -74,7 +74,7 @@ On macOS, your system Python will _not_ work. Either set up [pyenv](https://gith
 
 </div>
 
-To setup your current python to have an available kernel, run:
+To setup your current Python to have an available kernel, run:
 
 ```sh
 pip install ipykernel
@@ -99,7 +99,7 @@ python -m ipykernel install --user --name myenv --display-name "Python (myenv)"
 
 ### R (Ark Kernel) {#r-ark}
 
-Install [Ark](https://github.com/posit-dev/ark/releases) by downloading the release for your operating system. E.g. for macOS just unpack `ark` binary and put it into `/usr/local/bin`. Then run:
+Install [Ark](https://github.com/posit-dev/ark/releases) by downloading the release for your operating system. For example, for macOS just unpack `ark` binary and put it into `/usr/local/bin`. Then run:
 
 ```sh
 ark --install
@@ -137,9 +137,9 @@ TBD: Improve Julia REPL instructions
 
 ### Scala
 
-- Install Scala with `cs setup` (Coursier): https://www.scala-lang.org/download/
+- [Install Scala](https://www.scala-lang.org/download/) with `cs setup` (Coursier):
   - `brew install coursier/formulas/coursier && cs setup`
-- REPL (Almond) Setup Instructions https://almond.sh/docs/quick-start-install
+- REPL (Almond) [setup instructions](https://almond.sh/docs/quick-start-install):
   - `brew install --cask temurin` (Eclipse foundation official OpenJDK binaries)
   - `brew install coursier/formulas/coursier && cs setup`
   - `coursier launch --use-bootstrap almond -- --install`
@@ -180,4 +180,4 @@ Available kernels:
   rust                  /Users/z/Library/Jupyter/kernels/rust
 ```
 
-Note: Zed makes best effort usage of `sys.prefix` and `CONDA_PREFIX` to find kernels in Python environments. If you want explicitly control run `python -m ipykernel install --user --name myenv --display-name "Python (myenv)"` to install the kernel directly while in the environment.
+> Note: Zed makes best effort usage of `sys.prefix` and `CONDA_PREFIX` to find kernels in Python environments. If you want explicitly control run `python -m ipykernel install --user --name myenv --display-name "Python (myenv)"` to install the kernel directly while in the environment.

From a149a50946d352be1cceccccfcee2505ac3c2641 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 18 Sep 2024 12:34:51 +0200
Subject: [PATCH 176/762] docs: Fix links on the Telemetry page (#17995)

This PR tweaks some broken links in the Telemetry page as well as
capitalizing instances of "Zed".

Release Notes:

- N/A
---
 docs/src/telemetry.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/src/telemetry.md b/docs/src/telemetry.md
index cdb44979eade0f..dd6556c24f0b9a 100644
--- a/docs/src/telemetry.md
+++ b/docs/src/telemetry.md
@@ -31,7 +31,7 @@ Telemetry is sent from the application to our servers. Data is proxied through o
 
 Diagnostic events include debug information (stack traces) from crash reports. Reports are sent on the first application launch after the crash occurred. We've built dashboards that allow us to visualize the frequency and severity of issues experienced by users. Having these reports sent automatically allows us to begin implementing fixes without the user needing to file a report in our issue tracker. The plots in the dashboards also give us an informal measurement of the stability of Zed.
 
-You can see what data is sent when a panic occurs by inspecting the `Panic` struct in [crates/telemetry_events/src/telemetry_events.rs](https://github.com/zed-industries/zed/blob/main/crates/telemetry_events/src/telemetry_events.rs#L184) in the zed repo. You can find additional information in the [Debugging Crashes](./development/debugging-crashes.md) documentation.
+You can see what data is sent when a panic occurs by inspecting the `Panic` struct in [crates/telemetry_events/src/telemetry_events.rs](https://github.com/zed-industries/zed/blob/main/crates/telemetry_events/src/telemetry_events.rs#L184) in the Zed repo. You can find additional information in the [Debugging Crashes](./development/debugging-crashes.md) documentation.
 
 ### Usage Data (Metrics) {#metrics}
 
@@ -48,8 +48,8 @@ Usage Data is associated with a secure random telemetry ID which may be linked t
 
 You can audit the metrics data that Zed has reported by running the command {#action zed::OpenTelemetryLog} from the command palette, or clicking `Help > View Telemetry Log` in the application menu.
 
-You can see the full list of the event types and exactly the data sent for each by inspecting the `Event` enum and the associated structs in [crates/telemetry_events/src/telemetry_events.rs](https://github.com/zed-industries/zed/blob/main/crates/telemetry_events/src/telemetry_events.rs#L63] in the zed repo.
+You can see the full list of the event types and exactly the data sent for each by inspecting the `Event` enum and the associated structs in [crates/telemetry_events/src/telemetry_events.rs](https://github.com/zed-industries/zed/blob/main/crates/telemetry_events/src/telemetry_events.rs#L63) in the Zed repository.
 
 ## Concerns and Questions
 
-If you have concerns about telemetry, please feel free to open issues in our [Zed repository](https://github.com/zed-industries/zed/issues/new/choose).
+If you have concerns about telemetry, please feel free to [open an issue](https://github.com/zed-industries/zed/issues/new/choose).

From 430ce073d2e00fed8e7fbbe8dae56d4e5338bd9f Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 18 Sep 2024 12:36:02 +0200
Subject: [PATCH 177/762] docs: Improve warning callout docs (#17997)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR is a quick follow-up to
https://github.com/zed-industries/zed/pull/1795. 😊

Release Notes:

- N/A
---
 docs/theme/css/general.css   | 2 +-
 docs/theme/css/variables.css | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/docs/theme/css/general.css b/docs/theme/css/general.css
index 6f086a1052447b..5567ae7fb07d6c 100644
--- a/docs/theme/css/general.css
+++ b/docs/theme/css/general.css
@@ -268,7 +268,7 @@ blockquote .warning:before {
 .warning {
   margin: auto;
   padding: 1rem 1.25rem;
-  color: var(--fg);
+  color: var(--full-contrast);
   background-color: var(--warning-bg);
   border: 1px solid var(--warning-border);
 }
diff --git a/docs/theme/css/variables.css b/docs/theme/css/variables.css
index 59f239826472a8..a7c0ed7114b405 100644
--- a/docs/theme/css/variables.css
+++ b/docs/theme/css/variables.css
@@ -111,7 +111,7 @@
   --icons-hover: hsl(220, 14%, 90%);
   --icon-btn-bg-hover: hsl(220, 93%, 42%, 0.4);
 
-  --links: hsl(220, 93%, 70%);
+  --links: hsl(220, 93%, 75%);
   --link-line-decoration: hsl(220, 92%, 80%, 0.4);
   --link-line-decoration-hover: hsl(220, 92%, 80%, 0.8);
   --full-contrast: #fff;
@@ -136,6 +136,10 @@
   --table-header-bg: hsl(220, 13%, 25%, 0.5);
   --table-alternate-bg: hsl(220, 13%, 20%, 0.4);
 
+  --warning-border: hsl(25, 100%, 85%, 0.2);
+  --warning-bg: hsl(42, 100%, 40%, 0.1);
+  --warning-icon: hsl(42, 100%, 80%);
+
   --searchbar-border-color: hsl(220, 13%, 30%);
   --searchbar-bg: hsl(220, 13%, 22%, 0.5);
   --searchbar-fg: hsl(220, 14%, 71%);

From 3b153a54c271c21faf5ce53778e404cb0b6f8449 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 18 Sep 2024 14:14:03 +0200
Subject: [PATCH 178/762] docs: Improve dark mode syntax highlighting (#18002)

This PR introduces [GitHub
Light](https://github.com/highlightjs/highlight.js/blob/main/src/styles/github.css)
and [GitHub
Dark](https://github.com/highlightjs/highlight.js/blob/main/src/styles/github-dark.css)
as the syntax highlighting themes for the corresponding modes.

Release Notes:

- N/A
---
 docs/book.toml             |   4 +-
 docs/src/completions.md    |   2 +-
 docs/theme/css/general.css |   4 +-
 docs/theme/highlight.css   | 251 +++++++++++++++++++++++++++++++++++++
 4 files changed, 256 insertions(+), 5 deletions(-)
 create mode 100644 docs/theme/highlight.css

diff --git a/docs/book.toml b/docs/book.toml
index 6696d0bb12434b..fbf55ef90a868c 100644
--- a/docs/book.toml
+++ b/docs/book.toml
@@ -8,8 +8,8 @@ site-url = "/docs/"
 
 [output.html]
 no-section-label = true
-preferred-dark-theme = "light"
-additional-css = ["theme/page-toc.css", "theme/plugins.css"]
+preferred-dark-theme = "dark"
+additional-css = ["theme/page-toc.css", "theme/plugins.css", "theme/highlight.css"]
 additional-js  = ["theme/page-toc.js", "theme/plugins.js"]
 
 [output.html.print]
diff --git a/docs/src/completions.md b/docs/src/completions.md
index 167c7c48e63e64..814bf051e15424 100644
--- a/docs/src/completions.md
+++ b/docs/src/completions.md
@@ -10,7 +10,7 @@ Zed supports supports two sources for completions:
 When there is an appropriate language server available, Zed will by-default provide completions of variable names, functions, and other symbols in the current file. You can disable these by adding the following to your zed settings.json file:
 
 ```json
-  "show_completions_on_input": false
+"show_completions_on_input": false
 ```
 
 You can manually trigger completions with `ctrl-space` or by triggering the `editor::ShowCompletions` action from the command palette.
diff --git a/docs/theme/css/general.css b/docs/theme/css/general.css
index 5567ae7fb07d6c..b422890751c508 100644
--- a/docs/theme/css/general.css
+++ b/docs/theme/css/general.css
@@ -355,7 +355,7 @@ kbd {
   font-style: italic;
 }
 
-code.hljs {
+code:not(pre code).hljs {
   color: var(--code-text) !important;
-  background-color: var(--code-bg);
+  background-color: var(--code-bg) !important;
 }
diff --git a/docs/theme/highlight.css b/docs/theme/highlight.css
new file mode 100644
index 00000000000000..9d8f39d9030b23
--- /dev/null
+++ b/docs/theme/highlight.css
@@ -0,0 +1,251 @@
+/*!
+  Theme: GitHub
+  Description: Light theme as seen on github.com
+  Author: github.com
+  Maintainer: @Hirse
+  Updated: 2021-05-15
+
+  Outdated base version: https://github.com/primer/github-syntax-light
+  Current colors taken from GitHub's CSS
+*/
+
+.hljs {
+  color: #24292e;
+  background: #ffffff;
+}
+
+.hljs-doctag,
+.hljs-keyword,
+.hljs-meta .hljs-keyword,
+.hljs-template-tag,
+.hljs-template-variable,
+.hljs-type,
+.hljs-variable.language_ {
+  /* prettylights-syntax-keyword */
+  color: #d73a49;
+}
+
+.hljs-title,
+.hljs-title.class_,
+.hljs-title.class_.inherited__,
+.hljs-title.function_ {
+  /* prettylights-syntax-entity */
+  color: #6f42c1;
+}
+
+.hljs-attr,
+.hljs-attribute,
+.hljs-literal,
+.hljs-meta,
+.hljs-number,
+.hljs-operator,
+.hljs-variable,
+.hljs-selector-attr,
+.hljs-selector-class,
+.hljs-selector-id {
+  /* prettylights-syntax-constant */
+  color: #005cc5;
+}
+
+.hljs-regexp,
+.hljs-string,
+.hljs-meta .hljs-string {
+  /* prettylights-syntax-string */
+  color: #032f62;
+}
+
+.hljs-built_in,
+.hljs-symbol {
+  /* prettylights-syntax-variable */
+  color: #e36209;
+}
+
+.hljs-comment,
+.hljs-code,
+.hljs-formula {
+  /* prettylights-syntax-comment */
+  color: #6a737d;
+}
+
+.hljs-name,
+.hljs-quote,
+.hljs-selector-tag,
+.hljs-selector-pseudo {
+  /* prettylights-syntax-entity-tag */
+  color: #22863a;
+}
+
+.hljs-subst {
+  /* prettylights-syntax-storage-modifier-import */
+  color: #24292e;
+}
+
+.hljs-section {
+  /* prettylights-syntax-markup-heading */
+  color: #005cc5;
+  font-weight: bold;
+}
+
+.hljs-bullet {
+  /* prettylights-syntax-markup-list */
+  color: #735c0f;
+}
+
+.hljs-emphasis {
+  /* prettylights-syntax-markup-italic */
+  color: #24292e;
+  font-style: italic;
+}
+
+.hljs-strong {
+  /* prettylights-syntax-markup-bold */
+  color: #24292e;
+  font-weight: bold;
+}
+
+.hljs-addition {
+  /* prettylights-syntax-markup-inserted */
+  color: #22863a;
+  background-color: #f0fff4;
+}
+
+.hljs-deletion {
+  /* prettylights-syntax-markup-deleted */
+  color: #b31d28;
+  background-color: #ffeef0;
+}
+
+.hljs-char.escape_,
+.hljs-link,
+.hljs-params,
+.hljs-property,
+.hljs-punctuation,
+.hljs-tag {
+  /* purposely ignored */
+}
+
+/*!
+  Theme: GitHub Dark
+  Description: Dark theme as seen on github.com
+  Author: github.com
+  Maintainer: @Hirse
+  Updated: 2021-05-15
+
+  Outdated base version: https://github.com/primer/github-syntax-dark
+  Current colors taken from GitHub's CSS
+*/
+
+.dark .hljs {
+  color: #c9d1d9;
+  background: #0d1117;
+}
+
+.dark .hljs-doctag,
+.dark .hljs-keyword,
+.dark .hljs-meta .hljs-keyword,
+.dark .hljs-template-tag,
+.dark .hljs-template-variable,
+.dark .hljs-type,
+.dark .hljs-variable.language_ {
+  /* prettylights-syntax-keyword */
+  color: #ff7b72;
+}
+
+.dark .hljs-title,
+.dark .hljs-title.class_,
+.dark .hljs-title.class_.inherited__,
+.dark .hljs-title.function_ {
+  /* prettylights-syntax-entity */
+  color: #d2a8ff;
+}
+
+.dark .hljs-attr,
+.dark .hljs-attribute,
+.dark .hljs-literal,
+.dark .hljs-meta,
+.dark .hljs-number,
+.dark .hljs-operator,
+.dark .hljs-variable,
+.dark .hljs-selector-attr,
+.dark .hljs-selector-class,
+.dark .hljs-selector-id {
+  /* prettylights-syntax-constant */
+  color: #79c0ff;
+}
+
+.dark .hljs-regexp,
+.dark .hljs-string,
+.dark .hljs-meta .hljs-string {
+  /* prettylights-syntax-string */
+  color: #a5d6ff;
+}
+
+.dark .hljs-built_in,
+.dark .hljs-symbol {
+  /* prettylights-syntax-variable */
+  color: #ffa657;
+}
+
+.dark .hljs-comment,
+.dark .hljs-code,
+.dark .hljs-formula {
+  /* prettylights-syntax-comment */
+  color: #8b949e;
+}
+
+.dark .hljs-name,
+.dark .hljs-quote,
+.dark .hljs-selector-tag,
+.dark .hljs-selector-pseudo {
+  /* prettylights-syntax-entity-tag */
+  color: #7ee787;
+}
+
+.dark .hljs-subst {
+  /* prettylights-syntax-storage-modifier-import */
+  color: #c9d1d9;
+}
+
+.dark .hljs-section {
+  /* prettylights-syntax-markup-heading */
+  color: #1f6feb;
+  font-weight: bold;
+}
+
+.dark .hljs-bullet {
+  /* prettylights-syntax-markup-list */
+  color: #f2cc60;
+}
+
+.dark .hljs-emphasis {
+  /* prettylights-syntax-markup-italic */
+  color: #c9d1d9;
+  font-style: italic;
+}
+
+.dark .hljs-strong {
+  /* prettylights-syntax-markup-bold */
+  color: #c9d1d9;
+  font-weight: bold;
+}
+
+.dark .hljs-addition {
+  /* prettylights-syntax-markup-inserted */
+  color: #aff5b4;
+  background-color: #033a16;
+}
+
+.dark .hljs-deletion {
+  /* prettylights-syntax-markup-deleted */
+  color: #ffdcd7;
+  background-color: #67060c;
+}
+
+.dark .hljs-char.escape_,
+.dark .hljs-link,
+.dark .hljs-params,
+.dark .hljs-property,
+.dark .hljs-punctuation,
+.dark .hljs-tag {
+  /* purposely ignored */
+}

From 3ac201e448fd85b818d3d803615a36c1791d49bf Mon Sep 17 00:00:00 2001
From: ensi <66754841+ncor@users.noreply.github.com>
Date: Wed, 18 Sep 2024 16:32:37 +0300
Subject: [PATCH 179/762] gpui: Improve underline appearance (#17586)

---
 crates/gpui/src/platform/blade/shaders.wgsl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/gpui/src/platform/blade/shaders.wgsl b/crates/gpui/src/platform/blade/shaders.wgsl
index c3983c7acc6bc6..6099cbd93ad425 100644
--- a/crates/gpui/src/platform/blade/shaders.wgsl
+++ b/crates/gpui/src/platform/blade/shaders.wgsl
@@ -488,8 +488,8 @@ fn fs_underline(input: UnderlineVarying) -> @location(0) vec4<f32> {
 
     let half_thickness = underline.thickness * 0.5;
     let st = (input.position.xy - underline.bounds.origin) / underline.bounds.size.y - vec2<f32>(0.0, 0.5);
-    let frequency = M_PI_F * 3.0 * underline.thickness / 8.0;
-    let amplitude = 1.0 / (2.0 * underline.thickness);
+    let frequency = M_PI_F * 3.0 * underline.thickness / 3.0;
+    let amplitude = 1.0 / (4.0 * underline.thickness);
     let sine = sin(st.x * frequency) * amplitude;
     let dSine = cos(st.x * frequency) * amplitude * frequency;
     let distance = (st.y - sine) / sqrt(1.0 + dSine * dSine);

From 1a62396b1ee9cd7c8beed803539728ed8a8c784f Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 18 Sep 2024 08:19:06 -0600
Subject: [PATCH 180/762] vim: Fix gv after indent/toggle comments (#17986)

Release Notes:

- vim: Fixed `gv` after > and < in visual mode
---
 crates/vim/src/{normal => }/indent.rs    |  62 +++++++++++++-
 crates/vim/src/normal.rs                 | 104 ++++++++---------------
 crates/vim/src/normal/mark.rs            |   2 +-
 crates/vim/src/vim.rs                    |   2 +
 crates/vim/test_data/test_indent_gv.json |   8 ++
 5 files changed, 107 insertions(+), 71 deletions(-)
 rename crates/vim/src/{normal => }/indent.rs (58%)
 create mode 100644 crates/vim/test_data/test_indent_gv.json

diff --git a/crates/vim/src/normal/indent.rs b/crates/vim/src/indent.rs
similarity index 58%
rename from crates/vim/src/normal/indent.rs
rename to crates/vim/src/indent.rs
index 4b4d5e7e80bbf1..676713c816da52 100644
--- a/crates/vim/src/normal/indent.rs
+++ b/crates/vim/src/indent.rs
@@ -1,6 +1,7 @@
-use crate::{motion::Motion, object::Object, Vim};
+use crate::{motion::Motion, object::Object, state::Mode, Vim};
 use collections::HashMap;
-use editor::{display_map::ToDisplayPoint, Bias};
+use editor::{display_map::ToDisplayPoint, Bias, Editor};
+use gpui::actions;
 use language::SelectionGoal;
 use ui::ViewContext;
 
@@ -10,6 +11,46 @@ pub(crate) enum IndentDirection {
     Out,
 }
 
+actions!(vim, [Indent, Outdent,]);
+
+pub(crate) fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {
+    Vim::action(editor, cx, |vim, _: &Indent, cx| {
+        vim.record_current_action(cx);
+        let count = vim.take_count(cx).unwrap_or(1);
+        vim.store_visual_marks(cx);
+        vim.update_editor(cx, |vim, editor, cx| {
+            editor.transact(cx, |editor, cx| {
+                let mut original_positions = vim.save_selection_starts(editor, cx);
+                for _ in 0..count {
+                    editor.indent(&Default::default(), cx);
+                }
+                vim.restore_selection_cursors(editor, cx, &mut original_positions);
+            });
+        });
+        if vim.mode.is_visual() {
+            vim.switch_mode(Mode::Normal, true, cx)
+        }
+    });
+
+    Vim::action(editor, cx, |vim, _: &Outdent, cx| {
+        vim.record_current_action(cx);
+        let count = vim.take_count(cx).unwrap_or(1);
+        vim.store_visual_marks(cx);
+        vim.update_editor(cx, |vim, editor, cx| {
+            editor.transact(cx, |editor, cx| {
+                let mut original_positions = vim.save_selection_starts(editor, cx);
+                for _ in 0..count {
+                    editor.outdent(&Default::default(), cx);
+                }
+                vim.restore_selection_cursors(editor, cx, &mut original_positions);
+            });
+        });
+        if vim.mode.is_visual() {
+            vim.switch_mode(Mode::Normal, true, cx)
+        }
+    });
+}
+
 impl Vim {
     pub(crate) fn indent_motion(
         &mut self,
@@ -78,3 +119,20 @@ impl Vim {
         });
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::test::NeovimBackedTestContext;
+
+    #[gpui::test]
+    async fn test_indent_gv(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+        cx.set_neovim_option("shiftwidth=4").await;
+
+        cx.set_shared_state("ˇhello\nworld\n").await;
+        cx.simulate_shared_keystrokes("v j > g v").await;
+        cx.shared_state()
+            .await
+            .assert_eq("«    hello\n ˇ»   world\n");
+    }
+}
diff --git a/crates/vim/src/normal.rs b/crates/vim/src/normal.rs
index 8198c0da53b4f0..741e09f178ff3e 100644
--- a/crates/vim/src/normal.rs
+++ b/crates/vim/src/normal.rs
@@ -2,7 +2,6 @@ mod case;
 mod change;
 mod delete;
 mod increment;
-mod indent;
 pub(crate) mod mark;
 mod paste;
 pub(crate) mod repeat;
@@ -16,6 +15,7 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use crate::{
+    indent::IndentDirection,
     motion::{self, first_non_whitespace, next_line_end, right, Motion},
     object::Object,
     state::{Mode, Operator},
@@ -34,8 +34,6 @@ use language::{Point, SelectionGoal};
 use log::error;
 use multi_buffer::MultiBufferRow;
 
-use self::indent::IndentDirection;
-
 actions!(
     vim,
     [
@@ -56,8 +54,6 @@ actions!(
         ConvertToUpperCase,
         ConvertToLowerCase,
         JoinLines,
-        Indent,
-        Outdent,
         ToggleComments,
         Undo,
         Redo,
@@ -129,41 +125,7 @@ pub(crate) fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {
             })
         });
         if vim.mode.is_visual() {
-            vim.switch_mode(Mode::Normal, false, cx)
-        }
-    });
-
-    Vim::action(editor, cx, |vim, _: &Indent, cx| {
-        vim.record_current_action(cx);
-        let count = vim.take_count(cx).unwrap_or(1);
-        vim.update_editor(cx, |_, editor, cx| {
-            editor.transact(cx, |editor, cx| {
-                let mut original_positions = save_selection_starts(editor, cx);
-                for _ in 0..count {
-                    editor.indent(&Default::default(), cx);
-                }
-                restore_selection_cursors(editor, cx, &mut original_positions);
-            });
-        });
-        if vim.mode.is_visual() {
-            vim.switch_mode(Mode::Normal, false, cx)
-        }
-    });
-
-    Vim::action(editor, cx, |vim, _: &Outdent, cx| {
-        vim.record_current_action(cx);
-        let count = vim.take_count(cx).unwrap_or(1);
-        vim.update_editor(cx, |_, editor, cx| {
-            editor.transact(cx, |editor, cx| {
-                let mut original_positions = save_selection_starts(editor, cx);
-                for _ in 0..count {
-                    editor.outdent(&Default::default(), cx);
-                }
-                restore_selection_cursors(editor, cx, &mut original_positions);
-            });
-        });
-        if vim.mode.is_visual() {
-            vim.switch_mode(Mode::Normal, false, cx)
+            vim.switch_mode(Mode::Normal, true, cx)
         }
     });
 
@@ -428,15 +390,16 @@ impl Vim {
 
     fn toggle_comments(&mut self, _: &ToggleComments, cx: &mut ViewContext<Self>) {
         self.record_current_action(cx);
-        self.update_editor(cx, |_, editor, cx| {
+        self.store_visual_marks(cx);
+        self.update_editor(cx, |vim, editor, cx| {
             editor.transact(cx, |editor, cx| {
-                let mut original_positions = save_selection_starts(editor, cx);
+                let mut original_positions = vim.save_selection_starts(editor, cx);
                 editor.toggle_comments(&Default::default(), cx);
-                restore_selection_cursors(editor, cx, &mut original_positions);
+                vim.restore_selection_cursors(editor, cx, &mut original_positions);
             });
         });
         if self.mode.is_visual() {
-            self.switch_mode(Mode::Normal, false, cx)
+            self.switch_mode(Mode::Normal, true, cx)
         }
     }
 
@@ -480,33 +443,38 @@ impl Vim {
         });
         self.pop_operator(cx);
     }
-}
 
-fn save_selection_starts(editor: &Editor, cx: &mut ViewContext<Editor>) -> HashMap<usize, Anchor> {
-    let (map, selections) = editor.selections.all_display(cx);
-    selections
-        .iter()
-        .map(|selection| {
-            (
-                selection.id,
-                map.display_point_to_anchor(selection.start, Bias::Right),
-            )
-        })
-        .collect::<HashMap<_, _>>()
-}
+    pub fn save_selection_starts(
+        &self,
+        editor: &Editor,
+        cx: &mut ViewContext<Editor>,
+    ) -> HashMap<usize, Anchor> {
+        let (map, selections) = editor.selections.all_display(cx);
+        selections
+            .iter()
+            .map(|selection| {
+                (
+                    selection.id,
+                    map.display_point_to_anchor(selection.start, Bias::Right),
+                )
+            })
+            .collect::<HashMap<_, _>>()
+    }
 
-fn restore_selection_cursors(
-    editor: &mut Editor,
-    cx: &mut ViewContext<Editor>,
-    positions: &mut HashMap<usize, Anchor>,
-) {
-    editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
-        s.move_with(|map, selection| {
-            if let Some(anchor) = positions.remove(&selection.id) {
-                selection.collapse_to(anchor.to_display_point(map), SelectionGoal::None);
-            }
+    pub fn restore_selection_cursors(
+        &self,
+        editor: &mut Editor,
+        cx: &mut ViewContext<Editor>,
+        positions: &mut HashMap<usize, Anchor>,
+    ) {
+        editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+            s.move_with(|map, selection| {
+                if let Some(anchor) = positions.remove(&selection.id) {
+                    selection.collapse_to(anchor.to_display_point(map), SelectionGoal::None);
+                }
+            });
         });
-    });
+    }
 }
 #[cfg(test)]
 mod test {
diff --git a/crates/vim/src/normal/mark.rs b/crates/vim/src/normal/mark.rs
index ae6dd3eed7bcd3..787430e747e3f2 100644
--- a/crates/vim/src/normal/mark.rs
+++ b/crates/vim/src/normal/mark.rs
@@ -54,7 +54,7 @@ impl Vim {
                 );
                 starts.push(
                     map.buffer_snapshot
-                        .anchor_after(selection.start.to_offset(&map, Bias::Right)),
+                        .anchor_before(selection.start.to_offset(&map, Bias::Left)),
                 );
                 reversed.push(selection.reversed)
             }
diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs
index fc5097d8451282..a4b77b1a7a3ef8 100644
--- a/crates/vim/src/vim.rs
+++ b/crates/vim/src/vim.rs
@@ -6,6 +6,7 @@ mod test;
 mod change_list;
 mod command;
 mod digraph;
+mod indent;
 mod insert;
 mod mode_indicator;
 mod motion;
@@ -289,6 +290,7 @@ impl Vim {
             motion::register(editor, cx);
             command::register(editor, cx);
             replace::register(editor, cx);
+            indent::register(editor, cx);
             object::register(editor, cx);
             visual::register(editor, cx);
             change_list::register(editor, cx);
diff --git a/crates/vim/test_data/test_indent_gv.json b/crates/vim/test_data/test_indent_gv.json
new file mode 100644
index 00000000000000..2c24406aee301a
--- /dev/null
+++ b/crates/vim/test_data/test_indent_gv.json
@@ -0,0 +1,8 @@
+{"SetOption":{"value":"shiftwidth=4"}}
+{"Put":{"state":"ˇhello\nworld\n"}}
+{"Key":"v"}
+{"Key":"j"}
+{"Key":">"}
+{"Key":"g"}
+{"Key":"v"}
+{"Get":{"state":"«    hello\n ˇ»   world\n","mode":"Visual"}}

From 84f2e0ee375a0cd006061a735c75bc90979bc944 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 18 Sep 2024 16:36:32 +0200
Subject: [PATCH 181/762] Use buffer font in the terminal inline assistant
 (#18009)

This PR is a follow up to
https://github.com/zed-industries/zed/pull/17875.

Release Notes:

- N/A
---
 crates/assistant/src/terminal_inline_assistant.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/crates/assistant/src/terminal_inline_assistant.rs b/crates/assistant/src/terminal_inline_assistant.rs
index d5c085b646cd86..06661944d96a79 100644
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -570,7 +570,7 @@ impl Render for PromptEditor {
             .bg(cx.theme().colors().editor_background)
             .border_y_1()
             .border_color(cx.theme().status().info_border)
-            .py_1p5()
+            .py_2()
             .h_full()
             .w_full()
             .on_action(cx.listener(Self::confirm))
@@ -949,12 +949,11 @@ impl PromptEditor {
             } else {
                 cx.theme().colors().text
             },
-            font_family: settings.ui_font.family.clone(),
-            font_features: settings.ui_font.features.clone(),
-            font_fallbacks: settings.ui_font.fallbacks.clone(),
-            font_size: rems(0.875).into(),
-            font_weight: settings.ui_font.weight,
-            line_height: relative(1.3),
+            font_family: settings.buffer_font.family.clone(),
+            font_fallbacks: settings.buffer_font.fallbacks.clone(),
+            font_size: settings.buffer_font_size.into(),
+            font_weight: settings.buffer_font.weight,
+            line_height: relative(settings.buffer_line_height.value()),
             ..Default::default()
         };
         EditorElement::new(

From 425c8f8c3e8a9cc0cb9985e403ed26a1286c4a10 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Wed, 18 Sep 2024 10:42:17 -0400
Subject: [PATCH 182/762] Alphabetize actions (#18007)

Drive-by maintenance PR while working on another PR.

Release Notes:

- N/A
---
 crates/editor/src/actions.rs | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs
index 5811ec7b921d2f..93c83af1950ec5 100644
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -156,14 +156,14 @@ pub struct DeleteToPreviousWordStart {
 impl_actions!(
     editor,
     [
+        ComposeCompletion,
         ConfirmCodeAction,
         ConfirmCompletion,
-        ComposeCompletion,
         DeleteToNextWordEnd,
         DeleteToPreviousWordStart,
         ExpandExcerpts,
-        ExpandExcerptsUp,
         ExpandExcerptsDown,
+        ExpandExcerptsUp,
         FoldAt,
         HandleInput,
         MoveDownByLines,
@@ -188,8 +188,8 @@ impl_actions!(
 gpui::actions!(
     editor,
     [
-        AcceptPartialCopilotSuggestion,
         AcceptInlineCompletion,
+        AcceptPartialCopilotSuggestion,
         AcceptPartialInlineCompletion,
         AddSelectionAbove,
         AddSelectionBelow,
@@ -210,10 +210,10 @@ gpui::actions!(
         ConvertToUpperCamelCase,
         ConvertToUpperCase,
         Copy,
+        CopyFileLocation,
         CopyHighlightJson,
         CopyPath,
         CopyPermalinkToLine,
-        CopyFileLocation,
         CopyRelativePath,
         Cut,
         CutToEndOfLine,
@@ -232,10 +232,10 @@ gpui::actions!(
         Fold,
         FoldSelectedRanges,
         Format,
-        GoToDefinition,
-        GoToDefinitionSplit,
         GoToDeclaration,
         GoToDeclarationSplit,
+        GoToDefinition,
+        GoToDefinitionSplit,
         GoToDiagnostic,
         GoToHunk,
         GoToImplementation,
@@ -273,9 +273,9 @@ gpui::actions!(
         NextScreen,
         OpenExcerpts,
         OpenExcerptsSplit,
+        OpenFile,
         OpenPermalinkToLine,
         OpenUrl,
-        OpenFile,
         Outdent,
         PageDown,
         PageUp,
@@ -284,23 +284,25 @@ gpui::actions!(
         Redo,
         RedoSelection,
         Rename,
-        Rewrap,
         RestartLanguageServer,
         RevealInFileManager,
         ReverseLines,
         RevertFile,
         RevertSelectedHunks,
+        Rewrap,
         ScrollCursorBottom,
         ScrollCursorCenter,
-        ScrollCursorTop,
         ScrollCursorCenterTopBottom,
+        ScrollCursorTop,
         SelectAll,
         SelectAllMatches,
         SelectDown,
-        SelectLargerSyntaxNode,
         SelectEnclosingSymbol,
+        SelectLargerSyntaxNode,
         SelectLeft,
         SelectLine,
+        SelectPageDown,
+        SelectPageUp,
         SelectRight,
         SelectSmallerSyntaxNode,
         SelectToBeginning,
@@ -312,8 +314,6 @@ gpui::actions!(
         SelectToPreviousWordStart,
         SelectToStartOfParagraph,
         SelectUp,
-        SelectPageDown,
-        SelectPageUp,
         ShowCharacterPalette,
         ShowInlineCompletion,
         ShowSignatureHelp,
@@ -327,13 +327,13 @@ gpui::actions!(
         ToggleAutoSignatureHelp,
         ToggleGitBlame,
         ToggleGitBlameInline,
-        ToggleSelectionMenu,
         ToggleHunkDiff,
+        ToggleIndentGuides,
         ToggleInlayHints,
         ToggleInlineCompletions,
         ToggleLineNumbers,
         ToggleRelativeLineNumbers,
-        ToggleIndentGuides,
+        ToggleSelectionMenu,
         ToggleSoftWrap,
         ToggleTabBar,
         Transpose,

From 373a17acf413c293e445bbb7b266dc970079a7ba Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 18 Sep 2024 11:11:38 -0400
Subject: [PATCH 183/762] Add ability to display backgrounds for inlay hints
 (#18010)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR adds the ability to display backgrounds for inlay hints within
the editor.

This is controlled by the new `inlay_hints.show_background` setting.
This setting defaults to `false`.

To enable the setting, add the following to your `settings.json`:

```json
{
  "inlay_hints": {
    "enabled": true,
    "show_background": true
  }
}
```

When enabled, the inlay hint backgrounds will use the `hint.background`
color from the theme.

| Disabled | Enabled |
|
--------------------------------------------------------------------------------------------------------------------------------------------------
|
--------------------------------------------------------------------------------------------------------------------------------------------------
|
| <img width="1624" alt="Screenshot 2024-09-17 at 4 21 53 PM"
src="https://github.com/user-attachments/assets/5534d09b-1e22-4c6f-9d82-314796ed7d22">
| <img width="1624" alt="Screenshot 2024-09-17 at 4 21 43 PM"
src="https://github.com/user-attachments/assets/6ec58cde-6115-4db4-be95-97c5f2f54b2d">
|

Related issues:

- #12485
- #17392

Release Notes:

- Added an `inlay_hints.show_background` setting to allow displaying
backgrounds for inlay hints in the editor.
  - This setting defaults to `false`.
- If enabled, the inlay hint backgrounds will use the `hint.background`
color from the theme.
---
 assets/settings/default.json             |  4 ++++
 crates/assistant/src/prompt_library.rs   |  6 ++----
 crates/collab/src/tests/editor_tests.rs  |  4 ++++
 crates/editor/src/editor.rs              | 21 +++++++++++++++------
 crates/editor/src/hover_links.rs         |  1 +
 crates/editor/src/hover_popover.rs       |  1 +
 crates/editor/src/inlay_hint_cache.rs    | 15 +++++++++++++++
 crates/language/src/language_settings.rs |  8 ++++++++
 docs/src/configuring-zed.md              |  1 +
 9 files changed, 51 insertions(+), 10 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 35b2ca20f2a44b..a9e18652580be3 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -318,6 +318,10 @@
     "show_parameter_hints": true,
     // Corresponds to null/None LSP hint type value.
     "show_other_hints": true,
+    // Whether to show a background for inlay hints.
+    //
+    // If set to `true`, the background will use the `hint.background` color from the current theme.
+    "show_background": false,
     // Time to wait after editing the buffer, before requesting the hints,
     // set to 0 to disable debouncing.
     "edit_debounce_ms": 700,
diff --git a/crates/assistant/src/prompt_library.rs b/crates/assistant/src/prompt_library.rs
index c99a7c15214d24..76ee95d5070b82 100644
--- a/crates/assistant/src/prompt_library.rs
+++ b/crates/assistant/src/prompt_library.rs
@@ -921,10 +921,8 @@ impl PromptLibrary {
                                                     scrollbar_width: Pixels::ZERO,
                                                     syntax: cx.theme().syntax().clone(),
                                                     status: cx.theme().status().clone(),
-                                                    inlay_hints_style: HighlightStyle {
-                                                        color: Some(cx.theme().status().hint),
-                                                        ..HighlightStyle::default()
-                                                    },
+                                                    inlay_hints_style:
+                                                        editor::make_inlay_hints_style(cx),
                                                     suggestions_style: HighlightStyle {
                                                         color: Some(cx.theme().status().predictive),
                                                         ..HighlightStyle::default()
diff --git a/crates/collab/src/tests/editor_tests.rs b/crates/collab/src/tests/editor_tests.rs
index de0314477491a6..7fb1a49f870d97 100644
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -1524,6 +1524,7 @@ async fn test_mutual_editor_inlay_hint_cache_update(
                     show_type_hints: true,
                     show_parameter_hints: false,
                     show_other_hints: true,
+                    show_background: false,
                 })
             });
         });
@@ -1538,6 +1539,7 @@ async fn test_mutual_editor_inlay_hint_cache_update(
                     show_type_hints: true,
                     show_parameter_hints: false,
                     show_other_hints: true,
+                    show_background: false,
                 })
             });
         });
@@ -1786,6 +1788,7 @@ async fn test_inlay_hint_refresh_is_forwarded(
                     show_type_hints: false,
                     show_parameter_hints: false,
                     show_other_hints: false,
+                    show_background: false,
                 })
             });
         });
@@ -1800,6 +1803,7 @@ async fn test_inlay_hint_refresh_is_forwarded(
                     show_type_hints: true,
                     show_parameter_hints: true,
                     show_other_hints: true,
+                    show_background: false,
                 })
             });
         });
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 61a59665c15e3e..f797f82832f0ad 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -412,6 +412,19 @@ impl Default for EditorStyle {
     }
 }
 
+pub fn make_inlay_hints_style(cx: &WindowContext) -> HighlightStyle {
+    let show_background = all_language_settings(None, cx)
+        .language(None)
+        .inlay_hints
+        .show_background;
+
+    HighlightStyle {
+        color: Some(cx.theme().status().hint),
+        background_color: show_background.then(|| cx.theme().status().hint_background),
+        ..HighlightStyle::default()
+    }
+}
+
 type CompletionId = usize;
 
 #[derive(Clone, Debug)]
@@ -10034,9 +10047,8 @@ impl Editor {
                                                 syntax: cx.editor_style.syntax.clone(),
                                                 status: cx.editor_style.status.clone(),
                                                 inlay_hints_style: HighlightStyle {
-                                                    color: Some(cx.theme().status().hint),
                                                     font_weight: Some(FontWeight::BOLD),
-                                                    ..HighlightStyle::default()
+                                                    ..make_inlay_hints_style(cx)
                                                 },
                                                 suggestions_style: HighlightStyle {
                                                     color: Some(cx.theme().status().predictive),
@@ -12992,10 +13004,7 @@ impl Render for Editor {
                 scrollbar_width: EditorElement::SCROLLBAR_WIDTH,
                 syntax: cx.theme().syntax().clone(),
                 status: cx.theme().status().clone(),
-                inlay_hints_style: HighlightStyle {
-                    color: Some(cx.theme().status().hint),
-                    ..HighlightStyle::default()
-                },
+                inlay_hints_style: make_inlay_hints_style(cx),
                 suggestions_style: HighlightStyle {
                     color: Some(cx.theme().status().predictive),
                     ..HighlightStyle::default()
diff --git a/crates/editor/src/hover_links.rs b/crates/editor/src/hover_links.rs
index 3f590273df8e88..ac30b9199601ae 100644
--- a/crates/editor/src/hover_links.rs
+++ b/crates/editor/src/hover_links.rs
@@ -1205,6 +1205,7 @@ mod tests {
                 show_type_hints: true,
                 show_parameter_hints: true,
                 show_other_hints: true,
+                show_background: false,
             })
         });
 
diff --git a/crates/editor/src/hover_popover.rs b/crates/editor/src/hover_popover.rs
index adbb5899ff74d0..f6eb837ae8ceef 100644
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -1337,6 +1337,7 @@ mod tests {
                 show_type_hints: true,
                 show_parameter_hints: true,
                 show_other_hints: true,
+                show_background: false,
             })
         });
 
diff --git a/crates/editor/src/inlay_hint_cache.rs b/crates/editor/src/inlay_hint_cache.rs
index 62c5cde9d89f57..24ccf64c4ca0b2 100644
--- a/crates/editor/src/inlay_hint_cache.rs
+++ b/crates/editor/src/inlay_hint_cache.rs
@@ -1296,6 +1296,7 @@ pub mod tests {
                 show_type_hints: allowed_hint_kinds.contains(&Some(InlayHintKind::Type)),
                 show_parameter_hints: allowed_hint_kinds.contains(&Some(InlayHintKind::Parameter)),
                 show_other_hints: allowed_hint_kinds.contains(&None),
+                show_background: false,
             })
         });
 
@@ -1428,6 +1429,7 @@ pub mod tests {
                 show_type_hints: true,
                 show_parameter_hints: true,
                 show_other_hints: true,
+                show_background: false,
             })
         });
 
@@ -1547,6 +1549,7 @@ pub mod tests {
                 show_type_hints: true,
                 show_parameter_hints: true,
                 show_other_hints: true,
+                show_background: false,
             })
         });
 
@@ -1777,6 +1780,7 @@ pub mod tests {
                 show_type_hints: allowed_hint_kinds.contains(&Some(InlayHintKind::Type)),
                 show_parameter_hints: allowed_hint_kinds.contains(&Some(InlayHintKind::Parameter)),
                 show_other_hints: allowed_hint_kinds.contains(&None),
+                show_background: false,
             })
         });
 
@@ -1941,6 +1945,7 @@ pub mod tests {
                     show_parameter_hints: new_allowed_hint_kinds
                         .contains(&Some(InlayHintKind::Parameter)),
                     show_other_hints: new_allowed_hint_kinds.contains(&None),
+                    show_background: false,
                 })
             });
             cx.executor().run_until_parked();
@@ -1987,6 +1992,7 @@ pub mod tests {
                 show_parameter_hints: another_allowed_hint_kinds
                     .contains(&Some(InlayHintKind::Parameter)),
                 show_other_hints: another_allowed_hint_kinds.contains(&None),
+                show_background: false,
             })
         });
         cx.executor().run_until_parked();
@@ -2047,6 +2053,7 @@ pub mod tests {
                 show_parameter_hints: final_allowed_hint_kinds
                     .contains(&Some(InlayHintKind::Parameter)),
                 show_other_hints: final_allowed_hint_kinds.contains(&None),
+                show_background: false,
             })
         });
         cx.executor().run_until_parked();
@@ -2122,6 +2129,7 @@ pub mod tests {
                 show_type_hints: true,
                 show_parameter_hints: true,
                 show_other_hints: true,
+                show_background: false,
             })
         });
 
@@ -2256,6 +2264,7 @@ pub mod tests {
                 show_type_hints: true,
                 show_parameter_hints: true,
                 show_other_hints: true,
+                show_background: false,
             })
         });
 
@@ -2551,6 +2560,7 @@ pub mod tests {
                 show_type_hints: true,
                 show_parameter_hints: true,
                 show_other_hints: true,
+                show_background: false,
             })
         });
 
@@ -2902,6 +2912,7 @@ pub mod tests {
                 show_type_hints: false,
                 show_parameter_hints: false,
                 show_other_hints: false,
+                show_background: false,
             })
         });
 
@@ -3096,6 +3107,7 @@ pub mod tests {
                 show_type_hints: true,
                 show_parameter_hints: true,
                 show_other_hints: true,
+                show_background: false,
             })
         });
         cx.executor().run_until_parked();
@@ -3131,6 +3143,7 @@ pub mod tests {
                 show_type_hints: true,
                 show_parameter_hints: true,
                 show_other_hints: true,
+                show_background: false,
             })
         });
 
@@ -3225,6 +3238,7 @@ pub mod tests {
                 show_type_hints: true,
                 show_parameter_hints: true,
                 show_other_hints: true,
+                show_background: false,
             })
         });
 
@@ -3305,6 +3319,7 @@ pub mod tests {
                 show_type_hints: true,
                 show_parameter_hints: true,
                 show_other_hints: true,
+                show_background: false,
             })
         });
         cx.executor().run_until_parked();
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index b465173cee1e4d..77c9a1d18cee14 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -741,6 +741,14 @@ pub struct InlayHintSettings {
     /// Default: true
     #[serde(default = "default_true")]
     pub show_other_hints: bool,
+    /// Whether to show a background for inlay hints.
+    ///
+    /// If set to `true`, the background will use the `hint.background` color
+    /// from the current theme.
+    ///
+    /// Default: false
+    #[serde(default)]
+    pub show_background: bool,
     /// Whether or not to debounce inlay hints updates after buffer edits.
     ///
     /// Set to 0 to disable debouncing.
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 87cd053f1a0d1b..382c33c216adf9 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -982,6 +982,7 @@ To interpret all `.c` files as C++, files called `MyLockFile` as TOML and files
   "show_type_hints": true,
   "show_parameter_hints": true,
   "show_other_hints": true,
+  "show_background": false,
   "edit_debounce_ms": 700,
   "scroll_debounce_ms": 50
 }

From a7977aa64dc8a4c600eb167d645de880e9964d68 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 18 Sep 2024 17:18:56 +0200
Subject: [PATCH 184/762] Tweak multibuffer header padding (#18011)

---
 crates/editor/src/element.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 7e2b3cc63f725e..47107b97546871 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -2079,13 +2079,13 @@ impl EditorElement {
                         .id(("path excerpt header", EntityId::from(block_id)))
                         .w_full()
                         .px(header_padding)
+                        .pt(header_padding)
                         .child(
                             h_flex()
                                 .flex_basis(Length::Definite(DefiniteLength::Fraction(0.667)))
                                 .id("path header block")
                                 .h(2. * cx.line_height())
-                                .pl(gpui::px(12.))
-                                .pr(gpui::px(8.))
+                                .px(gpui::px(12.))
                                 .rounded_md()
                                 .shadow_md()
                                 .border_1()

From eda7e88fd4a9e500c951344f6ddd659ee13ca0fc Mon Sep 17 00:00:00 2001
From: Marek Fajkus <marek.faj@gmail.com>
Date: Wed, 18 Sep 2024 18:51:11 +0200
Subject: [PATCH 185/762] nix: Fix (potential) glibc errors in dev shell
 (#17974)

Previously the rustc and cargo did were not declared dependencies
supplied to devshell. This means that shell relied some impure cargo and
rustc version found in the system. This lead to issues with GLIBC
version on systems which have different GLIBC version globally.

This package exposes nixpkgs rustc and cargo version into the shell
preventing issues with incompatibility.

Release Notes:

- N/A
---
 nix/shell.nix | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/nix/shell.nix b/nix/shell.nix
index 03e298e132f9b0..476374b67ef091 100644
--- a/nix/shell.nix
+++ b/nix/shell.nix
@@ -20,6 +20,8 @@ in
       wayland
       xorg.libxcb
       vulkan-loader
+      rustc
+      cargo
     ];
   in
     pkgs.mkShell.override {inherit stdenv;} {
@@ -36,10 +38,7 @@ in
       inherit buildInputs;
 
       shellHook = ''
-        export LD_LIBRARY_PATH="${pkgs.lib.makeLibraryPath ([
-            pkgs.vulkan-loader
-          ]
-          ++ buildInputs)}:$LD_LIBRARY_PATH"
+        export LD_LIBRARY_PATH="${pkgs.lib.makeLibraryPath buildInputs}:$LD_LIBRARY_PATH"
         export PROTOC="${pkgs.protobuf}/bin/protoc"
       '';
 

From 826777a257b8e43900fd1d8cbf7cee3757bbe765 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 18 Sep 2024 11:15:46 -0600
Subject: [PATCH 186/762] Tidy up LSP (#17973)

Release Notes:

- N/A
---
 crates/extension/src/extension_lsp_adapter.rs |  2 +-
 crates/language/src/language.rs               | 10 +++++++---
 crates/language/src/language_registry.rs      | 12 +++++-------
 crates/project/src/lsp_store.rs               | 11 -----------
 crates/remote_server/src/headless_project.rs  |  6 +-----
 5 files changed, 14 insertions(+), 27 deletions(-)

diff --git a/crates/extension/src/extension_lsp_adapter.rs b/crates/extension/src/extension_lsp_adapter.rs
index f82b6c9e0e9eb4..d6125241f11a38 100644
--- a/crates/extension/src/extension_lsp_adapter.rs
+++ b/crates/extension/src/extension_lsp_adapter.rs
@@ -38,7 +38,7 @@ impl LspAdapter for ExtensionLspAdapter {
 
     fn get_language_server_command<'a>(
         self: Arc<Self>,
-        _: Arc<Path>,
+        _: Option<Arc<Path>>,
         delegate: Arc<dyn LspAdapterDelegate>,
         _: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
         _: &'a mut AsyncAppContext,
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index 7901a49d0021f8..309a67a1a96a41 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -208,7 +208,7 @@ impl CachedLspAdapter {
 
     pub async fn get_language_server_command(
         self: Arc<Self>,
-        container_dir: Arc<Path>,
+        container_dir: Option<Arc<Path>>,
         delegate: Arc<dyn LspAdapterDelegate>,
         cx: &mut AsyncAppContext,
     ) -> Result<LanguageServerBinary> {
@@ -294,7 +294,7 @@ pub trait LspAdapter: 'static + Send + Sync {
 
     fn get_language_server_command<'a>(
         self: Arc<Self>,
-        container_dir: Arc<Path>,
+        container_dir: Option<Arc<Path>>,
         delegate: Arc<dyn LspAdapterDelegate>,
         mut cached_binary: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
         cx: &'a mut AsyncAppContext,
@@ -325,6 +325,10 @@ pub trait LspAdapter: 'static + Send + Sync {
                 return Ok(cached_binary.clone());
             }
 
+            let Some(container_dir) = container_dir else {
+                anyhow::bail!("cannot download language servers for remotes (yet)")
+            };
+
             if !container_dir.exists() {
                 smol::fs::create_dir_all(&container_dir)
                     .await
@@ -1664,7 +1668,7 @@ impl LspAdapter for FakeLspAdapter {
 
     fn get_language_server_command<'a>(
         self: Arc<Self>,
-        _: Arc<Path>,
+        _: Option<Arc<Path>>,
         _: Arc<dyn LspAdapterDelegate>,
         _: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
         _: &'a mut AsyncAppContext,
diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index 918da4873f8667..17ebef50e8162e 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -869,12 +869,10 @@ impl LanguageRegistry {
             adapter.name.0
         );
 
-        let download_dir = &self
-                    .language_server_download_dir
-            .clone()
-            .ok_or_else(|| anyhow!("language server download directory has not been assigned before starting server"))
-            .log_err()?;
-        let container_dir: Arc<Path> = Arc::from(download_dir.join(adapter.name.0.as_ref()));
+        let container_dir: Option<Arc<Path>> = self
+            .language_server_download_dir
+            .as_ref()
+            .map(|dir| Arc::from(dir.join(adapter.name.0.as_ref())));
         let root_path = root_path.clone();
         let this = Arc::downgrade(self);
 
@@ -969,7 +967,7 @@ impl LanguageRegistry {
         Some(PendingLanguageServer {
             server_id,
             task,
-            container_dir: Some(container_dir),
+            container_dir,
         })
     }
 
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 24852afd702e18..6dd528147be322 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -4742,17 +4742,6 @@ impl LspStore {
             .reorder_language_servers(&language, enabled_lsp_adapters);
     }
 
-    /*
-    ssh client owns the lifecycle of the language servers
-    ssh host actually runs the binaries
-
-    in the future: ssh client will use the local extensions to get the downloads etc.
-        and send them up over the ssh connection (but today) we'll just the static config
-
-        languages::() <-- registers lsp adapters
-        on the ssh host we won't have adapters for the LSPs
-    */
-
     fn start_language_server_on_ssh_host(
         &mut self,
         worktree: &Model<Worktree>,
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index ec26bddfc3e7ab..bbd82281d86afc 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -42,11 +42,7 @@ impl HeadlessProject {
     }
 
     pub fn new(session: Arc<SshSession>, fs: Arc<dyn Fs>, cx: &mut ModelContext<Self>) -> Self {
-        let mut languages = LanguageRegistry::new(cx.background_executor().clone());
-        languages
-            .set_language_server_download_dir(PathBuf::from("/Users/conrad/what-could-go-wrong"));
-
-        let languages = Arc::new(languages);
+        let languages = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
 
         let worktree_store = cx.new_model(|_| WorktreeStore::new(true, fs.clone()));
         let buffer_store = cx.new_model(|cx| {

From fb7a7a564a54aa12f0f97a9dd36bf9bf30c16807 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 18 Sep 2024 11:15:54 -0600
Subject: [PATCH 187/762] ssh remoting: open settings locally (#18020)

Release Notes:

- ssh remoting: Open settings files in a non-remote window.
---
 crates/workspace/src/workspace.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index a7c63c57f698d4..98ac49992d0a4f 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -1578,7 +1578,7 @@ impl Workspace {
         T: 'static,
         F: 'static + FnOnce(&mut Workspace, &mut ViewContext<Workspace>) -> T,
     {
-        if self.project.read(cx).is_local_or_ssh() {
+        if self.project.read(cx).is_local() {
             Task::Ready(Some(Ok(callback(self, cx))))
         } else {
             let env = self.project.read(cx).cli_environment(cx);

From 772bda54a21079be9c6019f8a8836576add71d8c Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 18 Sep 2024 13:35:55 -0400
Subject: [PATCH 188/762] Move remaining self-hosted jobs to BuildJet (#18018)

---
 .github/workflows/bump_patch_version.yml | 3 +--
 .github/workflows/deploy_collab.yml      | 6 ++----
 .github/workflows/randomized_tests.yml   | 3 +--
 .github/workflows/release_nightly.yml    | 3 +--
 4 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/bump_patch_version.yml b/.github/workflows/bump_patch_version.yml
index e2789a7da77349..d05da31e6a0f67 100644
--- a/.github/workflows/bump_patch_version.yml
+++ b/.github/workflows/bump_patch_version.yml
@@ -15,8 +15,7 @@ concurrency:
 jobs:
   bump_patch_version:
     runs-on:
-      - self-hosted
-      - test
+      - buildjet-16vcpu-ubuntu-2204
     steps:
       - name: Checkout code
         uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
diff --git a/.github/workflows/deploy_collab.yml b/.github/workflows/deploy_collab.yml
index 6801be2a5494cd..7abd52e5a60dd3 100644
--- a/.github/workflows/deploy_collab.yml
+++ b/.github/workflows/deploy_collab.yml
@@ -61,8 +61,7 @@ jobs:
       - style
       - tests
     runs-on:
-      - self-hosted
-      - deploy
+      - buildjet-16vcpu-ubuntu-2204
     steps:
       - name: Add Rust to the PATH
         run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
@@ -89,8 +88,7 @@ jobs:
     needs:
       - publish
     runs-on:
-      - self-hosted
-      - deploy
+      - buildjet-16vcpu-ubuntu-2204
 
     steps:
       - name: Sign into Kubernetes
diff --git a/.github/workflows/randomized_tests.yml b/.github/workflows/randomized_tests.yml
index 8b628fe5a2df18..57f43d4961f3dd 100644
--- a/.github/workflows/randomized_tests.yml
+++ b/.github/workflows/randomized_tests.yml
@@ -19,8 +19,7 @@ jobs:
   tests:
     name: Run randomized tests
     runs-on:
-      - self-hosted
-      - randomized-tests
+      - buildjet-16vcpu-ubuntu-2204
     steps:
       - name: Install Node
         uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b # v4
diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml
index d8e6b6d919093b..450c63b82f9cbd 100644
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -97,8 +97,7 @@ jobs:
     name: Create a Linux *.tar.gz bundle for x86
     if: github.repository_owner == 'zed-industries'
     runs-on:
-      - self-hosted
-      - deploy
+      - buildjet-16vcpu-ubuntu-2204
     needs: tests
     env:
       DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}

From 97dc1d193f9a4b7cc90a63c7cc01870dbf05db79 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 18 Sep 2024 14:24:09 -0400
Subject: [PATCH 189/762] Use `@tag.doctype` for HTML doctype highlights
 (#18024)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR updates the following extensions to use the `@tag.doctype`
selector for highlighting HTML doctypes:

- Astro
- Elixir (HEEx)
- HTML

Additionally, it also changes the base selector for HTML tags from
`@keyword` to `@tag`.

| Before | After |
|
-------------------------------------------------------------------------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------------------------------------------------------------------------
|
| <img width="308" alt="Screenshot 2024-09-18 at 2 04 41 PM"
src="https://github.com/user-attachments/assets/818d98ba-fce7-4683-b67f-61c86543831c">
| <img width="358" alt="Screenshot 2024-09-18 at 2 05 00 PM"
src="https://github.com/user-attachments/assets/5071db7c-e0bf-44df-8959-38275833833b">
|

Extracted this from https://github.com/zed-industries/zed/pull/16723.

Release Notes:

- N/A

---------

Co-authored-by: 狐狸 <134658521+Huliiiiii@users.noreply.github.com>
---
 docs/src/extensions/languages.md                | 1 +
 extensions/astro/languages/astro/highlights.scm | 2 +-
 extensions/elixir/languages/heex/highlights.scm | 2 +-
 extensions/html/languages/html/highlights.scm   | 4 ++--
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/docs/src/extensions/languages.md b/docs/src/extensions/languages.md
index c00328530322b2..174a27c6e61d1a 100644
--- a/docs/src/extensions/languages.md
+++ b/docs/src/extensions/languages.md
@@ -123,6 +123,7 @@ This query marks strings, object keys, and numbers for highlighting. The followi
 | @string.special          | Captures special strings               |
 | @string.special.symbol   | Captures special symbols               |
 | @tag                     | Captures tags                          |
+| @tag.doctype             | Captures doctypes (e.g., in HTML)      |
 | @text.literal            | Captures literal text                  |
 | @title                   | Captures titles                        |
 | @type                    | Captures types                         |
diff --git a/extensions/astro/languages/astro/highlights.scm b/extensions/astro/languages/astro/highlights.scm
index 491e8cc337c4ca..a565e22b6e2275 100644
--- a/extensions/astro/languages/astro/highlights.scm
+++ b/extensions/astro/languages/astro/highlights.scm
@@ -1,6 +1,6 @@
 (tag_name) @tag
 (erroneous_end_tag_name) @keyword
-(doctype) @constant
+(doctype) @tag.doctype
 (attribute_name) @property
 (attribute_value) @string
 (comment) @comment
diff --git a/extensions/elixir/languages/heex/highlights.scm b/extensions/elixir/languages/heex/highlights.scm
index 5252b71facd533..9662c955242be3 100644
--- a/extensions/elixir/languages/heex/highlights.scm
+++ b/extensions/elixir/languages/heex/highlights.scm
@@ -27,7 +27,7 @@
 "=" @operator
 
 ; HEEx inherits the DOCTYPE tag from HTML
-(doctype) @constant
+(doctype) @tag.doctype
 
 (comment) @comment
 
diff --git a/extensions/html/languages/html/highlights.scm b/extensions/html/languages/html/highlights.scm
index e2b8e35bf4a790..6bb0c23374b8f4 100644
--- a/extensions/html/languages/html/highlights.scm
+++ b/extensions/html/languages/html/highlights.scm
@@ -1,6 +1,6 @@
-(tag_name) @keyword
+(tag_name) @tag
 (erroneous_end_tag_name) @keyword
-(doctype) @constant
+(doctype) @tag.doctype
 (attribute_name) @property
 (attribute_value) @string
 (comment) @comment

From 30ef7e62bfff3b2e4c5cdbeead502d5a0814c83e Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 18 Sep 2024 14:28:00 -0400
Subject: [PATCH 190/762] Fix arm buildjet (#18023)

Run `apt-get update` before `apt-get install` on Linux. Hopefully will fix building on Linux Arm.
---
 script/linux | 1 +
 1 file changed, 1 insertion(+)

diff --git a/script/linux b/script/linux
index d894d33ea80cd7..eca3bf7f7d2497 100755
--- a/script/linux
+++ b/script/linux
@@ -33,6 +33,7 @@ if [[ -n $apt ]]; then
     elfutils
     libsqlite3-dev
   )
+  $maysudo "$apt" update
   $maysudo "$apt" install -y "${deps[@]}"
   exit 0
 fi

From 71b6f739cdce3303ba129e41673cb6e38044f279 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 18 Sep 2024 15:08:19 -0400
Subject: [PATCH 191/762] Pin actions/checkout action to 692973e (#18030)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [actions/checkout](https://redirect.github.com/actions/checkout) |
action | pinDigest | -> `692973e` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 .github/workflows/bump_nightly_tag.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/bump_nightly_tag.yml b/.github/workflows/bump_nightly_tag.yml
index 54a3970a1cd83d..0959ae9677142c 100644
--- a/.github/workflows/bump_nightly_tag.yml
+++ b/.github/workflows/bump_nightly_tag.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
         with:
           fetch-depth: 0
 

From 97f5fcf8e6a42c07d0b12982030b701246ac3d65 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 18 Sep 2024 15:18:29 -0400
Subject: [PATCH 192/762] Fix nightly linux x86 build (#18029)

Makes our nightly script for Linux x86 (broken) match the steps for Linux ARM (working).
---
 .github/workflows/release_nightly.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml
index 450c63b82f9cbd..17db66a264bdc0 100644
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -113,6 +113,12 @@ jobs:
       - name: Add Rust to the PATH
         run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
 
+      - name: Install Linux dependencies
+        run: ./script/linux
+
+      - name: Limit target directory size
+        run: script/clear-target-dir-if-larger-than 100
+
       - name: Set release channel to nightly
         run: |
           set -euo pipefail

From 9016de5d6350e0a9bbf6a51076c04acd9b7fba96 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 18 Sep 2024 15:56:40 -0400
Subject: [PATCH 193/762] Update Rust crate anyhow to v1.0.89 (#18031)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [anyhow](https://redirect.github.com/dtolnay/anyhow) |
workspace.dependencies | patch | `1.0.86` -> `1.0.89` |

---

### Release Notes

<details>
<summary>dtolnay/anyhow (anyhow)</summary>

###
[`v1.0.89`](https://redirect.github.com/dtolnay/anyhow/releases/tag/1.0.89)

[Compare
Source](https://redirect.github.com/dtolnay/anyhow/compare/1.0.88...1.0.89)

- Make anyhow::Error's `UnwindSafe` and `RefUnwindSafe` impl
consistently available between versions of Rust newer and older than
1.72
([#&#8203;386](https://redirect.github.com/dtolnay/anyhow/issues/386))

###
[`v1.0.88`](https://redirect.github.com/dtolnay/anyhow/releases/tag/1.0.88)

[Compare
Source](https://redirect.github.com/dtolnay/anyhow/compare/1.0.87...1.0.88)

-   Documentation improvements

###
[`v1.0.87`](https://redirect.github.com/dtolnay/anyhow/releases/tag/1.0.87)

[Compare
Source](https://redirect.github.com/dtolnay/anyhow/compare/1.0.86...1.0.87)

- Support more APIs, including `Error::new` and `Error::chain`, in
no-std mode on Rust 1.81+
([#&#8203;383](https://redirect.github.com/dtolnay/anyhow/issues/383))

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 930415440ba0ad..0640aff19c26a8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -263,9 +263,9 @@ checksum = "34cd60c5e3152cef0a592f1b296f1cc93715d89d2551d85315828c3a09575ff4"
 
 [[package]]
 name = "anyhow"
-version = "1.0.86"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
+checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
 
 [[package]]
 name = "approx"

From 2c8a6ee7cc18cb8b3e29fa4c7efa74dde8458f4f Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Wed, 18 Sep 2024 23:29:34 +0200
Subject: [PATCH 194/762] remote_server: Remove dependency on libssl and
 libcrypto (#15446)

Fixes: #15599
Release Notes:

- N/A

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
Co-authored-by: Conrad <conrad@zed.dev>
---
 Cargo.lock                                    | 176 ++++++++++++++---
 Cargo.toml                                    |   7 +
 crates/auto_update/Cargo.toml                 |   1 -
 crates/auto_update/src/auto_update.rs         |   3 +-
 crates/client/Cargo.toml                      |   4 +-
 crates/client/src/client.rs                   |  42 ++--
 crates/collab/Cargo.toml                      |   1 +
 crates/collab/src/llm.rs                      |   3 +-
 crates/collab/src/rpc.rs                      |   8 +-
 crates/evals/Cargo.toml                       |   1 +
 crates/evals/src/eval.rs                      |  22 ++-
 crates/extension/Cargo.toml                   |   1 +
 crates/extension/src/extension_builder.rs     |   2 +
 crates/extension/src/extension_store.rs       |  13 +-
 crates/extension/src/extension_store_test.rs  |  24 ++-
 crates/extension_cli/Cargo.toml               |   2 +-
 crates/extension_cli/src/main.rs              |  10 +-
 crates/git_hosting_providers/Cargo.toml       |   1 -
 .../src/providers/codeberg.rs                 |  10 +-
 .../src/providers/github.rs                   |  10 +-
 crates/gpui/Cargo.toml                        |   6 +-
 crates/gpui/examples/image/image.rs           |   1 +
 crates/gpui/src/app.rs                        |  31 ++-
 crates/gpui/src/elements/img.rs               |   7 +-
 crates/gpui/src/gpui.rs                       |   1 +
 crates/http_client/Cargo.toml                 |   5 +-
 crates/http_client/src/async_body.rs          | 109 +++++++++++
 crates/http_client/src/github.rs              |   5 +-
 crates/http_client/src/http_client.rs         | 179 +++++++++---------
 crates/isahc_http_client/Cargo.toml           |  22 +++
 crates/isahc_http_client/LICENSE-APACHE       |   1 +
 .../src/isahc_http_client.rs                  |  93 +++++++++
 crates/ollama/Cargo.toml                      |   1 -
 crates/ollama/src/ollama.rs                   |  31 ++-
 crates/project/src/lsp_store.rs               |  12 +-
 crates/semantic_index/Cargo.toml              |   1 +
 crates/semantic_index/examples/index.rs       |   7 +-
 crates/semantic_index/src/embedding/ollama.rs |   2 +-
 crates/zed/Cargo.toml                         |   1 +
 crates/zed/src/main.rs                        |  31 ++-
 script/bundle-linux                           |   9 +-
 41 files changed, 670 insertions(+), 226 deletions(-)
 create mode 100644 crates/http_client/src/async_body.rs
 create mode 100644 crates/isahc_http_client/Cargo.toml
 create mode 120000 crates/isahc_http_client/LICENSE-APACHE
 create mode 100644 crates/isahc_http_client/src/isahc_http_client.rs

diff --git a/Cargo.lock b/Cargo.lock
index 0640aff19c26a8..652c584fd53795 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -876,6 +876,20 @@ version = "4.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
 
+[[package]]
+name = "async-tls"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfeefd0ca297cbbb3bd34fd6b228401c2a5177038257afd751bc29f0a2da4795"
+dependencies = [
+ "futures-core",
+ "futures-io",
+ "rustls 0.20.9",
+ "rustls-pemfile 1.0.4",
+ "webpki",
+ "webpki-roots 0.22.6",
+]
+
 [[package]]
 name = "async-trait"
 version = "0.1.81"
@@ -893,8 +907,8 @@ version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1e9efbe14612da0a19fb983059a0b621e9cf6225d7018ecab4f9988215540dc"
 dependencies = [
- "async-native-tls",
  "async-std",
+ "async-tls",
  "futures-io",
  "futures-util",
  "log",
@@ -981,7 +995,6 @@ dependencies = [
  "editor",
  "gpui",
  "http_client",
- "isahc",
  "log",
  "markdown_preview",
  "menu",
@@ -1049,7 +1062,7 @@ dependencies = [
  "fastrand 2.1.1",
  "hex",
  "http 0.2.12",
- "ring",
+ "ring 0.17.8",
  "time",
  "tokio",
  "tracing",
@@ -1218,7 +1231,7 @@ dependencies = [
  "once_cell",
  "p256",
  "percent-encoding",
- "ring",
+ "ring 0.17.8",
  "sha2",
  "subtle",
  "time",
@@ -1331,7 +1344,7 @@ dependencies = [
  "once_cell",
  "pin-project-lite",
  "pin-utils",
- "rustls",
+ "rustls 0.21.12",
  "tokio",
  "tracing",
 ]
@@ -2405,6 +2418,8 @@ dependencies = [
  "rand 0.8.5",
  "release_channel",
  "rpc",
+ "rustls 0.20.9",
+ "rustls-native-certs 0.8.0",
  "schemars",
  "serde",
  "serde_json",
@@ -2553,6 +2568,7 @@ dependencies = [
  "http_client",
  "hyper",
  "indoc",
+ "isahc_http_client",
  "jsonwebtoken",
  "language",
  "language_model",
@@ -4015,6 +4031,7 @@ dependencies = [
  "git",
  "gpui",
  "http_client",
+ "isahc_http_client",
  "language",
  "languages",
  "node_runtime",
@@ -4110,6 +4127,7 @@ dependencies = [
  "http_client",
  "indexed_docs",
  "isahc",
+ "isahc_http_client",
  "language",
  "log",
  "lsp",
@@ -4148,7 +4166,7 @@ dependencies = [
  "env_logger",
  "extension",
  "fs",
- "http_client",
+ "isahc_http_client",
  "language",
  "log",
  "rpc",
@@ -4395,7 +4413,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "nanorand",
- "spin",
+ "spin 0.9.8",
 ]
 
 [[package]]
@@ -4904,7 +4922,6 @@ dependencies = [
  "git",
  "gpui",
  "http_client",
- "isahc",
  "pretty_assertions",
  "regex",
  "serde",
@@ -5537,12 +5554,11 @@ dependencies = [
  "anyhow",
  "derive_more",
  "futures 0.3.30",
- "futures-lite 1.13.0",
- "http 1.1.0",
- "isahc",
+ "http 0.2.12",
  "log",
  "serde",
  "serde_json",
+ "smol",
  "url",
 ]
 
@@ -5604,8 +5620,8 @@ dependencies = [
  "http 0.2.12",
  "hyper",
  "log",
- "rustls",
- "rustls-native-certs",
+ "rustls 0.21.12",
+ "rustls-native-certs 0.6.3",
  "tokio",
  "tokio-rustls",
 ]
@@ -6017,6 +6033,17 @@ dependencies = [
  "waker-fn",
 ]
 
+[[package]]
+name = "isahc_http_client"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "futures 0.3.30",
+ "http_client",
+ "isahc",
+ "util",
+]
+
 [[package]]
 name = "itertools"
 version = "0.10.5"
@@ -6121,7 +6148,7 @@ dependencies = [
  "base64 0.21.7",
  "js-sys",
  "pem",
- "ring",
+ "ring 0.17.8",
  "serde",
  "serde_json",
  "simple_asn1",
@@ -6372,7 +6399,7 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 dependencies = [
- "spin",
+ "spin 0.9.8",
 ]
 
 [[package]]
@@ -7483,7 +7510,6 @@ dependencies = [
  "anyhow",
  "futures 0.3.30",
  "http_client",
- "isahc",
  "schemars",
  "serde",
  "serde_json",
@@ -9175,7 +9201,7 @@ dependencies = [
  "once_cell",
  "percent-encoding",
  "pin-project-lite",
- "rustls-pemfile",
+ "rustls-pemfile 1.0.4",
  "serde",
  "serde_json",
  "serde_urlencoded",
@@ -9239,6 +9265,21 @@ dependencies = [
  "util",
 ]
 
+[[package]]
+name = "ring"
+version = "0.16.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+dependencies = [
+ "cc",
+ "libc",
+ "once_cell",
+ "spin 0.5.2",
+ "untrusted 0.7.1",
+ "web-sys",
+ "winapi",
+]
+
 [[package]]
 name = "ring"
 version = "0.17.8"
@@ -9249,8 +9290,8 @@ dependencies = [
  "cfg-if",
  "getrandom 0.2.15",
  "libc",
- "spin",
- "untrusted",
+ "spin 0.9.8",
+ "untrusted 0.9.0",
  "windows-sys 0.52.0",
 ]
 
@@ -9406,7 +9447,7 @@ dependencies = [
  "futures 0.3.30",
  "glob",
  "rand 0.8.5",
- "ring",
+ "ring 0.17.8",
  "serde",
  "serde_json",
  "shellexpand 3.1.0",
@@ -9527,6 +9568,18 @@ dependencies = [
  "rustix 0.38.35",
 ]
 
+[[package]]
+name = "rustls"
+version = "0.20.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b80e3dec595989ea8510028f30c408a4630db12c9cbb8de34203b89d6577e99"
+dependencies = [
+ "log",
+ "ring 0.16.20",
+ "sct",
+ "webpki",
+]
+
 [[package]]
 name = "rustls"
 version = "0.21.12"
@@ -9534,7 +9587,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 dependencies = [
  "log",
- "ring",
+ "ring 0.17.8",
  "rustls-webpki",
  "sct",
 ]
@@ -9546,7 +9599,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00"
 dependencies = [
  "openssl-probe",
- "rustls-pemfile",
+ "rustls-pemfile 1.0.4",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcaf18a4f2be7326cd874a5fa579fae794320a0f388d365dca7e480e55f83f8a"
+dependencies = [
+ "openssl-probe",
+ "rustls-pemfile 2.1.3",
+ "rustls-pki-types",
  "schannel",
  "security-framework",
 ]
@@ -9560,14 +9626,30 @@ dependencies = [
  "base64 0.21.7",
 ]
 
+[[package]]
+name = "rustls-pemfile"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "196fe16b00e106300d3e45ecfcb764fa292a535d7326a29a5875c579c7417425"
+dependencies = [
+ "base64 0.22.1",
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0a2ce646f8655401bb81e7927b812614bd5d91dbc968696be50603510fcaf0"
+
 [[package]]
 name = "rustls-webpki"
 version = "0.101.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.8",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -9681,8 +9763,8 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.8",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -9878,6 +9960,7 @@ dependencies = [
  "gpui",
  "heed",
  "http_client",
+ "isahc_http_client",
  "language",
  "language_model",
  "languages",
@@ -10437,6 +10520,12 @@ dependencies = [
  "smallvec",
 ]
 
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -10559,8 +10648,8 @@ dependencies = [
  "paste",
  "percent-encoding",
  "rust_decimal",
- "rustls",
- "rustls-pemfile",
+ "rustls 0.21.12",
+ "rustls-pemfile 1.0.4",
  "serde",
  "serde_json",
  "sha2",
@@ -10573,7 +10662,7 @@ dependencies = [
  "tracing",
  "url",
  "uuid",
- "webpki-roots",
+ "webpki-roots 0.25.4",
 ]
 
 [[package]]
@@ -11705,7 +11794,7 @@ version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
 dependencies = [
- "rustls",
+ "rustls 0.21.12",
  "tokio",
 ]
 
@@ -12232,7 +12321,6 @@ dependencies = [
  "http 0.2.12",
  "httparse",
  "log",
- "native-tls",
  "rand 0.8.5",
  "sha1",
  "thiserror",
@@ -12417,6 +12505,12 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
 
+[[package]]
+name = "untrusted"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+
 [[package]]
 name = "untrusted"
 version = "0.9.0"
@@ -13271,6 +13365,25 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "webpki"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53"
+dependencies = [
+ "ring 0.17.8",
+ "untrusted 0.9.0",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c71e40d7d2c34a5106301fb632274ca37242cd0c9d3e64dbece371a40a2d87"
+dependencies = [
+ "webpki",
+]
+
 [[package]]
 name = "webpki-roots"
 version = "0.25.4"
@@ -14305,6 +14418,7 @@ dependencies = [
  "inline_completion_button",
  "install_cli",
  "isahc",
+ "isahc_http_client",
  "journal",
  "language",
  "language_model",
diff --git a/Cargo.toml b/Cargo.toml
index ec3138179b1c5a..2071fdcb6ff484 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,6 +52,7 @@ members = [
     "crates/indexed_docs",
     "crates/inline_completion_button",
     "crates/install_cli",
+    "crates/isahc_http_client",
     "crates/journal",
     "crates/language",
     "crates/language_model",
@@ -173,6 +174,9 @@ members = [
 default-members = ["crates/zed"]
 
 [workspace.dependencies]
+
+
+
 #
 # Workspace member crates
 #
@@ -212,6 +216,7 @@ file_icons = { path = "crates/file_icons" }
 fs = { path = "crates/fs" }
 fsevent = { path = "crates/fsevent" }
 fuzzy = { path = "crates/fuzzy" }
+isahc_http_client = { path = "crates/isahc_http_client" }
 git = { path = "crates/git" }
 git_hosting_providers = { path = "crates/git_hosting_providers" }
 go_to_line = { path = "crates/go_to_line" }
@@ -394,6 +399,8 @@ runtimelib = { version = "0.15", default-features = false, features = [
 ] }
 rustc-demangle = "0.1.23"
 rust-embed = { version = "8.4", features = ["include-exclude"] }
+rustls = "0.20.3"
+rustls-native-certs = "0.8.0"
 schemars = { version = "0.8", features = ["impl_json_schema"] }
 semver = "1.0"
 serde = { version = "1.0", features = ["derive", "rc"] }
diff --git a/crates/auto_update/Cargo.toml b/crates/auto_update/Cargo.toml
index 12e669780d83d7..1e08c9a768b0d5 100644
--- a/crates/auto_update/Cargo.toml
+++ b/crates/auto_update/Cargo.toml
@@ -19,7 +19,6 @@ db.workspace = true
 editor.workspace = true
 gpui.workspace = true
 http_client.workspace = true
-isahc.workspace = true
 log.workspace = true
 markdown_preview.workspace = true
 menu.workspace = true
diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index c0863e41d1aa9c..cfda6d6e584b91 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -9,7 +9,6 @@ use gpui::{
     actions, AppContext, AsyncAppContext, Context as _, Global, Model, ModelContext,
     SemanticVersion, SharedString, Task, View, ViewContext, VisualContext, WindowContext,
 };
-use isahc::AsyncBody;
 
 use markdown_preview::markdown_preview_view::{MarkdownPreviewMode, MarkdownPreviewView};
 use schemars::JsonSchema;
@@ -20,7 +19,7 @@ use smol::{fs, io::AsyncReadExt};
 use settings::{Settings, SettingsSources, SettingsStore};
 use smol::{fs::File, process::Command};
 
-use http_client::{HttpClient, HttpClientWithUrl};
+use http_client::{AsyncBody, HttpClient, HttpClientWithUrl};
 use release_channel::{AppCommitSha, AppVersion, ReleaseChannel};
 use std::{
     env::{
diff --git a/crates/client/Cargo.toml b/crates/client/Cargo.toml
index 82237ebaa5abbd..8ae4f15c9796b1 100644
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -18,7 +18,7 @@ test-support = ["clock/test-support", "collections/test-support", "gpui/test-sup
 [dependencies]
 anyhow.workspace = true
 async-recursion = "0.3"
-async-tungstenite = { workspace = true, features = ["async-std", "async-native-tls"] }
+async-tungstenite = { workspace = true, features = ["async-std", "async-tls"] }
 chrono = { workspace = true, features = ["serde"] }
 clock.workspace = true
 collections.workspace = true
@@ -35,6 +35,8 @@ postage.workspace = true
 rand.workspace = true
 release_channel.workspace = true
 rpc = { workspace = true, features = ["gpui"] }
+rustls.workspace = true
+rustls-native-certs.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 6e1362c43e16fb..09286300d9d38f 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -240,8 +240,6 @@ pub enum EstablishConnectionError {
     #[error("{0}")]
     Other(#[from] anyhow::Error),
     #[error("{0}")]
-    Http(#[from] http_client::Error),
-    #[error("{0}")]
     InvalidHeaderValue(#[from] async_tungstenite::tungstenite::http::header::InvalidHeaderValue),
     #[error("{0}")]
     Io(#[from] std::io::Error),
@@ -529,19 +527,13 @@ impl Client {
     }
 
     pub fn production(cx: &mut AppContext) -> Arc<Self> {
-        let user_agent = format!(
-            "Zed/{} ({}; {})",
-            AppVersion::global(cx),
-            std::env::consts::OS,
-            std::env::consts::ARCH
-        );
         let clock = Arc::new(clock::RealSystemClock);
-        let http = Arc::new(HttpClientWithUrl::new(
+        let http = Arc::new(HttpClientWithUrl::new_uri(
+            cx.http_client(),
             &ClientSettings::get_global(cx).server_url,
-            Some(user_agent),
-            ProxySettings::get_global(cx).proxy.clone(),
+            cx.http_client().proxy().cloned(),
         ));
-        Self::new(clock, http.clone(), cx)
+        Self::new(clock, http, cx)
     }
 
     pub fn id(&self) -> u64 {
@@ -1145,8 +1137,32 @@ impl Client {
 
             match url_scheme {
                 Https => {
+                    let client_config = {
+                        let mut root_store = rustls::RootCertStore::empty();
+
+                        let root_certs = rustls_native_certs::load_native_certs();
+                        for error in root_certs.errors {
+                            log::warn!("error loading native certs: {:?}", error);
+                        }
+                        root_store.add_parsable_certificates(
+                            &root_certs
+                                .certs
+                                .into_iter()
+                                .map(|cert| cert.as_ref().to_owned())
+                                .collect::<Vec<_>>(),
+                        );
+                        rustls::ClientConfig::builder()
+                            .with_safe_defaults()
+                            .with_root_certificates(root_store)
+                            .with_no_client_auth()
+                    };
                     let (stream, _) =
-                        async_tungstenite::async_std::client_async_tls(request, stream).await?;
+                        async_tungstenite::async_tls::client_async_tls_with_connector(
+                            request,
+                            stream,
+                            Some(client_config.into()),
+                        )
+                        .await?;
                     Ok(Connection::new(
                         stream
                             .map_err(|error| anyhow!(error))
diff --git a/crates/collab/Cargo.toml b/crates/collab/Cargo.toml
index f8ba847ab2b9c6..296809158dd14e 100644
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -36,6 +36,7 @@ envy = "0.4.2"
 futures.workspace = true
 google_ai.workspace = true
 hex.workspace = true
+isahc_http_client.workspace = true
 http_client.workspace = true
 jsonwebtoken.workspace = true
 live_kit_server.workspace = true
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index def4499ae41bac..53f0bfdfd0130a 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -22,7 +22,7 @@ use chrono::{DateTime, Duration, Utc};
 use collections::HashMap;
 use db::{usage_measure::UsageMeasure, ActiveUserCount, LlmDatabase};
 use futures::{Stream, StreamExt as _};
-use http_client::IsahcHttpClient;
+use isahc_http_client::IsahcHttpClient;
 use rpc::ListModelsResponse;
 use rpc::{
     proto::Plan, LanguageModelProvider, PerformCompletionParams, EXPIRED_LLM_TOKEN_HEADER_NAME,
@@ -72,6 +72,7 @@ impl LlmState {
         let http_client = IsahcHttpClient::builder()
             .default_header("User-Agent", user_agent)
             .build()
+            .map(IsahcHttpClient::from)
             .context("failed to construct http client")?;
 
         let this = Self {
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index 4146eafb870a44..b2a694027a6f8b 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -35,6 +35,8 @@ use chrono::Utc;
 use collections::{HashMap, HashSet};
 pub use connection_pool::{ConnectionPool, ZedVersion};
 use core::fmt::{self, Debug, Formatter};
+use http_client::HttpClient;
+use isahc_http_client::IsahcHttpClient;
 use open_ai::{OpenAiEmbeddingModel, OPEN_AI_API_URL};
 use sha2::Digest;
 use supermaven_api::{CreateExternalUserRequest, SupermavenAdminApi};
@@ -45,7 +47,6 @@ use futures::{
     stream::FuturesUnordered,
     FutureExt, SinkExt, StreamExt, TryStreamExt,
 };
-use http_client::IsahcHttpClient;
 use prometheus::{register_int_gauge, IntGauge};
 use rpc::{
     proto::{
@@ -139,7 +140,7 @@ struct Session {
     connection_pool: Arc<parking_lot::Mutex<ConnectionPool>>,
     app_state: Arc<AppState>,
     supermaven_client: Option<Arc<SupermavenAdminApi>>,
-    http_client: Arc<IsahcHttpClient>,
+    http_client: Arc<dyn HttpClient>,
     /// The GeoIP country code for the user.
     #[allow(unused)]
     geoip_country_code: Option<String>,
@@ -955,9 +956,10 @@ impl Server {
 
             tracing::info!("connection opened");
 
+
             let user_agent = format!("Zed Server/{}", env!("CARGO_PKG_VERSION"));
             let http_client = match IsahcHttpClient::builder().default_header("User-Agent", user_agent).build() {
-                Ok(http_client) => Arc::new(http_client),
+                Ok(http_client) => Arc::new(IsahcHttpClient::from(http_client)),
                 Err(error) => {
                     tracing::error!(?error, "failed to create HTTP client");
                     return;
diff --git a/crates/evals/Cargo.toml b/crates/evals/Cargo.toml
index e680e4f5046236..400ab139aa2e40 100644
--- a/crates/evals/Cargo.toml
+++ b/crates/evals/Cargo.toml
@@ -24,6 +24,7 @@ feature_flags.workspace = true
 fs.workspace = true
 git.workspace = true
 gpui.workspace = true
+isahc_http_client.workspace = true
 language.workspace = true
 languages.workspace = true
 http_client.workspace = true
diff --git a/crates/evals/src/eval.rs b/crates/evals/src/eval.rs
index d7e63fafbf8202..751dcd09aa1f5c 100644
--- a/crates/evals/src/eval.rs
+++ b/crates/evals/src/eval.rs
@@ -97,13 +97,14 @@ fn main() -> Result<()> {
 
     gpui::App::headless().run(move |cx| {
         let executor = cx.background_executor().clone();
-
+        let client = isahc_http_client::IsahcHttpClient::new(None, None);
+        cx.set_http_client(client.clone());
         match cli.command {
             Commands::Fetch {} => {
                 executor
                     .clone()
                     .spawn(async move {
-                        if let Err(err) = fetch_evaluation_resources(&executor).await {
+                        if let Err(err) = fetch_evaluation_resources(client, &executor).await {
                             eprintln!("Error: {}", err);
                             exit(1);
                         }
@@ -127,10 +128,12 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-async fn fetch_evaluation_resources(executor: &BackgroundExecutor) -> Result<()> {
-    let http_client = http_client::HttpClientWithProxy::new(None, None);
-    fetch_code_search_net_resources(&http_client).await?;
-    fetch_eval_repos(executor, &http_client).await?;
+async fn fetch_evaluation_resources(
+    http_client: Arc<dyn HttpClient>,
+    executor: &BackgroundExecutor,
+) -> Result<()> {
+    fetch_code_search_net_resources(&*http_client).await?;
+    fetch_eval_repos(executor, &*http_client).await?;
     Ok(())
 }
 
@@ -239,6 +242,7 @@ async fn run_evaluation(
     executor: &BackgroundExecutor,
     cx: &mut AsyncAppContext,
 ) -> Result<()> {
+    let mut http_client = None;
     cx.update(|cx| {
         let mut store = SettingsStore::new(cx);
         store
@@ -248,15 +252,15 @@ async fn run_evaluation(
         client::init_settings(cx);
         language::init(cx);
         Project::init_settings(cx);
+        http_client = Some(cx.http_client());
         cx.update_flags(false, vec![]);
     })
     .unwrap();
-
+    let http_client = http_client.unwrap();
     let dataset_dir = Path::new(CODESEARCH_NET_DIR);
     let evaluations_path = dataset_dir.join("evaluations.json");
     let repos_dir = Path::new(EVAL_REPOS_DIR);
     let db_path = Path::new(EVAL_DB_PATH);
-    let http_client = http_client::HttpClientWithProxy::new(None, None);
     let api_key = std::env::var("OPENAI_API_KEY").unwrap();
     let git_hosting_provider_registry = Arc::new(GitHostingProviderRegistry::new());
     let fs = Arc::new(RealFs::new(git_hosting_provider_registry, None)) as Arc<dyn Fs>;
@@ -266,9 +270,9 @@ async fn run_evaluation(
             Client::new(
                 clock,
                 Arc::new(http_client::HttpClientWithUrl::new(
+                    http_client.clone(),
                     "https://zed.dev",
                     None,
-                    None,
                 )),
                 cx,
             )
diff --git a/crates/extension/Cargo.toml b/crates/extension/Cargo.toml
index 0371b1866dfd9a..edf6184d38475d 100644
--- a/crates/extension/Cargo.toml
+++ b/crates/extension/Cargo.toml
@@ -57,6 +57,7 @@ task.workspace = true
 serde_json_lenient.workspace = true
 
 [dev-dependencies]
+isahc_http_client.workspace = true
 ctor.workspace = true
 env_logger.workspace = true
 parking_lot.workspace = true
diff --git a/crates/extension/src/extension_builder.rs b/crates/extension/src/extension_builder.rs
index e42929f78ebb1a..7380e699f9e715 100644
--- a/crates/extension/src/extension_builder.rs
+++ b/crates/extension/src/extension_builder.rs
@@ -246,6 +246,7 @@ impl ExtensionBuilder {
             .args(scanner_path.exists().then_some(scanner_path))
             .output()
             .context("failed to run clang")?;
+
         if !clang_output.status.success() {
             bail!(
                 "failed to compile {} parser with clang: {}",
@@ -431,6 +432,7 @@ impl ExtensionBuilder {
         let body = BufReader::new(response.body_mut());
         let body = GzipDecoder::new(body);
         let tar = Archive::new(body);
+
         tar.unpack(&tar_out_dir)
             .await
             .context("failed to unpack wasi-sdk archive")?;
diff --git a/crates/extension/src/extension_store.rs b/crates/extension/src/extension_store.rs
index 3ebc4f20d36975..bd416f4029f496 100644
--- a/crates/extension/src/extension_store.rs
+++ b/crates/extension/src/extension_store.rs
@@ -190,6 +190,7 @@ pub fn init(
             None,
             fs,
             client.http_client().clone(),
+            client.http_client().clone(),
             Some(client.telemetry().clone()),
             node_runtime,
             language_registry,
@@ -225,6 +226,7 @@ impl ExtensionStore {
         build_dir: Option<PathBuf>,
         fs: Arc<dyn Fs>,
         http_client: Arc<HttpClientWithUrl>,
+        builder_client: Arc<dyn HttpClient>,
         telemetry: Option<Arc<Telemetry>>,
         node_runtime: Arc<dyn NodeRuntime>,
         language_registry: Arc<LanguageRegistry>,
@@ -244,12 +246,7 @@ impl ExtensionStore {
             extension_index: Default::default(),
             installed_dir,
             index_path,
-            builder: Arc::new(ExtensionBuilder::new(
-                // Construct a real HTTP client for the extension builder, as we
-                // don't want to use a fake one in the tests.
-                ::http_client::client(None, http_client.proxy().cloned()),
-                build_dir,
-            )),
+            builder: Arc::new(ExtensionBuilder::new(builder_client, build_dir)),
             outstanding_operations: Default::default(),
             modified_extensions: Default::default(),
             reload_complete_senders: Vec::new(),
@@ -830,7 +827,6 @@ impl ExtensionStore {
             let mut extension_manifest =
                 ExtensionManifest::load(fs.clone(), &extension_source_path).await?;
             let extension_id = extension_manifest.id.clone();
-
             if !this.update(&mut cx, |this, cx| {
                 match this.outstanding_operations.entry(extension_id.clone()) {
                     btree_map::Entry::Occupied(_) => return false,
@@ -854,7 +850,6 @@ impl ExtensionStore {
                     .ok();
                 }
             });
-
             cx.background_executor()
                 .spawn({
                     let extension_source_path = extension_source_path.clone();
@@ -885,10 +880,8 @@ impl ExtensionStore {
                     bail!("extension {extension_id} is already installed");
                 }
             }
-
             fs.create_symlink(output_path, extension_source_path)
                 .await?;
-
             this.update(&mut cx, |this, cx| this.reload(None, cx))?
                 .await;
             Ok(())
diff --git a/crates/extension/src/extension_store_test.rs b/crates/extension/src/extension_store_test.rs
index 326c713bd563ff..0fbd00e0b4ca8a 100644
--- a/crates/extension/src/extension_store_test.rs
+++ b/crates/extension/src/extension_store_test.rs
@@ -13,10 +13,12 @@ use futures::{io::BufReader, AsyncReadExt, StreamExt};
 use gpui::{Context, SemanticVersion, TestAppContext};
 use http_client::{FakeHttpClient, Response};
 use indexed_docs::IndexedDocsRegistry;
+use isahc_http_client::IsahcHttpClient;
 use language::{LanguageMatcher, LanguageRegistry, LanguageServerBinaryStatus, LanguageServerName};
 use node_runtime::FakeNodeRuntime;
 use parking_lot::Mutex;
 use project::{Project, DEFAULT_COMPLETION_CONTEXT};
+use release_channel::AppVersion;
 use serde_json::json;
 use settings::{Settings as _, SettingsStore};
 use snippet_provider::SnippetRegistry;
@@ -270,6 +272,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
             None,
             fs.clone(),
             http_client.clone(),
+            http_client.clone(),
             None,
             node_runtime.clone(),
             language_registry.clone(),
@@ -397,6 +400,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
             None,
             fs.clone(),
             http_client.clone(),
+            http_client.clone(),
             None,
             node_runtime.clone(),
             language_registry.clone(),
@@ -453,6 +457,8 @@ async fn test_extension_store(cx: &mut TestAppContext) {
     });
 }
 
+// TODO remove
+#[ignore]
 #[gpui::test]
 async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
     init_test(cx);
@@ -502,7 +508,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
         http_request_count: 0,
     }));
 
-    let http_client = FakeHttpClient::create({
+    let extension_client = FakeHttpClient::create({
         let language_server_version = language_server_version.clone();
         move |request| {
             let language_server_version = language_server_version.clone();
@@ -558,19 +564,33 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
                     let mut encoder = GzipEncoder::new(BufReader::new(bytes.as_slice()));
                     encoder.read_to_end(&mut gzipped_bytes).await.unwrap();
                     Ok(Response::new(gzipped_bytes.into()))
+                // } else if uri == WASI_ADAPTER_URL {
+                //     let binary_contents =
+                //         include_bytes!("wasi_snapshot_preview1.reactor.wasm").as_slice();
+                //     Ok(Response::new(binary_contents.into()))
                 } else {
                     Ok(Response::builder().status(404).body("not found".into())?)
                 }
             }
         }
     });
+    let user_agent = cx.update(|cx| {
+        format!(
+            "Zed/{} ({}; {})",
+            AppVersion::global(cx),
+            std::env::consts::OS,
+            std::env::consts::ARCH
+        )
+    });
+    let builder_client = IsahcHttpClient::new(None, Some(user_agent));
 
     let extension_store = cx.new_model(|cx| {
         ExtensionStore::new(
             extensions_dir.clone(),
             Some(cache_dir),
             fs.clone(),
-            http_client.clone(),
+            extension_client.clone(),
+            builder_client,
             None,
             node_runtime,
             language_registry.clone(),
diff --git a/crates/extension_cli/Cargo.toml b/crates/extension_cli/Cargo.toml
index 54c47f4a829af6..bc649d8e04989f 100644
--- a/crates/extension_cli/Cargo.toml
+++ b/crates/extension_cli/Cargo.toml
@@ -18,7 +18,7 @@ clap = { workspace = true, features = ["derive"] }
 env_logger.workspace = true
 extension = { workspace = true, features = ["no-webrtc"] }
 fs.workspace = true
-http_client.workspace = true
+isahc_http_client.workspace = true
 language.workspace = true
 log.workspace = true
 rpc.workspace = true
diff --git a/crates/extension_cli/src/main.rs b/crates/extension_cli/src/main.rs
index 029c560e57db81..6eaebca2f0e9bf 100644
--- a/crates/extension_cli/src/main.rs
+++ b/crates/extension_cli/src/main.rs
@@ -7,13 +7,13 @@ use std::{
 };
 
 use ::fs::{copy_recursive, CopyOptions, Fs, RealFs};
-use ::http_client::HttpClientWithProxy;
 use anyhow::{anyhow, bail, Context, Result};
 use clap::Parser;
 use extension::{
     extension_builder::{CompileExtensionOptions, ExtensionBuilder},
     ExtensionManifest,
 };
+use isahc_http_client::IsahcHttpClient;
 use language::LanguageConfig;
 use theme::ThemeRegistry;
 use tree_sitter::{Language, Query, WasmStore};
@@ -66,7 +66,13 @@ async fn main() -> Result<()> {
         std::env::consts::OS,
         std::env::consts::ARCH
     );
-    let http_client = Arc::new(HttpClientWithProxy::new(Some(user_agent), None));
+    let http_client = Arc::new(
+        IsahcHttpClient::builder()
+            .default_header("User-Agent", user_agent)
+            .build()
+            .map(IsahcHttpClient::from)?,
+    );
+
     let builder = ExtensionBuilder::new(http_client, scratch_dir);
     builder
         .compile_extension(
diff --git a/crates/git_hosting_providers/Cargo.toml b/crates/git_hosting_providers/Cargo.toml
index caca91c1ab93d6..b8ad1ed05d1605 100644
--- a/crates/git_hosting_providers/Cargo.toml
+++ b/crates/git_hosting_providers/Cargo.toml
@@ -18,7 +18,6 @@ futures.workspace = true
 git.workspace = true
 gpui.workspace = true
 http_client.workspace = true
-isahc.workspace = true
 regex.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/git_hosting_providers/src/providers/codeberg.rs b/crates/git_hosting_providers/src/providers/codeberg.rs
index b34d809100be56..eaadca1ecf9618 100644
--- a/crates/git_hosting_providers/src/providers/codeberg.rs
+++ b/crates/git_hosting_providers/src/providers/codeberg.rs
@@ -3,9 +3,7 @@ use std::sync::Arc;
 use anyhow::{bail, Context, Result};
 use async_trait::async_trait;
 use futures::AsyncReadExt;
-use http_client::HttpClient;
-use isahc::config::Configurable;
-use isahc::{AsyncBody, Request};
+use http_client::{AsyncBody, HttpClient, Request};
 use serde::Deserialize;
 use url::Url;
 
@@ -51,16 +49,14 @@ impl Codeberg {
         let url =
             format!("https://codeberg.org/api/v1/repos/{repo_owner}/{repo}/git/commits/{commit}");
 
-        let mut request = Request::get(&url)
-            .redirect_policy(isahc::config::RedirectPolicy::Follow)
-            .header("Content-Type", "application/json");
+        let mut request = Request::get(&url).header("Content-Type", "application/json");
 
         if let Ok(codeberg_token) = std::env::var("CODEBERG_TOKEN") {
             request = request.header("Authorization", format!("Bearer {}", codeberg_token));
         }
 
         let mut response = client
-            .send(request.body(AsyncBody::default())?)
+            .send_with_redirect_policy(request.body(AsyncBody::default())?, true)
             .await
             .with_context(|| format!("error fetching Codeberg commit details at {:?}", url))?;
 
diff --git a/crates/git_hosting_providers/src/providers/github.rs b/crates/git_hosting_providers/src/providers/github.rs
index 103f6ae1ce734c..be46b51ddf7bdf 100644
--- a/crates/git_hosting_providers/src/providers/github.rs
+++ b/crates/git_hosting_providers/src/providers/github.rs
@@ -3,9 +3,7 @@ use std::sync::{Arc, OnceLock};
 use anyhow::{bail, Context, Result};
 use async_trait::async_trait;
 use futures::AsyncReadExt;
-use http_client::HttpClient;
-use isahc::config::Configurable;
-use isahc::{AsyncBody, Request};
+use http_client::{AsyncBody, HttpClient, Request};
 use regex::Regex;
 use serde::Deserialize;
 use url::Url;
@@ -55,16 +53,14 @@ impl Github {
     ) -> Result<Option<User>> {
         let url = format!("https://api.github.com/repos/{repo_owner}/{repo}/commits/{commit}");
 
-        let mut request = Request::get(&url)
-            .redirect_policy(isahc::config::RedirectPolicy::Follow)
-            .header("Content-Type", "application/json");
+        let mut request = Request::get(&url).header("Content-Type", "application/json");
 
         if let Ok(github_token) = std::env::var("GITHUB_TOKEN") {
             request = request.header("Authorization", format!("Bearer {}", github_token));
         }
 
         let mut response = client
-            .send(request.body(AsyncBody::default())?)
+            .send_with_redirect_policy(request.body(AsyncBody::default())?, true)
             .await
             .with_context(|| format!("error fetching GitHub commit details at {:?}", url))?;
 
diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml
index d0d75b73e97a7d..e2339a38edd1f4 100644
--- a/crates/gpui/Cargo.toml
+++ b/crates/gpui/Cargo.toml
@@ -11,13 +11,13 @@ license = "Apache-2.0"
 workspace = true
 
 [features]
-default = []
+default = ["http_client"]
 test-support = [
     "backtrace",
     "collections/test-support",
     "rand",
     "util/test-support",
-    "http_client/test-support",
+    "http_client?/test-support",
 ]
 runtime_shaders = []
 macos-blade = ["blade-graphics", "blade-macros", "blade-util", "bytemuck"]
@@ -40,7 +40,7 @@ derive_more.workspace = true
 etagere = "0.2"
 futures.workspace = true
 gpui_macros.workspace = true
-http_client.workspace = true
+http_client = { optional = true, workspace = true }
 image = "0.25.1"
 itertools.workspace = true
 linkme = "0.3"
diff --git a/crates/gpui/examples/image/image.rs b/crates/gpui/examples/image/image.rs
index ac7af186d30ba0..157dbdf70f1afc 100644
--- a/crates/gpui/examples/image/image.rs
+++ b/crates/gpui/examples/image/image.rs
@@ -131,6 +131,7 @@ fn main() {
                         PathBuf::from_str("crates/gpui/examples/image/app-icon.png").unwrap(),
                     ),
                     remote_resource: "https://picsum.photos/512/512".into(),
+
                     asset_resource: "image/color.svg".into(),
                 })
             })
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index ee7a6ef191a6e2..6cb491b100810b 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -117,7 +117,7 @@ impl App {
         Self(AppContext::new(
             current_platform(false),
             Arc::new(()),
-            http_client::client(None, None),
+            Arc::new(NullHttpClient),
         ))
     }
 
@@ -128,7 +128,7 @@ impl App {
         Self(AppContext::new(
             current_platform(true),
             Arc::new(()),
-            http_client::client(None, None),
+            Arc::new(NullHttpClient),
         ))
     }
 
@@ -142,6 +142,14 @@ impl App {
         self
     }
 
+    /// Set the http client for the application
+    pub fn with_http_client(self, http_client: Arc<dyn HttpClient>) -> Self {
+        let mut context_lock = self.0.borrow_mut();
+        context_lock.http_client = http_client;
+        drop(context_lock);
+        self
+    }
+
     /// Start the application. The provided callback will be called once the
     /// app is fully launched.
     pub fn run<F>(self, on_finish_launching: F)
@@ -1512,3 +1520,22 @@ pub struct KeystrokeEvent {
     /// The action that was resolved for the keystroke, if any
     pub action: Option<Box<dyn Action>>,
 }
+
+struct NullHttpClient;
+
+impl HttpClient for NullHttpClient {
+    fn send_with_redirect_policy(
+        &self,
+        _req: http_client::Request<http_client::AsyncBody>,
+        _follow_redirects: bool,
+    ) -> futures::future::BoxFuture<
+        'static,
+        Result<http_client::Response<http_client::AsyncBody>, anyhow::Error>,
+    > {
+        async move { Err(anyhow!("No HttpClient available")) }.boxed()
+    }
+
+    fn proxy(&self) -> Option<&http_client::Uri> {
+        None
+    }
+}
diff --git a/crates/gpui/src/elements/img.rs b/crates/gpui/src/elements/img.rs
index f1e8bb68e3237e..63236d5309f145 100644
--- a/crates/gpui/src/elements/img.rs
+++ b/crates/gpui/src/elements/img.rs
@@ -345,7 +345,10 @@ impl Asset for ImageAsset {
             let bytes = match source.clone() {
                 UriOrPath::Path(uri) => fs::read(uri.as_ref())?,
                 UriOrPath::Uri(uri) => {
-                    let mut response = client.get(uri.as_ref(), ().into(), true).await?;
+                    let mut response = client
+                        .get(uri.as_ref(), ().into(), true)
+                        .await
+                        .map_err(|e| ImageCacheError::Client(Arc::new(e)))?;
                     let mut body = Vec::new();
                     response.body_mut().read_to_end(&mut body).await?;
                     if !response.status().is_success() {
@@ -429,7 +432,7 @@ impl Asset for ImageAsset {
 pub enum ImageCacheError {
     /// An error that occurred while fetching an image from a remote source.
     #[error("http error: {0}")]
-    Client(#[from] http_client::Error),
+    Client(#[from] Arc<anyhow::Error>),
     /// An error that occurred while reading the image from disk.
     #[error("IO error: {0}")]
     Io(Arc<std::io::Error>),
diff --git a/crates/gpui/src/gpui.rs b/crates/gpui/src/gpui.rs
index a447478a9be4b3..7ba3ce055ecc67 100644
--- a/crates/gpui/src/gpui.rs
+++ b/crates/gpui/src/gpui.rs
@@ -128,6 +128,7 @@ pub use executor::*;
 pub use geometry::*;
 pub use global::*;
 pub use gpui_macros::{register_action, test, IntoElement, Render};
+pub use http_client;
 pub use input::*;
 pub use interactive::*;
 use key_dispatch::*;
diff --git a/crates/http_client/Cargo.toml b/crates/http_client/Cargo.toml
index ae017685a9471a..0244ac41042b6f 100644
--- a/crates/http_client/Cargo.toml
+++ b/crates/http_client/Cargo.toml
@@ -16,13 +16,12 @@ path = "src/http_client.rs"
 doctest = true
 
 [dependencies]
-http = "1.0.0"
+http = "0.2"
 anyhow.workspace = true
 derive_more.workspace = true
 futures.workspace = true
-isahc.workspace = true
 log.workspace = true
 serde.workspace = true
 serde_json.workspace = true
-futures-lite.workspace = true
+smol.workspace = true
 url.workspace = true
diff --git a/crates/http_client/src/async_body.rs b/crates/http_client/src/async_body.rs
new file mode 100644
index 00000000000000..e2544f60fe5404
--- /dev/null
+++ b/crates/http_client/src/async_body.rs
@@ -0,0 +1,109 @@
+use std::{borrow::Cow, io::Read, pin::Pin, task::Poll};
+
+use futures::{AsyncRead, AsyncReadExt};
+
+/// Based on the implementation of AsyncBody in
+/// https://github.com/sagebind/isahc/blob/5c533f1ef4d6bdf1fd291b5103c22110f41d0bf0/src/body/mod.rs
+pub struct AsyncBody(pub Inner);
+
+pub enum Inner {
+    /// An empty body.
+    Empty,
+
+    /// A body stored in memory.
+    SyncReader(std::io::Cursor<Cow<'static, [u8]>>),
+
+    /// An asynchronous reader.
+    AsyncReader(Pin<Box<dyn futures::AsyncRead + Send + Sync>>),
+}
+
+impl AsyncBody {
+    /// Create a new empty body.
+    ///
+    /// An empty body represents the *absence* of a body, which is semantically
+    /// different than the presence of a body of zero length.
+    pub fn empty() -> Self {
+        Self(Inner::Empty)
+    }
+    /// Create a streaming body that reads from the given reader.
+    pub fn from_reader<R>(read: R) -> Self
+    where
+        R: AsyncRead + Send + Sync + 'static,
+    {
+        Self(Inner::AsyncReader(Box::pin(read)))
+    }
+}
+
+impl Default for AsyncBody {
+    fn default() -> Self {
+        Self(Inner::Empty)
+    }
+}
+
+impl From<()> for AsyncBody {
+    fn from(_: ()) -> Self {
+        Self(Inner::Empty)
+    }
+}
+
+impl From<Vec<u8>> for AsyncBody {
+    fn from(body: Vec<u8>) -> Self {
+        Self(Inner::SyncReader(std::io::Cursor::new(Cow::Owned(body))))
+    }
+}
+
+impl From<&'_ [u8]> for AsyncBody {
+    fn from(body: &[u8]) -> Self {
+        body.to_vec().into()
+    }
+}
+
+impl From<String> for AsyncBody {
+    fn from(body: String) -> Self {
+        body.into_bytes().into()
+    }
+}
+
+impl From<&'_ str> for AsyncBody {
+    fn from(body: &str) -> Self {
+        body.as_bytes().into()
+    }
+}
+
+impl<T: Into<Self>> From<Option<T>> for AsyncBody {
+    fn from(body: Option<T>) -> Self {
+        match body {
+            Some(body) => body.into(),
+            None => Self(Inner::Empty),
+        }
+    }
+}
+
+impl std::io::Read for AsyncBody {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        match &mut self.0 {
+            Inner::Empty => Ok(0),
+            Inner::SyncReader(cursor) => cursor.read(buf),
+            Inner::AsyncReader(async_reader) => smol::block_on(async_reader.read(buf)),
+        }
+    }
+}
+
+impl futures::AsyncRead for AsyncBody {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &mut [u8],
+    ) -> std::task::Poll<std::io::Result<usize>> {
+        // SAFETY: Standard Enum pin projection
+        let inner = unsafe { &mut self.get_unchecked_mut().0 };
+        match inner {
+            Inner::Empty => Poll::Ready(Ok(0)),
+            // Blocking call is over an in-memory buffer
+            Inner::SyncReader(cursor) => Poll::Ready(cursor.read(buf)),
+            Inner::AsyncReader(async_reader) => {
+                AsyncRead::poll_read(async_reader.as_mut(), cx, buf)
+            }
+        }
+    }
+}
diff --git a/crates/http_client/src/github.rs b/crates/http_client/src/github.rs
index a64a5bae5c681c..70587fa3cea04b 100644
--- a/crates/http_client/src/github.rs
+++ b/crates/http_client/src/github.rs
@@ -34,7 +34,7 @@ pub async fn latest_github_release(
 ) -> Result<GithubRelease, anyhow::Error> {
     let mut response = http
         .get(
-            &format!("https://api.github.com/repos/{repo_name_with_owner}/releases"),
+            format!("https://api.github.com/repos/{repo_name_with_owner}/releases").as_str(),
             Default::default(),
             true,
         )
@@ -91,13 +91,14 @@ pub async fn get_release_by_tag_name(
         .context("error fetching latest release")?;
 
     let mut body = Vec::new();
+    let status = response.status();
     response
         .body_mut()
         .read_to_end(&mut body)
         .await
         .context("error reading latest release")?;
 
-    if response.status().is_client_error() {
+    if status.is_client_error() {
         let text = String::from_utf8_lossy(body.as_slice());
         bail!(
             "status error {}, response: {text:?}",
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index 7ea0029d79029f..d78b2dd23c7f7f 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -1,47 +1,48 @@
+mod async_body;
 pub mod github;
 
 pub use anyhow::{anyhow, Result};
+pub use async_body::{AsyncBody, Inner};
 use derive_more::Deref;
+pub use http::{self, Method, Request, Response, StatusCode, Uri};
+
 use futures::future::BoxFuture;
-use futures_lite::FutureExt;
-use isahc::config::{Configurable, RedirectPolicy};
-pub use isahc::http;
-pub use isahc::{
-    http::{Method, StatusCode, Uri},
-    AsyncBody, Error, HttpClient as IsahcHttpClient, Request, Response,
-};
+use http::request::Builder;
 #[cfg(feature = "test-support")]
 use std::fmt;
-use std::{
-    sync::{Arc, Mutex},
-    time::Duration,
-};
+use std::sync::{Arc, Mutex};
 pub use url::Url;
 
-pub trait HttpClient: Send + Sync {
+pub trait HttpClient: 'static + Send + Sync {
     fn send(
+        &self,
+        req: http::Request<AsyncBody>,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
+        self.send_with_redirect_policy(req, false)
+    }
+
+    // TODO: Make a better API for this
+    fn send_with_redirect_policy(
         &self,
         req: Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>>;
+        follow_redirects: bool,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>>;
 
     fn get<'a>(
         &'a self,
         uri: &str,
         body: AsyncBody,
         follow_redirects: bool,
-    ) -> BoxFuture<'a, Result<Response<AsyncBody>, Error>> {
-        let request = isahc::Request::builder()
-            .redirect_policy(if follow_redirects {
-                RedirectPolicy::Follow
-            } else {
-                RedirectPolicy::None
-            })
-            .method(Method::GET)
-            .uri(uri)
-            .body(body);
+    ) -> BoxFuture<'a, Result<Response<AsyncBody>, anyhow::Error>> {
+        let request = Builder::new().uri(uri).body(body);
+
         match request {
-            Ok(request) => self.send(request),
-            Err(error) => async move { Err(error.into()) }.boxed(),
+            Ok(request) => Box::pin(async move {
+                self.send_with_redirect_policy(request, follow_redirects)
+                    .await
+                    .map_err(Into::into)
+            }),
+            Err(e) => Box::pin(async move { Err(e.into()) }),
         }
     }
 
@@ -49,15 +50,16 @@ pub trait HttpClient: Send + Sync {
         &'a self,
         uri: &str,
         body: AsyncBody,
-    ) -> BoxFuture<'a, Result<Response<AsyncBody>, Error>> {
-        let request = isahc::Request::builder()
-            .method(Method::POST)
+    ) -> BoxFuture<'a, Result<Response<AsyncBody>, anyhow::Error>> {
+        let request = Builder::new()
             .uri(uri)
+            .method(Method::POST)
             .header("Content-Type", "application/json")
             .body(body);
+
         match request {
-            Ok(request) => self.send(request),
-            Err(error) => async move { Err(error.into()) }.boxed(),
+            Ok(request) => Box::pin(async move { self.send(request).await.map_err(Into::into) }),
+            Err(e) => Box::pin(async move { Err(e.into()) }),
         }
     }
 
@@ -74,29 +76,28 @@ pub struct HttpClientWithProxy {
 
 impl HttpClientWithProxy {
     /// Returns a new [`HttpClientWithProxy`] with the given proxy URL.
-    pub fn new(user_agent: Option<String>, proxy_url: Option<String>) -> Self {
-        let proxy_url = proxy_url
-            .and_then(|input| {
-                input
-                    .parse::<Uri>()
-                    .inspect_err(|e| log::error!("Error parsing proxy settings: {}", e))
-                    .ok()
-            })
+    pub fn new(client: Arc<dyn HttpClient>, proxy_url: Option<String>) -> Self {
+        let proxy_uri = proxy_url
+            .and_then(|proxy| proxy.parse().ok())
             .or_else(read_proxy_from_env);
 
+        Self::new_uri(client, proxy_uri)
+    }
+    pub fn new_uri(client: Arc<dyn HttpClient>, proxy_uri: Option<Uri>) -> Self {
         Self {
-            client: client(user_agent, proxy_url.clone()),
-            proxy: proxy_url,
+            client,
+            proxy: proxy_uri,
         }
     }
 }
 
 impl HttpClient for HttpClientWithProxy {
-    fn send(
+    fn send_with_redirect_policy(
         &self,
         req: Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>> {
-        self.client.send(req)
+        follow_redirects: bool,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
+        self.client.send_with_redirect_policy(req, follow_redirects)
     }
 
     fn proxy(&self) -> Option<&Uri> {
@@ -105,11 +106,12 @@ impl HttpClient for HttpClientWithProxy {
 }
 
 impl HttpClient for Arc<HttpClientWithProxy> {
-    fn send(
+    fn send_with_redirect_policy(
         &self,
         req: Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>> {
-        self.client.send(req)
+        follow_redirects: bool,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
+        self.client.send_with_redirect_policy(req, follow_redirects)
     }
 
     fn proxy(&self) -> Option<&Uri> {
@@ -123,14 +125,35 @@ pub struct HttpClientWithUrl {
     client: HttpClientWithProxy,
 }
 
+impl std::ops::Deref for HttpClientWithUrl {
+    type Target = HttpClientWithProxy;
+
+    fn deref(&self) -> &Self::Target {
+        &self.client
+    }
+}
+
 impl HttpClientWithUrl {
     /// Returns a new [`HttpClientWithUrl`] with the given base URL.
     pub fn new(
+        client: Arc<dyn HttpClient>,
         base_url: impl Into<String>,
-        user_agent: Option<String>,
         proxy_url: Option<String>,
     ) -> Self {
-        let client = HttpClientWithProxy::new(user_agent, proxy_url);
+        let client = HttpClientWithProxy::new(client, proxy_url);
+
+        Self {
+            base_url: Mutex::new(base_url.into()),
+            client,
+        }
+    }
+
+    pub fn new_uri(
+        client: Arc<dyn HttpClient>,
+        base_url: impl Into<String>,
+        proxy_uri: Option<Uri>,
+    ) -> Self {
+        let client = HttpClientWithProxy::new_uri(client, proxy_uri);
 
         Self {
             base_url: Mutex::new(base_url.into()),
@@ -195,11 +218,12 @@ impl HttpClientWithUrl {
 }
 
 impl HttpClient for Arc<HttpClientWithUrl> {
-    fn send(
+    fn send_with_redirect_policy(
         &self,
         req: Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>> {
-        self.client.send(req)
+        follow_redirects: bool,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
+        self.client.send_with_redirect_policy(req, follow_redirects)
     }
 
     fn proxy(&self) -> Option<&Uri> {
@@ -208,11 +232,12 @@ impl HttpClient for Arc<HttpClientWithUrl> {
 }
 
 impl HttpClient for HttpClientWithUrl {
-    fn send(
+    fn send_with_redirect_policy(
         &self,
         req: Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>> {
-        self.client.send(req)
+        follow_redirects: bool,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
+        self.client.send_with_redirect_policy(req, follow_redirects)
     }
 
     fn proxy(&self) -> Option<&Uri> {
@@ -220,26 +245,7 @@ impl HttpClient for HttpClientWithUrl {
     }
 }
 
-pub fn client(user_agent: Option<String>, proxy: Option<Uri>) -> Arc<dyn HttpClient> {
-    let mut builder = isahc::HttpClient::builder()
-        // Some requests to Qwen2 models on Runpod can take 32+ seconds,
-        // especially if there's a cold boot involved. We may need to have
-        // those requests use a different http client, because global timeouts
-        // of 50 and 60 seconds, respectively, would be very high!
-        .connect_timeout(Duration::from_secs(5))
-        .low_speed_timeout(100, Duration::from_secs(30))
-        .proxy(proxy.clone());
-    if let Some(user_agent) = user_agent {
-        builder = builder.default_header("User-Agent", user_agent);
-    }
-
-    Arc::new(HttpClientWithProxy {
-        client: Arc::new(builder.build().unwrap()),
-        proxy,
-    })
-}
-
-fn read_proxy_from_env() -> Option<Uri> {
+pub fn read_proxy_from_env() -> Option<Uri> {
     const ENV_VARS: &[&str] = &[
         "ALL_PROXY",
         "all_proxy",
@@ -258,23 +264,9 @@ fn read_proxy_from_env() -> Option<Uri> {
     None
 }
 
-impl HttpClient for isahc::HttpClient {
-    fn send(
-        &self,
-        req: Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>> {
-        let client = self.clone();
-        Box::pin(async move { client.send_async(req).await })
-    }
-
-    fn proxy(&self) -> Option<&Uri> {
-        None
-    }
-}
-
 #[cfg(feature = "test-support")]
 type FakeHttpHandler = Box<
-    dyn Fn(Request<AsyncBody>) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>>
+    dyn Fn(Request<AsyncBody>) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>>
         + Send
         + Sync
         + 'static,
@@ -289,7 +281,7 @@ pub struct FakeHttpClient {
 impl FakeHttpClient {
     pub fn create<Fut, F>(handler: F) -> Arc<HttpClientWithUrl>
     where
-        Fut: futures::Future<Output = Result<Response<AsyncBody>, Error>> + Send + 'static,
+        Fut: futures::Future<Output = Result<Response<AsyncBody>, anyhow::Error>> + Send + 'static,
         F: Fn(Request<AsyncBody>) -> Fut + Send + Sync + 'static,
     {
         Arc::new(HttpClientWithUrl {
@@ -331,12 +323,13 @@ impl fmt::Debug for FakeHttpClient {
 
 #[cfg(feature = "test-support")]
 impl HttpClient for FakeHttpClient {
-    fn send(
+    fn send_with_redirect_policy(
         &self,
         req: Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>> {
+        _follow_redirects: bool,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
         let future = (self.handler)(req);
-        Box::pin(async move { future.await.map(Into::into) })
+        future
     }
 
     fn proxy(&self) -> Option<&Uri> {
diff --git a/crates/isahc_http_client/Cargo.toml b/crates/isahc_http_client/Cargo.toml
new file mode 100644
index 00000000000000..b90163ef7495d5
--- /dev/null
+++ b/crates/isahc_http_client/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "isahc_http_client"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "Apache-2.0"
+
+[lints]
+workspace = true
+
+[features]
+test-support = []
+
+[lib]
+path = "src/isahc_http_client.rs"
+
+[dependencies]
+http_client.workspace = true
+isahc.workspace = true
+futures.workspace = true
+anyhow.workspace = true
+util.workspace = true
diff --git a/crates/isahc_http_client/LICENSE-APACHE b/crates/isahc_http_client/LICENSE-APACHE
new file mode 120000
index 00000000000000..1cd601d0a3affa
--- /dev/null
+++ b/crates/isahc_http_client/LICENSE-APACHE
@@ -0,0 +1 @@
+../../LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/isahc_http_client/src/isahc_http_client.rs b/crates/isahc_http_client/src/isahc_http_client.rs
new file mode 100644
index 00000000000000..6c40b9f53b3f8e
--- /dev/null
+++ b/crates/isahc_http_client/src/isahc_http_client.rs
@@ -0,0 +1,93 @@
+use std::{mem, sync::Arc, time::Duration};
+
+use futures::future::BoxFuture;
+use isahc::config::RedirectPolicy;
+use util::maybe;
+
+pub use isahc::config::Configurable;
+pub struct IsahcHttpClient(isahc::HttpClient);
+
+pub use http_client::*;
+
+impl IsahcHttpClient {
+    pub fn new(proxy: Option<Uri>, user_agent: Option<String>) -> Arc<IsahcHttpClient> {
+        let mut builder = isahc::HttpClient::builder()
+            .connect_timeout(Duration::from_secs(5))
+            .low_speed_timeout(100, Duration::from_secs(5))
+            .proxy(proxy.clone());
+        if let Some(agent) = user_agent {
+            builder = builder.default_header("User-Agent", agent);
+        }
+        Arc::new(IsahcHttpClient(builder.build().unwrap()))
+    }
+    pub fn builder() -> isahc::HttpClientBuilder {
+        isahc::HttpClientBuilder::new()
+    }
+}
+
+impl From<isahc::HttpClient> for IsahcHttpClient {
+    fn from(client: isahc::HttpClient) -> Self {
+        Self(client)
+    }
+}
+
+impl HttpClient for IsahcHttpClient {
+    fn proxy(&self) -> Option<&Uri> {
+        None
+    }
+
+    fn send_with_redirect_policy(
+        &self,
+        req: http_client::http::Request<http_client::AsyncBody>,
+        follow_redirects: bool,
+    ) -> BoxFuture<'static, Result<http_client::Response<http_client::AsyncBody>, anyhow::Error>>
+    {
+        let req = maybe!({
+            let (mut parts, body) = req.into_parts();
+            let mut builder = isahc::Request::builder()
+                .method(parts.method)
+                .uri(parts.uri)
+                .version(parts.version);
+
+            let headers = builder.headers_mut()?;
+            mem::swap(headers, &mut parts.headers);
+
+            let extensions = builder.extensions_mut()?;
+            mem::swap(extensions, &mut parts.extensions);
+
+            let isahc_body = match body.0 {
+                http_client::Inner::Empty => isahc::AsyncBody::empty(),
+                http_client::Inner::AsyncReader(reader) => isahc::AsyncBody::from_reader(reader),
+                http_client::Inner::SyncReader(reader) => {
+                    isahc::AsyncBody::from_bytes_static(reader.into_inner())
+                }
+            };
+
+            builder
+                .redirect_policy(if follow_redirects {
+                    RedirectPolicy::Follow
+                } else {
+                    RedirectPolicy::None
+                })
+                .body(isahc_body)
+                .ok()
+        });
+
+        let client = self.0.clone();
+
+        Box::pin(async move {
+            match req {
+                Some(req) => client
+                    .send_async(req)
+                    .await
+                    .map_err(Into::into)
+                    .map(|response| {
+                        let (parts, body) = response.into_parts();
+                        let body = http_client::AsyncBody::from_reader(body);
+                        http_client::Response::from_parts(parts, body)
+                    }),
+                None => Err(anyhow::anyhow!("Request was malformed")),
+            }
+        })
+    }
+}
diff --git a/crates/ollama/Cargo.toml b/crates/ollama/Cargo.toml
index 76a8b1a8c16cfc..34d8802b977df3 100644
--- a/crates/ollama/Cargo.toml
+++ b/crates/ollama/Cargo.toml
@@ -19,7 +19,6 @@ schemars = ["dep:schemars"]
 anyhow.workspace = true
 futures.workspace = true
 http_client.workspace = true
-isahc.workspace = true
 schemars = { workspace = true, optional = true }
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/ollama/src/ollama.rs b/crates/ollama/src/ollama.rs
index a65d6eaf900312..972520e61f53e5 100644
--- a/crates/ollama/src/ollama.rs
+++ b/crates/ollama/src/ollama.rs
@@ -1,7 +1,6 @@
 use anyhow::{anyhow, Context, Result};
 use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, StreamExt};
-use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
-use isahc::config::Configurable;
+use http_client::{http, AsyncBody, HttpClient, Method, Request as HttpRequest};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_json::{value::RawValue, Value};
@@ -262,18 +261,14 @@ pub async fn stream_chat_completion(
     client: &dyn HttpClient,
     api_url: &str,
     request: ChatRequest,
-    low_speed_timeout: Option<Duration>,
+    _: Option<Duration>,
 ) -> Result<BoxStream<'static, Result<ChatResponseDelta>>> {
     let uri = format!("{api_url}/api/chat");
-    let mut request_builder = HttpRequest::builder()
+    let request_builder = http::Request::builder()
         .method(Method::POST)
         .uri(uri)
         .header("Content-Type", "application/json");
 
-    if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
-    };
-
     let request = request_builder.body(AsyncBody::from(serde_json::to_string(&request)?))?;
     let mut response = client.send(request).await?;
     if response.status().is_success() {
@@ -305,18 +300,14 @@ pub async fn stream_chat_completion(
 pub async fn get_models(
     client: &dyn HttpClient,
     api_url: &str,
-    low_speed_timeout: Option<Duration>,
+    _: Option<Duration>,
 ) -> Result<Vec<LocalModelListing>> {
     let uri = format!("{api_url}/api/tags");
-    let mut request_builder = HttpRequest::builder()
+    let request_builder = HttpRequest::builder()
         .method(Method::GET)
         .uri(uri)
         .header("Accept", "application/json");
 
-    if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
-    };
-
     let request = request_builder.body(AsyncBody::default())?;
 
     let mut response = client.send(request).await?;
@@ -354,13 +345,13 @@ pub async fn preload_model(client: Arc<dyn HttpClient>, api_url: &str, model: &s
 
     let mut response = match client.send(request).await {
         Ok(response) => response,
-        Err(err) => {
+        Err(error) => {
             // Be ok with a timeout during preload of the model
-            if err.is_timeout() {
-                return Ok(());
-            } else {
-                return Err(err.into());
-            }
+            // if err.is_timeout() {
+            //     return Ok(());
+            // } else {
+            return Err(error);
+            //}
         }
     };
 
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 6dd528147be322..58d9ba8926737d 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -26,7 +26,7 @@ use gpui::{
     AppContext, AsyncAppContext, Context, Entity, EventEmitter, Model, ModelContext, PromptLevel,
     Task, WeakModel,
 };
-use http_client::{AsyncBody, Error, HttpClient, Request, Response, Uri};
+use http_client::{AsyncBody, HttpClient, Request, Response, Uri};
 use language::{
     language_settings::{
         all_language_settings, language_settings, AllLanguageSettings, LanguageSettings,
@@ -7339,7 +7339,7 @@ impl HttpClient for BlockedHttpClient {
     fn send(
         &self,
         _req: Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, Error>> {
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
         Box::pin(async {
             Err(std::io::Error::new(
                 std::io::ErrorKind::PermissionDenied,
@@ -7352,6 +7352,14 @@ impl HttpClient for BlockedHttpClient {
     fn proxy(&self) -> Option<&Uri> {
         None
     }
+
+    fn send_with_redirect_policy(
+        &self,
+        req: Request<AsyncBody>,
+        _: bool,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
+        self.send(req)
+    }
 }
 
 struct SshLspAdapterDelegate {
diff --git a/crates/semantic_index/Cargo.toml b/crates/semantic_index/Cargo.toml
index c8dbb6a9f53dd2..691d6e57f6d448 100644
--- a/crates/semantic_index/Cargo.toml
+++ b/crates/semantic_index/Cargo.toml
@@ -51,6 +51,7 @@ workspace.workspace = true
 worktree.workspace = true
 
 [dev-dependencies]
+isahc_http_client.workspace = true
 env_logger.workspace = true
 client = { workspace = true, features = ["test-support"] }
 fs = { workspace = true, features = ["test-support"] }
diff --git a/crates/semantic_index/examples/index.rs b/crates/semantic_index/examples/index.rs
index 977473d1dc38ba..0cc3f9f317b08f 100644
--- a/crates/semantic_index/examples/index.rs
+++ b/crates/semantic_index/examples/index.rs
@@ -2,6 +2,7 @@ use client::Client;
 use futures::channel::oneshot;
 use gpui::App;
 use http_client::HttpClientWithUrl;
+use isahc_http_client::IsahcHttpClient;
 use language::language_settings::AllLanguageSettings;
 use project::Project;
 use semantic_index::{OpenAiEmbeddingModel, OpenAiEmbeddingProvider, SemanticDb};
@@ -26,8 +27,12 @@ fn main() {
         });
 
         let clock = Arc::new(FakeSystemClock::default());
-        let http = Arc::new(HttpClientWithUrl::new("http://localhost:11434", None, None));
 
+        let http = Arc::new(HttpClientWithUrl::new(
+            IsahcHttpClient::new(None, None),
+            "http://localhost:11434",
+            None,
+        ));
         let client = client::Client::new(clock, http.clone(), cx);
         Client::set_global(client.clone(), cx);
 
diff --git a/crates/semantic_index/src/embedding/ollama.rs b/crates/semantic_index/src/embedding/ollama.rs
index 09d33c584a9af5..6d3fa679021ee3 100644
--- a/crates/semantic_index/src/embedding/ollama.rs
+++ b/crates/semantic_index/src/embedding/ollama.rs
@@ -1,5 +1,5 @@
 use anyhow::{Context as _, Result};
-use futures::{future::BoxFuture, AsyncReadExt, FutureExt};
+use futures::{future::BoxFuture, AsyncReadExt as _, FutureExt};
 use http_client::HttpClient;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index 28d2c7f82576d8..7fa9602a141073 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -47,6 +47,7 @@ file_finder.workspace = true
 file_icons.workspace = true
 fs.workspace = true
 futures.workspace = true
+isahc_http_client.workspace = true
 git.workspace = true
 git_hosting_providers.workspace = true
 go_to_line.workspace = true
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index eb6d2853fdad7e..d3a722ec657898 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -11,7 +11,7 @@ use assistant::PromptBuilder;
 use chrono::Offset;
 use clap::{command, Parser};
 use cli::FORCE_CLI_MODE_ENV_VAR_NAME;
-use client::{parse_zed_link, Client, DevServerToken, UserStore};
+use client::{parse_zed_link, Client, DevServerToken, ProxySettings, UserStore};
 use collab_ui::channel_view::ChannelView;
 use db::kvp::KEY_VALUE_STORE;
 use editor::Editor;
@@ -23,6 +23,8 @@ use gpui::{
     Action, App, AppContext, AsyncAppContext, Context, DismissEvent, Global, Task,
     UpdateGlobal as _, VisualContext,
 };
+use http_client::{read_proxy_from_env, Uri};
+use isahc_http_client::IsahcHttpClient;
 use language::LanguageRegistry;
 use log::LevelFilter;
 
@@ -327,7 +329,10 @@ fn main() {
     init_logger();
 
     log::info!("========== starting zed ==========");
-    let app = App::new().with_assets(Assets);
+
+    let app = App::new()
+        .with_assets(Assets)
+        .with_http_client(IsahcHttpClient::new(None, None));
 
     let (installation_id, existing_installation_id_found) = app
         .background_executor()
@@ -436,6 +441,26 @@ fn main() {
         if let Some(build_sha) = option_env!("ZED_COMMIT_SHA") {
             AppCommitSha::set_global(AppCommitSha(build_sha.into()), cx);
         }
+        settings::init(cx);
+        client::init_settings(cx);
+        let user_agent = format!(
+            "Zed/{} ({}; {})",
+            AppVersion::global(cx),
+            std::env::consts::OS,
+            std::env::consts::ARCH
+        );
+        let proxy_str = ProxySettings::get_global(cx).proxy.to_owned();
+        let proxy_url = proxy_str
+            .as_ref()
+            .and_then(|input| {
+                input
+                    .parse::<Uri>()
+                    .inspect_err(|e| log::error!("Error parsing proxy settings: {}", e))
+                    .ok()
+            })
+            .or_else(read_proxy_from_env);
+        let http = IsahcHttpClient::new(proxy_url, Some(user_agent));
+        cx.set_http_client(http);
 
         <dyn Fs>::set_global(fs.clone(), cx);
 
@@ -444,11 +469,9 @@ fn main() {
 
         OpenListener::set_global(cx, open_listener.clone());
 
-        settings::init(cx);
         handle_settings_file_changes(user_settings_file_rx, cx, handle_settings_changed);
         handle_keymap_file_changes(user_keymap_file_rx, cx, handle_keymap_changed);
 
-        client::init_settings(cx);
         let client = Client::production(cx);
         cx.set_http_client(client.http_client().clone());
         let mut languages = LanguageRegistry::new(cx.background_executor().clone());
diff --git a/script/bundle-linux b/script/bundle-linux
index 029d748f4f10bc..deecd0984bece3 100755
--- a/script/bundle-linux
+++ b/script/bundle-linux
@@ -43,7 +43,10 @@ script/generate-licenses
 
 # Build binary in release mode
 export RUSTFLAGS="${RUSTFLAGS:-} -C link-args=-Wl,--disable-new-dtags,-rpath,\$ORIGIN/../lib"
-cargo build --release --target "${target_triple}" --package zed --package cli --package remote_server
+cargo build --release --target "${target_triple}" --package zed --package cli
+# Build remote_server in separate invocation to prevent feature unification from other crates
+# from influencing dynamic libraries required by it.
+cargo build --release --target "${target_triple}" --package remote_server
 
 # Strip the binary of all debug symbols
 # Later, we probably want to do something like this: https://github.com/GabrielMajeri/separate-symbols
@@ -51,6 +54,10 @@ strip --strip-debug "${target_dir}/${target_triple}/release/zed"
 strip --strip-debug "${target_dir}/${target_triple}/release/cli"
 strip --strip-debug "${target_dir}/${target_triple}/release/remote_server"
 
+
+# Ensure that remote_server does not depend on libssl nor libcrypto, as we got rid of these deps.
+ldd "${target_dir}/${target_triple}/release/remote_server" | grep -q 'libcrypto\|libssl'
+
 suffix=""
 if [ "$channel" != "stable" ]; then
   suffix="-$channel"

From a62e8f6396bf41176ddd00cbc705b699d71fe6cf Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 18 Sep 2024 18:05:30 -0400
Subject: [PATCH 195/762] ci: Explicitly set cache-provider for
 swatinem/rust-cache (#18034)

- Switches the Cache Dependencies step (`swatinem/rust-cache`) of Linux
tests to use buildjet as `cache-provider`. Explicitly add 'github' (the
default cache provider) to other uses of `swatinem/rust-cache` for
consistency.

Release Notes:

- N/A
---
 .github/workflows/ci.yml                    | 2 ++
 .github/workflows/publish_extension_cli.yml | 1 +
 2 files changed, 3 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c55a3a9907f47f..f059b470040129 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -115,6 +115,7 @@ jobs:
         uses: swatinem/rust-cache@23bce251a8cd2ffc3c1075eaa2367cf899916d84 # v2
         with:
           save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-provider: "buildjet"
 
       - name: Install Linux dependencies
         run: ./script/linux
@@ -143,6 +144,7 @@ jobs:
         uses: swatinem/rust-cache@23bce251a8cd2ffc3c1075eaa2367cf899916d84 # v2
         with:
           save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-provider: "github"
 
       - name: cargo clippy
         # Windows can't run shell scripts, so we need to use `cargo xtask`.
diff --git a/.github/workflows/publish_extension_cli.yml b/.github/workflows/publish_extension_cli.yml
index 698a09ad007f88..7c47ec5dedfdd1 100644
--- a/.github/workflows/publish_extension_cli.yml
+++ b/.github/workflows/publish_extension_cli.yml
@@ -24,6 +24,7 @@ jobs:
         uses: swatinem/rust-cache@23bce251a8cd2ffc3c1075eaa2367cf899916d84 # v2
         with:
           save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-provider: "github"
 
       - name: Configure linux
         shell: bash -euxo pipefail {0}

From 2cd9a88f53954051f639b120940c06d7bebcf250 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 18 Sep 2024 19:39:15 -0400
Subject: [PATCH 196/762] Clean up after `isahc_http_client` introduction
 (#18045)

This PR does some clean up after #15446.

Release Notes:

- N/A
---
 Cargo.toml                              | 5 +----
 crates/collab/Cargo.toml                | 2 +-
 crates/collab/src/rpc.rs                | 1 -
 crates/extension/src/extension_store.rs | 4 ++++
 crates/isahc_http_client/Cargo.toml     | 4 ++--
 crates/zed/Cargo.toml                   | 2 +-
 6 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 2071fdcb6ff484..c72fec020fe678 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -174,9 +174,6 @@ members = [
 default-members = ["crates/zed"]
 
 [workspace.dependencies]
-
-
-
 #
 # Workspace member crates
 #
@@ -216,7 +213,6 @@ file_icons = { path = "crates/file_icons" }
 fs = { path = "crates/fs" }
 fsevent = { path = "crates/fsevent" }
 fuzzy = { path = "crates/fuzzy" }
-isahc_http_client = { path = "crates/isahc_http_client" }
 git = { path = "crates/git" }
 git_hosting_providers = { path = "crates/git_hosting_providers" }
 go_to_line = { path = "crates/go_to_line" }
@@ -231,6 +227,7 @@ image_viewer = { path = "crates/image_viewer" }
 indexed_docs = { path = "crates/indexed_docs" }
 inline_completion_button = { path = "crates/inline_completion_button" }
 install_cli = { path = "crates/install_cli" }
+isahc_http_client = { path = "crates/isahc_http_client" }
 journal = { path = "crates/journal" }
 language = { path = "crates/language" }
 language_model = { path = "crates/language_model" }
diff --git a/crates/collab/Cargo.toml b/crates/collab/Cargo.toml
index 296809158dd14e..ad43d2d1f0cf50 100644
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -36,8 +36,8 @@ envy = "0.4.2"
 futures.workspace = true
 google_ai.workspace = true
 hex.workspace = true
-isahc_http_client.workspace = true
 http_client.workspace = true
+isahc_http_client.workspace = true
 jsonwebtoken.workspace = true
 live_kit_server.workspace = true
 log.workspace = true
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index b2a694027a6f8b..bc0f827e78ba51 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -956,7 +956,6 @@ impl Server {
 
             tracing::info!("connection opened");
 
-
             let user_agent = format!("Zed Server/{}", env!("CARGO_PKG_VERSION"));
             let http_client = match IsahcHttpClient::builder().default_header("User-Agent", user_agent).build() {
                 Ok(http_client) => Arc::new(IsahcHttpClient::from(http_client)),
diff --git a/crates/extension/src/extension_store.rs b/crates/extension/src/extension_store.rs
index bd416f4029f496..8dbd618a25784b 100644
--- a/crates/extension/src/extension_store.rs
+++ b/crates/extension/src/extension_store.rs
@@ -827,6 +827,7 @@ impl ExtensionStore {
             let mut extension_manifest =
                 ExtensionManifest::load(fs.clone(), &extension_source_path).await?;
             let extension_id = extension_manifest.id.clone();
+
             if !this.update(&mut cx, |this, cx| {
                 match this.outstanding_operations.entry(extension_id.clone()) {
                     btree_map::Entry::Occupied(_) => return false,
@@ -850,6 +851,7 @@ impl ExtensionStore {
                     .ok();
                 }
             });
+
             cx.background_executor()
                 .spawn({
                     let extension_source_path = extension_source_path.clone();
@@ -880,8 +882,10 @@ impl ExtensionStore {
                     bail!("extension {extension_id} is already installed");
                 }
             }
+
             fs.create_symlink(output_path, extension_source_path)
                 .await?;
+
             this.update(&mut cx, |this, cx| this.reload(None, cx))?
                 .await;
             Ok(())
diff --git a/crates/isahc_http_client/Cargo.toml b/crates/isahc_http_client/Cargo.toml
index b90163ef7495d5..82f7621bf8cace 100644
--- a/crates/isahc_http_client/Cargo.toml
+++ b/crates/isahc_http_client/Cargo.toml
@@ -15,8 +15,8 @@ test-support = []
 path = "src/isahc_http_client.rs"
 
 [dependencies]
+anyhow.workspace = true
+futures.workspace = true
 http_client.workspace = true
 isahc.workspace = true
-futures.workspace = true
-anyhow.workspace = true
 util.workspace = true
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index 7fa9602a141073..645d12fc76a350 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -47,7 +47,6 @@ file_finder.workspace = true
 file_icons.workspace = true
 fs.workspace = true
 futures.workspace = true
-isahc_http_client.workspace = true
 git.workspace = true
 git_hosting_providers.workspace = true
 go_to_line.workspace = true
@@ -58,6 +57,7 @@ image_viewer.workspace = true
 inline_completion_button.workspace = true
 install_cli.workspace = true
 isahc.workspace = true
+isahc_http_client.workspace = true
 journal.workspace = true
 language.workspace = true
 language_model.workspace = true

From 106ca5076fd8d485a9016fa202d618efb66e40dc Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Wed, 18 Sep 2024 16:43:59 -0700
Subject: [PATCH 197/762] Fix leak of LMDB connection in semantic index
 (#17992)

Apparently, to close LMDB's file descriptors when using the `heed`
library, you need to explicitly call `prepare_for_closing`.

Release Notes:

- N/A

---------

Co-authored-by: Richard Feldman <oss@rtfeldman.com>
Co-authored-by: Jason <jason@zed.dev>
---
 crates/evals/src/eval.rs                    |  9 +++++++++
 crates/semantic_index/src/semantic_index.rs | 12 +++++++++---
 2 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/crates/evals/src/eval.rs b/crates/evals/src/eval.rs
index 751dcd09aa1f5c..708cfa7511a402 100644
--- a/crates/evals/src/eval.rs
+++ b/crates/evals/src/eval.rs
@@ -446,6 +446,15 @@ async fn run_evaluation(
 
             println!("{}", serde_json::to_string(&query_results).unwrap());
         }
+
+        user_store
+            .update(cx, |_, _| {
+                drop(semantic_index);
+                drop(project);
+                drop(worktree);
+                drop(project_index);
+            })
+            .unwrap();
     }
 
     eprint!(
diff --git a/crates/semantic_index/src/semantic_index.rs b/crates/semantic_index/src/semantic_index.rs
index 3435d0a9ca4f79..6c97ece024c7fe 100644
--- a/crates/semantic_index/src/semantic_index.rs
+++ b/crates/semantic_index/src/semantic_index.rs
@@ -25,7 +25,7 @@ pub use summary_index::FileSummary;
 
 pub struct SemanticDb {
     embedding_provider: Arc<dyn EmbeddingProvider>,
-    db_connection: heed::Env,
+    db_connection: Option<heed::Env>,
     project_indices: HashMap<WeakModel<Project>, Model<ProjectIndex>>,
 }
 
@@ -70,7 +70,7 @@ impl SemanticDb {
         .ok();
 
         Ok(SemanticDb {
-            db_connection,
+            db_connection: Some(db_connection),
             embedding_provider,
             project_indices: HashMap::default(),
         })
@@ -148,7 +148,7 @@ impl SemanticDb {
         let project_index = cx.new_model(|cx| {
             ProjectIndex::new(
                 project.clone(),
-                self.db_connection.clone(),
+                self.db_connection.clone().unwrap(),
                 self.embedding_provider.clone(),
                 cx,
             )
@@ -171,6 +171,12 @@ impl SemanticDb {
     }
 }
 
+impl Drop for SemanticDb {
+    fn drop(&mut self) {
+        self.db_connection.take().unwrap().prepare_for_closing();
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

From eef44aff7f9b17f1ea38cbc64ac52bbbd435ef10 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 18 Sep 2024 19:48:34 -0400
Subject: [PATCH 198/762] extension: Re-enable
 `test_extension_store_with_test_extension` test (#18046)

The `test_extension_store_with_test_extension` test was disabled in
#15446, which got merged before re-enabling the test.

This PR re-enables that test.

Release Notes:

- N/A
---
 crates/extension/src/extension_store_test.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/crates/extension/src/extension_store_test.rs b/crates/extension/src/extension_store_test.rs
index 0fbd00e0b4ca8a..4bdafaa32c2aff 100644
--- a/crates/extension/src/extension_store_test.rs
+++ b/crates/extension/src/extension_store_test.rs
@@ -457,8 +457,6 @@ async fn test_extension_store(cx: &mut TestAppContext) {
     });
 }
 
-// TODO remove
-#[ignore]
 #[gpui::test]
 async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
     init_test(cx);
@@ -564,10 +562,6 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
                     let mut encoder = GzipEncoder::new(BufReader::new(bytes.as_slice()));
                     encoder.read_to_end(&mut gzipped_bytes).await.unwrap();
                     Ok(Response::new(gzipped_bytes.into()))
-                // } else if uri == WASI_ADAPTER_URL {
-                //     let binary_contents =
-                //         include_bytes!("wasi_snapshot_preview1.reactor.wasm").as_slice();
-                //     Ok(Response::new(binary_contents.into()))
                 } else {
                     Ok(Response::builder().status(404).body("not found".into())?)
                 }

From b43b800a54919103062e8fd7f5ff82c80026f211 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 18 Sep 2024 18:07:39 -0600
Subject: [PATCH 199/762] More assistant events (#18032)

Release Notes:

- N/A
---
 crates/assistant/src/context.rs               |  3 +-
 crates/assistant/src/inline_assistant.rs      | 29 +++++++++++++++++++
 .../src/terminal_inline_assistant.rs          |  1 +
 crates/client/src/telemetry.rs                |  8 +++--
 crates/collab/src/api/events.rs               |  2 ++
 .../telemetry_events/src/telemetry_events.rs  | 28 +++++++++++++++++-
 6 files changed, 66 insertions(+), 5 deletions(-)

diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index d55b1aee088642..d72b04e3cddb17 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -46,7 +46,7 @@ use std::{
     sync::Arc,
     time::{Duration, Instant},
 };
-use telemetry_events::AssistantKind;
+use telemetry_events::{AssistantKind, AssistantPhase};
 use text::BufferSnapshot;
 use util::{post_inc, ResultExt, TryFutureExt};
 use uuid::Uuid;
@@ -2134,6 +2134,7 @@ impl Context {
                         telemetry.report_assistant_event(
                             Some(this.id.0.clone()),
                             AssistantKind::Panel,
+                            AssistantPhase::Response,
                             model.telemetry_id(),
                             response_latency,
                             error_message,
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index eb1bc1eee8b0da..c9360213ae5138 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -174,6 +174,18 @@ impl InlineAssistant {
         initial_prompt: Option<String>,
         cx: &mut WindowContext,
     ) {
+        if let Some(telemetry) = self.telemetry.as_ref() {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+                telemetry.report_assistant_event(
+                    None,
+                    telemetry_events::AssistantKind::Inline,
+                    telemetry_events::AssistantPhase::Invoked,
+                    model.telemetry_id(),
+                    None,
+                    None,
+                );
+            }
+        }
         let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
 
         let mut selections = Vec::<Selection<Point>>::new();
@@ -708,6 +720,22 @@ impl InlineAssistant {
     }
 
     pub fn finish_assist(&mut self, assist_id: InlineAssistId, undo: bool, cx: &mut WindowContext) {
+        if let Some(telemetry) = self.telemetry.as_ref() {
+            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+                telemetry.report_assistant_event(
+                    None,
+                    telemetry_events::AssistantKind::Inline,
+                    if undo {
+                        telemetry_events::AssistantPhase::Rejected
+                    } else {
+                        telemetry_events::AssistantPhase::Accepted
+                    },
+                    model.telemetry_id(),
+                    None,
+                    None,
+                );
+            }
+        }
         if let Some(assist) = self.assists.get(&assist_id) {
             let assist_group_id = assist.group_id;
             if self.assist_groups[&assist_group_id].linked {
@@ -2558,6 +2586,7 @@ impl Codegen {
                                 telemetry.report_assistant_event(
                                     None,
                                     telemetry_events::AssistantKind::Inline,
+                                    telemetry_events::AssistantPhase::Response,
                                     model_telemetry_id,
                                     response_latency,
                                     error_message,
diff --git a/crates/assistant/src/terminal_inline_assistant.rs b/crates/assistant/src/terminal_inline_assistant.rs
index 06661944d96a79..caf819bae535ee 100644
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -1066,6 +1066,7 @@ impl Codegen {
                         telemetry.report_assistant_event(
                             None,
                             telemetry_events::AssistantKind::Inline,
+                            telemetry_events::AssistantPhase::Response,
                             model_telemetry_id,
                             response_latency,
                             error_message,
diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index b415cae14c60a2..46304819a4db5b 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -16,9 +16,9 @@ use std::io::Write;
 use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
 use sysinfo::{CpuRefreshKind, Pid, ProcessRefreshKind, RefreshKind, System};
 use telemetry_events::{
-    ActionEvent, AppEvent, AssistantEvent, AssistantKind, CallEvent, CpuEvent, EditEvent,
-    EditorEvent, Event, EventRequestBody, EventWrapper, ExtensionEvent, InlineCompletionEvent,
-    MemoryEvent, ReplEvent, SettingEvent,
+    ActionEvent, AppEvent, AssistantEvent, AssistantKind, AssistantPhase, CallEvent, CpuEvent,
+    EditEvent, EditorEvent, Event, EventRequestBody, EventWrapper, ExtensionEvent,
+    InlineCompletionEvent, MemoryEvent, ReplEvent, SettingEvent,
 };
 use tempfile::NamedTempFile;
 #[cfg(not(debug_assertions))]
@@ -391,6 +391,7 @@ impl Telemetry {
         self: &Arc<Self>,
         conversation_id: Option<String>,
         kind: AssistantKind,
+        phase: AssistantPhase,
         model: String,
         response_latency: Option<Duration>,
         error_message: Option<String>,
@@ -398,6 +399,7 @@ impl Telemetry {
         let event = Event::Assistant(AssistantEvent {
             conversation_id,
             kind,
+            phase,
             model: model.to_string(),
             response_latency,
             error_message,
diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index 30ed10a76fb0c0..45c25d261e1de8 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -834,6 +834,7 @@ pub struct AssistantEventRow {
     // AssistantEventRow
     conversation_id: String,
     kind: String,
+    phase: String,
     model: String,
     response_latency_in_ms: Option<i64>,
     error_message: Option<String>,
@@ -866,6 +867,7 @@ impl AssistantEventRow {
             time: time.timestamp_millis(),
             conversation_id: event.conversation_id.unwrap_or_default(),
             kind: event.kind.to_string(),
+            phase: event.phase.to_string(),
             model: event.model,
             response_latency_in_ms: event
                 .response_latency
diff --git a/crates/telemetry_events/src/telemetry_events.rs b/crates/telemetry_events/src/telemetry_events.rs
index 87ecfb76b6f7e7..eb84322e83d94c 100644
--- a/crates/telemetry_events/src/telemetry_events.rs
+++ b/crates/telemetry_events/src/telemetry_events.rs
@@ -44,7 +44,6 @@ pub enum AssistantKind {
     Panel,
     Inline,
 }
-
 impl Display for AssistantKind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
@@ -58,6 +57,31 @@ impl Display for AssistantKind {
     }
 }
 
+#[derive(Default, Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum AssistantPhase {
+    #[default]
+    Response,
+    Invoked,
+    Accepted,
+    Rejected,
+}
+
+impl Display for AssistantPhase {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::Response => "response",
+                Self::Invoked => "invoked",
+                Self::Accepted => "accepted",
+                Self::Rejected => "rejected",
+            }
+        )
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(tag = "type")]
 pub enum Event {
@@ -121,6 +145,8 @@ pub struct AssistantEvent {
     pub conversation_id: Option<String>,
     /// The kind of assistant (Panel, Inline)
     pub kind: AssistantKind,
+    #[serde(default)]
+    pub phase: AssistantPhase,
     /// Name of the AI model used (gpt-4o, claude-3-5-sonnet, etc)
     pub model: String,
     pub response_latency: Option<Duration>,

From 43e005e936e13947ed99799375bcbfa35703b8cd Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Thu, 19 Sep 2024 02:19:58 +0200
Subject: [PATCH 200/762] chore: Remove commented out code following 15446
 (#18047)

Closes #ISSUE

Release Notes:

- N/A
---
 crates/ollama/src/ollama.rs | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/crates/ollama/src/ollama.rs b/crates/ollama/src/ollama.rs
index 972520e61f53e5..51c48290488147 100644
--- a/crates/ollama/src/ollama.rs
+++ b/crates/ollama/src/ollama.rs
@@ -343,17 +343,7 @@ pub async fn preload_model(client: Arc<dyn HttpClient>, api_url: &str, model: &s
             }),
         )?))?;
 
-    let mut response = match client.send(request).await {
-        Ok(response) => response,
-        Err(error) => {
-            // Be ok with a timeout during preload of the model
-            // if err.is_timeout() {
-            //     return Ok(());
-            // } else {
-            return Err(error);
-            //}
-        }
-    };
+    let mut response = client.send(request).await?;
 
     if response.status().is_success() {
         Ok(())

From c3f47b8040a83b6414b8a28399628370fb7224f4 Mon Sep 17 00:00:00 2001
From: hekmyr <163496286+hekmyr@users.noreply.github.com>
Date: Thu, 19 Sep 2024 02:28:31 +0200
Subject: [PATCH 201/762] vim: Fix increment/decrement command (#17644)

Improving vim increment and decrement command.

Closes: #16672

## Release Notes:

- vim: Improved edge-case handling for ctrl-a/ctrl-x

---------

Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>
---
 crates/vim/src/normal/increment.rs            | 241 ++++++++++++++++--
 ...st_increment_bin_wrapping_and_padding.json |  10 +
 .../test_data/test_increment_hex_casing.json  |   5 +
 ...st_increment_hex_wrapping_and_padding.json |  10 +
 .../vim/test_data/test_increment_inline.json  |  10 +
 .../test_data/test_increment_sign_change.json |   6 +
 .../test_data/test_increment_wrapping.json    |  13 +
 7 files changed, 273 insertions(+), 22 deletions(-)
 create mode 100644 crates/vim/test_data/test_increment_bin_wrapping_and_padding.json
 create mode 100644 crates/vim/test_data/test_increment_hex_casing.json
 create mode 100644 crates/vim/test_data/test_increment_hex_wrapping_and_padding.json
 create mode 100644 crates/vim/test_data/test_increment_inline.json
 create mode 100644 crates/vim/test_data/test_increment_sign_change.json
 create mode 100644 crates/vim/test_data/test_increment_wrapping.json

diff --git a/crates/vim/src/normal/increment.rs b/crates/vim/src/normal/increment.rs
index 8786eae872bbed..6d66e380c30b80 100644
--- a/crates/vim/src/normal/increment.rs
+++ b/crates/vim/src/normal/increment.rs
@@ -28,18 +28,18 @@ pub fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {
         vim.record_current_action(cx);
         let count = vim.take_count(cx).unwrap_or(1);
         let step = if action.step { 1 } else { 0 };
-        vim.increment(count as i32, step, cx)
+        vim.increment(count as i64, step, cx)
     });
     Vim::action(editor, cx, |vim, action: &Decrement, cx| {
         vim.record_current_action(cx);
         let count = vim.take_count(cx).unwrap_or(1);
         let step = if action.step { -1 } else { 0 };
-        vim.increment(-(count as i32), step, cx)
+        vim.increment(-(count as i64), step, cx)
     });
 }
 
 impl Vim {
-    fn increment(&mut self, mut delta: i32, step: i32, cx: &mut ViewContext<Self>) {
+    fn increment(&mut self, mut delta: i64, step: i32, cx: &mut ViewContext<Self>) {
         self.store_visual_marks(cx);
         self.update_editor(cx, |vim, editor, cx| {
             let mut edits = Vec::new();
@@ -60,23 +60,14 @@ impl Vim {
                     };
 
                     if let Some((range, num, radix)) = find_number(&snapshot, start) {
-                        if let Ok(val) = i32::from_str_radix(&num, radix) {
-                            let result = val + delta;
-                            delta += step;
-                            let replace = match radix {
-                                10 => format!("{}", result),
-                                16 => {
-                                    if num.to_ascii_lowercase() == num {
-                                        format!("{:x}", result)
-                                    } else {
-                                        format!("{:X}", result)
-                                    }
-                                }
-                                2 => format!("{:b}", result),
-                                _ => unreachable!(),
-                            };
-                            edits.push((range.clone(), replace));
-                        }
+                        let replace = match radix {
+                            10 => increment_decimal_string(&num, delta),
+                            16 => increment_hex_string(&num, delta),
+                            2 => increment_binary_string(&num, delta),
+                            _ => unreachable!(),
+                        };
+                        delta += step as i64;
+                        edits.push((range.clone(), replace));
                         if selection.is_empty() {
                             new_anchors.push((false, snapshot.anchor_after(range.end)))
                         }
@@ -107,6 +98,70 @@ impl Vim {
     }
 }
 
+fn increment_decimal_string(mut num: &str, mut delta: i64) -> String {
+    let mut negative = false;
+    if num.chars().next() == Some('-') {
+        negative = true;
+        delta = 0 - delta;
+        num = &num[1..];
+    }
+    let result = if let Ok(value) = u64::from_str_radix(num, 10) {
+        let wrapped = value.wrapping_add_signed(delta);
+        if delta < 0 && wrapped > value {
+            negative = !negative;
+            (u64::MAX - wrapped).wrapping_add(1)
+        } else if delta > 0 && wrapped < value {
+            negative = !negative;
+            u64::MAX - wrapped
+        } else {
+            wrapped
+        }
+    } else {
+        u64::MAX
+    };
+
+    if result == 0 || !negative {
+        format!("{}", result)
+    } else {
+        format!("-{}", result)
+    }
+}
+
+fn increment_hex_string(num: &str, delta: i64) -> String {
+    let result = if let Ok(val) = u64::from_str_radix(&num, 16) {
+        val.wrapping_add_signed(delta)
+    } else {
+        u64::MAX
+    };
+    if should_use_lowercase(num) {
+        format!("{:0width$x}", result, width = num.len())
+    } else {
+        format!("{:0width$X}", result, width = num.len())
+    }
+}
+
+fn should_use_lowercase(num: &str) -> bool {
+    let mut use_uppercase = false;
+    for ch in num.chars() {
+        if ch.is_ascii_lowercase() {
+            return true;
+        }
+        if ch.is_ascii_uppercase() {
+            use_uppercase = true;
+        }
+    }
+    !use_uppercase
+}
+
+fn increment_binary_string(num: &str, delta: i64) -> String {
+    let result = if let Ok(val) = u64::from_str_radix(&num, 2) {
+        val.wrapping_add_signed(delta)
+    } else {
+        u64::MAX
+    };
+    format!("{:0width$b}", result, width = num.len())
+}
+
 fn find_number(
     snapshot: &MultiBufferSnapshot,
     start: Point,
@@ -114,10 +169,10 @@ fn find_number(
     let mut offset = start.to_offset(snapshot);
 
     let ch0 = snapshot.chars_at(offset).next();
-    if ch0.as_ref().is_some_and(char::is_ascii_digit) || matches!(ch0, Some('-' | 'b' | 'x')) {
+    if ch0.as_ref().is_some_and(char::is_ascii_hexdigit) || matches!(ch0, Some('-' | 'b' | 'x')) {
         // go backwards to the start of any number the selection is within
         for ch in snapshot.reversed_chars_at(offset) {
-            if ch.is_ascii_digit() || ch == '-' || ch == 'b' || ch == 'x' {
+            if ch.is_ascii_hexdigit() || ch == '-' || ch == 'b' || ch == 'x' {
                 offset -= ch.len_utf8();
                 continue;
             }
@@ -158,6 +213,8 @@ fn find_number(
                 begin = Some(offset);
             }
             num.push(ch);
+            println!("pushing {}", ch);
+            println!();
         } else if begin.is_some() {
             end = Some(offset);
             break;
@@ -250,6 +307,146 @@ mod test {
             "});
     }
 
+    #[gpui::test]
+    async fn test_increment_sign_change(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+        cx.set_shared_state(indoc! {"
+                ˇ0
+                "})
+            .await;
+        cx.simulate_shared_keystrokes("ctrl-x").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                -ˇ1
+                "});
+        cx.simulate_shared_keystrokes("2 ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                ˇ1
+                "});
+    }
+
+    #[gpui::test]
+    async fn test_increment_bin_wrapping_and_padding(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+        cx.set_shared_state(indoc! {"
+                    0b111111111111111111111111111111111111111111111111111111111111111111111ˇ1
+                    "})
+            .await;
+
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    0b000000111111111111111111111111111111111111111111111111111111111111111ˇ1
+                    "});
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    0b000000000000000000000000000000000000000000000000000000000000000000000ˇ0
+                    "});
+
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    0b000000000000000000000000000000000000000000000000000000000000000000000ˇ1
+                    "});
+        cx.simulate_shared_keystrokes("2 ctrl-x").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    0b000000111111111111111111111111111111111111111111111111111111111111111ˇ1
+                    "});
+    }
+
+    #[gpui::test]
+    async fn test_increment_hex_wrapping_and_padding(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+        cx.set_shared_state(indoc! {"
+                    0xfffffffffffffffffffˇf
+                    "})
+            .await;
+
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    0x0000fffffffffffffffˇf
+                    "});
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    0x0000000000000000000ˇ0
+                    "});
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    0x0000000000000000000ˇ1
+                    "});
+        cx.simulate_shared_keystrokes("2 ctrl-x").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    0x0000fffffffffffffffˇf
+                    "});
+    }
+
+    #[gpui::test]
+    async fn test_increment_wrapping(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+        cx.set_shared_state(indoc! {"
+                    1844674407370955161ˇ9
+                    "})
+            .await;
+
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    1844674407370955161ˇ5
+                    "});
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    -1844674407370955161ˇ5
+                    "});
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    -1844674407370955161ˇ4
+                    "});
+        cx.simulate_shared_keystrokes("3 ctrl-x").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    1844674407370955161ˇ4
+                    "});
+        cx.simulate_shared_keystrokes("2 ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    -1844674407370955161ˇ5
+                    "});
+    }
+
+    #[gpui::test]
+    async fn test_increment_inline(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+        cx.set_shared_state(indoc! {"
+                    inline0x3ˇ9u32
+                    "})
+            .await;
+
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    inline0x3ˇau32
+                    "});
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    inline0x3ˇbu32
+                    "});
+        cx.simulate_shared_keystrokes("l l l ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    inline0x3bu3ˇ3
+                    "});
+    }
+
+    #[gpui::test]
+    async fn test_increment_hex_casing(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+        cx.set_shared_state(indoc! {"
+                        0xFˇa
+                    "})
+            .await;
+
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    0xfˇb
+                    "});
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                    0xfˇc
+                    "});
+    }
+
     #[gpui::test]
     async fn test_increment_radix(cx: &mut gpui::TestAppContext) {
         let mut cx = NeovimBackedTestContext::new(cx).await;
diff --git a/crates/vim/test_data/test_increment_bin_wrapping_and_padding.json b/crates/vim/test_data/test_increment_bin_wrapping_and_padding.json
new file mode 100644
index 00000000000000..4f1a6aa1d364b7
--- /dev/null
+++ b/crates/vim/test_data/test_increment_bin_wrapping_and_padding.json
@@ -0,0 +1,10 @@
+{"Put":{"state":"0b111111111111111111111111111111111111111111111111111111111111111111111ˇ1\n"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"0b000000111111111111111111111111111111111111111111111111111111111111111ˇ1\n", "mode":"Normal"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"0b000000000000000000000000000000000000000000000000000000000000000000000ˇ0\n","mode":"Normal"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"0b000000000000000000000000000000000000000000000000000000000000000000000ˇ1\n","mode":"Normal"}}
+{"Key":"2"}
+{"Key":"ctrl-x"}
+{"Get":{"state":"0b000000111111111111111111111111111111111111111111111111111111111111111ˇ1\n", "mode":"Normal"}}
diff --git a/crates/vim/test_data/test_increment_hex_casing.json b/crates/vim/test_data/test_increment_hex_casing.json
new file mode 100644
index 00000000000000..951906fa255578
--- /dev/null
+++ b/crates/vim/test_data/test_increment_hex_casing.json
@@ -0,0 +1,5 @@
+{"Put":{"state":"0xFˇa\n"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"0xfˇb\n","mode":"Normal"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"0xfˇc\n","mode":"Normal"}}
diff --git a/crates/vim/test_data/test_increment_hex_wrapping_and_padding.json b/crates/vim/test_data/test_increment_hex_wrapping_and_padding.json
new file mode 100644
index 00000000000000..23a561126487c6
--- /dev/null
+++ b/crates/vim/test_data/test_increment_hex_wrapping_and_padding.json
@@ -0,0 +1,10 @@
+{"Put":{"state":"0xfffffffffffffffffffˇf\n"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"0x0000fffffffffffffffˇf\n", "mode":"Normal"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"0x0000000000000000000ˇ0\n","mode":"Normal"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"0x0000000000000000000ˇ1\n","mode":"Normal"}}
+{"Key":"2"}
+{"Key":"ctrl-x"}
+{"Get":{"state":"0x0000fffffffffffffffˇf\n", "mode":"Normal"}}
diff --git a/crates/vim/test_data/test_increment_inline.json b/crates/vim/test_data/test_increment_inline.json
new file mode 100644
index 00000000000000..98c4fc28052724
--- /dev/null
+++ b/crates/vim/test_data/test_increment_inline.json
@@ -0,0 +1,10 @@
+{"Put":{"state":"inline0x3ˇ9u32\n"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"inline0x3ˇau32\n","mode":"Normal"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"inline0x3ˇbu32\n", "mode":"Normal"}}
+{"Key":"l"}
+{"Key":"l"}
+{"Key":"l"}
+{"Key":"ctrl-a"}
+{"Get":{"state":"inline0x3bu3ˇ3\n", "mode":"Normal"}}
diff --git a/crates/vim/test_data/test_increment_sign_change.json b/crates/vim/test_data/test_increment_sign_change.json
new file mode 100644
index 00000000000000..1f4edd57b456af
--- /dev/null
+++ b/crates/vim/test_data/test_increment_sign_change.json
@@ -0,0 +1,6 @@
+{"Put":{"state":"ˇ0\n"}}
+{"Key":"ctrl-x"}
+{"Get":{"state":"-ˇ1\n","mode":"Normal"}}
+{"Key":"2"}
+{"Key":"ctrl-a"}
+{"Get":{"state":"ˇ1\n", "mode":"Normal"}}
diff --git a/crates/vim/test_data/test_increment_wrapping.json b/crates/vim/test_data/test_increment_wrapping.json
new file mode 100644
index 00000000000000..9f84c8cb1145d4
--- /dev/null
+++ b/crates/vim/test_data/test_increment_wrapping.json
@@ -0,0 +1,13 @@
+{"Put":{"state":"1844674407370955161ˇ9\n"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"1844674407370955161ˇ5\n","mode":"Normal"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"-1844674407370955161ˇ5\n", "mode":"Normal"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"-1844674407370955161ˇ4\n", "mode":"Normal"}}
+{"Key":"3"}
+{"Key":"ctrl-x"}
+{"Get":{"state":"1844674407370955161ˇ4\n", "mode":"Normal"}}
+{"Key":"2"}
+{"Key":"ctrl-a"}
+{"Get":{"state":"-1844674407370955161ˇ5\n", "mode":"Normal"}}

From 1b612108bae7e4c7ac194e5803b4144fbc218df6 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Thu, 19 Sep 2024 11:40:01 +0200
Subject: [PATCH 202/762] linux: Fix invalid check for denylisted dependencies
 (#18050)

Closes #ISSUE

Release Notes:

- N/A
---
 script/bundle-linux | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/script/bundle-linux b/script/bundle-linux
index deecd0984bece3..c519f3b9abf0da 100755
--- a/script/bundle-linux
+++ b/script/bundle-linux
@@ -56,7 +56,7 @@ strip --strip-debug "${target_dir}/${target_triple}/release/remote_server"
 
 
 # Ensure that remote_server does not depend on libssl nor libcrypto, as we got rid of these deps.
-ldd "${target_dir}/${target_triple}/release/remote_server" | grep -q 'libcrypto\|libssl'
+! ldd "${target_dir}/${target_triple}/release/remote_server" | grep -q 'libcrypto\|libssl'
 
 suffix=""
 if [ "$channel" != "stable" ]; then

From 5e6d1814e5c69d4e2e50d01744f5effe2b92ce70 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 19 Sep 2024 12:22:10 +0200
Subject: [PATCH 203/762] Add stray UI tweaks on the task picker (#18059)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR adds tiny UI tweaks to the task picker. Just making sure it is
consistent with other pickers throughout Zed.

| Before | After |
|--------|--------|
| <img width="577" alt="Screenshot 2024-09-19 at 12 07 44 PM"
src="https://github.com/user-attachments/assets/c0f010a3-6e08-47ee-9997-9df2b203977c">
| <img width="577" alt="Screenshot 2024-09-19 at 12 07 09 PM"
src="https://github.com/user-attachments/assets/74baf191-4dd9-4765-b2fd-2390d4cb31c6">
|

Release Notes:

- N/A
---
 crates/tasks_ui/src/modal.rs | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/crates/tasks_ui/src/modal.rs b/crates/tasks_ui/src/modal.rs
index 1255d3a94e392d..931a0b09c365fb 100644
--- a/crates/tasks_ui/src/modal.rs
+++ b/crates/tasks_ui/src/modal.rs
@@ -410,7 +410,7 @@ impl PickerDelegate for TasksModalDelegate {
 
         Some(
             ListItem::new(SharedString::from(format!("tasks-modal-{ix}")))
-                .inset(false)
+                .inset(true)
                 .start_slot::<Icon>(icon)
                 .end_slot::<AnyElement>(history_run_icon)
                 .spacing(ListItemSpacing::Sparse)
@@ -448,7 +448,7 @@ impl PickerDelegate for TasksModalDelegate {
                                     picker.refresh(cx);
                                 }))
                                 .tooltip(|cx| {
-                                    Tooltip::text("Delete previously scheduled task", cx)
+                                    Tooltip::text("Delete Previously Scheduled Task", cx)
                                 }),
                         );
                         item.end_hover_slot(delete_button)
@@ -499,7 +499,7 @@ impl PickerDelegate for TasksModalDelegate {
             .last_scheduled_task(None)
             .is_some()
         {
-            Some(("Rerun last task", Rerun::default().boxed_clone()))
+            Some(("Rerun Last Task", Rerun::default().boxed_clone()))
         } else {
             None
         };
@@ -511,6 +511,8 @@ impl PickerDelegate for TasksModalDelegate {
                 .justify_between()
                 .rounded_b_md()
                 .bg(cx.theme().colors().ghost_element_selected)
+                .border_t_1()
+                .border_color(cx.theme().colors().border_variant)
                 .child(
                     left_button
                         .map(|(label, action)| {
@@ -535,9 +537,9 @@ impl PickerDelegate for TasksModalDelegate {
                         .boxed_clone();
                         this.children(KeyBinding::for_action(&*action, cx).map(|keybind| {
                             let spawn_oneshot_label = if current_modifiers.secondary() {
-                                "Spawn oneshot without history"
+                                "Spawn Oneshot Without History"
                             } else {
-                                "Spawn oneshot"
+                                "Spawn Oneshot"
                             };
 
                             Button::new("spawn-onehshot", spawn_oneshot_label)
@@ -549,9 +551,9 @@ impl PickerDelegate for TasksModalDelegate {
                         this.children(KeyBinding::for_action(&menu::SecondaryConfirm, cx).map(
                             |keybind| {
                                 let label = if is_recent_selected {
-                                    "Rerun without history"
+                                    "Rerun Without History"
                                 } else {
-                                    "Spawn without history"
+                                    "Spawn Without History"
                                 };
                                 Button::new("spawn", label)
                                     .label_size(LabelSize::Small)

From ca4980df02aa2618ebcb3969963c6fdc8ac23fd7 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Thu, 19 Sep 2024 07:20:27 -0400
Subject: [PATCH 204/762] Add system_id (#18040)

This PR adds `system_id` to telemetry, which is contained within a new
`global` database (accessible by any release channel of Zed on a single
system). This will help us get a more accurate understanding of user
count, instead of relying on `installationd_id`, which is different per
release channel. This doesn't solve the problem of a user with multiple
machines, but it gets us closer.

Release Notes:

- N/A
---
 crates/client/src/telemetry.rs                | 17 ++--
 crates/collab/src/api/events.rs               | 25 ++++--
 crates/db/src/db.rs                           | 68 ++++++++------
 crates/db/src/kvp.rs                          | 30 +++++++
 crates/feedback/src/feedback_modal.rs         |  6 +-
 .../telemetry_events/src/telemetry_events.rs  |  8 +-
 crates/zed/src/main.rs                        | 88 ++++++++++++++-----
 crates/zed/src/reliability.rs                 |  4 +-
 8 files changed, 184 insertions(+), 62 deletions(-)

diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index 46304819a4db5b..6c1803df3d02d5 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -37,9 +37,10 @@ pub struct Telemetry {
 
 struct TelemetryState {
     settings: TelemetrySettings,
-    metrics_id: Option<Arc<str>>,      // Per logged-in user
+    system_id: Option<Arc<str>>,       // Per system
     installation_id: Option<Arc<str>>, // Per app installation (different for dev, nightly, preview, and stable)
     session_id: Option<String>,        // Per app launch
+    metrics_id: Option<Arc<str>>,      // Per logged-in user
     release_channel: Option<&'static str>,
     architecture: &'static str,
     events_queue: Vec<EventWrapper>,
@@ -191,9 +192,10 @@ impl Telemetry {
             settings: *TelemetrySettings::get_global(cx),
             architecture: env::consts::ARCH,
             release_channel,
+            system_id: None,
             installation_id: None,
-            metrics_id: None,
             session_id: None,
+            metrics_id: None,
             events_queue: Vec::new(),
             flush_events_task: None,
             log_file: None,
@@ -283,11 +285,13 @@ impl Telemetry {
 
     pub fn start(
         self: &Arc<Self>,
+        system_id: Option<String>,
         installation_id: Option<String>,
         session_id: String,
         cx: &mut AppContext,
     ) {
         let mut state = self.state.lock();
+        state.system_id = system_id.map(|id| id.into());
         state.installation_id = installation_id.map(|id| id.into());
         state.session_id = Some(session_id);
         state.app_version = release_channel::AppVersion::global(cx).to_string();
@@ -637,9 +641,10 @@ impl Telemetry {
                         let state = this.state.lock();
 
                         let request_body = EventRequestBody {
+                            system_id: state.system_id.as_deref().map(Into::into),
                             installation_id: state.installation_id.as_deref().map(Into::into),
-                            metrics_id: state.metrics_id.as_deref().map(Into::into),
                             session_id: state.session_id.clone(),
+                            metrics_id: state.metrics_id.as_deref().map(Into::into),
                             is_staff: state.is_staff,
                             app_version: state.app_version.clone(),
                             os_name: state.os_name.clone(),
@@ -711,6 +716,7 @@ mod tests {
             Utc.with_ymd_and_hms(1990, 4, 12, 12, 0, 0).unwrap(),
         ));
         let http = FakeHttpClient::with_200_response();
+        let system_id = Some("system_id".to_string());
         let installation_id = Some("installation_id".to_string());
         let session_id = "session_id".to_string();
 
@@ -718,7 +724,7 @@ mod tests {
             let telemetry = Telemetry::new(clock.clone(), http, cx);
 
             telemetry.state.lock().max_queue_size = 4;
-            telemetry.start(installation_id, session_id, cx);
+            telemetry.start(system_id, installation_id, session_id, cx);
 
             assert!(is_empty_state(&telemetry));
 
@@ -796,13 +802,14 @@ mod tests {
             Utc.with_ymd_and_hms(1990, 4, 12, 12, 0, 0).unwrap(),
         ));
         let http = FakeHttpClient::with_200_response();
+        let system_id = Some("system_id".to_string());
         let installation_id = Some("installation_id".to_string());
         let session_id = "session_id".to_string();
 
         cx.update(|cx| {
             let telemetry = Telemetry::new(clock.clone(), http, cx);
             telemetry.state.lock().max_queue_size = 4;
-            telemetry.start(installation_id, session_id, cx);
+            telemetry.start(system_id, installation_id, session_id, cx);
 
             assert!(is_empty_state(&telemetry));
 
diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index 45c25d261e1de8..1be8f9c37b4d09 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -149,7 +149,8 @@ pub async fn post_crash(
         installation_id = %installation_id,
         description = %description,
         backtrace = %summary,
-        "crash report");
+        "crash report"
+    );
 
     if let Some(slack_panics_webhook) = app.config.slack_panics_webhook.clone() {
         let payload = slack::WebhookBody::new(|w| {
@@ -627,7 +628,9 @@ where
 
 #[derive(Serialize, Debug, clickhouse::Row)]
 pub struct EditorEventRow {
+    system_id: String,
     installation_id: String,
+    session_id: Option<String>,
     metrics_id: String,
     operation: String,
     app_version: String,
@@ -647,7 +650,6 @@ pub struct EditorEventRow {
     historical_event: bool,
     architecture: String,
     is_staff: Option<bool>,
-    session_id: Option<String>,
     major: Option<i32>,
     minor: Option<i32>,
     patch: Option<i32>,
@@ -677,9 +679,10 @@ impl EditorEventRow {
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
             architecture: body.architecture.clone(),
+            system_id: body.system_id.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone().unwrap_or_default(),
-            metrics_id: body.metrics_id.clone().unwrap_or_default(),
             session_id: body.session_id.clone(),
+            metrics_id: body.metrics_id.clone().unwrap_or_default(),
             is_staff: body.is_staff,
             time: time.timestamp_millis(),
             operation: event.operation,
@@ -699,6 +702,7 @@ impl EditorEventRow {
 #[derive(Serialize, Debug, clickhouse::Row)]
 pub struct InlineCompletionEventRow {
     installation_id: String,
+    session_id: Option<String>,
     provider: String,
     suggestion_accepted: bool,
     app_version: String,
@@ -713,7 +717,6 @@ pub struct InlineCompletionEventRow {
     city: String,
     time: i64,
     is_staff: Option<bool>,
-    session_id: Option<String>,
     major: Option<i32>,
     minor: Option<i32>,
     patch: Option<i32>,
@@ -879,7 +882,9 @@ impl AssistantEventRow {
 
 #[derive(Debug, clickhouse::Row, Serialize)]
 pub struct CpuEventRow {
+    system_id: Option<String>,
     installation_id: Option<String>,
+    session_id: Option<String>,
     is_staff: Option<bool>,
     usage_as_percentage: f32,
     core_count: u32,
@@ -888,7 +893,6 @@ pub struct CpuEventRow {
     os_name: String,
     os_version: String,
     time: i64,
-    session_id: Option<String>,
     // pub normalized_cpu_usage: f64, MATERIALIZED
     major: Option<i32>,
     minor: Option<i32>,
@@ -917,6 +921,7 @@ impl CpuEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
+            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,
@@ -940,6 +945,7 @@ pub struct MemoryEventRow {
     os_version: String,
 
     // ClientEventBase
+    system_id: Option<String>,
     installation_id: Option<String>,
     session_id: Option<String>,
     is_staff: Option<bool>,
@@ -971,6 +977,7 @@ impl MemoryEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
+            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,
@@ -994,6 +1001,7 @@ pub struct AppEventRow {
     os_version: String,
 
     // ClientEventBase
+    system_id: Option<String>,
     installation_id: Option<String>,
     session_id: Option<String>,
     is_staff: Option<bool>,
@@ -1024,6 +1032,7 @@ impl AppEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
+            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,
@@ -1046,6 +1055,7 @@ pub struct SettingEventRow {
     os_version: String,
 
     // ClientEventBase
+    system_id: Option<String>,
     installation_id: Option<String>,
     session_id: Option<String>,
     is_staff: Option<bool>,
@@ -1076,6 +1086,7 @@ impl SettingEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
+            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,
@@ -1099,6 +1110,7 @@ pub struct ExtensionEventRow {
     os_version: String,
 
     // ClientEventBase
+    system_id: Option<String>,
     installation_id: Option<String>,
     session_id: Option<String>,
     is_staff: Option<bool>,
@@ -1134,6 +1146,7 @@ impl ExtensionEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
+            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,
@@ -1224,6 +1237,7 @@ pub struct EditEventRow {
     os_version: String,
 
     // ClientEventBase
+    system_id: Option<String>,
     installation_id: Option<String>,
     // Note: This column name has a typo in the ClickHouse table.
     #[serde(rename = "sesssion_id")]
@@ -1261,6 +1275,7 @@ impl EditEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
+            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,
diff --git a/crates/db/src/db.rs b/crates/db/src/db.rs
index 768f382203020d..4d87222c773ab1 100644
--- a/crates/db/src/db.rs
+++ b/crates/db/src/db.rs
@@ -11,16 +11,14 @@ pub use smol;
 pub use sqlez;
 pub use sqlez_macros;
 
-use release_channel::ReleaseChannel;
 pub use release_channel::RELEASE_CHANNEL;
 use sqlez::domain::Migrator;
 use sqlez::thread_safe_connection::ThreadSafeConnection;
 use sqlez_macros::sql;
-use std::env;
 use std::future::Future;
 use std::path::Path;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::LazyLock;
+use std::sync::{atomic::Ordering, LazyLock};
+use std::{env, sync::atomic::AtomicBool};
 use util::{maybe, ResultExt};
 
 const CONNECTION_INITIALIZE_QUERY: &str = sql!(
@@ -47,16 +45,12 @@ pub static ALL_FILE_DB_FAILED: LazyLock<AtomicBool> = LazyLock::new(|| AtomicBoo
 /// This will retry a couple times if there are failures. If opening fails once, the db directory
 /// is moved to a backup folder and a new one is created. If that fails, a shared in memory db is created.
 /// In either case, static variables are set so that the user can be notified.
-pub async fn open_db<M: Migrator + 'static>(
-    db_dir: &Path,
-    release_channel: &ReleaseChannel,
-) -> ThreadSafeConnection<M> {
+pub async fn open_db<M: Migrator + 'static>(db_dir: &Path, scope: &str) -> ThreadSafeConnection<M> {
     if *ZED_STATELESS {
         return open_fallback_db().await;
     }
 
-    let release_channel_name = release_channel.dev_name();
-    let main_db_dir = db_dir.join(Path::new(&format!("0-{}", release_channel_name)));
+    let main_db_dir = db_dir.join(format!("0-{}", scope));
 
     let connection = maybe!(async {
         smol::fs::create_dir_all(&main_db_dir)
@@ -118,7 +112,7 @@ pub async fn open_test_db<M: Migrator>(db_name: &str) -> ThreadSafeConnection<M>
 /// Implements a basic DB wrapper for a given domain
 #[macro_export]
 macro_rules! define_connection {
-    (pub static ref $id:ident: $t:ident<()> = $migrations:expr;) => {
+    (pub static ref $id:ident: $t:ident<()> = $migrations:expr; $($global:ident)?) => {
         pub struct $t($crate::sqlez::thread_safe_connection::ThreadSafeConnection<$t>);
 
         impl ::std::ops::Deref for $t {
@@ -139,18 +133,23 @@ macro_rules! define_connection {
             }
         }
 
-        use std::sync::LazyLock;
         #[cfg(any(test, feature = "test-support"))]
-        pub static $id: LazyLock<$t> = LazyLock::new(|| {
+        pub static $id: std::sync::LazyLock<$t> = std::sync::LazyLock::new(|| {
             $t($crate::smol::block_on($crate::open_test_db(stringify!($id))))
         });
 
         #[cfg(not(any(test, feature = "test-support")))]
-        pub static $id: LazyLock<$t> = LazyLock::new(|| {
-            $t($crate::smol::block_on($crate::open_db($crate::database_dir(), &$crate::RELEASE_CHANNEL)))
+        pub static $id: std::sync::LazyLock<$t> = std::sync::LazyLock::new(|| {
+            let db_dir = $crate::database_dir();
+            let scope = if false $(|| stringify!($global) == "global")? {
+                "global"
+            } else {
+                $crate::RELEASE_CHANNEL.dev_name()
+            };
+            $t($crate::smol::block_on($crate::open_db(db_dir, scope)))
         });
     };
-    (pub static ref $id:ident: $t:ident<$($d:ty),+> = $migrations:expr;) => {
+    (pub static ref $id:ident: $t:ident<$($d:ty),+> = $migrations:expr; $($global:ident)?) => {
         pub struct $t($crate::sqlez::thread_safe_connection::ThreadSafeConnection<( $($d),+, $t )>);
 
         impl ::std::ops::Deref for $t {
@@ -178,7 +177,13 @@ macro_rules! define_connection {
 
         #[cfg(not(any(test, feature = "test-support")))]
         pub static $id: std::sync::LazyLock<$t> = std::sync::LazyLock::new(|| {
-            $t($crate::smol::block_on($crate::open_db($crate::database_dir(), &$crate::RELEASE_CHANNEL)))
+            let db_dir = $crate::database_dir();
+            let scope = if false $(|| stringify!($global) == "global")? {
+                "global"
+            } else {
+                $crate::RELEASE_CHANNEL.dev_name()
+            };
+            $t($crate::smol::block_on($crate::open_db(db_dir, scope)))
         });
     };
 }
@@ -225,7 +230,11 @@ mod tests {
             .prefix("DbTests")
             .tempdir()
             .unwrap();
-        let _bad_db = open_db::<BadDB>(tempdir.path(), &release_channel::ReleaseChannel::Dev).await;
+        let _bad_db = open_db::<BadDB>(
+            tempdir.path(),
+            &release_channel::ReleaseChannel::Dev.dev_name(),
+        )
+        .await;
     }
 
     /// Test that DB exists but corrupted (causing recreate)
@@ -262,13 +271,19 @@ mod tests {
             .tempdir()
             .unwrap();
         {
-            let corrupt_db =
-                open_db::<CorruptedDB>(tempdir.path(), &release_channel::ReleaseChannel::Dev).await;
+            let corrupt_db = open_db::<CorruptedDB>(
+                tempdir.path(),
+                &release_channel::ReleaseChannel::Dev.dev_name(),
+            )
+            .await;
             assert!(corrupt_db.persistent());
         }
 
-        let good_db =
-            open_db::<GoodDB>(tempdir.path(), &release_channel::ReleaseChannel::Dev).await;
+        let good_db = open_db::<GoodDB>(
+            tempdir.path(),
+            &release_channel::ReleaseChannel::Dev.dev_name(),
+        )
+        .await;
         assert!(
             good_db.select_row::<usize>("SELECT * FROM test2").unwrap()()
                 .unwrap()
@@ -311,8 +326,11 @@ mod tests {
             .unwrap();
         {
             // Setup the bad database
-            let corrupt_db =
-                open_db::<CorruptedDB>(tempdir.path(), &release_channel::ReleaseChannel::Dev).await;
+            let corrupt_db = open_db::<CorruptedDB>(
+                tempdir.path(),
+                &release_channel::ReleaseChannel::Dev.dev_name(),
+            )
+            .await;
             assert!(corrupt_db.persistent());
         }
 
@@ -323,7 +341,7 @@ mod tests {
             let guard = thread::spawn(move || {
                 let good_db = smol::block_on(open_db::<GoodDB>(
                     tmp_path.as_path(),
-                    &release_channel::ReleaseChannel::Dev,
+                    &release_channel::ReleaseChannel::Dev.dev_name(),
                 ));
                 assert!(
                     good_db.select_row::<usize>("SELECT * FROM test2").unwrap()()
diff --git a/crates/db/src/kvp.rs b/crates/db/src/kvp.rs
index 0b0cdd9aa11177..c9d994d34da7d1 100644
--- a/crates/db/src/kvp.rs
+++ b/crates/db/src/kvp.rs
@@ -60,3 +60,33 @@ mod tests {
         assert_eq!(db.read_kvp("key-1").unwrap(), None);
     }
 }
+
+define_connection!(pub static ref GLOBAL_KEY_VALUE_STORE: GlobalKeyValueStore<()> =
+    &[sql!(
+        CREATE TABLE IF NOT EXISTS kv_store(
+            key TEXT PRIMARY KEY,
+            value TEXT NOT NULL
+        ) STRICT;
+    )];
+    global
+);
+
+impl GlobalKeyValueStore {
+    query! {
+        pub fn read_kvp(key: &str) -> Result<Option<String>> {
+            SELECT value FROM kv_store WHERE key = (?)
+        }
+    }
+
+    query! {
+        pub async fn write_kvp(key: String, value: String) -> Result<()> {
+            INSERT OR REPLACE INTO kv_store(key, value) VALUES ((?), (?))
+        }
+    }
+
+    query! {
+        pub async fn delete_kvp(key: String) -> Result<()> {
+            DELETE FROM kv_store WHERE key = (?)
+        }
+    }
+}
diff --git a/crates/feedback/src/feedback_modal.rs b/crates/feedback/src/feedback_modal.rs
index 7369bcd8530c45..a4a07ad2ad44d0 100644
--- a/crates/feedback/src/feedback_modal.rs
+++ b/crates/feedback/src/feedback_modal.rs
@@ -44,8 +44,8 @@ const FEEDBACK_SUBMISSION_ERROR_TEXT: &str =
 struct FeedbackRequestBody<'a> {
     feedback_text: &'a str,
     email: Option<String>,
-    metrics_id: Option<Arc<str>>,
     installation_id: Option<Arc<str>>,
+    metrics_id: Option<Arc<str>>,
     system_specs: SystemSpecs,
     is_staff: bool,
 }
@@ -296,16 +296,16 @@ impl FeedbackModal {
         }
 
         let telemetry = zed_client.telemetry();
-        let metrics_id = telemetry.metrics_id();
         let installation_id = telemetry.installation_id();
+        let metrics_id = telemetry.metrics_id();
         let is_staff = telemetry.is_staff();
         let http_client = zed_client.http_client();
         let feedback_endpoint = http_client.build_url("/api/feedback");
         let request = FeedbackRequestBody {
             feedback_text,
             email,
-            metrics_id,
             installation_id,
+            metrics_id,
             system_specs,
             is_staff: is_staff.unwrap_or(false),
         };
diff --git a/crates/telemetry_events/src/telemetry_events.rs b/crates/telemetry_events/src/telemetry_events.rs
index eb84322e83d94c..d6e737b929e1f5 100644
--- a/crates/telemetry_events/src/telemetry_events.rs
+++ b/crates/telemetry_events/src/telemetry_events.rs
@@ -5,12 +5,14 @@ use std::{fmt::Display, sync::Arc, time::Duration};
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct EventRequestBody {
+    /// Identifier unique to each system Zed is installed on
+    pub system_id: Option<String>,
     /// Identifier unique to each Zed installation (differs for stable, preview, dev)
     pub installation_id: Option<String>,
     /// Identifier unique to each logged in Zed user (randomly generated on first sign in)
-    pub metrics_id: Option<String>,
     /// Identifier unique to each Zed session (differs for each time you open Zed)
     pub session_id: Option<String>,
+    pub metrics_id: Option<String>,
     /// True for Zed staff, otherwise false
     pub is_staff: Option<bool>,
     /// Zed version number
@@ -34,6 +36,7 @@ pub struct EventWrapper {
     pub signed_in: bool,
     /// Duration between this event's timestamp and the timestamp of the first event in the current batch
     pub milliseconds_since_first_event: i64,
+    /// The event itself
     #[serde(flatten)]
     pub event: Event,
 }
@@ -245,8 +248,11 @@ pub struct Panic {
     pub architecture: String,
     /// The time the panic occurred (UNIX millisecond timestamp)
     pub panicked_on: i64,
+    /// Identifier unique to each system Zed is installed on
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub system_id: Option<String>,
     /// Identifier unique to each Zed installation (differs for stable, preview, dev)
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub installation_id: Option<String>,
     /// Identifier unique to each Zed session (differs for each time you open Zed)
     pub session_id: String,
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index d3a722ec657898..c127a975a95e89 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -13,7 +13,7 @@ use clap::{command, Parser};
 use cli::FORCE_CLI_MODE_ENV_VAR_NAME;
 use client::{parse_zed_link, Client, DevServerToken, ProxySettings, UserStore};
 use collab_ui::channel_view::ChannelView;
-use db::kvp::KEY_VALUE_STORE;
+use db::kvp::{GLOBAL_KEY_VALUE_STORE, KEY_VALUE_STORE};
 use editor::Editor;
 use env_logger::Builder;
 use fs::{Fs, RealFs};
@@ -334,19 +334,17 @@ fn main() {
         .with_assets(Assets)
         .with_http_client(IsahcHttpClient::new(None, None));
 
-    let (installation_id, existing_installation_id_found) = app
-        .background_executor()
-        .block(installation_id())
-        .ok()
-        .unzip();
-
+    let system_id = app.background_executor().block(system_id()).ok();
+    let installation_id = app.background_executor().block(installation_id()).ok();
+    let session_id = Uuid::new_v4().to_string();
     let session = app.background_executor().block(Session::new());
-
     let app_version = AppVersion::init(env!("CARGO_PKG_VERSION"));
+
     reliability::init_panic_hook(
-        installation_id.clone(),
         app_version,
-        session.id().to_owned(),
+        system_id.as_ref().map(|id| id.to_string()),
+        installation_id.as_ref().map(|id| id.to_string()),
+        session_id.clone(),
     );
 
     let (open_listener, mut open_rx) = OpenListener::new();
@@ -491,14 +489,26 @@ fn main() {
         client::init(&client, cx);
         language::init(cx);
         let telemetry = client.telemetry();
-        telemetry.start(installation_id.clone(), session.id().to_owned(), cx);
-        telemetry.report_app_event(
-            match existing_installation_id_found {
-                Some(false) => "first open",
-                _ => "open",
-            }
-            .to_string(),
+        telemetry.start(
+            system_id.as_ref().map(|id| id.to_string()),
+            installation_id.as_ref().map(|id| id.to_string()),
+            session_id,
+            cx,
         );
+        if let (Some(system_id), Some(installation_id)) = (&system_id, &installation_id) {
+            match (&system_id, &installation_id) {
+                (IdType::New(_), IdType::New(_)) => {
+                    telemetry.report_app_event("first open".to_string());
+                    telemetry.report_app_event("first open for release channel".to_string());
+                }
+                (IdType::Existing(_), IdType::New(_)) => {
+                    telemetry.report_app_event("first open for release channel".to_string());
+                }
+                (_, IdType::Existing(_)) => {
+                    telemetry.report_app_event("open".to_string());
+                }
+            }
+        }
         let app_session = cx.new_model(|cx| AppSession::new(session, cx));
 
         let app_state = Arc::new(AppState {
@@ -514,7 +524,11 @@ fn main() {
         AppState::set_global(Arc::downgrade(&app_state), cx);
 
         auto_update::init(client.http_client(), cx);
-        reliability::init(client.http_client(), installation_id, cx);
+        reliability::init(
+            client.http_client(),
+            installation_id.clone().map(|id| id.to_string()),
+            cx,
+        );
         let prompt_builder = init_common(app_state.clone(), cx);
 
         let args = Args::parse();
@@ -755,7 +769,23 @@ async fn authenticate(client: Arc<Client>, cx: &AsyncAppContext) -> Result<()> {
     Ok::<_, anyhow::Error>(())
 }
 
-async fn installation_id() -> Result<(String, bool)> {
+async fn system_id() -> Result<IdType> {
+    let key_name = "system_id".to_string();
+
+    if let Ok(Some(system_id)) = GLOBAL_KEY_VALUE_STORE.read_kvp(&key_name) {
+        return Ok(IdType::Existing(system_id));
+    }
+
+    let system_id = Uuid::new_v4().to_string();
+
+    GLOBAL_KEY_VALUE_STORE
+        .write_kvp(key_name, system_id.clone())
+        .await?;
+
+    Ok(IdType::New(system_id))
+}
+
+async fn installation_id() -> Result<IdType> {
     let legacy_key_name = "device_id".to_string();
     let key_name = "installation_id".to_string();
 
@@ -765,11 +795,11 @@ async fn installation_id() -> Result<(String, bool)> {
             .write_kvp(key_name, installation_id.clone())
             .await?;
         KEY_VALUE_STORE.delete_kvp(legacy_key_name).await?;
-        return Ok((installation_id, true));
+        return Ok(IdType::Existing(installation_id));
     }
 
     if let Ok(Some(installation_id)) = KEY_VALUE_STORE.read_kvp(&key_name) {
-        return Ok((installation_id, true));
+        return Ok(IdType::Existing(installation_id));
     }
 
     let installation_id = Uuid::new_v4().to_string();
@@ -778,7 +808,7 @@ async fn installation_id() -> Result<(String, bool)> {
         .write_kvp(key_name, installation_id.clone())
         .await?;
 
-    Ok((installation_id, false))
+    Ok(IdType::New(installation_id))
 }
 
 async fn restore_or_create_workspace(
@@ -1087,6 +1117,20 @@ struct Args {
     dev_server_token: Option<String>,
 }
 
+#[derive(Clone, Debug)]
+enum IdType {
+    New(String),
+    Existing(String),
+}
+
+impl ToString for IdType {
+    fn to_string(&self) -> String {
+        match self {
+            IdType::New(id) | IdType::Existing(id) => id.clone(),
+        }
+    }
+}
+
 fn parse_url_arg(arg: &str, cx: &AppContext) -> Result<String> {
     match std::fs::canonicalize(Path::new(&arg)) {
         Ok(path) => Ok(format!(
diff --git a/crates/zed/src/reliability.rs b/crates/zed/src/reliability.rs
index 188cf417f7c38b..9e811d7c9afbb4 100644
--- a/crates/zed/src/reliability.rs
+++ b/crates/zed/src/reliability.rs
@@ -28,8 +28,9 @@ use crate::stdout_is_a_pty;
 static PANIC_COUNT: AtomicU32 = AtomicU32::new(0);
 
 pub fn init_panic_hook(
-    installation_id: Option<String>,
     app_version: SemanticVersion,
+    system_id: Option<String>,
+    installation_id: Option<String>,
     session_id: String,
 ) {
     let is_pty = stdout_is_a_pty();
@@ -102,6 +103,7 @@ pub fn init_panic_hook(
             architecture: env::consts::ARCH.into(),
             panicked_on: Utc::now().timestamp_millis(),
             backtrace,
+            system_id: system_id.clone(),
             installation_id: installation_id.clone(),
             session_id: session_id.clone(),
         };

From 1723713dc292074e558935b9f5c81eac7938c396 Mon Sep 17 00:00:00 2001
From: thataboy <dearbart@yahoo.com>
Date: Thu, 19 Sep 2024 04:43:49 -0700
Subject: [PATCH 205/762] Add ability to copy assistant code block to clipboard
 or insert into editor, without manual selection (#17853)

Some notes:

- You can put the cursor on the start or end line with triple backticks,
it doesn't actually have to be inside the block.
- Placing the cursor outside of a code block does nothing.
- Code blocks are determined by counting triple backticks pairs from
either start or end of buffer, and nothing else.
- If you manually select something, the selection takes precedence over
any code blocks.

Release Notes:

- Added the ability to copy surrounding code blocks in the assistant
panel into the clipboard, or inserting them directly into the editor,
without manually selecting. Place cursor anywhere in a code block
(marked by triple backticks) and use the `assistant::CopyCode` action
(`cmd-k c` / `ctrl-k c`) to copy to the clipboard, or the
`assistant::InsertIntoEditor` action (`cmd-<` / `ctrl-<`) to insert into
editor.

---------

Co-authored-by: Thorsten Ball <mrnugget@gmail.com>
Co-authored-by: Bennet <bennet@zed.dev>
---
 Cargo.lock                              |   2 +
 assets/keymaps/default-linux.json       |   1 +
 assets/keymaps/default-macos.json       |   1 +
 crates/assistant/Cargo.toml             |   2 +
 crates/assistant/src/assistant.rs       |   1 +
 crates/assistant/src/assistant_panel.rs | 218 ++++++++++++++++++++++--
 6 files changed, 207 insertions(+), 18 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 652c584fd53795..a37a5350f55eab 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -402,6 +402,7 @@ dependencies = [
  "indoc",
  "language",
  "language_model",
+ "languages",
  "log",
  "markdown",
  "menu",
@@ -436,6 +437,7 @@ dependencies = [
  "text",
  "theme",
  "toml 0.8.19",
+ "tree-sitter-md",
  "ui",
  "unindent",
  "util",
diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index 02fc6d8e04da8a..542f6c2df42b48 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -166,6 +166,7 @@
   {
     "context": "AssistantPanel",
     "bindings": {
+      "ctrl-k c": "assistant::CopyCode",
       "ctrl-g": "search::SelectNextMatch",
       "ctrl-shift-g": "search::SelectPrevMatch",
       "alt-m": "assistant::ToggleModelSelector",
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index 33536cc9ff9e4b..77fac3254bec17 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -188,6 +188,7 @@
   {
     "context": "AssistantPanel",
     "bindings": {
+      "cmd-k c": "assistant::CopyCode",
       "cmd-g": "search::SelectNextMatch",
       "cmd-shift-g": "search::SelectPrevMatch",
       "alt-m": "assistant::ToggleModelSelector",
diff --git a/crates/assistant/Cargo.toml b/crates/assistant/Cargo.toml
index b700702062c0a7..9f715d822474d2 100644
--- a/crates/assistant/Cargo.toml
+++ b/crates/assistant/Cargo.toml
@@ -94,9 +94,11 @@ editor = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
 language = { workspace = true, features = ["test-support"] }
 language_model = { workspace = true, features = ["test-support"] }
+languages = { workspace = true, features = ["test-support"] }
 log.workspace = true
 project = { workspace = true, features = ["test-support"] }
 rand.workspace = true
 serde_json_lenient.workspace = true
 text = { workspace = true, features = ["test-support"] }
+tree-sitter-md.workspace = true
 unindent.workspace = true
diff --git a/crates/assistant/src/assistant.rs b/crates/assistant/src/assistant.rs
index af7f03ebb35264..d7466878c9ce1e 100644
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -58,6 +58,7 @@ actions!(
     [
         Assist,
         Split,
+        CopyCode,
         CycleMessageRole,
         QuoteSelection,
         InsertIntoEditor,
diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 5d06720fe0095b..094d187df29789 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -12,11 +12,11 @@ use crate::{
     slash_command_picker,
     terminal_inline_assistant::TerminalInlineAssistant,
     Assist, CacheStatus, ConfirmCommand, Content, Context, ContextEvent, ContextId, ContextStore,
-    ContextStoreEvent, CycleMessageRole, DeployHistory, DeployPromptLibrary, InlineAssistId,
-    InlineAssistant, InsertDraggedFiles, InsertIntoEditor, Message, MessageId, MessageMetadata,
-    MessageStatus, ModelPickerDelegate, ModelSelector, NewContext, PendingSlashCommand,
-    PendingSlashCommandStatus, QuoteSelection, RemoteContextMetadata, SavedContextMetadata, Split,
-    ToggleFocus, ToggleModelSelector, WorkflowStepResolution,
+    ContextStoreEvent, CopyCode, CycleMessageRole, DeployHistory, DeployPromptLibrary,
+    InlineAssistId, InlineAssistant, InsertDraggedFiles, InsertIntoEditor, Message, MessageId,
+    MessageMetadata, MessageStatus, ModelPickerDelegate, ModelSelector, NewContext,
+    PendingSlashCommand, PendingSlashCommandStatus, QuoteSelection, RemoteContextMetadata,
+    SavedContextMetadata, Split, ToggleFocus, ToggleModelSelector, WorkflowStepResolution,
 };
 use anyhow::{anyhow, Result};
 use assistant_slash_command::{SlashCommand, SlashCommandOutputSection};
@@ -45,7 +45,8 @@ use gpui::{
 };
 use indexed_docs::IndexedDocsStore;
 use language::{
-    language_settings::SoftWrap, Capability, LanguageRegistry, LspAdapterDelegate, Point, ToOffset,
+    language_settings::SoftWrap, BufferSnapshot, Capability, LanguageRegistry, LspAdapterDelegate,
+    ToOffset,
 };
 use language_model::{
     provider::cloud::PROVIDER_ID, LanguageModelProvider, LanguageModelProviderId,
@@ -56,6 +57,7 @@ use multi_buffer::MultiBufferRow;
 use picker::{Picker, PickerDelegate};
 use project::lsp_store::LocalLspAdapterDelegate;
 use project::{Project, Worktree};
+use rope::Point;
 use search::{buffer_search::DivRegistrar, BufferSearchBar};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings};
@@ -81,9 +83,10 @@ use util::{maybe, ResultExt};
 use workspace::{
     dock::{DockPosition, Panel, PanelEvent},
     item::{self, FollowableItem, Item, ItemHandle},
+    notifications::NotificationId,
     pane::{self, SaveIntent},
     searchable::{SearchEvent, SearchableItem},
-    DraggedSelection, Pane, Save, ShowConfiguration, ToggleZoom, ToolbarItemEvent,
+    DraggedSelection, Pane, Save, ShowConfiguration, Toast, ToggleZoom, ToolbarItemEvent,
     ToolbarItemLocation, ToolbarItemView, Workspace,
 };
 use workspace::{searchable::SearchableItemHandle, DraggedTab};
@@ -105,6 +108,7 @@ pub fn init(cx: &mut AppContext) {
                 .register_action(AssistantPanel::inline_assist)
                 .register_action(ContextEditor::quote_selection)
                 .register_action(ContextEditor::insert_selection)
+                .register_action(ContextEditor::copy_code)
                 .register_action(ContextEditor::insert_dragged_files)
                 .register_action(AssistantPanel::show_configuration)
                 .register_action(AssistantPanel::create_new_context);
@@ -3100,6 +3104,40 @@ impl ContextEditor {
         });
     }
 
+    /// Returns either the selected text, or the content of the Markdown code
+    /// block surrounding the cursor.
+    fn get_selection_or_code_block(
+        context_editor_view: &View<ContextEditor>,
+        cx: &mut ViewContext<Workspace>,
+    ) -> Option<(String, bool)> {
+        let context_editor = context_editor_view.read(cx).editor.read(cx);
+
+        if context_editor.selections.newest::<Point>(cx).is_empty() {
+            let snapshot = context_editor.buffer().read(cx).snapshot(cx);
+            let (_, _, snapshot) = snapshot.as_singleton()?;
+
+            let head = context_editor.selections.newest::<Point>(cx).head();
+            let offset = snapshot.point_to_offset(head);
+
+            let surrounding_code_block_range = find_surrounding_code_block(snapshot, offset)?;
+            let text = snapshot
+                .text_for_range(surrounding_code_block_range)
+                .collect::<String>();
+
+            (!text.is_empty()).then_some((text, true))
+        } else {
+            let anchor = context_editor.selections.newest_anchor();
+            let text = context_editor
+                .buffer()
+                .read(cx)
+                .read(cx)
+                .text_for_range(anchor.range())
+                .collect::<String>();
+
+            (!text.is_empty()).then_some((text, false))
+        }
+    }
+
     fn insert_selection(
         workspace: &mut Workspace,
         _: &InsertIntoEditor,
@@ -3118,17 +3156,7 @@ impl ContextEditor {
             return;
         };
 
-        let context_editor = context_editor_view.read(cx).editor.read(cx);
-        let anchor = context_editor.selections.newest_anchor();
-        let text = context_editor
-            .buffer()
-            .read(cx)
-            .read(cx)
-            .text_for_range(anchor.range())
-            .collect::<String>();
-
-        // If nothing is selected, don't delete the current selection; instead, be a no-op.
-        if !text.is_empty() {
+        if let Some((text, _)) = Self::get_selection_or_code_block(&context_editor_view, cx) {
             active_editor_view.update(cx, |editor, cx| {
                 editor.insert(&text, cx);
                 editor.focus(cx);
@@ -3136,6 +3164,36 @@ impl ContextEditor {
         }
     }
 
+    fn copy_code(workspace: &mut Workspace, _: &CopyCode, cx: &mut ViewContext<Workspace>) {
+        let result = maybe!({
+            let panel = workspace.panel::<AssistantPanel>(cx)?;
+            let context_editor_view = panel.read(cx).active_context_editor(cx)?;
+            Self::get_selection_or_code_block(&context_editor_view, cx)
+        });
+        let Some((text, is_code_block)) = result else {
+            return;
+        };
+
+        cx.write_to_clipboard(ClipboardItem::new_string(text));
+
+        struct CopyToClipboardToast;
+        workspace.show_toast(
+            Toast::new(
+                NotificationId::unique::<CopyToClipboardToast>(),
+                format!(
+                    "{} copied to clipboard.",
+                    if is_code_block {
+                        "Code block"
+                    } else {
+                        "Selection"
+                    }
+                ),
+            )
+            .autohide(),
+            cx,
+        );
+    }
+
     fn insert_dragged_files(
         workspace: &mut Workspace,
         action: &InsertDraggedFiles,
@@ -4215,6 +4273,48 @@ impl ContextEditor {
     }
 }
 
+/// Returns the contents of the *outermost* fenced code block that contains the given offset.
+fn find_surrounding_code_block(snapshot: &BufferSnapshot, offset: usize) -> Option<Range<usize>> {
+    const CODE_BLOCK_NODE: &'static str = "fenced_code_block";
+    const CODE_BLOCK_CONTENT: &'static str = "code_fence_content";
+
+    let layer = snapshot.syntax_layers().next()?;
+
+    let root_node = layer.node();
+    let mut cursor = root_node.walk();
+
+    // Go to the first child for the given offset
+    while cursor.goto_first_child_for_byte(offset).is_some() {
+        // If we're at the end of the node, go to the next one.
+        // Example: if you have a fenced-code-block, and you're on the start of the line
+        // right after the closing ```, you want to skip the fenced-code-block and
+        // go to the next sibling.
+        if cursor.node().end_byte() == offset {
+            cursor.goto_next_sibling();
+        }
+
+        if cursor.node().start_byte() > offset {
+            break;
+        }
+
+        // We found the fenced code block.
+        if cursor.node().kind() == CODE_BLOCK_NODE {
+            // Now we need to find the child node that contains the code.
+            cursor.goto_first_child();
+            loop {
+                if cursor.node().kind() == CODE_BLOCK_CONTENT {
+                    return Some(cursor.node().byte_range());
+                }
+                if !cursor.goto_next_sibling() {
+                    break;
+                }
+            }
+        }
+    }
+
+    None
+}
+
 fn render_fold_icon_button(
     editor: WeakView<Editor>,
     icon: IconName,
@@ -5497,3 +5597,85 @@ fn configuration_error(cx: &AppContext) -> Option<ConfigurationError> {
 
     None
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gpui::{AppContext, Context};
+    use language::Buffer;
+    use unindent::Unindent;
+
+    #[gpui::test]
+    fn test_find_code_blocks(cx: &mut AppContext) {
+        let markdown = languages::language("markdown", tree_sitter_md::LANGUAGE.into());
+
+        let buffer = cx.new_model(|cx| {
+            let text = r#"
+                line 0
+                line 1
+                ```rust
+                fn main() {}
+                ```
+                line 5
+                line 6
+                line 7
+                ```go
+                func main() {}
+                ```
+                line 11
+                ```
+                this is plain text code block
+                ```
+
+                ```go
+                func another() {}
+                ```
+                line 19
+            "#
+            .unindent();
+            let mut buffer = Buffer::local(text, cx);
+            buffer.set_language(Some(markdown.clone()), cx);
+            buffer
+        });
+        let snapshot = buffer.read(cx).snapshot();
+
+        let code_blocks = vec![
+            Point::new(3, 0)..Point::new(4, 0),
+            Point::new(9, 0)..Point::new(10, 0),
+            Point::new(13, 0)..Point::new(14, 0),
+            Point::new(17, 0)..Point::new(18, 0),
+        ]
+        .into_iter()
+        .map(|range| snapshot.point_to_offset(range.start)..snapshot.point_to_offset(range.end))
+        .collect::<Vec<_>>();
+
+        let expected_results = vec![
+            (0, None),
+            (1, None),
+            (2, Some(code_blocks[0].clone())),
+            (3, Some(code_blocks[0].clone())),
+            (4, Some(code_blocks[0].clone())),
+            (5, None),
+            (6, None),
+            (7, None),
+            (8, Some(code_blocks[1].clone())),
+            (9, Some(code_blocks[1].clone())),
+            (10, Some(code_blocks[1].clone())),
+            (11, None),
+            (12, Some(code_blocks[2].clone())),
+            (13, Some(code_blocks[2].clone())),
+            (14, Some(code_blocks[2].clone())),
+            (15, None),
+            (16, Some(code_blocks[3].clone())),
+            (17, Some(code_blocks[3].clone())),
+            (18, Some(code_blocks[3].clone())),
+            (19, None),
+        ];
+
+        for (row, expected) in expected_results {
+            let offset = snapshot.point_to_offset(Point::new(row, 0));
+            let range = find_surrounding_code_block(&snapshot, offset);
+            assert_eq!(range, expected, "unexpected result on row {:?}", row);
+        }
+    }
+}

From 23e1faa48524f55c5a9a2c7be084d730667abecb Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 19 Sep 2024 14:43:56 +0200
Subject: [PATCH 206/762] assistant panel: Fix copying code when trailing
 newline is missing (#18067)

Follow-up to #17853.

Apparently tree-sitter-md extends the range of the content node to
include the backticks when there is no newline.

Release Notes:

- N/A

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/assistant/src/assistant_panel.rs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 094d187df29789..da176ebeee61e0 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -3110,6 +3110,8 @@ impl ContextEditor {
         context_editor_view: &View<ContextEditor>,
         cx: &mut ViewContext<Workspace>,
     ) -> Option<(String, bool)> {
+        const CODE_FENCE_DELIMITER: &'static str = "```";
+
         let context_editor = context_editor_view.read(cx).editor.read(cx);
 
         if context_editor.selections.newest::<Point>(cx).is_empty() {
@@ -3120,10 +3122,17 @@ impl ContextEditor {
             let offset = snapshot.point_to_offset(head);
 
             let surrounding_code_block_range = find_surrounding_code_block(snapshot, offset)?;
-            let text = snapshot
+            let mut text = snapshot
                 .text_for_range(surrounding_code_block_range)
                 .collect::<String>();
 
+            // If there is no newline trailing the closing three-backticks, then
+            // tree-sitter-md extends the range of the content node to include
+            // the backticks.
+            if text.ends_with(CODE_FENCE_DELIMITER) {
+                text.drain((text.len() - CODE_FENCE_DELIMITER.len())..);
+            }
+
             (!text.is_empty()).then_some((text, true))
         } else {
             let anchor = context_editor.selections.newest_anchor();

From 4338ff6be496edcdd86d5b97284f3a5ba9e140c2 Mon Sep 17 00:00:00 2001
From: Casey Watson <watsoncj@gmail.com>
Date: Thu, 19 Sep 2024 07:01:28 -0600
Subject: [PATCH 207/762] terminal: Add ability to open file from Git diff
 (#17446)

- strip "a/" and "b/" prefix for potential paths.

Release Notes:

- Allow clicking on filepaths when using `git diff` inside the built-in
terminal
---
 crates/terminal_view/src/terminal_view.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs
index f19bfa70101ce3..e0b92035d107b3 100644
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -58,6 +58,8 @@ const REGEX_SPECIAL_CHARS: &[char] = &[
 
 const CURSOR_BLINK_INTERVAL: Duration = Duration::from_millis(500);
 
+const GIT_DIFF_PATH_PREFIXES: &[char] = &['a', 'b'];
+
 ///Event to transmit the scroll from the element to the view
 #[derive(Clone, Debug, PartialEq)]
 pub struct ScrollTerminal(pub i32);
@@ -826,6 +828,19 @@ fn possible_open_targets(
                 {
                     potential_cwd_and_workspace_paths.insert(potential_worktree_path);
                 }
+
+                for prefix in GIT_DIFF_PATH_PREFIXES {
+                    let prefix_str = &prefix.to_string();
+                    if maybe_path.starts_with(prefix_str) {
+                        let stripped = maybe_path.strip_prefix(prefix_str).unwrap_or(&maybe_path);
+                        for potential_worktree_path in workspace
+                            .worktrees(cx)
+                            .map(|worktree| worktree.read(cx).abs_path().join(&stripped))
+                        {
+                            potential_cwd_and_workspace_paths.insert(potential_worktree_path);
+                        }
+                    }
+                }
             });
         }
 

From 3d5c023fdae99907cf7cf9e67f7ae20bd7bd080c Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 19 Sep 2024 09:55:51 -0400
Subject: [PATCH 208/762] ci: Move collab deploys back to DigitalOcean runners
 (#18071)

This PR moves the collab deployment steps in CI back to the DigitalOcean
runners temporarily, so that we can deploy collab.

Release Notes:

- N/A
---
 .github/workflows/deploy_collab.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/deploy_collab.yml b/.github/workflows/deploy_collab.yml
index 7abd52e5a60dd3..6801be2a5494cd 100644
--- a/.github/workflows/deploy_collab.yml
+++ b/.github/workflows/deploy_collab.yml
@@ -61,7 +61,8 @@ jobs:
       - style
       - tests
     runs-on:
-      - buildjet-16vcpu-ubuntu-2204
+      - self-hosted
+      - deploy
     steps:
       - name: Add Rust to the PATH
         run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
@@ -88,7 +89,8 @@ jobs:
     needs:
       - publish
     runs-on:
-      - buildjet-16vcpu-ubuntu-2204
+      - self-hosted
+      - deploy
 
     steps:
       - name: Sign into Kubernetes

From d91e62524f7c6437349426687ded6d1182ad7346 Mon Sep 17 00:00:00 2001
From: CharlesChen0823 <yongchen0823@gmail.com>
Date: Thu, 19 Sep 2024 22:41:42 +0800
Subject: [PATCH 209/762] assistant: Fix offset calculation not in char
 boundary (#18069)

Closes #17825

Release Notes:

- N/A
---
 crates/assistant/src/prompts.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/assistant/src/prompts.rs b/crates/assistant/src/prompts.rs
index 83e894f7978746..ae2ab4787e6f40 100644
--- a/crates/assistant/src/prompts.rs
+++ b/crates/assistant/src/prompts.rs
@@ -220,7 +220,8 @@ impl PromptBuilder {
         let before_range = 0..range.start;
         let truncated_before = if before_range.len() > MAX_CTX {
             is_truncated = true;
-            range.start - MAX_CTX..range.start
+            let start = buffer.clip_offset(range.start - MAX_CTX, text::Bias::Right);
+            start..range.start
         } else {
             before_range
         };
@@ -228,7 +229,8 @@ impl PromptBuilder {
         let after_range = range.end..buffer.len();
         let truncated_after = if after_range.len() > MAX_CTX {
             is_truncated = true;
-            range.end..range.end + MAX_CTX
+            let end = buffer.clip_offset(range.end + MAX_CTX, text::Bias::Left);
+            range.end..end
         } else {
             after_range
         };

From d2894ce9c99586e9cd0588fa9b4db27bbd64f0ca Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Thu, 19 Sep 2024 17:00:26 +0200
Subject: [PATCH 210/762] pane: Do not autopin new item created as a neighbour
 of pinned tab (#18072)

When I used editor::NewFile or ProjectSearch from a pinned tab, the
resulting new tab would be pinned (and the last pinned tab would be
pushed off). This PR fixes it by always storing new tabs outside of the
pinned area if there's no destination index for the new tab.

Release Notes:

- Fixed tab bar not preserving pinned tab state when an editor::NewFile
action is executed.
---
 crates/workspace/src/pane.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index 09b4683c0c5552..a5f83f961f0400 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -831,13 +831,14 @@ impl Pane {
                 }
             }
         }
-        // If no destination index is specified, add or move the item after the active item.
+        // If no destination index is specified, add or move the item after the
+        // active item (or at the start of tab bar, if the active item is pinned)
         let mut insertion_index = {
             cmp::min(
                 if let Some(destination_index) = destination_index {
                     destination_index
                 } else {
-                    self.active_item_index + 1
+                    cmp::max(self.active_item_index + 1, self.pinned_count())
                 },
                 self.items.len(),
             )

From a944bb2f24bea7e492ced79fe0e92a7205d6f42e Mon Sep 17 00:00:00 2001
From: Joseph T Lyons <JosephTLyons@gmail.com>
Date: Thu, 19 Sep 2024 11:02:44 -0400
Subject: [PATCH 211/762] v0.155.x dev

---
 Cargo.lock            | 2 +-
 crates/zed/Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a37a5350f55eab..ca5d68881ffb3f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14375,7 +14375,7 @@ dependencies = [
 
 [[package]]
 name = "zed"
-version = "0.154.0"
+version = "0.155.0"
 dependencies = [
  "activity_indicator",
  "anyhow",
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index 645d12fc76a350..ad2e7cd48c67d8 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -2,7 +2,7 @@
 description = "The fast, collaborative code editor."
 edition = "2021"
 name = "zed"
-version = "0.154.0"
+version = "0.155.0"
 publish = false
 license = "GPL-3.0-or-later"
 authors = ["Zed Team <hi@zed.dev>"]

From 7d0a7541bfd1ca44a7511ec077067902b0e461ef Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 19 Sep 2024 11:45:06 -0400
Subject: [PATCH 212/762] ci: Fix collab deploys (#18077)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR fixes issues with deploying collab.

We reverted 4882a75971abafa89467e779466749086d7d3f96—as the DigitalOcean
runners are gone now—and moved back to BuildJet.

We needed to make some changes to the deployment jobs to setup `doctl`.

This PR also adds an automatic bump of the `collab-staging` tag on
merges to `main`. This should help catch issues with collab deploys
earlier.

Release Notes:

- N/A

---------

Co-authored-by: Conrad <conrad@zed.dev>
---
 .github/workflows/bump_collab_staging.yml | 23 +++++++++++++++++++++++
 .github/workflows/deploy_collab.yml       | 23 ++++++++++++++++-------
 2 files changed, 39 insertions(+), 7 deletions(-)
 create mode 100644 .github/workflows/bump_collab_staging.yml

diff --git a/.github/workflows/bump_collab_staging.yml b/.github/workflows/bump_collab_staging.yml
new file mode 100644
index 00000000000000..89cc7c48481d97
--- /dev/null
+++ b/.github/workflows/bump_collab_staging.yml
@@ -0,0 +1,23 @@
+name: Bump collab-staging Tag
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  update-collab-staging-tag:
+    if: github.repository_owner == 'zed-industries'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        with:
+          fetch-depth: 0
+
+      - name: Update collab-staging tag
+        run: |
+          git config user.name github-actions
+          git config user.email github-actions@github.com
+          git tag -f collab-staging
+          git push origin collab-staging --force
diff --git a/.github/workflows/deploy_collab.yml b/.github/workflows/deploy_collab.yml
index 6801be2a5494cd..c4193adcd24349 100644
--- a/.github/workflows/deploy_collab.yml
+++ b/.github/workflows/deploy_collab.yml
@@ -8,7 +8,6 @@ on:
 
 env:
   DOCKER_BUILDKIT: 1
-  DIGITALOCEAN_ACCESS_TOKEN: ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }}
 
 jobs:
   style:
@@ -61,11 +60,12 @@ jobs:
       - style
       - tests
     runs-on:
-      - self-hosted
-      - deploy
+      - buildjet-16vcpu-ubuntu-2204
     steps:
-      - name: Add Rust to the PATH
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+      - name: Install doctl
+        uses: digitalocean/action-doctl@v2
+        with:
+          token: ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }}
 
       - name: Sign into DigitalOcean docker registry
         run: doctl registry login
@@ -89,10 +89,19 @@ jobs:
     needs:
       - publish
     runs-on:
-      - self-hosted
-      - deploy
+      - buildjet-16vcpu-ubuntu-2204
 
     steps:
+      - name: Checkout repo
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        with:
+          clean: false
+
+      - name: Install doctl
+        uses: digitalocean/action-doctl@v2
+        with:
+          token: ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }}
+
       - name: Sign into Kubernetes
         run: doctl kubernetes cluster kubeconfig save --expiry-seconds 600 ${{ secrets.CLUSTER_NAME }}
 

From e9f2e72ff03c60f8a9a1ce9612cc51a368813cf0 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 19 Sep 2024 17:51:28 +0200
Subject: [PATCH 213/762] Workspace persistence for SSH projects (#17996)

TODOs:

- [x] Add tests to `workspace/src/persistence.rs`
- [x] Add a icon for ssh projects
- [x] Fix all `TODO` comments
- [x] Use `port` if it's passed in the ssh connection options

In next PRs:
- Make sure unsaved buffers are persisted/restored, along with other
items/layout
- Handle multiple paths/worktrees correctly


Release Notes:

- N/A

---------

Co-authored-by: Bennet Bo Fenner <bennet@zed.dev>
---
 Cargo.lock                                    |   1 +
 crates/recent_projects/src/dev_servers.rs     |   7 +-
 crates/recent_projects/src/recent_projects.rs | 108 +++--
 crates/recent_projects/src/ssh_connections.rs |  67 ++--
 crates/remote/src/ssh_session.rs              |   5 +
 crates/sqlez/src/bindable.rs                  |  16 +
 crates/sqlez/src/typed_statements.rs          |   2 +-
 crates/workspace/Cargo.toml                   |   1 +
 crates/workspace/src/persistence.rs           | 374 +++++++++++++++---
 crates/workspace/src/persistence/model.rs     |  66 +++-
 crates/workspace/src/workspace.rs             |  80 +++-
 crates/zed/src/main.rs                        |   6 +-
 12 files changed, 592 insertions(+), 141 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ca5d68881ffb3f..16ee627d2c8f08 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14096,6 +14096,7 @@ dependencies = [
  "parking_lot",
  "postage",
  "project",
+ "remote",
  "schemars",
  "serde",
  "serde_json",
diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 491f378f30ce64..af5f51f14fca2c 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -39,7 +39,6 @@ use ui::{
     RadioWithLabel, Tooltip,
 };
 use ui_input::{FieldLabelLayout, TextField};
-use util::paths::PathWithPosition;
 use util::ResultExt;
 use workspace::notifications::NotifyResultExt;
 use workspace::OpenOptions;
@@ -987,11 +986,7 @@ impl DevServerProjects {
                 cx.spawn(|_, mut cx| async move {
                     let result = open_ssh_project(
                         server.into(),
-                        project
-                            .paths
-                            .into_iter()
-                            .map(|path| PathWithPosition::from_path(PathBuf::from(path)))
-                            .collect(),
+                        project.paths.into_iter().map(PathBuf::from).collect(),
                         app_state,
                         OpenOptions::default(),
                         &mut cx,
diff --git a/crates/recent_projects/src/recent_projects.rs b/crates/recent_projects/src/recent_projects.rs
index 182cec4614d456..cb3d3ab65950f0 100644
--- a/crates/recent_projects/src/recent_projects.rs
+++ b/crates/recent_projects/src/recent_projects.rs
@@ -2,6 +2,7 @@ mod dev_servers;
 pub mod disconnected_overlay;
 mod ssh_connections;
 mod ssh_remotes;
+use remote::SshConnectionOptions;
 pub use ssh_connections::open_ssh_project;
 
 use client::{DevServerProjectId, ProjectId};
@@ -32,8 +33,8 @@ use ui::{
 };
 use util::{paths::PathExt, ResultExt};
 use workspace::{
-    AppState, CloseIntent, ModalView, SerializedWorkspaceLocation, Workspace, WorkspaceId,
-    WORKSPACE_DB,
+    AppState, CloseIntent, ModalView, OpenOptions, SerializedWorkspaceLocation, Workspace,
+    WorkspaceId, WORKSPACE_DB,
 };
 
 #[derive(PartialEq, Clone, Deserialize, Default)]
@@ -172,7 +173,7 @@ pub struct RecentProjectsDelegate {
     create_new_window: bool,
     // Flag to reset index when there is a new query vs not reset index when user delete an item
     reset_selected_match_index: bool,
-    has_any_dev_server_projects: bool,
+    has_any_non_local_projects: bool,
 }
 
 impl RecentProjectsDelegate {
@@ -185,16 +186,16 @@ impl RecentProjectsDelegate {
             create_new_window,
             render_paths,
             reset_selected_match_index: true,
-            has_any_dev_server_projects: false,
+            has_any_non_local_projects: false,
         }
     }
 
     pub fn set_workspaces(&mut self, workspaces: Vec<(WorkspaceId, SerializedWorkspaceLocation)>) {
         self.workspaces = workspaces;
-        self.has_any_dev_server_projects = self
+        self.has_any_non_local_projects = !self
             .workspaces
             .iter()
-            .any(|(_, location)| matches!(location, SerializedWorkspaceLocation::DevServer(_)));
+            .all(|(_, location)| matches!(location, SerializedWorkspaceLocation::Local(_, _)));
     }
 }
 impl EventEmitter<DismissEvent> for RecentProjectsDelegate {}
@@ -258,6 +259,23 @@ impl PickerDelegate for RecentProjectsDelegate {
                             dev_server_project.paths.join("")
                         )
                     }
+                    SerializedWorkspaceLocation::Ssh(ssh_project) => {
+                        format!(
+                            "{}{}{}{}",
+                            ssh_project.host,
+                            ssh_project
+                                .port
+                                .as_ref()
+                                .map(|port| port.to_string())
+                                .unwrap_or_default(),
+                            ssh_project.path,
+                            ssh_project
+                                .user
+                                .as_ref()
+                                .map(|user| user.to_string())
+                                .unwrap_or_default()
+                        )
+                    }
                 };
 
                 StringMatchCandidate::new(id, combined_string)
@@ -364,6 +382,33 @@ impl PickerDelegate for RecentProjectsDelegate {
                                 };
                                 open_dev_server_project(replace_current_window, dev_server_project.id, project_id, cx)
                         }
+                        SerializedWorkspaceLocation::Ssh(ssh_project) => {
+                            let app_state = workspace.app_state().clone();
+
+                            let replace_window = if replace_current_window {
+                                cx.window_handle().downcast::<Workspace>()
+                            } else {
+                                None
+                            };
+
+                            let open_options = OpenOptions {
+                                replace_window,
+                                ..Default::default()
+                            };
+
+                            let connection_options = SshConnectionOptions {
+                                host: ssh_project.host.clone(),
+                                username: ssh_project.user.clone(),
+                                port: ssh_project.port,
+                                password: None,
+                            };
+
+                            let paths = vec![PathBuf::from(ssh_project.path.clone())];
+
+                            cx.spawn(|_, mut cx| async move {
+                                open_ssh_project(connection_options, paths, app_state, open_options, &mut cx).await
+                            })
+                        }
                     }
                 }
                 })
@@ -392,7 +437,6 @@ impl PickerDelegate for RecentProjectsDelegate {
 
         let (_, location) = self.workspaces.get(hit.candidate_id)?;
 
-        let is_remote = matches!(location, SerializedWorkspaceLocation::DevServer(_));
         let dev_server_status =
             if let SerializedWorkspaceLocation::DevServer(dev_server_project) = location {
                 let store = dev_server_projects::Store::global(cx).read(cx);
@@ -416,6 +460,9 @@ impl PickerDelegate for RecentProjectsDelegate {
                     .filter_map(|i| paths.paths().get(*i).cloned())
                     .collect(),
             ),
+            SerializedWorkspaceLocation::Ssh(ssh_project) => {
+                Arc::new(vec![PathBuf::from(ssh_project.ssh_url())])
+            }
             SerializedWorkspaceLocation::DevServer(dev_server_project) => {
                 Arc::new(vec![PathBuf::from(format!(
                     "{}:{}",
@@ -457,29 +504,34 @@ impl PickerDelegate for RecentProjectsDelegate {
                     h_flex()
                         .flex_grow()
                         .gap_3()
-                        .when(self.has_any_dev_server_projects, |this| {
-                            this.child(if is_remote {
-                                // if disabled, Color::Disabled
-                                let indicator_color = match dev_server_status {
-                                    Some(DevServerStatus::Online) => Color::Created,
-                                    Some(DevServerStatus::Offline) => Color::Hidden,
-                                    _ => unreachable!(),
-                                };
-                                IconWithIndicator::new(
-                                    Icon::new(IconName::Server).color(Color::Muted),
-                                    Some(Indicator::dot()),
-                                )
-                                .indicator_color(indicator_color)
-                                .indicator_border_color(if selected {
-                                    Some(cx.theme().colors().element_selected)
-                                } else {
-                                    None
-                                })
-                                .into_any_element()
-                            } else {
-                                Icon::new(IconName::Screen)
+                        .when(self.has_any_non_local_projects, |this| {
+                            this.child(match location {
+                                SerializedWorkspaceLocation::Local(_, _) => {
+                                    Icon::new(IconName::Screen)
+                                        .color(Color::Muted)
+                                        .into_any_element()
+                                }
+                                SerializedWorkspaceLocation::Ssh(_) => Icon::new(IconName::Screen)
                                     .color(Color::Muted)
+                                    .into_any_element(),
+                                SerializedWorkspaceLocation::DevServer(_) => {
+                                    let indicator_color = match dev_server_status {
+                                        Some(DevServerStatus::Online) => Color::Created,
+                                        Some(DevServerStatus::Offline) => Color::Hidden,
+                                        _ => unreachable!(),
+                                    };
+                                    IconWithIndicator::new(
+                                        Icon::new(IconName::Server).color(Color::Muted),
+                                        Some(Indicator::dot()),
+                                    )
+                                    .indicator_color(indicator_color)
+                                    .indicator_border_color(if selected {
+                                        Some(cx.theme().colors().element_selected)
+                                    } else {
+                                        None
+                                    })
                                     .into_any_element()
+                                }
                             })
                         })
                         .child({
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 8da4284b7f56a7..ad23a5c8963b4e 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -19,7 +19,6 @@ use ui::{
     h_flex, v_flex, FluentBuilder as _, Icon, IconName, IconSize, InteractiveElement, IntoElement,
     Label, LabelCommon, Styled, StyledExt as _, ViewContext, VisualContext, WindowContext,
 };
-use util::paths::PathWithPosition;
 use workspace::{AppState, ModalView, Workspace};
 
 #[derive(Deserialize)]
@@ -358,24 +357,29 @@ pub fn connect_over_ssh(
 
 pub async fn open_ssh_project(
     connection_options: SshConnectionOptions,
-    paths: Vec<PathWithPosition>,
+    paths: Vec<PathBuf>,
     app_state: Arc<AppState>,
-    _open_options: workspace::OpenOptions,
+    open_options: workspace::OpenOptions,
     cx: &mut AsyncAppContext,
 ) -> Result<()> {
     let options = cx.update(|cx| (app_state.build_window_options)(None, cx))?;
-    let window = cx.open_window(options, |cx| {
-        let project = project::Project::local(
-            app_state.client.clone(),
-            app_state.node_runtime.clone(),
-            app_state.user_store.clone(),
-            app_state.languages.clone(),
-            app_state.fs.clone(),
-            None,
-            cx,
-        );
-        cx.new_view(|cx| Workspace::new(None, project, app_state.clone(), cx))
-    })?;
+
+    let window = if let Some(window) = open_options.replace_window {
+        window
+    } else {
+        cx.open_window(options, |cx| {
+            let project = project::Project::local(
+                app_state.client.clone(),
+                app_state.node_runtime.clone(),
+                app_state.user_store.clone(),
+                app_state.languages.clone(),
+                app_state.fs.clone(),
+                None,
+                cx,
+            );
+            cx.new_view(|cx| Workspace::new(None, project, app_state.clone(), cx))
+        })?
+    };
 
     let result = window
         .update(cx, |workspace, cx| {
@@ -387,40 +391,17 @@ pub async fn open_ssh_project(
                 .read(cx)
                 .prompt
                 .clone();
-            connect_over_ssh(connection_options, ui, cx)
+            connect_over_ssh(connection_options.clone(), ui, cx)
         })?
         .await;
 
     if result.is_err() {
         window.update(cx, |_, cx| cx.remove_window()).ok();
     }
-
     let session = result?;
 
-    let project = cx.update(|cx| {
-        project::Project::ssh(
-            session,
-            app_state.client.clone(),
-            app_state.node_runtime.clone(),
-            app_state.user_store.clone(),
-            app_state.languages.clone(),
-            app_state.fs.clone(),
-            cx,
-        )
-    })?;
-
-    for path in paths {
-        project
-            .update(cx, |project, cx| {
-                project.find_or_create_worktree(&path.path, true, cx)
-            })?
-            .await?;
-    }
-
-    window.update(cx, |_, cx| {
-        cx.replace_root_view(|cx| Workspace::new(None, project, app_state, cx))
-    })?;
-    window.update(cx, |_, cx| cx.activate_window())?;
-
-    Ok(())
+    cx.update(|cx| {
+        workspace::open_ssh_project(window, connection_options, session, app_state, paths, cx)
+    })?
+    .await
 }
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 7556b38f3ed0f4..4aab731e645934 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -33,6 +33,11 @@ use std::{
 };
 use tempfile::TempDir;
 
+#[derive(
+    Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, serde::Serialize, serde::Deserialize,
+)]
+pub struct SshProjectId(pub u64);
+
 #[derive(Clone)]
 pub struct SshSocket {
     connection_options: SshConnectionOptions,
diff --git a/crates/sqlez/src/bindable.rs b/crates/sqlez/src/bindable.rs
index e8b9679936d742..8cf4329f929891 100644
--- a/crates/sqlez/src/bindable.rs
+++ b/crates/sqlez/src/bindable.rs
@@ -196,6 +196,22 @@ impl Column for u32 {
     }
 }
 
+impl StaticColumnCount for u16 {}
+impl Bind for u16 {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        (*self as i64)
+            .bind(statement, start_index)
+            .with_context(|| format!("Failed to bind usize at index {start_index}"))
+    }
+}
+
+impl Column for u16 {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let result = statement.column_int64(start_index)?;
+        Ok((result as u16, start_index + 1))
+    }
+}
+
 impl StaticColumnCount for usize {}
 impl Bind for usize {
     fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
diff --git a/crates/sqlez/src/typed_statements.rs b/crates/sqlez/src/typed_statements.rs
index d7f25cde5174b6..95f4f829ec8c16 100644
--- a/crates/sqlez/src/typed_statements.rs
+++ b/crates/sqlez/src/typed_statements.rs
@@ -74,7 +74,7 @@ impl Connection {
     }
 
     /// Prepare a statement which takes a binding and selects a single row
-    /// from the database. WIll return none if no rows are returned and will
+    /// from the database. Will return none if no rows are returned and will
     /// error if more than 1 row is returned.
     ///
     /// Note: If there are multiple statements that depend upon each other
diff --git a/crates/workspace/Cargo.toml b/crates/workspace/Cargo.toml
index 7f5c1ccce8a576..1b998eeabe5373 100644
--- a/crates/workspace/Cargo.toml
+++ b/crates/workspace/Cargo.toml
@@ -51,6 +51,7 @@ postage.workspace = true
 project.workspace = true
 dev_server_projects.workspace = true
 task.workspace = true
+remote.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs
index 88ede4228d622d..034328a30b2ffa 100644
--- a/crates/workspace/src/persistence.rs
+++ b/crates/workspace/src/persistence.rs
@@ -7,6 +7,7 @@ use client::DevServerProjectId;
 use db::{define_connection, query, sqlez::connection::Connection, sqlez_macros::sql};
 use gpui::{point, size, Axis, Bounds, WindowBounds, WindowId};
 
+use remote::ssh_session::SshProjectId;
 use sqlez::{
     bindable::{Bind, Column, StaticColumnCount},
     statement::Statement,
@@ -20,7 +21,7 @@ use crate::WorkspaceId;
 
 use model::{
     GroupId, LocalPaths, PaneId, SerializedItem, SerializedPane, SerializedPaneGroup,
-    SerializedWorkspace,
+    SerializedSshProject, SerializedWorkspace,
 };
 
 use self::model::{
@@ -354,7 +355,17 @@ define_connection! {
     ),
     sql!(
         ALTER TABLE panes ADD COLUMN pinned_count INTEGER DEFAULT 0;
-    )
+    ),
+    sql!(
+        CREATE TABLE ssh_projects (
+            id INTEGER PRIMARY KEY,
+            host TEXT NOT NULL,
+            port INTEGER,
+            path TEXT NOT NULL,
+            user TEXT
+        );
+        ALTER TABLE workspaces ADD COLUMN ssh_project_id INTEGER REFERENCES ssh_projects(id) ON DELETE CASCADE;
+    ),
     ];
 }
 
@@ -374,7 +385,6 @@ impl WorkspaceDb {
             workspace_id,
             local_paths,
             local_paths_order,
-            dev_server_project_id,
             window_bounds,
             display,
             centered_layout,
@@ -384,7 +394,6 @@ impl WorkspaceDb {
             WorkspaceId,
             Option<LocalPaths>,
             Option<LocalPathsOrder>,
-            Option<u64>,
             Option<SerializedWindowBounds>,
             Option<Uuid>,
             Option<bool>,
@@ -396,7 +405,6 @@ impl WorkspaceDb {
                     workspace_id,
                     local_paths,
                     local_paths_order,
-                    dev_server_project_id,
                     window_state,
                     window_x,
                     window_y,
@@ -422,28 +430,13 @@ impl WorkspaceDb {
             .warn_on_err()
             .flatten()?;
 
-        let location = if let Some(dev_server_project_id) = dev_server_project_id {
-            let dev_server_project: SerializedDevServerProject = self
-                .select_row_bound(sql! {
-                    SELECT id, path, dev_server_name
-                    FROM dev_server_projects
-                    WHERE id = ?
-                })
-                .and_then(|mut prepared_statement| (prepared_statement)(dev_server_project_id))
-                .context("No remote project found")
-                .warn_on_err()
-                .flatten()?;
-            SerializedWorkspaceLocation::DevServer(dev_server_project)
-        } else if let Some(local_paths) = local_paths {
-            match local_paths_order {
-                Some(order) => SerializedWorkspaceLocation::Local(local_paths, order),
-                None => {
-                    let order = LocalPathsOrder::default_for_paths(&local_paths);
-                    SerializedWorkspaceLocation::Local(local_paths, order)
-                }
+        let local_paths = local_paths?;
+        let location = match local_paths_order {
+            Some(order) => SerializedWorkspaceLocation::Local(local_paths, order),
+            None => {
+                let order = LocalPathsOrder::default_for_paths(&local_paths);
+                SerializedWorkspaceLocation::Local(local_paths, order)
             }
-        } else {
-            return None;
         };
 
         Some(SerializedWorkspace {
@@ -470,8 +463,6 @@ impl WorkspaceDb {
         // and we've grabbed the most recent workspace
         let (
             workspace_id,
-            local_paths,
-            local_paths_order,
             dev_server_project_id,
             window_bounds,
             display,
@@ -480,8 +471,6 @@ impl WorkspaceDb {
             window_id,
         ): (
             WorkspaceId,
-            Option<LocalPaths>,
-            Option<LocalPathsOrder>,
             Option<u64>,
             Option<SerializedWindowBounds>,
             Option<Uuid>,
@@ -492,8 +481,6 @@ impl WorkspaceDb {
             .select_row_bound(sql! {
                 SELECT
                     workspace_id,
-                    local_paths,
-                    local_paths_order,
                     dev_server_project_id,
                     window_state,
                     window_x,
@@ -520,29 +507,20 @@ impl WorkspaceDb {
             .warn_on_err()
             .flatten()?;
 
-        let location = if let Some(dev_server_project_id) = dev_server_project_id {
-            let dev_server_project: SerializedDevServerProject = self
-                .select_row_bound(sql! {
-                    SELECT id, path, dev_server_name
-                    FROM dev_server_projects
-                    WHERE id = ?
-                })
-                .and_then(|mut prepared_statement| (prepared_statement)(dev_server_project_id))
-                .context("No remote project found")
-                .warn_on_err()
-                .flatten()?;
-            SerializedWorkspaceLocation::DevServer(dev_server_project)
-        } else if let Some(local_paths) = local_paths {
-            match local_paths_order {
-                Some(order) => SerializedWorkspaceLocation::Local(local_paths, order),
-                None => {
-                    let order = LocalPathsOrder::default_for_paths(&local_paths);
-                    SerializedWorkspaceLocation::Local(local_paths, order)
-                }
-            }
-        } else {
-            return None;
-        };
+        let dev_server_project_id = dev_server_project_id?;
+
+        let dev_server_project: SerializedDevServerProject = self
+            .select_row_bound(sql! {
+                SELECT id, path, dev_server_name
+                FROM dev_server_projects
+                WHERE id = ?
+            })
+            .and_then(|mut prepared_statement| (prepared_statement)(dev_server_project_id))
+            .context("No remote project found")
+            .warn_on_err()
+            .flatten()?;
+
+        let location = SerializedWorkspaceLocation::DevServer(dev_server_project);
 
         Some(SerializedWorkspace {
             id: workspace_id,
@@ -560,6 +538,62 @@ impl WorkspaceDb {
         })
     }
 
+    pub(crate) fn workspace_for_ssh_project(
+        &self,
+        ssh_project: &SerializedSshProject,
+    ) -> Option<SerializedWorkspace> {
+        let (workspace_id, window_bounds, display, centered_layout, docks, window_id): (
+            WorkspaceId,
+            Option<SerializedWindowBounds>,
+            Option<Uuid>,
+            Option<bool>,
+            DockStructure,
+            Option<u64>,
+        ) = self
+            .select_row_bound(sql! {
+                SELECT
+                    workspace_id,
+                    window_state,
+                    window_x,
+                    window_y,
+                    window_width,
+                    window_height,
+                    display,
+                    centered_layout,
+                    left_dock_visible,
+                    left_dock_active_panel,
+                    left_dock_zoom,
+                    right_dock_visible,
+                    right_dock_active_panel,
+                    right_dock_zoom,
+                    bottom_dock_visible,
+                    bottom_dock_active_panel,
+                    bottom_dock_zoom,
+                    window_id
+                FROM workspaces
+                WHERE ssh_project_id = ?
+            })
+            .and_then(|mut prepared_statement| (prepared_statement)(ssh_project.id.0))
+            .context("No workspaces found")
+            .warn_on_err()
+            .flatten()?;
+
+        Some(SerializedWorkspace {
+            id: workspace_id,
+            location: SerializedWorkspaceLocation::Ssh(ssh_project.clone()),
+            center_group: self
+                .get_center_pane_group(workspace_id)
+                .context("Getting center group")
+                .log_err()?,
+            window_bounds,
+            centered_layout: centered_layout.unwrap_or(false),
+            display,
+            docks,
+            session_id: None,
+            window_id,
+        })
+    }
+
     /// Saves a workspace using the worktree roots. Will garbage collect any workspaces
     /// that used this workspace previously
     pub(crate) async fn save_workspace(&self, workspace: SerializedWorkspace) {
@@ -674,6 +708,49 @@ impl WorkspaceDb {
                             workspace.docks,
                         ))
                         .context("Updating workspace")?;
+                    },
+                    SerializedWorkspaceLocation::Ssh(ssh_project) => {
+                        conn.exec_bound(sql!(
+                            DELETE FROM workspaces WHERE ssh_project_id = ? AND workspace_id != ?
+                        ))?((ssh_project.id.0, workspace.id))
+                        .context("clearing out old locations")?;
+
+                        // Upsert
+                        conn.exec_bound(sql!(
+                            INSERT INTO workspaces(
+                                workspace_id,
+                                ssh_project_id,
+                                left_dock_visible,
+                                left_dock_active_panel,
+                                left_dock_zoom,
+                                right_dock_visible,
+                                right_dock_active_panel,
+                                right_dock_zoom,
+                                bottom_dock_visible,
+                                bottom_dock_active_panel,
+                                bottom_dock_zoom,
+                                timestamp
+                            )
+                            VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, CURRENT_TIMESTAMP)
+                            ON CONFLICT DO
+                            UPDATE SET
+                                ssh_project_id = ?2,
+                                left_dock_visible = ?3,
+                                left_dock_active_panel = ?4,
+                                left_dock_zoom = ?5,
+                                right_dock_visible = ?6,
+                                right_dock_active_panel = ?7,
+                                right_dock_zoom = ?8,
+                                bottom_dock_visible = ?9,
+                                bottom_dock_active_panel = ?10,
+                                bottom_dock_zoom = ?11,
+                                timestamp = CURRENT_TIMESTAMP
+                        ))?((
+                            workspace.id,
+                            ssh_project.id.0,
+                            workspace.docks,
+                        ))
+                        .context("Updating workspace")?;
                     }
                 }
 
@@ -688,6 +765,46 @@ impl WorkspaceDb {
         .await;
     }
 
+    pub(crate) async fn get_or_create_ssh_project(
+        &self,
+        host: String,
+        port: Option<u16>,
+        path: String,
+        user: Option<String>,
+    ) -> Result<SerializedSshProject> {
+        if let Some(project) = self
+            .get_ssh_project(host.clone(), port, path.clone(), user.clone())
+            .await?
+        {
+            Ok(project)
+        } else {
+            self.insert_ssh_project(host, port, path, user)
+                .await?
+                .ok_or_else(|| anyhow!("failed to insert ssh project"))
+        }
+    }
+
+    query! {
+        async fn get_ssh_project(host: String, port: Option<u16>, path: String, user: Option<String>) -> Result<Option<SerializedSshProject>> {
+            SELECT id, host, port, path, user
+            FROM ssh_projects
+            WHERE host IS ? AND port IS ? AND path IS ? AND user IS ?
+            LIMIT 1
+        }
+    }
+
+    query! {
+        async fn insert_ssh_project(host: String, port: Option<u16>, path: String, user: Option<String>) -> Result<Option<SerializedSshProject>> {
+            INSERT INTO ssh_projects(
+                host,
+                port,
+                path,
+                user
+            ) VALUES (?1, ?2, ?3, ?4)
+            RETURNING id, host, port, path, user
+        }
+    }
+
     query! {
         pub async fn next_id() -> Result<WorkspaceId> {
             INSERT INTO workspaces DEFAULT VALUES RETURNING workspace_id
@@ -695,10 +812,12 @@ impl WorkspaceDb {
     }
 
     query! {
-        fn recent_workspaces() -> Result<Vec<(WorkspaceId, LocalPaths, LocalPathsOrder, Option<u64>)>> {
-            SELECT workspace_id, local_paths, local_paths_order, dev_server_project_id
+        fn recent_workspaces() -> Result<Vec<(WorkspaceId, LocalPaths, LocalPathsOrder, Option<u64>, Option<u64>)>> {
+            SELECT workspace_id, local_paths, local_paths_order, dev_server_project_id, ssh_project_id
             FROM workspaces
-            WHERE local_paths IS NOT NULL OR dev_server_project_id IS NOT NULL
+            WHERE local_paths IS NOT NULL
+                OR dev_server_project_id IS NOT NULL
+                OR ssh_project_id IS NOT NULL
             ORDER BY timestamp DESC
         }
     }
@@ -719,6 +838,13 @@ impl WorkspaceDb {
         }
     }
 
+    query! {
+        fn ssh_projects() -> Result<Vec<SerializedSshProject>> {
+            SELECT id, host, port, path, user
+            FROM ssh_projects
+        }
+    }
+
     pub(crate) fn last_window(
         &self,
     ) -> anyhow::Result<(Option<Uuid>, Option<SerializedWindowBounds>)> {
@@ -768,8 +894,11 @@ impl WorkspaceDb {
         let mut result = Vec::new();
         let mut delete_tasks = Vec::new();
         let dev_server_projects = self.dev_server_projects()?;
+        let ssh_projects = self.ssh_projects()?;
 
-        for (id, location, order, dev_server_project_id) in self.recent_workspaces()? {
+        for (id, location, order, dev_server_project_id, ssh_project_id) in
+            self.recent_workspaces()?
+        {
             if let Some(dev_server_project_id) = dev_server_project_id.map(DevServerProjectId) {
                 if let Some(dev_server_project) = dev_server_projects
                     .iter()
@@ -782,6 +911,15 @@ impl WorkspaceDb {
                 continue;
             }
 
+            if let Some(ssh_project_id) = ssh_project_id.map(SshProjectId) {
+                if let Some(ssh_project) = ssh_projects.iter().find(|rp| rp.id == ssh_project_id) {
+                    result.push((id, SerializedWorkspaceLocation::Ssh(ssh_project.clone())));
+                } else {
+                    delete_tasks.push(self.delete_workspace_by_id(id));
+                }
+                continue;
+            }
+
             if location.paths().iter().all(|path| path.exists())
                 && location.paths().iter().any(|path| path.is_dir())
             {
@@ -802,7 +940,9 @@ impl WorkspaceDb {
             .into_iter()
             .filter_map(|(_, location)| match location {
                 SerializedWorkspaceLocation::Local(local_paths, _) => Some(local_paths),
+                // Do not automatically reopen Dev Server and SSH workspaces
                 SerializedWorkspaceLocation::DevServer(_) => None,
+                SerializedWorkspaceLocation::Ssh(_) => None,
             })
             .next())
     }
@@ -1512,6 +1652,122 @@ mod tests {
         assert_eq!(have[3], LocalPaths::new([dir1.path().to_str().unwrap()]));
     }
 
+    #[gpui::test]
+    async fn test_get_or_create_ssh_project() {
+        let db = WorkspaceDb(open_test_db("test_get_or_create_ssh_project").await);
+
+        let (host, port, path, user) = (
+            "example.com".to_string(),
+            Some(22_u16),
+            "/home/user".to_string(),
+            Some("user".to_string()),
+        );
+
+        let project = db
+            .get_or_create_ssh_project(host.clone(), port, path.clone(), user.clone())
+            .await
+            .unwrap();
+
+        assert_eq!(project.host, host);
+        assert_eq!(project.path, path);
+        assert_eq!(project.user, user);
+
+        // Test that calling the function again with the same parameters returns the same project
+        let same_project = db
+            .get_or_create_ssh_project(host.clone(), port, path.clone(), user.clone())
+            .await
+            .unwrap();
+
+        assert_eq!(project.id, same_project.id);
+
+        // Test with different parameters
+        let (host2, path2, user2) = (
+            "otherexample.com".to_string(),
+            "/home/otheruser".to_string(),
+            Some("otheruser".to_string()),
+        );
+
+        let different_project = db
+            .get_or_create_ssh_project(host2.clone(), None, path2.clone(), user2.clone())
+            .await
+            .unwrap();
+
+        assert_ne!(project.id, different_project.id);
+        assert_eq!(different_project.host, host2);
+        assert_eq!(different_project.path, path2);
+        assert_eq!(different_project.user, user2);
+    }
+
+    #[gpui::test]
+    async fn test_get_or_create_ssh_project_with_null_user() {
+        let db = WorkspaceDb(open_test_db("test_get_or_create_ssh_project_with_null_user").await);
+
+        let (host, port, path, user) = (
+            "example.com".to_string(),
+            None,
+            "/home/user".to_string(),
+            None,
+        );
+
+        let project = db
+            .get_or_create_ssh_project(host.clone(), port, path.clone(), None)
+            .await
+            .unwrap();
+
+        assert_eq!(project.host, host);
+        assert_eq!(project.path, path);
+        assert_eq!(project.user, None);
+
+        // Test that calling the function again with the same parameters returns the same project
+        let same_project = db
+            .get_or_create_ssh_project(host.clone(), port, path.clone(), user.clone())
+            .await
+            .unwrap();
+
+        assert_eq!(project.id, same_project.id);
+    }
+
+    #[gpui::test]
+    async fn test_get_ssh_projects() {
+        let db = WorkspaceDb(open_test_db("test_get_ssh_projects").await);
+
+        let projects = vec![
+            (
+                "example.com".to_string(),
+                None,
+                "/home/user".to_string(),
+                None,
+            ),
+            (
+                "anotherexample.com".to_string(),
+                Some(123_u16),
+                "/home/user2".to_string(),
+                Some("user2".to_string()),
+            ),
+            (
+                "yetanother.com".to_string(),
+                Some(345_u16),
+                "/home/user3".to_string(),
+                None,
+            ),
+        ];
+
+        for (host, port, path, user) in projects.iter() {
+            let project = db
+                .get_or_create_ssh_project(host.clone(), *port, path.clone(), user.clone())
+                .await
+                .unwrap();
+
+            assert_eq!(&project.host, host);
+            assert_eq!(&project.port, port);
+            assert_eq!(&project.path, path);
+            assert_eq!(&project.user, user);
+        }
+
+        let stored_projects = db.ssh_projects().unwrap();
+        assert_eq!(stored_projects.len(), projects.len());
+    }
+
     #[gpui::test]
     async fn test_simple_split() {
         env_logger::try_init().ok();
diff --git a/crates/workspace/src/persistence/model.rs b/crates/workspace/src/persistence/model.rs
index d6f8001f25fc3e..0ad3fa5e606e5b 100644
--- a/crates/workspace/src/persistence/model.rs
+++ b/crates/workspace/src/persistence/model.rs
@@ -11,6 +11,7 @@ use db::sqlez::{
 };
 use gpui::{AsyncWindowContext, Model, View, WeakView};
 use project::Project;
+use remote::ssh_session::SshProjectId;
 use serde::{Deserialize, Serialize};
 use std::{
     path::{Path, PathBuf},
@@ -20,6 +21,69 @@ use ui::SharedString;
 use util::ResultExt;
 use uuid::Uuid;
 
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
+pub struct SerializedSshProject {
+    pub id: SshProjectId,
+    pub host: String,
+    pub port: Option<u16>,
+    pub path: String,
+    pub user: Option<String>,
+}
+
+impl SerializedSshProject {
+    pub fn ssh_url(&self) -> String {
+        let mut result = String::from("ssh://");
+        if let Some(user) = &self.user {
+            result.push_str(user);
+            result.push('@');
+        }
+        result.push_str(&self.host);
+        if let Some(port) = &self.port {
+            result.push(':');
+            result.push_str(&port.to_string());
+        }
+        result.push_str(&self.path);
+        result
+    }
+}
+
+impl StaticColumnCount for SerializedSshProject {
+    fn column_count() -> usize {
+        5
+    }
+}
+
+impl Bind for &SerializedSshProject {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        let next_index = statement.bind(&self.id.0, start_index)?;
+        let next_index = statement.bind(&self.host, next_index)?;
+        let next_index = statement.bind(&self.port, next_index)?;
+        let next_index = statement.bind(&self.path, next_index)?;
+        statement.bind(&self.user, next_index)
+    }
+}
+
+impl Column for SerializedSshProject {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let id = statement.column_int64(start_index)?;
+        let host = statement.column_text(start_index + 1)?.to_string();
+        let (port, _) = Option::<u16>::column(statement, start_index + 2)?;
+        let path = statement.column_text(start_index + 3)?.to_string();
+        let (user, _) = Option::<String>::column(statement, start_index + 4)?;
+
+        Ok((
+            Self {
+                id: SshProjectId(id as u64),
+                host,
+                port,
+                path,
+                user,
+            },
+            start_index + 5,
+        ))
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
 pub struct SerializedDevServerProject {
     pub id: DevServerProjectId,
@@ -58,7 +122,6 @@ impl Column for LocalPaths {
     fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
         let path_blob = statement.column_blob(start_index)?;
         let paths: Arc<Vec<PathBuf>> = if path_blob.is_empty() {
-            println!("path blog is empty");
             Default::default()
         } else {
             bincode::deserialize(path_blob).context("Bincode deserialization of paths failed")?
@@ -146,6 +209,7 @@ impl Column for SerializedDevServerProject {
 #[derive(Debug, PartialEq, Clone)]
 pub enum SerializedWorkspaceLocation {
     Local(LocalPaths, LocalPathsOrder),
+    Ssh(SerializedSshProject),
     DevServer(SerializedDevServerProject),
 }
 
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 98ac49992d0a4f..5855dcce1e5919 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -49,15 +49,19 @@ use node_runtime::NodeRuntime;
 use notifications::{simple_message_notification::MessageNotification, NotificationHandle};
 pub use pane::*;
 pub use pane_group::*;
-use persistence::{model::SerializedWorkspace, SerializedWindowBounds, DB};
 pub use persistence::{
     model::{ItemId, LocalPaths, SerializedDevServerProject, SerializedWorkspaceLocation},
     WorkspaceDb, DB as WORKSPACE_DB,
 };
+use persistence::{
+    model::{SerializedSshProject, SerializedWorkspace},
+    SerializedWindowBounds, DB,
+};
 use postage::stream::Stream;
 use project::{
     DirectoryLister, Project, ProjectEntryId, ProjectPath, ResolvedPath, Worktree, WorktreeId,
 };
+use remote::{SshConnectionOptions, SshSession};
 use serde::Deserialize;
 use session::AppSession;
 use settings::Settings;
@@ -756,6 +760,7 @@ pub struct Workspace {
     render_disconnected_overlay:
         Option<Box<dyn Fn(&mut Self, &mut ViewContext<Self>) -> AnyElement>>,
     serializable_items_tx: UnboundedSender<Box<dyn SerializableItemHandle>>,
+    serialized_ssh_project: Option<SerializedSshProject>,
     _items_serializer: Task<Result<()>>,
     session_id: Option<String>,
 }
@@ -1054,6 +1059,7 @@ impl Workspace {
             serializable_items_tx,
             _items_serializer,
             session_id: Some(session_id),
+            serialized_ssh_project: None,
         }
     }
 
@@ -1440,6 +1446,10 @@ impl Workspace {
         self.on_prompt_for_open_path = Some(prompt)
     }
 
+    pub fn set_serialized_ssh_project(&mut self, serialized_ssh_project: SerializedSshProject) {
+        self.serialized_ssh_project = Some(serialized_ssh_project);
+    }
+
     pub fn set_render_disconnected_overlay(
         &mut self,
         render: impl Fn(&mut Self, &mut ViewContext<Self>) -> AnyElement + 'static,
@@ -4097,7 +4107,9 @@ impl Workspace {
             }
         }
 
-        let location = if let Some(local_paths) = self.local_paths(cx) {
+        let location = if let Some(ssh_project) = &self.serialized_ssh_project {
+            Some(SerializedWorkspaceLocation::Ssh(ssh_project.clone()))
+        } else if let Some(local_paths) = self.local_paths(cx) {
             if !local_paths.is_empty() {
                 Some(SerializedWorkspaceLocation::from_local_paths(local_paths))
             } else {
@@ -5476,6 +5488,70 @@ pub fn join_hosted_project(
     })
 }
 
+pub fn open_ssh_project(
+    window: WindowHandle<Workspace>,
+    connection_options: SshConnectionOptions,
+    session: Arc<SshSession>,
+    app_state: Arc<AppState>,
+    paths: Vec<PathBuf>,
+    cx: &mut AppContext,
+) -> Task<Result<()>> {
+    cx.spawn(|mut cx| async move {
+        // TODO: Handle multiple paths
+        let path = paths.iter().next().cloned().unwrap_or_default();
+
+        let serialized_ssh_project = persistence::DB
+            .get_or_create_ssh_project(
+                connection_options.host.clone(),
+                connection_options.port,
+                path.to_string_lossy().to_string(),
+                connection_options.username.clone(),
+            )
+            .await?;
+
+        let project = cx.update(|cx| {
+            project::Project::ssh(
+                session,
+                app_state.client.clone(),
+                app_state.node_runtime.clone(),
+                app_state.user_store.clone(),
+                app_state.languages.clone(),
+                app_state.fs.clone(),
+                cx,
+            )
+        })?;
+
+        for path in paths {
+            project
+                .update(&mut cx, |project, cx| {
+                    project.find_or_create_worktree(&path, true, cx)
+                })?
+                .await?;
+        }
+
+        let serialized_workspace =
+            persistence::DB.workspace_for_ssh_project(&serialized_ssh_project);
+
+        let workspace_id =
+            if let Some(workspace_id) = serialized_workspace.map(|workspace| workspace.id) {
+                workspace_id
+            } else {
+                persistence::DB.next_id().await?
+            };
+
+        cx.update_window(window.into(), |_, cx| {
+            cx.replace_root_view(|cx| {
+                let mut workspace =
+                    Workspace::new(Some(workspace_id), project, app_state.clone(), cx);
+                workspace.set_serialized_ssh_project(serialized_ssh_project);
+                workspace
+            });
+        })?;
+
+        window.update(&mut cx, |_, cx| cx.activate_window())
+    })
+}
+
 pub fn join_dev_server_project(
     dev_server_project_id: DevServerProjectId,
     project_id: ProjectId,
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index c127a975a95e89..3104001f992726 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -667,7 +667,11 @@ fn handle_open_request(
         cx.spawn(|mut cx| async move {
             open_ssh_project(
                 connection_info,
-                request.open_paths,
+                request
+                    .open_paths
+                    .into_iter()
+                    .map(|path| path.path)
+                    .collect::<Vec<_>>(),
                 app_state,
                 workspace::OpenOptions::default(),
                 &mut cx,

From 3fd690ade401f7d665448977c674db4780e23165 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Thu, 19 Sep 2024 12:00:13 -0400
Subject: [PATCH 214/762] docs: Update lsp.settings examples for
 yaml-language-server (#18081)

---
 docs/src/configuring-zed.md      | 21 ++++++++-
 docs/src/languages/typescript.md | 26 +++++------
 docs/src/languages/yaml.md       | 80 ++++++++++++++++++++++++++++++--
 3 files changed, 108 insertions(+), 19 deletions(-)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 382c33c216adf9..1befa7d93abb7e 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -575,8 +575,13 @@ Each option controls displaying of a particular toolbar element. If all elements
 The following settings can be overridden for specific language servers:
 
 - `initialization_options`
+- `settings`
 
-To override settings for a language, add an entry for that language server's name to the `lsp` value. Example:
+To override configuration for a language server, add an entry for that language server's name to the `lsp` value.
+
+Some options are passed via `initialization_options` to the language server. These are for options which must be specified at language server startup and when changed will require restarting the language server.
+
+For example to pass the `check` option to `rust-analyzer`, use the following configuration:
 
 ```json
 "lsp": {
@@ -590,6 +595,20 @@ To override settings for a language, add an entry for that language server's nam
 }
 ```
 
+While other options may be changed at a runtime and should be placed under `settings`:
+
+```json
+"lsp": {
+  "yaml-language-server": {
+    "settings": {
+      "yaml": {
+        "keyOrdering": true // Enforces alphabetical ordering of keys in maps
+      }
+    }
+  }
+}
+```
+
 ## Format On Save
 
 - Description: Whether or not to perform a buffer format before saving.
diff --git a/docs/src/languages/typescript.md b/docs/src/languages/typescript.md
index feb7d76622f121..080d41efb33c28 100644
--- a/docs/src/languages/typescript.md
+++ b/docs/src/languages/typescript.md
@@ -72,20 +72,20 @@ You can override these settings in your configuration file:
 
 ```json
 "lsp": {
-    "$LANGUAGE_SERVER_NAME": {
-        "initialization_options": {
-            "preferences": {
-              "includeInlayParameterNameHints": "all",
-              "includeInlayParameterNameHintsWhenArgumentMatchesName": true,
-              "includeInlayFunctionParameterTypeHints": true,
-              "includeInlayVariableTypeHints": true,
-              "includeInlayVariableTypeHintsWhenTypeMatchesName": true,
-              "includeInlayPropertyDeclarationTypeHints": true,
-              "includeInlayFunctionLikeReturnTypeHints": true,
-              "includeInlayEnumMemberValueHints": true,
-            }
-        }
+  "$LANGUAGE_SERVER_NAME": {
+    "initialization_options": {
+      "preferences": {
+      "includeInlayParameterNameHints": "all",
+        "includeInlayParameterNameHintsWhenArgumentMatchesName": true,
+        "includeInlayFunctionParameterTypeHints": true,
+        "includeInlayVariableTypeHints": true,
+        "includeInlayVariableTypeHintsWhenTypeMatchesName": true,
+        "includeInlayPropertyDeclarationTypeHints": true,
+        "includeInlayFunctionLikeReturnTypeHints": true,
+        "includeInlayEnumMemberValueHints": true,
+      }
     }
+  }
 }
 ```
 
diff --git a/docs/src/languages/yaml.md b/docs/src/languages/yaml.md
index 5ef614394cac9d..7b840d08252ca4 100644
--- a/docs/src/languages/yaml.md
+++ b/docs/src/languages/yaml.md
@@ -12,7 +12,7 @@ You can configure various [yaml-language-server settings](https://github.com/red
 ```json
   "lsp": {
     "yaml-language-server": {
-      "initialization_options": {
+      "settings": {
         "yaml": {
           "keyOrdering": true,
           "format": {
@@ -32,9 +32,9 @@ Note, settings keys must be nested, so `yaml.keyOrdering` becomes `{"yaml": { "k
 
 ## Schemas
 
-By default yaml-language-server will attempt to determine the correct schema for a given yaml file and retrieve the appropriate JSON Schema from [Json Schema Store].
+By default yaml-language-server will attempt to determine the correct schema for a given yaml file and retrieve the appropriate JSON Schema from [Json Schema Store](https://schemastore.org/).
 
-You can override this by [using an inlined schema] reference via a modeline comment at the top of your yaml file:
+You can override any auto-detected schema via the `schemas` settings key (demonstrated above) or by providing an [inlined schema](https://github.com/redhat-developer/yaml-language-server#using-inlined-schema) reference via a modeline comment at the top of your yaml file:
 
 ```yaml
 # yaml-language-server: $schema=https://json.schemastore.org/github-action.json
@@ -44,12 +44,12 @@ on:
     types: [oppened]
 ```
 
-You can disable this functionality entirely if desired:
+You can disable the automatic detection and retrieval of schemas from the JSON Schema if desired:
 
 ```json
   "lsp": {
     "yaml-language-server": {
-      "initialization_options": {
+      "settings": {
         "yaml": {
           "schemaStore": {
             "enable": false
@@ -59,3 +59,73 @@ You can disable this functionality entirely if desired:
     }
   }
 ```
+
+## Custom Tags
+
+Yaml-language-server supports [custom tags](https://github.com/redhat-developer/yaml-language-server#adding-custom-tags) which can be used to inject custom application functionality at runtime into your yaml files.
+
+For example Amazon CloudFormation YAML uses a number of custom tags, to support these you can add the following to your settings.json:
+
+```json
+  "lsp": {
+    "yaml-language-server": {
+      "settings": {
+        "yaml": {
+          "customTags": [
+            "!And scalar",
+            "!And mapping",
+            "!And sequence",
+            "!If scalar",
+            "!If mapping",
+            "!If sequence",
+            "!Not scalar",
+            "!Not mapping",
+            "!Not sequence",
+            "!Equals scalar",
+            "!Equals mapping",
+            "!Equals sequence",
+            "!Or scalar",
+            "!Or mapping",
+            "!Or sequence",
+            "!FindInMap scalar",
+            "!FindInMap mapping",
+            "!FindInMap sequence",
+            "!Base64 scalar",
+            "!Base64 mapping",
+            "!Base64 sequence",
+            "!Cidr scalar",
+            "!Cidr mapping",
+            "!Cidr sequence",
+            "!Ref scalar",
+            "!Ref mapping",
+            "!Ref sequence",
+            "!Sub scalar",
+            "!Sub mapping",
+            "!Sub sequence",
+            "!GetAtt scalar",
+            "!GetAtt mapping",
+            "!GetAtt sequence",
+            "!GetAZs scalar",
+            "!GetAZs mapping",
+            "!GetAZs sequence",
+            "!ImportValue scalar",
+            "!ImportValue mapping",
+            "!ImportValue sequence",
+            "!Select scalar",
+            "!Select mapping",
+            "!Select sequence",
+            "!Split scalar",
+            "!Split mapping",
+            "!Split sequence",
+            "!Join scalar",
+            "!Join mapping",
+            "!Join sequence",
+            "!Condition scalar",
+            "!Condition mapping",
+            "!Condition sequence"
+          ]
+        }
+      }
+    }
+  }
+```

From 713b39bac0702b008c461c87764a603010562b65 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 19 Sep 2024 10:13:55 -0600
Subject: [PATCH 215/762] Auto deploy collab staging daily (#18085)

This should avoid us breaking the collab build and not noticing for a
month

Release Notes:

- N/A
---
 .github/workflows/bump_collab_staging.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/bump_collab_staging.yml b/.github/workflows/bump_collab_staging.yml
index 89cc7c48481d97..224325d53ffc2e 100644
--- a/.github/workflows/bump_collab_staging.yml
+++ b/.github/workflows/bump_collab_staging.yml
@@ -1,9 +1,9 @@
 name: Bump collab-staging Tag
 
 on:
-  push:
-    branches:
-      - main
+  schedule:
+    # Fire every day at 16:00 UTC (At the start of the US workday)
+    - cron: "0 16 * * *"
 
 jobs:
   update-collab-staging-tag:

From 3986bcf9dc23cd32b5155310136f53d9d8a5cc73 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 19 Sep 2024 10:14:37 -0600
Subject: [PATCH 216/762] Update Rust crate async-trait to v0.1.82 (#18038)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [async-trait](https://redirect.github.com/dtolnay/async-trait) |
workspace.dependencies | patch | `0.1.81` -> `0.1.82` |

---

### Release Notes

<details>
<summary>dtolnay/async-trait (async-trait)</summary>

###
[`v0.1.82`](https://redirect.github.com/dtolnay/async-trait/releases/tag/0.1.82)

[Compare
Source](https://redirect.github.com/dtolnay/async-trait/compare/0.1.81...0.1.82)

- Prevent elided_named_lifetimes lint being produced in generated code
([#&#8203;276](https://redirect.github.com/dtolnay/async-trait/issues/276))

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 16ee627d2c8f08..38c3e74ce15409 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -894,9 +894,9 @@ dependencies = [
 
 [[package]]
 name = "async-trait"
-version = "0.1.81"
+version = "0.1.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e0c28dcc82d7c8ead5cb13beb15405b57b8546e93215673ff8ca0349a028107"
+checksum = "a27b8a3a6e1a44fa4c8baf1f653e4172e81486d4941f2237e20dc2d0cf4ddff1"
 dependencies = [
  "proc-macro2",
  "quote",

From 6670c9eb3b5033caf4b78d59aecab9bee5cb09d1 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 19 Sep 2024 10:15:31 -0600
Subject: [PATCH 217/762] Update Rust crate backtrace to v0.3.74 (#18039)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [backtrace](https://redirect.github.com/rust-lang/backtrace-rs) |
dependencies | patch | `0.3.73` -> `0.3.74` |
| [backtrace](https://redirect.github.com/rust-lang/backtrace-rs) |
dev-dependencies | patch | `0.3.73` -> `0.3.74` |

---

### Release Notes

<details>
<summary>rust-lang/backtrace-rs (backtrace)</summary>

###
[`v0.3.74`](https://redirect.github.com/rust-lang/backtrace-rs/releases/tag/0.3.74)

[Compare
Source](https://redirect.github.com/rust-lang/backtrace-rs/compare/0.3.73...0.3.74)

#### What's Changed

- QNX Neutrino 7.0 support, thanks to
[@&#8203;nyurik](https://redirect.github.com/nyurik) in
[https://github.com/rust-lang/backtrace-rs/pull/648](https://redirect.github.com/rust-lang/backtrace-rs/pull/648)
- Cleaned up our Android support. This should massively improve
backtraces for ones with the API level sufficient to ship with
libunwind, etc. Unfortunately, it comes at the cost of dropping support
for older ones! Thanks to
[@&#8203;fengys](https://redirect.github.com/fengys) in
[https://github.com/rust-lang/backtrace-rs/pull/656](https://redirect.github.com/rust-lang/backtrace-rs/pull/656)
- Made PrintFmt, which was using the `Enum::__NonExhaustiveVariant`
pattern, use `#[non_exhaustive]` for real. Don't @&#8203; me if you were
matching on that! Thanks to
[@&#8203;nyurik](https://redirect.github.com/nyurik) in
[https://github.com/rust-lang/backtrace-rs/pull/651](https://redirect.github.com/rust-lang/backtrace-rs/pull/651)
- Massively cleaned up the windows code! We moved from winapi to
windows-sys with windows-targets thanks to
[@&#8203;CraftSpider](https://redirect.github.com/CraftSpider) and
[@&#8203;ChrisDenton](https://redirect.github.com/ChrisDenton) in
- Don't cast HANDLE to usize and back by
[@&#8203;CraftSpider](https://redirect.github.com/CraftSpider) in
[https://github.com/rust-lang/backtrace-rs/pull/635](https://redirect.github.com/rust-lang/backtrace-rs/pull/635)
- Switch from `winapi` to `windows-sys` by
[@&#8203;CraftSpider](https://redirect.github.com/CraftSpider) in
[https://github.com/rust-lang/backtrace-rs/pull/641](https://redirect.github.com/rust-lang/backtrace-rs/pull/641)
- Update windows bindings and use windows-targets by
[@&#8203;ChrisDenton](https://redirect.github.com/ChrisDenton) in
[https://github.com/rust-lang/backtrace-rs/pull/653](https://redirect.github.com/rust-lang/backtrace-rs/pull/653)
- A bunch of updated dependencies. Thanks
[@&#8203;djc](https://redirect.github.com/djc) and
[@&#8203;khuey](https://redirect.github.com/khuey)!
- Sorry if you were testing this code in miri! It started yelling about
sussy casts. A lot. We did a bunch of internal cleanups that should make
it quiet down, thanks to
[@&#8203;workingjubilee](https://redirect.github.com/workingjubilee) in
[https://github.com/rust-lang/backtrace-rs/pull/641](https://redirect.github.com/rust-lang/backtrace-rs/pull/641)
- Uhhh we had to tweak `dl_iterate_phdr` in
[https://github.com/rust-lang/backtrace-rs/pull/660](https://redirect.github.com/rust-lang/backtrace-rs/pull/660)
after Android revealed it was... kind of unsound actually and not doing
things like checking for null pointers before making slices! WHOOPS!
Thanks to [@&#8203;saethlin](https://redirect.github.com/saethlin) for
implementing detection for precisely that in rustc! It's really hard to
find soundness issues in inherited codebases like this one...

#### New Contributors

- [@&#8203;CraftSpider](https://redirect.github.com/CraftSpider) made
their first contribution in
[https://github.com/rust-lang/backtrace-rs/pull/635](https://redirect.github.com/rust-lang/backtrace-rs/pull/635)
- [@&#8203;fengys1996](https://redirect.github.com/fengys1996) made
their first contribution in
[https://github.com/rust-lang/backtrace-rs/pull/656](https://redirect.github.com/rust-lang/backtrace-rs/pull/656)
- [@&#8203;djc](https://redirect.github.com/djc) made their first
contribution in
[https://github.com/rust-lang/backtrace-rs/pull/657](https://redirect.github.com/rust-lang/backtrace-rs/pull/657)

**Full Changelog**:
https://github.com/rust-lang/backtrace-rs/compare/0.3.73...0.3.74

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about these
updates again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 30 ++++++++++++++++++------------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 38c3e74ce15409..4a1a58446977fe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -21,11 +21,11 @@ dependencies = [
 
 [[package]]
 name = "addr2line"
-version = "0.22.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
+checksum = "f5fb1d8e4442bd405fdfd1dacb42792696b0cf9cb15882e5d097b742a676d375"
 dependencies = [
- "gimli",
+ "gimli 0.31.0",
 ]
 
 [[package]]
@@ -1493,17 +1493,17 @@ dependencies = [
 
 [[package]]
 name = "backtrace"
-version = "0.3.73"
+version = "0.3.74"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a"
+checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a"
 dependencies = [
  "addr2line",
- "cc",
  "cfg-if",
  "libc",
- "miniz_oxide 0.7.4",
+ "miniz_oxide 0.8.0",
  "object",
  "rustc-demangle",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -3083,7 +3083,7 @@ dependencies = [
  "cranelift-control",
  "cranelift-entity",
  "cranelift-isle",
- "gimli",
+ "gimli 0.29.0",
  "hashbrown 0.14.5",
  "log",
  "regalloc2",
@@ -4873,6 +4873,12 @@ dependencies = [
  "stable_deref_trait",
 ]
 
+[[package]]
+name = "gimli"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32085ea23f3234fc7846555e85283ba4de91e21016dc0455a16286d87a292d64"
+
 [[package]]
 name = "git"
 version = "0.1.0"
@@ -13108,7 +13114,7 @@ dependencies = [
  "cranelift-frontend",
  "cranelift-native",
  "cranelift-wasm",
- "gimli",
+ "gimli 0.29.0",
  "log",
  "object",
  "target-lexicon",
@@ -13128,7 +13134,7 @@ dependencies = [
  "cpp_demangle",
  "cranelift-bitset",
  "cranelift-entity",
- "gimli",
+ "gimli 0.29.0",
  "indexmap 2.4.0",
  "log",
  "object",
@@ -13242,7 +13248,7 @@ checksum = "2a25199625effa4c13dd790d64bd56884b014c69829431bfe43991c740bd5bc1"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
- "gimli",
+ "gimli 0.29.0",
  "object",
  "target-lexicon",
  "wasmparser 0.215.0",
@@ -13539,7 +13545,7 @@ checksum = "073efe897d9ead7fc609874f94580afc831114af5149b6a90ee0a3a39b497fe0"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
- "gimli",
+ "gimli 0.29.0",
  "regalloc2",
  "smallvec",
  "target-lexicon",

From 157c57aa8d3e35a5d7d750ae552740b412b5911b Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 19 Sep 2024 10:15:46 -0600
Subject: [PATCH 218/762] Update Rust crate clap to v4.5.17 (#18041)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [clap](https://redirect.github.com/clap-rs/clap) |
workspace.dependencies | patch | `4.5.16` -> `4.5.17` |

---

### Release Notes

<details>
<summary>clap-rs/clap (clap)</summary>

###
[`v4.5.17`](https://redirect.github.com/clap-rs/clap/blob/HEAD/CHANGELOG.md#4517---2024-09-04)

[Compare
Source](https://redirect.github.com/clap-rs/clap/compare/v4.5.16...v4.5.17)

##### Fixes

-   *(help)* Style required argument groups
-   *(derive)* Improve error messages when unsupported fields are used

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4a1a58446977fe..68625d5520a047 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2282,9 +2282,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.16"
+version = "4.5.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed6719fffa43d0d87e5fd8caeab59be1554fb028cd30edc88fc4369b17971019"
+checksum = "3e5a21b8495e732f1b3c364c9949b201ca7bae518c502c80256c96ad79eaf6ac"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -2292,9 +2292,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.15"
+version = "4.5.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "216aec2b177652e3846684cbfe25c9964d18ec45234f0f5da5157b207ed1aab6"
+checksum = "8cf2dd12af7a047ad9d6da2b6b249759a22a7abc0f474c1dae1777afa4b21a73"
 dependencies = [
  "anstream",
  "anstyle",

From ce4f07bd3cbfa20a95e14af112e83002bfd486d4 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 19 Sep 2024 10:16:31 -0600
Subject: [PATCH 219/762] Update Rust crate globset to v0.4.15 (#18042)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
|
[globset](https://redirect.github.com/BurntSushi/ripgrep/tree/master/crates/globset)
([source](https://redirect.github.com/BurntSushi/ripgrep/tree/HEAD/crates/globset))
| workspace.dependencies | patch | `0.4.14` -> `0.4.15` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 68625d5520a047..7c298c2a9ad31c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4946,9 +4946,9 @@ checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
 
 [[package]]
 name = "globset"
-version = "0.4.14"
+version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57da3b9b5b85bd66f31093f8c408b90a74431672542466497dcbdfdc02034be1"
+checksum = "15f1ce686646e7f1e19bf7d5533fe443a45dbfb990e00629110797578b42fb19"
 dependencies = [
  "aho-corasick",
  "bstr",

From c3bdc1c178190dd223d6b4718905f86822329da3 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 19 Sep 2024 10:18:14 -0600
Subject: [PATCH 220/762] Update Rust crate ignore to v0.4.23 (#18044)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
|
[ignore](https://redirect.github.com/BurntSushi/ripgrep/tree/master/crates/ignore)
([source](https://redirect.github.com/BurntSushi/ripgrep/tree/HEAD/crates/ignore))
| workspace.dependencies | patch | `0.4.22` -> `0.4.23` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7c298c2a9ad31c..26b8847041ba60 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5688,9 +5688,9 @@ dependencies = [
 
 [[package]]
 name = "ignore"
-version = "0.4.22"
+version = "0.4.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b46810df39e66e925525d6e38ce1e7f6e1d208f72dc39757880fcb66e2c58af1"
+checksum = "6d89fd380afde86567dfba715db065673989d6253f42b88179abd3eae47bda4b"
 dependencies = [
  "crossbeam-deque",
  "globset",
@@ -6474,7 +6474,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
  "cfg-if",
- "windows-targets 0.52.6",
+ "windows-targets 0.48.5",
 ]
 
 [[package]]
@@ -13528,7 +13528,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]

From ac0d5d3152fe09201b907210c917e82fee62d450 Mon Sep 17 00:00:00 2001
From: Junkui Zhang <364772080@qq.com>
Date: Fri, 20 Sep 2024 00:19:13 +0800
Subject: [PATCH 221/762] windows: Fix regional indicator symbols broken
 (#18053)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes #18027


Unlike macOS, not all glyphs in color fonts are color glyphs, such as
`🇩🇪` in `Segoe UI Emoji`. As a result, attempting to retrieve color
information for these glyphs can cause an error, preventing the glyph
from being rendered.

This PR addresses the issue by setting the `is_emoji` variable to
`false` for non-color glyphs within color fonts.



Release Notes:

- N/A
---
 .../gpui/src/platform/windows/direct_write.rs | 42 ++++++++++++++++++-
 1 file changed, 41 insertions(+), 1 deletion(-)

diff --git a/crates/gpui/src/platform/windows/direct_write.rs b/crates/gpui/src/platform/windows/direct_write.rs
index 6253881f5aca8b..fb53a833d64e66 100644
--- a/crates/gpui/src/platform/windows/direct_write.rs
+++ b/crates/gpui/src/platform/windows/direct_write.rs
@@ -1063,7 +1063,7 @@ impl IDWriteTextRenderer_Impl for TextRenderer_Impl {
             // This `cast()` action here should never fail since we are running on Win10+, and
             // `IDWriteFontFace3` requires Win10
             let font_face = &font_face.cast::<IDWriteFontFace3>().unwrap();
-            let Some((font_identifier, font_struct, is_emoji)) =
+            let Some((font_identifier, font_struct, color_font)) =
                 get_font_identifier_and_font_struct(font_face, &self.locale)
             else {
                 return Ok(());
@@ -1084,6 +1084,8 @@ impl IDWriteTextRenderer_Impl for TextRenderer_Impl {
                 context
                     .index_converter
                     .advance_to_utf16_ix(context.utf16_index);
+                let is_emoji = color_font
+                    && is_color_glyph(font_face, id, &context.text_system.components.factory);
                 glyphs.push(ShapedGlyph {
                     id,
                     position: point(px(context.width), px(0.0)),
@@ -1446,6 +1448,44 @@ fn get_render_target_property(
     }
 }
 
+// One would think that with newer DirectWrite method: IDWriteFontFace4::GetGlyphImageFormats
+// but that doesn't seem to work for some glyphs, say ❤
+fn is_color_glyph(
+    font_face: &IDWriteFontFace3,
+    glyph_id: GlyphId,
+    factory: &IDWriteFactory5,
+) -> bool {
+    let glyph_run = DWRITE_GLYPH_RUN {
+        fontFace: unsafe { std::mem::transmute_copy(font_face) },
+        fontEmSize: 14.0,
+        glyphCount: 1,
+        glyphIndices: &(glyph_id.0 as u16),
+        glyphAdvances: &0.0,
+        glyphOffsets: &DWRITE_GLYPH_OFFSET {
+            advanceOffset: 0.0,
+            ascenderOffset: 0.0,
+        },
+        isSideways: BOOL(0),
+        bidiLevel: 0,
+    };
+    unsafe {
+        factory.TranslateColorGlyphRun(
+            D2D_POINT_2F::default(),
+            &glyph_run as _,
+            None,
+            DWRITE_GLYPH_IMAGE_FORMATS_COLR
+                | DWRITE_GLYPH_IMAGE_FORMATS_SVG
+                | DWRITE_GLYPH_IMAGE_FORMATS_PNG
+                | DWRITE_GLYPH_IMAGE_FORMATS_JPEG
+                | DWRITE_GLYPH_IMAGE_FORMATS_PREMULTIPLIED_B8G8R8A8,
+            DWRITE_MEASURING_MODE_NATURAL,
+            None,
+            0,
+        )
+    }
+    .is_ok()
+}
+
 const DEFAULT_LOCALE_NAME: PCWSTR = windows::core::w!("en-US");
 const BRUSH_COLOR: D2D1_COLOR_F = D2D1_COLOR_F {
     r: 1.0,

From 8074fba76b4352077fed94364fcfb9d095f177a9 Mon Sep 17 00:00:00 2001
From: Nate Butler <iamnbutler@gmail.com>
Date: Thu, 19 Sep 2024 12:31:40 -0400
Subject: [PATCH 222/762] Update List to support UI Density (#18079)

Tracking issue: #18078

Improve UI Density support for List.

UI density is an unstable feature. You can read more about it in the
above issue!

| Before Normal - Before Dense - After Normal - After Dense |
|--------------------------------------------------------|
| ![Group
8](https://github.com/user-attachments/assets/bb896fcf-e4a6-4776-9308-1405906d2dbe)
| | | |

| Before Normal - Before Dense - After Normal - After Dense |
|--------------------------------------------------------|
| ![Group
9](https://github.com/user-attachments/assets/00815a1b-071b-4d02-96bc-36bf37b5ae8b)
|

Release Notes:

- N/A
---
 crates/ui/src/components/list/list.rs         | 12 ++--
 crates/ui/src/components/list/list_header.rs  | 15 +++--
 crates/ui/src/components/list/list_item.rs    |  8 +--
 .../ui/src/components/list/list_separator.rs  |  2 +-
 .../ui/src/components/list/list_sub_header.rs | 57 +++++++++++--------
 5 files changed, 55 insertions(+), 39 deletions(-)

diff --git a/crates/ui/src/components/list/list.rs b/crates/ui/src/components/list/list.rs
index a09abf92e45cd4..4bf157ef4067d8 100644
--- a/crates/ui/src/components/list/list.rs
+++ b/crates/ui/src/components/list/list.rs
@@ -52,13 +52,15 @@ impl ParentElement for List {
 }
 
 impl RenderOnce for List {
-    fn render(self, _cx: &mut WindowContext) -> impl IntoElement {
-        v_flex().w_full().py_1().children(self.header).map(|this| {
-            match (self.children.is_empty(), self.toggle) {
+    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
+        v_flex()
+            .w_full()
+            .py(Spacing::Small.rems(cx))
+            .children(self.header)
+            .map(|this| match (self.children.is_empty(), self.toggle) {
                 (false, _) => this.children(self.children),
                 (true, Some(false)) => this,
                 (true, _) => this.child(Label::new(self.empty_message.clone()).color(Color::Muted)),
-            }
-        })
+            })
     }
 }
diff --git a/crates/ui/src/components/list/list_header.rs b/crates/ui/src/components/list/list_header.rs
index 4377efbc46772e..3b15f8cd3dd090 100644
--- a/crates/ui/src/components/list/list_header.rs
+++ b/crates/ui/src/components/list/list_header.rs
@@ -2,6 +2,8 @@ use std::sync::Arc;
 
 use crate::{h_flex, prelude::*, Disclosure, Label};
 use gpui::{AnyElement, ClickEvent};
+use settings::Settings;
+use theme::ThemeSettings;
 
 #[derive(IntoElement)]
 pub struct ListHeader {
@@ -78,6 +80,8 @@ impl Selectable for ListHeader {
 
 impl RenderOnce for ListHeader {
     fn render(self, cx: &mut WindowContext) -> impl IntoElement {
+        let ui_density = ThemeSettings::get_global(cx).ui_density;
+
         h_flex()
             .id(self.label.clone())
             .w_full()
@@ -85,7 +89,10 @@ impl RenderOnce for ListHeader {
             .group("list_header")
             .child(
                 div()
-                    .h_7()
+                    .map(|this| match ui_density {
+                        theme::UiDensity::Comfortable => this.h_5(),
+                        _ => this.h_7(),
+                    })
                     .when(self.inset, |this| this.px_2())
                     .when(self.selected, |this| {
                         this.bg(cx.theme().colors().ghost_element_selected)
@@ -95,10 +102,10 @@ impl RenderOnce for ListHeader {
                     .items_center()
                     .justify_between()
                     .w_full()
-                    .gap_1()
+                    .gap(Spacing::Small.rems(cx))
                     .child(
                         h_flex()
-                            .gap_1()
+                            .gap(Spacing::Small.rems(cx))
                             .children(self.toggle.map(|is_open| {
                                 Disclosure::new("toggle", is_open).on_toggle(self.on_toggle.clone())
                             }))
@@ -106,7 +113,7 @@ impl RenderOnce for ListHeader {
                                 div()
                                     .id("label_container")
                                     .flex()
-                                    .gap_1()
+                                    .gap(Spacing::Small.rems(cx))
                                     .items_center()
                                     .children(self.start_slot)
                                     .child(Label::new(self.label.clone()).color(Color::Muted))
diff --git a/crates/ui/src/components/list/list_item.rs b/crates/ui/src/components/list/list_item.rs
index 6b38b7f963fee3..e1c90894fdd3d2 100644
--- a/crates/ui/src/components/list/list_item.rs
+++ b/crates/ui/src/components/list/list_item.rs
@@ -162,7 +162,7 @@ impl RenderOnce for ListItem {
             // When an item is inset draw the indent spacing outside of the item
             .when(self.inset, |this| {
                 this.ml(self.indent_level as f32 * self.indent_step_size)
-                    .px_1()
+                    .px(Spacing::Small.rems(cx))
             })
             .when(!self.inset && !self.disabled, |this| {
                 this
@@ -185,7 +185,7 @@ impl RenderOnce for ListItem {
                     .w_full()
                     .relative()
                     .gap_1()
-                    .px_1p5()
+                    .px(Spacing::Medium.rems(cx))
                     .map(|this| match self.spacing {
                         ListItemSpacing::Dense => this,
                         ListItemSpacing::Sparse => this.py_1(),
@@ -238,7 +238,7 @@ impl RenderOnce for ListItem {
                             .flex_grow()
                             .flex_shrink_0()
                             .flex_basis(relative(0.25))
-                            .gap_1()
+                            .gap(Spacing::Small.rems(cx))
                             .overflow_hidden()
                             .children(self.start_slot)
                             .children(self.children),
@@ -260,7 +260,7 @@ impl RenderOnce for ListItem {
                             h_flex()
                                 .h_full()
                                 .absolute()
-                                .right_1p5()
+                                .right(Spacing::Medium.rems(cx))
                                 .top_0()
                                 .visible_on_hover("list_item")
                                 .child(end_hover_slot),
diff --git a/crates/ui/src/components/list/list_separator.rs b/crates/ui/src/components/list/list_separator.rs
index b53dc7a0433d6b..0d5fdf8d494fbe 100644
--- a/crates/ui/src/components/list/list_separator.rs
+++ b/crates/ui/src/components/list/list_separator.rs
@@ -8,7 +8,7 @@ impl RenderOnce for ListSeparator {
         div()
             .h_px()
             .w_full()
-            .my_1p5()
+            .my(Spacing::Medium.rems(cx))
             .bg(cx.theme().colors().border_variant)
     }
 }
diff --git a/crates/ui/src/components/list/list_sub_header.rs b/crates/ui/src/components/list/list_sub_header.rs
index 2aa9387129beb2..0ed072ebbf2c90 100644
--- a/crates/ui/src/components/list/list_sub_header.rs
+++ b/crates/ui/src/components/list/list_sub_header.rs
@@ -39,30 +39,37 @@ impl Selectable for ListSubHeader {
 
 impl RenderOnce for ListSubHeader {
     fn render(self, cx: &mut WindowContext) -> impl IntoElement {
-        h_flex().flex_1().w_full().relative().pb_1().px_0p5().child(
-            div()
-                .h_6()
-                .when(self.inset, |this| this.px_2())
-                .when(self.selected, |this| {
-                    this.bg(cx.theme().colors().ghost_element_selected)
-                })
-                .flex()
-                .flex_1()
-                .w_full()
-                .gap_1()
-                .items_center()
-                .justify_between()
-                .child(
-                    div()
-                        .flex()
-                        .gap_1()
-                        .items_center()
-                        .children(
-                            self.start_slot
-                                .map(|i| Icon::new(i).color(Color::Muted).size(IconSize::Small)),
-                        )
-                        .child(Label::new(self.label.clone()).color(Color::Muted)),
-                ),
-        )
+        h_flex()
+            .flex_1()
+            .w_full()
+            .relative()
+            .pb(Spacing::Small.rems(cx))
+            .px(Spacing::XSmall.rems(cx))
+            .child(
+                div()
+                    .h_6()
+                    .when(self.inset, |this| this.px_2())
+                    .when(self.selected, |this| {
+                        this.bg(cx.theme().colors().ghost_element_selected)
+                    })
+                    .flex()
+                    .flex_1()
+                    .w_full()
+                    .gap_1()
+                    .items_center()
+                    .justify_between()
+                    .child(
+                        div()
+                            .flex()
+                            .gap_1()
+                            .items_center()
+                            .children(
+                                self.start_slot.map(|i| {
+                                    Icon::new(i).color(Color::Muted).size(IconSize::Small)
+                                }),
+                            )
+                            .child(Label::new(self.label.clone()).color(Color::Muted)),
+                    ),
+            )
     }
 }

From 1fc391f696a828780b6a651df0b797be91aee91e Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 19 Sep 2024 13:14:15 -0400
Subject: [PATCH 223/762] Make `Buffer::apply_ops` infallible (#18089)

This PR makes the `Buffer::apply_ops` method infallible for
`text::Buffer` and `language::Buffer`.

We discovered that `text::Buffer::apply_ops` was only fallible due to
`apply_undo`, which didn't actually need to be fallible.

Release Notes:

- N/A
---
 crates/assistant/src/context.rs               |  8 ++--
 crates/assistant/src/context/context_tests.rs |  8 +---
 crates/assistant/src/context_store.rs         |  6 +--
 crates/channel/src/channel_buffer.rs          |  4 +-
 crates/channel/src/channel_store.rs           |  2 +-
 crates/collab/src/db/queries/buffers.rs       |  4 +-
 crates/collab/src/db/tests/buffer_tests.rs    | 18 ++++----
 crates/language/src/buffer.rs                 |  5 +-
 crates/language/src/buffer_tests.rs           | 46 ++++++++-----------
 crates/multi_buffer/src/multi_buffer.rs       | 12 ++---
 crates/project/src/buffer_store.rs            |  9 ++--
 crates/text/src/tests.rs                      | 32 ++++++-------
 crates/text/src/text.rs                       | 39 +++++++---------
 13 files changed, 85 insertions(+), 108 deletions(-)

diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index d72b04e3cddb17..830c0980491f7c 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -683,7 +683,7 @@ impl Context {
             buffer.set_text(saved_context.text.as_str(), cx)
         });
         let operations = saved_context.into_ops(&this.buffer, cx);
-        this.apply_ops(operations, cx).unwrap();
+        this.apply_ops(operations, cx);
         this
     }
 
@@ -756,7 +756,7 @@ impl Context {
         &mut self,
         ops: impl IntoIterator<Item = ContextOperation>,
         cx: &mut ModelContext<Self>,
-    ) -> Result<()> {
+    ) {
         let mut buffer_ops = Vec::new();
         for op in ops {
             match op {
@@ -765,10 +765,8 @@ impl Context {
             }
         }
         self.buffer
-            .update(cx, |buffer, cx| buffer.apply_ops(buffer_ops, cx))?;
+            .update(cx, |buffer, cx| buffer.apply_ops(buffer_ops, cx));
         self.flush_ops(cx);
-
-        Ok(())
     }
 
     fn flush_ops(&mut self, cx: &mut ModelContext<Context>) {
diff --git a/crates/assistant/src/context/context_tests.rs b/crates/assistant/src/context/context_tests.rs
index 842ac050786344..2d6a2894c9521a 100644
--- a/crates/assistant/src/context/context_tests.rs
+++ b/crates/assistant/src/context/context_tests.rs
@@ -1166,9 +1166,7 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
                     );
 
                     network.lock().broadcast(replica_id, ops_to_send);
-                    context
-                        .update(cx, |context, cx| context.apply_ops(ops_to_receive, cx))
-                        .unwrap();
+                    context.update(cx, |context, cx| context.apply_ops(ops_to_receive, cx));
                 } else if rng.gen_bool(0.1) && replica_id != 0 {
                     log::info!("Context {}: disconnecting", context_index);
                     network.lock().disconnect_peer(replica_id);
@@ -1180,9 +1178,7 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
                         .map(ContextOperation::from_proto)
                         .collect::<Result<Vec<_>>>()
                         .unwrap();
-                    context
-                        .update(cx, |context, cx| context.apply_ops(ops, cx))
-                        .unwrap();
+                    context.update(cx, |context, cx| context.apply_ops(ops, cx));
                 }
             }
         }
diff --git a/crates/assistant/src/context_store.rs b/crates/assistant/src/context_store.rs
index 867d9067914854..f57a2fbca613c3 100644
--- a/crates/assistant/src/context_store.rs
+++ b/crates/assistant/src/context_store.rs
@@ -223,7 +223,7 @@ impl ContextStore {
             if let Some(context) = this.loaded_context_for_id(&context_id, cx) {
                 let operation_proto = envelope.payload.operation.context("invalid operation")?;
                 let operation = ContextOperation::from_proto(operation_proto)?;
-                context.update(cx, |context, cx| context.apply_ops([operation], cx))?;
+                context.update(cx, |context, cx| context.apply_ops([operation], cx));
             }
             Ok(())
         })?
@@ -394,7 +394,7 @@ impl ContextStore {
                         .collect::<Result<Vec<_>>>()
                 })
                 .await?;
-            context.update(&mut cx, |context, cx| context.apply_ops(operations, cx))??;
+            context.update(&mut cx, |context, cx| context.apply_ops(operations, cx))?;
             this.update(&mut cx, |this, cx| {
                 if let Some(existing_context) = this.loaded_context_for_id(&context_id, cx) {
                     existing_context
@@ -531,7 +531,7 @@ impl ContextStore {
                         .collect::<Result<Vec<_>>>()
                 })
                 .await?;
-            context.update(&mut cx, |context, cx| context.apply_ops(operations, cx))??;
+            context.update(&mut cx, |context, cx| context.apply_ops(operations, cx))?;
             this.update(&mut cx, |this, cx| {
                 if let Some(existing_context) = this.loaded_context_for_id(&context_id, cx) {
                     existing_context
diff --git a/crates/channel/src/channel_buffer.rs b/crates/channel/src/channel_buffer.rs
index df3e66483f873f..755e7400e1b66e 100644
--- a/crates/channel/src/channel_buffer.rs
+++ b/crates/channel/src/channel_buffer.rs
@@ -66,7 +66,7 @@ impl ChannelBuffer {
             let capability = channel_store.read(cx).channel_capability(channel.id);
             language::Buffer::remote(buffer_id, response.replica_id as u16, capability, base_text)
         })?;
-        buffer.update(&mut cx, |buffer, cx| buffer.apply_ops(operations, cx))??;
+        buffer.update(&mut cx, |buffer, cx| buffer.apply_ops(operations, cx))?;
 
         let subscription = client.subscribe_to_entity(channel.id.0)?;
 
@@ -151,7 +151,7 @@ impl ChannelBuffer {
             cx.notify();
             this.buffer
                 .update(cx, |buffer, cx| buffer.apply_ops(ops, cx))
-        })??;
+        })?;
 
         Ok(())
     }
diff --git a/crates/channel/src/channel_store.rs b/crates/channel/src/channel_store.rs
index 9bd5fd564f29dc..fc5b12cfae1c39 100644
--- a/crates/channel/src/channel_store.rs
+++ b/crates/channel/src/channel_store.rs
@@ -1007,7 +1007,7 @@ impl ChannelStore {
                                                 .into_iter()
                                                 .map(language::proto::deserialize_operation)
                                                 .collect::<Result<Vec<_>>>()?;
-                                        buffer.apply_ops(incoming_operations, cx)?;
+                                        buffer.apply_ops(incoming_operations, cx);
                                         anyhow::Ok(outgoing_operations)
                                     })
                                     .log_err();
diff --git a/crates/collab/src/db/queries/buffers.rs b/crates/collab/src/db/queries/buffers.rs
index 7b19dee315476d..06ad2b45946511 100644
--- a/crates/collab/src/db/queries/buffers.rs
+++ b/crates/collab/src/db/queries/buffers.rs
@@ -689,9 +689,7 @@ impl Database {
         }
 
         let mut text_buffer = text::Buffer::new(0, text::BufferId::new(1).unwrap(), base_text);
-        text_buffer
-            .apply_ops(operations.into_iter().filter_map(operation_from_wire))
-            .unwrap();
+        text_buffer.apply_ops(operations.into_iter().filter_map(operation_from_wire));
 
         let base_text = text_buffer.text();
         let epoch = buffer.epoch + 1;
diff --git a/crates/collab/src/db/tests/buffer_tests.rs b/crates/collab/src/db/tests/buffer_tests.rs
index 55a8f216c49406..adc571580a0724 100644
--- a/crates/collab/src/db/tests/buffer_tests.rs
+++ b/crates/collab/src/db/tests/buffer_tests.rs
@@ -96,16 +96,14 @@ async fn test_channel_buffers(db: &Arc<Database>) {
         text::BufferId::new(1).unwrap(),
         buffer_response_b.base_text,
     );
-    buffer_b
-        .apply_ops(buffer_response_b.operations.into_iter().map(|operation| {
-            let operation = proto::deserialize_operation(operation).unwrap();
-            if let language::Operation::Buffer(operation) = operation {
-                operation
-            } else {
-                unreachable!()
-            }
-        }))
-        .unwrap();
+    buffer_b.apply_ops(buffer_response_b.operations.into_iter().map(|operation| {
+        let operation = proto::deserialize_operation(operation).unwrap();
+        if let language::Operation::Buffer(operation) = operation {
+            operation
+        } else {
+            unreachable!()
+        }
+    }));
 
     assert_eq!(buffer_b.text(), "hello, cruel world");
 
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 43fe1565acb796..08fc1ccdb45d5b 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -1972,7 +1972,7 @@ impl Buffer {
         &mut self,
         ops: I,
         cx: &mut ModelContext<Self>,
-    ) -> Result<()> {
+    ) {
         self.pending_autoindent.take();
         let was_dirty = self.is_dirty();
         let old_version = self.version.clone();
@@ -1991,14 +1991,13 @@ impl Buffer {
                 }
             })
             .collect::<Vec<_>>();
-        self.text.apply_ops(buffer_ops)?;
+        self.text.apply_ops(buffer_ops);
         self.deferred_ops.insert(deferred_ops);
         self.flush_deferred_ops(cx);
         self.did_edit(&old_version, was_dirty, cx);
         // Notify independently of whether the buffer was edited as the operations could include a
         // selection update.
         cx.notify();
-        Ok(())
     }
 
     fn flush_deferred_ops(&mut self, cx: &mut ModelContext<Self>) {
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index 50dea8d2562b00..23faa33316da79 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -308,7 +308,7 @@ fn test_edit_events(cx: &mut gpui::AppContext) {
     // Incorporating a set of remote ops emits a single edited event,
     // followed by a dirty changed event.
     buffer2.update(cx, |buffer, cx| {
-        buffer.apply_ops(buffer1_ops.lock().drain(..), cx).unwrap();
+        buffer.apply_ops(buffer1_ops.lock().drain(..), cx);
     });
     assert_eq!(
         mem::take(&mut *buffer_1_events.lock()),
@@ -332,7 +332,7 @@ fn test_edit_events(cx: &mut gpui::AppContext) {
     // Incorporating the remote ops again emits a single edited event,
     // followed by a dirty changed event.
     buffer2.update(cx, |buffer, cx| {
-        buffer.apply_ops(buffer1_ops.lock().drain(..), cx).unwrap();
+        buffer.apply_ops(buffer1_ops.lock().drain(..), cx);
     });
     assert_eq!(
         mem::take(&mut *buffer_1_events.lock()),
@@ -2274,13 +2274,11 @@ fn test_serialization(cx: &mut gpui::AppContext) {
         .block(buffer1.read(cx).serialize_ops(None, cx));
     let buffer2 = cx.new_model(|cx| {
         let mut buffer = Buffer::from_proto(1, Capability::ReadWrite, state, None).unwrap();
-        buffer
-            .apply_ops(
-                ops.into_iter()
-                    .map(|op| proto::deserialize_operation(op).unwrap()),
-                cx,
-            )
-            .unwrap();
+        buffer.apply_ops(
+            ops.into_iter()
+                .map(|op| proto::deserialize_operation(op).unwrap()),
+            cx,
+        );
         buffer
     });
     assert_eq!(buffer2.read(cx).text(), "abcDF");
@@ -2401,13 +2399,11 @@ fn test_random_collaboration(cx: &mut AppContext, mut rng: StdRng) {
                 .block(base_buffer.read(cx).serialize_ops(None, cx));
             let mut buffer =
                 Buffer::from_proto(i as ReplicaId, Capability::ReadWrite, state, None).unwrap();
-            buffer
-                .apply_ops(
-                    ops.into_iter()
-                        .map(|op| proto::deserialize_operation(op).unwrap()),
-                    cx,
-                )
-                .unwrap();
+            buffer.apply_ops(
+                ops.into_iter()
+                    .map(|op| proto::deserialize_operation(op).unwrap()),
+                cx,
+            );
             buffer.set_group_interval(Duration::from_millis(rng.gen_range(0..=200)));
             let network = network.clone();
             cx.subscribe(&cx.handle(), move |buffer, _, event, _| {
@@ -2523,14 +2519,12 @@ fn test_random_collaboration(cx: &mut AppContext, mut rng: StdRng) {
                         None,
                     )
                     .unwrap();
-                    new_buffer
-                        .apply_ops(
-                            old_buffer_ops
-                                .into_iter()
-                                .map(|op| deserialize_operation(op).unwrap()),
-                            cx,
-                        )
-                        .unwrap();
+                    new_buffer.apply_ops(
+                        old_buffer_ops
+                            .into_iter()
+                            .map(|op| deserialize_operation(op).unwrap()),
+                        cx,
+                    );
                     log::info!(
                         "New replica {} text: {:?}",
                         new_buffer.replica_id(),
@@ -2570,7 +2564,7 @@ fn test_random_collaboration(cx: &mut AppContext, mut rng: StdRng) {
                                 ops
                             );
                             new_buffer.update(cx, |new_buffer, cx| {
-                                new_buffer.apply_ops(ops, cx).unwrap();
+                                new_buffer.apply_ops(ops, cx);
                             });
                         }
                     }
@@ -2598,7 +2592,7 @@ fn test_random_collaboration(cx: &mut AppContext, mut rng: StdRng) {
                         ops.len(),
                         ops
                     );
-                    buffer.update(cx, |buffer, cx| buffer.apply_ops(ops, cx).unwrap());
+                    buffer.update(cx, |buffer, cx| buffer.apply_ops(ops, cx));
                 }
             }
             _ => {}
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index 9dee092dea9f29..29bd9a80682a10 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -5019,13 +5019,11 @@ mod tests {
                 .background_executor()
                 .block(host_buffer.read(cx).serialize_ops(None, cx));
             let mut buffer = Buffer::from_proto(1, Capability::ReadWrite, state, None).unwrap();
-            buffer
-                .apply_ops(
-                    ops.into_iter()
-                        .map(|op| language::proto::deserialize_operation(op).unwrap()),
-                    cx,
-                )
-                .unwrap();
+            buffer.apply_ops(
+                ops.into_iter()
+                    .map(|op| language::proto::deserialize_operation(op).unwrap()),
+                cx,
+            );
             buffer
         });
         let multibuffer = cx.new_model(|cx| MultiBuffer::singleton(guest_buffer.clone(), cx));
diff --git a/crates/project/src/buffer_store.rs b/crates/project/src/buffer_store.rs
index ead32359970e25..0045aba2e89ecf 100644
--- a/crates/project/src/buffer_store.rs
+++ b/crates/project/src/buffer_store.rs
@@ -644,7 +644,7 @@ impl BufferStore {
             }
             hash_map::Entry::Occupied(mut entry) => {
                 if let OpenBuffer::Operations(operations) = entry.get_mut() {
-                    buffer.update(cx, |b, cx| b.apply_ops(operations.drain(..), cx))?;
+                    buffer.update(cx, |b, cx| b.apply_ops(operations.drain(..), cx));
                 } else if entry.get().upgrade().is_some() {
                     if is_remote {
                         return Ok(());
@@ -1051,12 +1051,12 @@ impl BufferStore {
             match this.opened_buffers.entry(buffer_id) {
                 hash_map::Entry::Occupied(mut e) => match e.get_mut() {
                     OpenBuffer::Strong(buffer) => {
-                        buffer.update(cx, |buffer, cx| buffer.apply_ops(ops, cx))?;
+                        buffer.update(cx, |buffer, cx| buffer.apply_ops(ops, cx));
                     }
                     OpenBuffer::Operations(operations) => operations.extend_from_slice(&ops),
                     OpenBuffer::Weak(buffer) => {
                         if let Some(buffer) = buffer.upgrade() {
-                            buffer.update(cx, |buffer, cx| buffer.apply_ops(ops, cx))?;
+                            buffer.update(cx, |buffer, cx| buffer.apply_ops(ops, cx));
                         }
                     }
                 },
@@ -1217,7 +1217,8 @@ impl BufferStore {
                         .into_iter()
                         .map(language::proto::deserialize_operation)
                         .collect::<Result<Vec<_>>>()?;
-                    buffer.update(cx, |buffer, cx| buffer.apply_ops(operations, cx))
+                    buffer.update(cx, |buffer, cx| buffer.apply_ops(operations, cx));
+                    anyhow::Ok(())
                 });
 
                 if let Err(error) = result {
diff --git a/crates/text/src/tests.rs b/crates/text/src/tests.rs
index 6f748fb5880b31..8c5d7014eebda0 100644
--- a/crates/text/src/tests.rs
+++ b/crates/text/src/tests.rs
@@ -515,25 +515,25 @@ fn test_undo_redo() {
     let entries = buffer.history.undo_stack.clone();
     assert_eq!(entries.len(), 3);
 
-    buffer.undo_or_redo(entries[0].transaction.clone()).unwrap();
+    buffer.undo_or_redo(entries[0].transaction.clone());
     assert_eq!(buffer.text(), "1cdef234");
-    buffer.undo_or_redo(entries[0].transaction.clone()).unwrap();
+    buffer.undo_or_redo(entries[0].transaction.clone());
     assert_eq!(buffer.text(), "1abcdef234");
 
-    buffer.undo_or_redo(entries[1].transaction.clone()).unwrap();
+    buffer.undo_or_redo(entries[1].transaction.clone());
     assert_eq!(buffer.text(), "1abcdx234");
-    buffer.undo_or_redo(entries[2].transaction.clone()).unwrap();
+    buffer.undo_or_redo(entries[2].transaction.clone());
     assert_eq!(buffer.text(), "1abx234");
-    buffer.undo_or_redo(entries[1].transaction.clone()).unwrap();
+    buffer.undo_or_redo(entries[1].transaction.clone());
     assert_eq!(buffer.text(), "1abyzef234");
-    buffer.undo_or_redo(entries[2].transaction.clone()).unwrap();
+    buffer.undo_or_redo(entries[2].transaction.clone());
     assert_eq!(buffer.text(), "1abcdef234");
 
-    buffer.undo_or_redo(entries[2].transaction.clone()).unwrap();
+    buffer.undo_or_redo(entries[2].transaction.clone());
     assert_eq!(buffer.text(), "1abyzef234");
-    buffer.undo_or_redo(entries[0].transaction.clone()).unwrap();
+    buffer.undo_or_redo(entries[0].transaction.clone());
     assert_eq!(buffer.text(), "1yzef234");
-    buffer.undo_or_redo(entries[1].transaction.clone()).unwrap();
+    buffer.undo_or_redo(entries[1].transaction.clone());
     assert_eq!(buffer.text(), "1234");
 }
 
@@ -692,12 +692,12 @@ fn test_concurrent_edits() {
     let buf3_op = buffer3.edit([(5..6, "56")]);
     assert_eq!(buffer3.text(), "abcde56");
 
-    buffer1.apply_op(buf2_op.clone()).unwrap();
-    buffer1.apply_op(buf3_op.clone()).unwrap();
-    buffer2.apply_op(buf1_op.clone()).unwrap();
-    buffer2.apply_op(buf3_op).unwrap();
-    buffer3.apply_op(buf1_op).unwrap();
-    buffer3.apply_op(buf2_op).unwrap();
+    buffer1.apply_op(buf2_op.clone());
+    buffer1.apply_op(buf3_op.clone());
+    buffer2.apply_op(buf1_op.clone());
+    buffer2.apply_op(buf3_op);
+    buffer3.apply_op(buf1_op);
+    buffer3.apply_op(buf2_op);
 
     assert_eq!(buffer1.text(), "a12c34e56");
     assert_eq!(buffer2.text(), "a12c34e56");
@@ -756,7 +756,7 @@ fn test_random_concurrent_edits(mut rng: StdRng) {
                         replica_id,
                         ops.len()
                     );
-                    buffer.apply_ops(ops).unwrap();
+                    buffer.apply_ops(ops);
                 }
             }
             _ => {}
diff --git a/crates/text/src/text.rs b/crates/text/src/text.rs
index 9630ec5b80334c..8d2cd97aacaaee 100644
--- a/crates/text/src/text.rs
+++ b/crates/text/src/text.rs
@@ -38,7 +38,6 @@ pub use subscription::*;
 pub use sum_tree::Bias;
 use sum_tree::{FilterCursor, SumTree, TreeMap};
 use undo_map::UndoMap;
-use util::ResultExt;
 
 #[cfg(any(test, feature = "test-support"))]
 use util::RandomCharIter;
@@ -927,23 +926,22 @@ impl Buffer {
         self.snapshot.line_ending = line_ending;
     }
 
-    pub fn apply_ops<I: IntoIterator<Item = Operation>>(&mut self, ops: I) -> Result<()> {
+    pub fn apply_ops<I: IntoIterator<Item = Operation>>(&mut self, ops: I) {
         let mut deferred_ops = Vec::new();
         for op in ops {
             self.history.push(op.clone());
             if self.can_apply_op(&op) {
-                self.apply_op(op)?;
+                self.apply_op(op);
             } else {
                 self.deferred_replicas.insert(op.replica_id());
                 deferred_ops.push(op);
             }
         }
         self.deferred_ops.insert(deferred_ops);
-        self.flush_deferred_ops()?;
-        Ok(())
+        self.flush_deferred_ops();
     }
 
-    fn apply_op(&mut self, op: Operation) -> Result<()> {
+    fn apply_op(&mut self, op: Operation) {
         match op {
             Operation::Edit(edit) => {
                 if !self.version.observed(edit.timestamp) {
@@ -960,7 +958,7 @@ impl Buffer {
             }
             Operation::Undo(undo) => {
                 if !self.version.observed(undo.timestamp) {
-                    self.apply_undo(&undo)?;
+                    self.apply_undo(&undo);
                     self.snapshot.version.observe(undo.timestamp);
                     self.lamport_clock.observe(undo.timestamp);
                 }
@@ -974,7 +972,6 @@ impl Buffer {
                 true
             }
         });
-        Ok(())
     }
 
     fn apply_remote_edit(
@@ -1217,7 +1214,7 @@ impl Buffer {
         fragment_ids
     }
 
-    fn apply_undo(&mut self, undo: &UndoOperation) -> Result<()> {
+    fn apply_undo(&mut self, undo: &UndoOperation) {
         self.snapshot.undo_map.insert(undo);
 
         let mut edits = Patch::default();
@@ -1268,22 +1265,20 @@ impl Buffer {
         self.snapshot.visible_text = visible_text;
         self.snapshot.deleted_text = deleted_text;
         self.subscriptions.publish_mut(&edits);
-        Ok(())
     }
 
-    fn flush_deferred_ops(&mut self) -> Result<()> {
+    fn flush_deferred_ops(&mut self) {
         self.deferred_replicas.clear();
         let mut deferred_ops = Vec::new();
         for op in self.deferred_ops.drain().iter().cloned() {
             if self.can_apply_op(&op) {
-                self.apply_op(op)?;
+                self.apply_op(op);
             } else {
                 self.deferred_replicas.insert(op.replica_id());
                 deferred_ops.push(op);
             }
         }
         self.deferred_ops.insert(deferred_ops);
-        Ok(())
     }
 
     fn can_apply_op(&self, op: &Operation) -> bool {
@@ -1352,7 +1347,7 @@ impl Buffer {
         if let Some(entry) = self.history.pop_undo() {
             let transaction = entry.transaction.clone();
             let transaction_id = transaction.id;
-            let op = self.undo_or_redo(transaction).unwrap();
+            let op = self.undo_or_redo(transaction);
             Some((transaction_id, op))
         } else {
             None
@@ -1365,7 +1360,7 @@ impl Buffer {
             .remove_from_undo(transaction_id)?
             .transaction
             .clone();
-        self.undo_or_redo(transaction).log_err()
+        Some(self.undo_or_redo(transaction))
     }
 
     pub fn undo_to_transaction(&mut self, transaction_id: TransactionId) -> Vec<Operation> {
@@ -1378,7 +1373,7 @@ impl Buffer {
 
         transactions
             .into_iter()
-            .map(|transaction| self.undo_or_redo(transaction).unwrap())
+            .map(|transaction| self.undo_or_redo(transaction))
             .collect()
     }
 
@@ -1394,7 +1389,7 @@ impl Buffer {
         if let Some(entry) = self.history.pop_redo() {
             let transaction = entry.transaction.clone();
             let transaction_id = transaction.id;
-            let op = self.undo_or_redo(transaction).unwrap();
+            let op = self.undo_or_redo(transaction);
             Some((transaction_id, op))
         } else {
             None
@@ -1411,11 +1406,11 @@ impl Buffer {
 
         transactions
             .into_iter()
-            .map(|transaction| self.undo_or_redo(transaction).unwrap())
+            .map(|transaction| self.undo_or_redo(transaction))
             .collect()
     }
 
-    fn undo_or_redo(&mut self, transaction: Transaction) -> Result<Operation> {
+    fn undo_or_redo(&mut self, transaction: Transaction) -> Operation {
         let mut counts = HashMap::default();
         for edit_id in transaction.edit_ids {
             counts.insert(edit_id, self.undo_map.undo_count(edit_id) + 1);
@@ -1426,11 +1421,11 @@ impl Buffer {
             version: self.version(),
             counts,
         };
-        self.apply_undo(&undo)?;
+        self.apply_undo(&undo);
         self.snapshot.version.observe(undo.timestamp);
         let operation = Operation::Undo(undo);
         self.history.push(operation.clone());
-        Ok(operation)
+        operation
     }
 
     pub fn push_transaction(&mut self, transaction: Transaction, now: Instant) {
@@ -1762,7 +1757,7 @@ impl Buffer {
                     self.replica_id,
                     transaction
                 );
-                ops.push(self.undo_or_redo(transaction).unwrap());
+                ops.push(self.undo_or_redo(transaction));
             }
         }
         ops

From 27c1106fadef97dc56d17d9359fd7514b71c8643 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Thu, 19 Sep 2024 13:26:14 -0400
Subject: [PATCH 224/762] Fix bug where copying from assistant panel appends
 extra newline to clipboard (#18090)

Closes https://github.com/zed-industries/zed/issues/17661

Release Notes:

- Fixed a bug where copying from the assistant panel appended an
additional newline to the end of the clipboard contents.
---
 crates/assistant/src/assistant_panel.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index da176ebeee61e0..364c6f9663120c 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -3533,7 +3533,9 @@ impl ContextEditor {
                     for chunk in context.buffer().read(cx).text_for_range(range) {
                         text.push_str(chunk);
                     }
-                    text.push('\n');
+                    if message.offset_range.end < selection.range().end {
+                        text.push('\n');
+                    }
                 }
             }
         }

From 00b1c81c9f8f209667140036da4c9ac578031546 Mon Sep 17 00:00:00 2001
From: David Soria Parra <167242713+dsp-ant@users.noreply.github.com>
Date: Thu, 19 Sep 2024 20:51:48 +0100
Subject: [PATCH 225/762] context_servers: Remove context_type from
 ResourceContent (#18097)

This is removed in the protocol

Release Notes:

- N/A
---
 crates/context_servers/src/types.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/context_servers/src/types.rs b/crates/context_servers/src/types.rs
index c0e9a79f1589c5..cd95ecd7adb368 100644
--- a/crates/context_servers/src/types.rs
+++ b/crates/context_servers/src/types.rs
@@ -239,7 +239,6 @@ pub struct Resource {
 pub struct ResourceContent {
     pub uri: Url,
     pub mime_type: Option<String>,
-    pub content_type: String,
     pub text: Option<String>,
     pub data: Option<String>,
 }

From fbbf0393cbe9b2094bbdd496a5d5d15419eeaeb3 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 19 Sep 2024 14:04:46 -0600
Subject: [PATCH 226/762] ssh-remoting: Fix go to definition out of worktree
 (#18094)

Release Notes:

- ssh-remoting: Fixed go to definition outside of worktree

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 crates/client/src/client.rs                  |   4 +
 crates/project/src/lsp_store.rs              |  21 ++-
 crates/project/src/project.rs                | 181 ++++++++-----------
 crates/project/src/worktree_store.rs         | 173 ++++++++++++++----
 crates/remote/src/ssh_session.rs             |   7 +-
 crates/remote_server/src/headless_project.rs |  17 +-
 crates/rpc/src/proto_client.rs               |   6 +
 7 files changed, 251 insertions(+), 158 deletions(-)

diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 09286300d9d38f..a8387f7c5ac9ba 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -1621,6 +1621,10 @@ impl ProtoClient for Client {
     fn message_handler_set(&self) -> &parking_lot::Mutex<ProtoMessageHandlerSet> {
         &self.handler_set
     }
+
+    fn goes_via_collab(&self) -> bool {
+        true
+    }
 }
 
 #[derive(Serialize, Deserialize)]
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 58d9ba8926737d..5c32c9030db3ff 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -534,6 +534,9 @@ impl LspStore {
             }
             WorktreeStoreEvent::WorktreeRemoved(_, id) => self.remove_worktree(*id, cx),
             WorktreeStoreEvent::WorktreeOrderChanged => {}
+            WorktreeStoreEvent::WorktreeUpdateSent(worktree) => {
+                worktree.update(cx, |worktree, _cx| self.send_diagnostic_summaries(worktree));
+            }
         }
     }
 
@@ -764,24 +767,22 @@ impl LspStore {
         self.active_entry = active_entry;
     }
 
-    pub(crate) fn send_diagnostic_summaries(
-        &self,
-        worktree: &mut Worktree,
-    ) -> Result<(), anyhow::Error> {
+    pub(crate) fn send_diagnostic_summaries(&self, worktree: &mut Worktree) {
         if let Some(client) = self.downstream_client.clone() {
             if let Some(summaries) = self.diagnostic_summaries.get(&worktree.id()) {
                 for (path, summaries) in summaries {
                     for (&server_id, summary) in summaries {
-                        client.send(proto::UpdateDiagnosticSummary {
-                            project_id: self.project_id,
-                            worktree_id: worktree.id().to_proto(),
-                            summary: Some(summary.to_proto(server_id, path)),
-                        })?;
+                        client
+                            .send(proto::UpdateDiagnosticSummary {
+                                project_id: self.project_id,
+                                worktree_id: worktree.id().to_proto(),
+                                summary: Some(summary.to_proto(server_id, path)),
+                            })
+                            .log_err();
                     }
                 }
             }
         }
-        Ok(())
     }
 
     pub fn request_lsp<R: LspCommand>(
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index f4816cf0cde66f..fcf10d11c2cca7 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -31,7 +31,7 @@ pub use environment::ProjectEnvironment;
 use futures::{
     channel::mpsc::{self, UnboundedReceiver},
     future::try_join_all,
-    AsyncWriteExt, FutureExt, StreamExt,
+    AsyncWriteExt, StreamExt,
 };
 
 use git::{blame::Blame, repository::GitRepository};
@@ -152,7 +152,7 @@ pub struct Project {
     _subscriptions: Vec<gpui::Subscription>,
     buffers_needing_diff: HashSet<WeakModel<Buffer>>,
     git_diff_debouncer: DebouncedDelay<Self>,
-    remotely_created_buffers: Arc<Mutex<RemotelyCreatedBuffers>>,
+    remotely_created_models: Arc<Mutex<RemotelyCreatedModels>>,
     terminals: Terminals,
     node: Option<Arc<dyn NodeRuntime>>,
     tasks: Model<Inventory>,
@@ -169,26 +169,28 @@ pub struct Project {
 }
 
 #[derive(Default)]
-struct RemotelyCreatedBuffers {
+struct RemotelyCreatedModels {
+    worktrees: Vec<Model<Worktree>>,
     buffers: Vec<Model<Buffer>>,
     retain_count: usize,
 }
 
-struct RemotelyCreatedBufferGuard {
-    remote_buffers: std::sync::Weak<Mutex<RemotelyCreatedBuffers>>,
+struct RemotelyCreatedModelGuard {
+    remote_models: std::sync::Weak<Mutex<RemotelyCreatedModels>>,
 }
 
-impl Drop for RemotelyCreatedBufferGuard {
+impl Drop for RemotelyCreatedModelGuard {
     fn drop(&mut self) {
-        if let Some(remote_buffers) = self.remote_buffers.upgrade() {
-            let mut remote_buffers = remote_buffers.lock();
+        if let Some(remote_models) = self.remote_models.upgrade() {
+            let mut remote_models = remote_models.lock();
             assert!(
-                remote_buffers.retain_count > 0,
-                "RemotelyCreatedBufferGuard dropped too many times"
+                remote_models.retain_count > 0,
+                "RemotelyCreatedModelGuard dropped too many times"
             );
-            remote_buffers.retain_count -= 1;
-            if remote_buffers.retain_count == 0 {
-                remote_buffers.buffers.clear();
+            remote_models.retain_count -= 1;
+            if remote_models.retain_count == 0 {
+                remote_models.buffers.clear();
+                remote_models.worktrees.clear();
             }
         }
     }
@@ -620,7 +622,7 @@ impl Project {
             let snippets =
                 SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
 
-            let worktree_store = cx.new_model(|_| WorktreeStore::new(false, fs.clone()));
+            let worktree_store = cx.new_model(|_| WorktreeStore::new(None, false, fs.clone()));
             cx.subscribe(&worktree_store, Self::on_worktree_store_event)
                 .detach();
 
@@ -687,7 +689,7 @@ impl Project {
                 dev_server_project_id: None,
                 search_history: Self::new_search_history(),
                 environment,
-                remotely_created_buffers: Default::default(),
+                remotely_created_models: Default::default(),
                 last_formatting_failure: None,
                 buffers_being_formatted: Default::default(),
                 search_included_history: Self::new_search_history(),
@@ -714,11 +716,8 @@ impl Project {
             let snippets =
                 SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
 
-            let worktree_store = cx.new_model(|_| {
-                let mut worktree_store = WorktreeStore::new(false, fs.clone());
-                worktree_store.set_upstream_client(ssh.clone().into());
-                worktree_store
-            });
+            let worktree_store =
+                cx.new_model(|_| WorktreeStore::new(Some(ssh.clone().into()), false, fs.clone()));
             cx.subscribe(&worktree_store, Self::on_worktree_store_event)
                 .detach();
 
@@ -773,7 +772,7 @@ impl Project {
                 dev_server_project_id: None,
                 search_history: Self::new_search_history(),
                 environment,
-                remotely_created_buffers: Default::default(),
+                remotely_created_models: Default::default(),
                 last_formatting_failure: None,
                 buffers_being_formatted: Default::default(),
                 search_included_history: Self::new_search_history(),
@@ -787,8 +786,9 @@ impl Project {
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.worktree_store);
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.lsp_store);
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.settings_observer);
-            client.add_model_message_handler(Self::handle_update_worktree);
             client.add_model_message_handler(Self::handle_create_buffer_for_peer);
+            client.add_model_message_handler(Self::handle_update_worktree);
+            client.add_model_message_handler(Self::handle_update_project);
             client.add_model_request_handler(BufferStore::handle_update_buffer);
             BufferStore::init(&client);
             LspStore::init(&client);
@@ -867,8 +867,7 @@ impl Project {
         let role = response.payload.role();
 
         let worktree_store = cx.new_model(|_| {
-            let mut store = WorktreeStore::new(true, fs.clone());
-            store.set_upstream_client(client.clone().into());
+            let mut store = WorktreeStore::new(Some(client.clone().into()), true, fs.clone());
             if let Some(dev_server_project_id) = response.payload.dev_server_project_id {
                 store.set_dev_server_project_id(DevServerProjectId(dev_server_project_id));
             }
@@ -955,7 +954,7 @@ impl Project {
                 search_included_history: Self::new_search_history(),
                 search_excluded_history: Self::new_search_history(),
                 environment: ProjectEnvironment::new(&worktree_store, None, cx),
-                remotely_created_buffers: Arc::new(Mutex::new(RemotelyCreatedBuffers::default())),
+                remotely_created_models: Arc::new(Mutex::new(RemotelyCreatedModels::default())),
                 last_formatting_failure: None,
                 buffers_being_formatted: Default::default(),
             };
@@ -1259,43 +1258,6 @@ impl Project {
         }
     }
 
-    fn metadata_changed(&mut self, cx: &mut ModelContext<Self>) {
-        cx.notify();
-
-        let ProjectClientState::Shared { remote_id } = self.client_state else {
-            return;
-        };
-        let project_id = remote_id;
-
-        let update_project = self.client.request(proto::UpdateProject {
-            project_id,
-            worktrees: self.worktree_metadata_protos(cx),
-        });
-        cx.spawn(|this, mut cx| async move {
-            update_project.await?;
-            this.update(&mut cx, |this, cx| {
-                let client = this.client.clone();
-                let worktrees = this.worktree_store.read(cx).worktrees().collect::<Vec<_>>();
-
-                for worktree in worktrees {
-                    worktree.update(cx, |worktree, cx| {
-                        let client = client.clone();
-                        worktree.observe_updates(project_id, cx, {
-                            move |update| client.request(update).map(|result| result.is_ok())
-                        });
-
-                        this.lsp_store.update(cx, |lsp_store, _| {
-                            lsp_store.send_diagnostic_summaries(worktree)
-                        })
-                    })?;
-                }
-
-                anyhow::Ok(())
-            })
-        })
-        .detach_and_log_err(cx);
-    }
-
     pub fn task_inventory(&self) -> &Model<Inventory> {
         &self.tasks
     }
@@ -1513,7 +1475,7 @@ impl Project {
             buffer_store.shared(project_id, self.client.clone().into(), cx)
         });
         self.worktree_store.update(cx, |worktree_store, cx| {
-            worktree_store.set_shared(true, cx);
+            worktree_store.shared(project_id, self.client.clone().into(), cx);
         });
         self.lsp_store.update(cx, |lsp_store, cx| {
             lsp_store.shared(project_id, self.client.clone().into(), cx)
@@ -1526,7 +1488,6 @@ impl Project {
             remote_id: project_id,
         };
 
-        self.metadata_changed(cx);
         cx.emit(Event::RemoteIdChanged(Some(project_id)));
         cx.notify();
         Ok(())
@@ -1540,7 +1501,11 @@ impl Project {
         self.buffer_store
             .update(cx, |buffer_store, _| buffer_store.forget_shared_buffers());
         self.set_collaborators_from_proto(message.collaborators, cx)?;
-        self.metadata_changed(cx);
+
+        self.worktree_store.update(cx, |worktree_store, cx| {
+            worktree_store.send_project_updates(cx);
+        });
+        cx.notify();
         cx.emit(Event::Reshared);
         Ok(())
     }
@@ -1576,7 +1541,6 @@ impl Project {
 
     pub fn unshare(&mut self, cx: &mut ModelContext<Self>) -> Result<()> {
         self.unshare_internal(cx)?;
-        self.metadata_changed(cx);
         cx.notify();
         Ok(())
     }
@@ -1598,7 +1562,7 @@ impl Project {
             self.collaborators.clear();
             self.client_subscriptions.clear();
             self.worktree_store.update(cx, |store, cx| {
-                store.set_shared(false, cx);
+                store.unshared(cx);
             });
             self.buffer_store.update(cx, |buffer_store, cx| {
                 buffer_store.forget_shared_buffers();
@@ -1867,9 +1831,9 @@ impl Project {
         cx: &mut ModelContext<Self>,
     ) -> Result<()> {
         {
-            let mut remotely_created_buffers = self.remotely_created_buffers.lock();
-            if remotely_created_buffers.retain_count > 0 {
-                remotely_created_buffers.buffers.push(buffer.clone())
+            let mut remotely_created_models = self.remotely_created_models.lock();
+            if remotely_created_models.retain_count > 0 {
+                remotely_created_models.buffers.push(buffer.clone())
             }
         }
 
@@ -2110,10 +2074,17 @@ impl Project {
                 cx.emit(Event::WorktreeRemoved(*id));
             }
             WorktreeStoreEvent::WorktreeOrderChanged => cx.emit(Event::WorktreeOrderChanged),
+            WorktreeStoreEvent::WorktreeUpdateSent(_) => {}
         }
     }
 
     fn on_worktree_added(&mut self, worktree: &Model<Worktree>, cx: &mut ModelContext<Self>) {
+        {
+            let mut remotely_created_models = self.remotely_created_models.lock();
+            if remotely_created_models.retain_count > 0 {
+                remotely_created_models.worktrees.push(worktree.clone())
+            }
+        }
         cx.observe(worktree, |_, _, cx| cx.notify()).detach();
         cx.subscribe(worktree, |this, worktree, event, cx| {
             let is_local = worktree.read(cx).is_local();
@@ -2140,7 +2111,7 @@ impl Project {
             }
         })
         .detach();
-        self.metadata_changed(cx);
+        cx.notify();
     }
 
     fn on_worktree_removed(&mut self, id_to_remove: WorktreeId, cx: &mut ModelContext<Self>) {
@@ -2171,7 +2142,7 @@ impl Project {
             inventory.remove_worktree_sources(id_to_remove);
         });
 
-        self.metadata_changed(cx);
+        cx.notify();
     }
 
     fn on_buffer_event(
@@ -3012,7 +2983,7 @@ impl Project {
 
     #[inline(never)]
     fn definition_impl(
-        &self,
+        &mut self,
         buffer: &Model<Buffer>,
         position: PointUtf16,
         cx: &mut ModelContext<Self>,
@@ -3025,7 +2996,7 @@ impl Project {
         )
     }
     pub fn definition<T: ToPointUtf16>(
-        &self,
+        &mut self,
         buffer: &Model<Buffer>,
         position: T,
         cx: &mut ModelContext<Self>,
@@ -3035,7 +3006,7 @@ impl Project {
     }
 
     fn declaration_impl(
-        &self,
+        &mut self,
         buffer: &Model<Buffer>,
         position: PointUtf16,
         cx: &mut ModelContext<Self>,
@@ -3049,7 +3020,7 @@ impl Project {
     }
 
     pub fn declaration<T: ToPointUtf16>(
-        &self,
+        &mut self,
         buffer: &Model<Buffer>,
         position: T,
         cx: &mut ModelContext<Self>,
@@ -3059,7 +3030,7 @@ impl Project {
     }
 
     fn type_definition_impl(
-        &self,
+        &mut self,
         buffer: &Model<Buffer>,
         position: PointUtf16,
         cx: &mut ModelContext<Self>,
@@ -3073,7 +3044,7 @@ impl Project {
     }
 
     pub fn type_definition<T: ToPointUtf16>(
-        &self,
+        &mut self,
         buffer: &Model<Buffer>,
         position: T,
         cx: &mut ModelContext<Self>,
@@ -3083,7 +3054,7 @@ impl Project {
     }
 
     pub fn implementation<T: ToPointUtf16>(
-        &self,
+        &mut self,
         buffer: &Model<Buffer>,
         position: T,
         cx: &mut ModelContext<Self>,
@@ -3098,7 +3069,7 @@ impl Project {
     }
 
     pub fn references<T: ToPointUtf16>(
-        &self,
+        &mut self,
         buffer: &Model<Buffer>,
         position: T,
         cx: &mut ModelContext<Self>,
@@ -3113,7 +3084,7 @@ impl Project {
     }
 
     fn document_highlights_impl(
-        &self,
+        &mut self,
         buffer: &Model<Buffer>,
         position: PointUtf16,
         cx: &mut ModelContext<Self>,
@@ -3127,7 +3098,7 @@ impl Project {
     }
 
     pub fn document_highlights<T: ToPointUtf16>(
-        &self,
+        &mut self,
         buffer: &Model<Buffer>,
         position: T,
         cx: &mut ModelContext<Self>,
@@ -3514,7 +3485,7 @@ impl Project {
             query: Some(query.to_proto()),
             limit: limit as _,
         });
-        let guard = self.retain_remotely_created_buffers(cx);
+        let guard = self.retain_remotely_created_models(cx);
 
         cx.spawn(move |this, mut cx| async move {
             let response = request.await?;
@@ -3536,7 +3507,7 @@ impl Project {
     }
 
     pub fn request_lsp<R: LspCommand>(
-        &self,
+        &mut self,
         buffer_handle: Model<Buffer>,
         server: LanguageServerToQuery,
         request: R,
@@ -3546,8 +3517,14 @@ impl Project {
         <R::LspRequest as lsp::request::Request>::Result: Send,
         <R::LspRequest as lsp::request::Request>::Params: Send,
     {
-        self.lsp_store.update(cx, |lsp_store, cx| {
+        let guard = self.retain_remotely_created_models(cx);
+        let task = self.lsp_store.update(cx, |lsp_store, cx| {
             lsp_store.request_lsp(buffer_handle, server, request, cx)
+        });
+        cx.spawn(|_, _| async move {
+            let result = task.await;
+            drop(guard);
+            result
         })
     }
 
@@ -4095,6 +4072,7 @@ impl Project {
         })?
     }
 
+    // Collab sends UpdateWorktree protos as messages
     async fn handle_update_worktree(
         this: Model<Self>,
         envelope: TypedEnvelope<proto::UpdateWorktree>,
@@ -4130,19 +4108,21 @@ impl Project {
         BufferStore::handle_update_buffer(buffer_store, envelope, cx).await
     }
 
-    fn retain_remotely_created_buffers(
+    fn retain_remotely_created_models(
         &mut self,
         cx: &mut ModelContext<Self>,
-    ) -> RemotelyCreatedBufferGuard {
+    ) -> RemotelyCreatedModelGuard {
         {
-            let mut remotely_created_buffers = self.remotely_created_buffers.lock();
-            if remotely_created_buffers.retain_count == 0 {
-                remotely_created_buffers.buffers = self.buffer_store.read(cx).buffers().collect();
+            let mut remotely_create_models = self.remotely_created_models.lock();
+            if remotely_create_models.retain_count == 0 {
+                remotely_create_models.buffers = self.buffer_store.read(cx).buffers().collect();
+                remotely_create_models.worktrees =
+                    self.worktree_store.read(cx).worktrees().collect();
             }
-            remotely_created_buffers.retain_count += 1;
+            remotely_create_models.retain_count += 1;
         }
-        RemotelyCreatedBufferGuard {
-            remote_buffers: Arc::downgrade(&self.remotely_created_buffers),
+        RemotelyCreatedModelGuard {
+            remote_models: Arc::downgrade(&self.remotely_created_models),
         }
     }
 
@@ -4637,16 +4617,11 @@ impl Project {
         worktrees: Vec<proto::WorktreeMetadata>,
         cx: &mut ModelContext<Project>,
     ) -> Result<()> {
-        self.metadata_changed(cx);
-        self.worktree_store.update(cx, |worktree_store, cx| {
-            worktree_store.set_worktrees_from_proto(
-                worktrees,
-                self.replica_id(),
-                self.remote_id().ok_or_else(|| anyhow!("invalid project"))?,
-                self.client.clone().into(),
-                cx,
-            )
-        })
+        cx.notify();
+        let result = self.worktree_store.update(cx, |worktree_store, cx| {
+            worktree_store.set_worktrees_from_proto(worktrees, self.replica_id(), cx)
+        });
+        result
     }
 
     fn set_collaborators_from_proto(
diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 07764d4a05ce71..7fae8b9e1dbdd7 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -39,8 +39,10 @@ struct MatchingEntry {
 pub struct WorktreeStore {
     next_entry_id: Arc<AtomicUsize>,
     upstream_client: Option<AnyProtoClient>,
+    downstream_client: Option<AnyProtoClient>,
+    remote_id: u64,
     dev_server_project_id: Option<DevServerProjectId>,
-    is_shared: bool,
+    retain_worktrees: bool,
     worktrees: Vec<WorktreeHandle>,
     worktrees_reordered: bool,
     #[allow(clippy::type_complexity)]
@@ -53,6 +55,7 @@ pub enum WorktreeStoreEvent {
     WorktreeAdded(Model<Worktree>),
     WorktreeRemoved(EntityId, WorktreeId),
     WorktreeOrderChanged,
+    WorktreeUpdateSent(Model<Worktree>),
 }
 
 impl EventEmitter<WorktreeStoreEvent> for WorktreeStore {}
@@ -66,23 +69,25 @@ impl WorktreeStore {
         client.add_model_request_handler(Self::handle_expand_project_entry);
     }
 
-    pub fn new(retain_worktrees: bool, fs: Arc<dyn Fs>) -> Self {
+    pub fn new(
+        upstream_client: Option<AnyProtoClient>,
+        retain_worktrees: bool,
+        fs: Arc<dyn Fs>,
+    ) -> Self {
         Self {
             next_entry_id: Default::default(),
             loading_worktrees: Default::default(),
-            upstream_client: None,
             dev_server_project_id: None,
-            is_shared: retain_worktrees,
+            downstream_client: None,
             worktrees: Vec::new(),
             worktrees_reordered: false,
+            retain_worktrees,
+            remote_id: 0,
+            upstream_client,
             fs,
         }
     }
 
-    pub fn set_upstream_client(&mut self, client: AnyProtoClient) {
-        self.upstream_client = Some(client);
-    }
-
     pub fn set_dev_server_project_id(&mut self, id: DevServerProjectId) {
         self.dev_server_project_id = Some(id);
     }
@@ -201,6 +206,13 @@ impl WorktreeStore {
                     path: abs_path.clone(),
                 })
                 .await?;
+
+            if let Some(existing_worktree) = this.read_with(&cx, |this, cx| {
+                this.worktree_for_id(WorktreeId::from_proto(response.worktree_id), cx)
+            })? {
+                return Ok(existing_worktree);
+            }
+
             let worktree = cx.update(|cx| {
                 Worktree::remote(
                     0,
@@ -302,7 +314,10 @@ impl WorktreeStore {
     }
 
     pub fn add(&mut self, worktree: &Model<Worktree>, cx: &mut ModelContext<Self>) {
-        let push_strong_handle = self.is_shared || worktree.read(cx).is_visible();
+        let worktree_id = worktree.read(cx).id();
+        debug_assert!(!self.worktrees().any(|w| w.read(cx).id() == worktree_id));
+
+        let push_strong_handle = self.retain_worktrees || worktree.read(cx).is_visible();
         let handle = if push_strong_handle {
             WorktreeHandle::Strong(worktree.clone())
         } else {
@@ -322,13 +337,15 @@ impl WorktreeStore {
         }
 
         cx.emit(WorktreeStoreEvent::WorktreeAdded(worktree.clone()));
+        self.send_project_updates(cx);
 
         let handle_id = worktree.entity_id();
-        cx.observe_release(worktree, move |_, worktree, cx| {
+        cx.observe_release(worktree, move |this, worktree, cx| {
             cx.emit(WorktreeStoreEvent::WorktreeRemoved(
                 handle_id,
                 worktree.id(),
             ));
+            this.send_project_updates(cx);
         })
         .detach();
     }
@@ -349,6 +366,7 @@ impl WorktreeStore {
                 false
             }
         });
+        self.send_project_updates(cx);
     }
 
     pub fn set_worktrees_reordered(&mut self, worktrees_reordered: bool) {
@@ -359,8 +377,6 @@ impl WorktreeStore {
         &mut self,
         worktrees: Vec<proto::WorktreeMetadata>,
         replica_id: ReplicaId,
-        remote_id: u64,
-        client: AnyProtoClient,
         cx: &mut ModelContext<Self>,
     ) -> Result<()> {
         let mut old_worktrees_by_id = self
@@ -372,18 +388,31 @@ impl WorktreeStore {
             })
             .collect::<HashMap<_, _>>();
 
+        let client = self
+            .upstream_client
+            .clone()
+            .ok_or_else(|| anyhow!("invalid project"))?;
+
         for worktree in worktrees {
             if let Some(old_worktree) =
                 old_worktrees_by_id.remove(&WorktreeId::from_proto(worktree.id))
             {
-                self.worktrees.push(WorktreeHandle::Strong(old_worktree));
+                let push_strong_handle =
+                    self.retain_worktrees || old_worktree.read(cx).is_visible();
+                let handle = if push_strong_handle {
+                    WorktreeHandle::Strong(old_worktree.clone())
+                } else {
+                    WorktreeHandle::Weak(old_worktree.downgrade())
+                };
+                self.worktrees.push(handle);
             } else {
                 self.add(
-                    &Worktree::remote(remote_id, replica_id, worktree, client.clone(), cx),
+                    &Worktree::remote(self.remote_id, replica_id, worktree, client.clone(), cx),
                     cx,
                 );
             }
         }
+        self.send_project_updates(cx);
 
         Ok(())
     }
@@ -446,33 +475,109 @@ impl WorktreeStore {
         }
     }
 
-    pub fn set_shared(&mut self, is_shared: bool, cx: &mut ModelContext<Self>) {
-        self.is_shared = is_shared;
+    pub fn send_project_updates(&mut self, cx: &mut ModelContext<Self>) {
+        let Some(downstream_client) = self.downstream_client.clone() else {
+            return;
+        };
+        let project_id = self.remote_id;
+
+        let update = proto::UpdateProject {
+            project_id,
+            worktrees: self.worktree_metadata_protos(cx),
+        };
+
+        // collab has bad concurrency guarantees, so we send requests in serial.
+        let update_project = if downstream_client.goes_via_collab() {
+            Some(downstream_client.request(update))
+        } else {
+            downstream_client.send(update).log_err();
+            None
+        };
+        cx.spawn(|this, mut cx| async move {
+            if let Some(update_project) = update_project {
+                update_project.await?;
+            }
+
+            this.update(&mut cx, |this, cx| {
+                let worktrees = this.worktrees().collect::<Vec<_>>();
+
+                for worktree in worktrees {
+                    worktree.update(cx, |worktree, cx| {
+                        let client = downstream_client.clone();
+                        worktree.observe_updates(project_id, cx, {
+                            move |update| {
+                                let client = client.clone();
+                                async move {
+                                    if client.goes_via_collab() {
+                                        client.request(update).map(|result| result.is_ok()).await
+                                    } else {
+                                        client.send(update).is_ok()
+                                    }
+                                }
+                            }
+                        });
+                    });
+
+                    cx.emit(WorktreeStoreEvent::WorktreeUpdateSent(worktree.clone()))
+                }
+
+                anyhow::Ok(())
+            })
+        })
+        .detach_and_log_err(cx);
+    }
+
+    pub fn worktree_metadata_protos(&self, cx: &AppContext) -> Vec<proto::WorktreeMetadata> {
+        self.worktrees()
+            .map(|worktree| {
+                let worktree = worktree.read(cx);
+                proto::WorktreeMetadata {
+                    id: worktree.id().to_proto(),
+                    root_name: worktree.root_name().into(),
+                    visible: worktree.is_visible(),
+                    abs_path: worktree.abs_path().to_string_lossy().into(),
+                }
+            })
+            .collect()
+    }
+
+    pub fn shared(
+        &mut self,
+        remote_id: u64,
+        downsteam_client: AnyProtoClient,
+        cx: &mut ModelContext<Self>,
+    ) {
+        self.retain_worktrees = true;
+        self.remote_id = remote_id;
+        self.downstream_client = Some(downsteam_client);
 
         // When shared, retain all worktrees
-        if is_shared {
-            for worktree_handle in self.worktrees.iter_mut() {
-                match worktree_handle {
-                    WorktreeHandle::Strong(_) => {}
-                    WorktreeHandle::Weak(worktree) => {
-                        if let Some(worktree) = worktree.upgrade() {
-                            *worktree_handle = WorktreeHandle::Strong(worktree);
-                        }
+        for worktree_handle in self.worktrees.iter_mut() {
+            match worktree_handle {
+                WorktreeHandle::Strong(_) => {}
+                WorktreeHandle::Weak(worktree) => {
+                    if let Some(worktree) = worktree.upgrade() {
+                        *worktree_handle = WorktreeHandle::Strong(worktree);
                     }
                 }
             }
         }
+        self.send_project_updates(cx);
+    }
+
+    pub fn unshared(&mut self, cx: &mut ModelContext<Self>) {
+        self.retain_worktrees = false;
+        self.downstream_client.take();
+
         // When not shared, only retain the visible worktrees
-        else {
-            for worktree_handle in self.worktrees.iter_mut() {
-                if let WorktreeHandle::Strong(worktree) = worktree_handle {
-                    let is_visible = worktree.update(cx, |worktree, _| {
-                        worktree.stop_observing_updates();
-                        worktree.is_visible()
-                    });
-                    if !is_visible {
-                        *worktree_handle = WorktreeHandle::Weak(worktree.downgrade());
-                    }
+        for worktree_handle in self.worktrees.iter_mut() {
+            if let WorktreeHandle::Strong(worktree) = worktree_handle {
+                let is_visible = worktree.update(cx, |worktree, _| {
+                    worktree.stop_observing_updates();
+                    worktree.is_visible()
+                });
+                if !is_visible {
+                    *worktree_handle = WorktreeHandle::Weak(worktree.downgrade());
                 }
             }
         }
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 4aab731e645934..10608b74f3593f 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -247,7 +247,8 @@ impl SshSession {
                                     let line_ix = start_ix + ix;
                                     let content = &stderr_buffer[start_ix..line_ix];
                                     start_ix = line_ix + 1;
-                                    if let Ok(record) = serde_json::from_slice::<LogRecord>(content) {
+                                    if let Ok(mut record) = serde_json::from_slice::<LogRecord>(content) {
+                                        record.message = format!("(remote) {}", record.message);
                                         record.log(log::logger())
                                     } else {
                                         eprintln!("(remote) {}", String::from_utf8_lossy(content));
@@ -469,6 +470,10 @@ impl ProtoClient for SshSession {
     fn message_handler_set(&self) -> &Mutex<ProtoMessageHandlerSet> {
         &self.state
     }
+
+    fn goes_via_collab(&self) -> bool {
+        false
+    }
 }
 
 impl SshClientState {
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index bbd82281d86afc..54f48e36269baf 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -44,7 +44,11 @@ impl HeadlessProject {
     pub fn new(session: Arc<SshSession>, fs: Arc<dyn Fs>, cx: &mut ModelContext<Self>) -> Self {
         let languages = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
 
-        let worktree_store = cx.new_model(|_| WorktreeStore::new(true, fs.clone()));
+        let worktree_store = cx.new_model(|cx| {
+            let mut store = WorktreeStore::new(None, true, fs.clone());
+            store.shared(SSH_PROJECT_ID, session.clone().into(), cx);
+            store
+        });
         let buffer_store = cx.new_model(|cx| {
             let mut buffer_store =
                 BufferStore::new(worktree_store.clone(), Some(SSH_PROJECT_ID), cx);
@@ -196,18 +200,11 @@ impl HeadlessProject {
             .await?;
 
         this.update(&mut cx, |this, cx| {
-            let session = this.session.clone();
             this.worktree_store.update(cx, |worktree_store, cx| {
                 worktree_store.add(&worktree, cx);
             });
-            worktree.update(cx, |worktree, cx| {
-                worktree.observe_updates(0, cx, move |update| {
-                    session.send(update).ok();
-                    futures::future::ready(true)
-                });
-                proto::AddWorktreeResponse {
-                    worktree_id: worktree.id().to_proto(),
-                }
+            worktree.update(cx, |worktree, _| proto::AddWorktreeResponse {
+                worktree_id: worktree.id().to_proto(),
             })
         })
     }
diff --git a/crates/rpc/src/proto_client.rs b/crates/rpc/src/proto_client.rs
index 4a990a84336dfd..89ef580cdfb3d7 100644
--- a/crates/rpc/src/proto_client.rs
+++ b/crates/rpc/src/proto_client.rs
@@ -27,6 +27,8 @@ pub trait ProtoClient: Send + Sync {
     fn send_response(&self, envelope: Envelope, message_type: &'static str) -> anyhow::Result<()>;
 
     fn message_handler_set(&self) -> &parking_lot::Mutex<ProtoMessageHandlerSet>;
+
+    fn goes_via_collab(&self) -> bool;
 }
 
 #[derive(Default)]
@@ -139,6 +141,10 @@ impl AnyProtoClient {
         Self(client)
     }
 
+    pub fn goes_via_collab(&self) -> bool {
+        self.0.goes_via_collab()
+    }
+
     pub fn request<T: RequestMessage>(
         &self,
         request: T,

From 28a54ce122fdd5efb2e23cc77a5efab78c07061c Mon Sep 17 00:00:00 2001
From: Roy Williams <roy@anthropic.com>
Date: Thu, 19 Sep 2024 14:16:01 -0600
Subject: [PATCH 227/762] Add diagnostic information to context of inline
 assistant (#18096)

Release Notes:

- Added Diagnostic information to inline assistant. This enables users
to just say "Fix this" and have the model know what the errors are.
---
 assets/prompts/content_prompt.hbs | 11 +++++++++++
 crates/assistant/src/prompts.rs   | 23 +++++++++++++++++++++--
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/assets/prompts/content_prompt.hbs b/assets/prompts/content_prompt.hbs
index cf4141349b356c..e944e230f56f9b 100644
--- a/assets/prompts/content_prompt.hbs
+++ b/assets/prompts/content_prompt.hbs
@@ -47,6 +47,17 @@ And here's the section to rewrite based on that prompt again for reference:
 <rewrite_this>
 {{{rewrite_section}}}
 </rewrite_this>
+
+{{#if diagnostic_errors}}
+{{#each diagnostic_errors}}
+<diagnostic_error>
+    <line_number>{{line_number}}</line_number>
+    <error_message>{{error_message}}</error_message>
+    <code_content>{{code_content}}</code_content>
+</diagnostic_error>
+{{/each}}
+{{/if}}
+
 {{/if}}
 
 Only make changes that are necessary to fulfill the prompt, leave everything else as-is. All surrounding {{content_type}} will be preserved.
diff --git a/crates/assistant/src/prompts.rs b/crates/assistant/src/prompts.rs
index ae2ab4787e6f40..7d99a70d1419c9 100644
--- a/crates/assistant/src/prompts.rs
+++ b/crates/assistant/src/prompts.rs
@@ -4,13 +4,20 @@ use fs::Fs;
 use futures::StreamExt;
 use gpui::AssetSource;
 use handlebars::{Handlebars, RenderError};
-use language::{BufferSnapshot, LanguageName};
+use language::{BufferSnapshot, LanguageName, Point};
 use parking_lot::Mutex;
 use serde::Serialize;
 use std::{ops::Range, path::PathBuf, sync::Arc, time::Duration};
 use text::LineEnding;
 use util::ResultExt;
 
+#[derive(Serialize)]
+pub struct ContentPromptDiagnosticContext {
+    pub line_number: usize,
+    pub error_message: String,
+    pub code_content: String,
+}
+
 #[derive(Serialize)]
 pub struct ContentPromptContext {
     pub content_type: String,
@@ -20,6 +27,7 @@ pub struct ContentPromptContext {
     pub document_content: String,
     pub user_prompt: String,
     pub rewrite_section: Option<String>,
+    pub diagnostic_errors: Vec<ContentPromptDiagnosticContext>,
 }
 
 #[derive(Serialize)]
@@ -261,6 +269,17 @@ impl PromptBuilder {
         } else {
             None
         };
+        let diagnostics = buffer.diagnostics_in_range::<_, Point>(range, false);
+        let diagnostic_errors: Vec<ContentPromptDiagnosticContext> = diagnostics
+            .map(|entry| {
+                let start = entry.range.start;
+                ContentPromptDiagnosticContext {
+                    line_number: (start.row + 1) as usize,
+                    error_message: entry.diagnostic.message.clone(),
+                    code_content: buffer.text_for_range(entry.range.clone()).collect(),
+                }
+            })
+            .collect();
 
         let context = ContentPromptContext {
             content_type: content_type.to_string(),
@@ -270,8 +289,8 @@ impl PromptBuilder {
             document_content,
             user_prompt,
             rewrite_section,
+            diagnostic_errors,
         };
-
         self.handlebars.lock().render("content_prompt", &context)
     }
 

From 82e6b1e0e5fe4f2a04fba2fb6f3e7d1aae0974a1 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Thu, 19 Sep 2024 17:22:11 -0400
Subject: [PATCH 228/762] docs: Update glibc requirements for current binaries
 (#18101)

---
 docs/src/linux.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/src/linux.md b/docs/src/linux.md
index 812a3707d01b1b..17334c325ca309 100644
--- a/docs/src/linux.md
+++ b/docs/src/linux.md
@@ -16,7 +16,7 @@ The Zed installed by the script works best on systems that:
 
 - have a Vulkan compatible GPU available (for example Linux on an M-series macBook)
 - have a system-wide glibc (NixOS and Alpine do not by default)
-  - x86_64 (Intel/AMD): glibc version >= 2.29 (Ubuntu 20 and newer; Amazon Linux >2023)
+  - x86_64 (Intel/AMD): glibc version >= 2.35 (Ubuntu 22 and newer)
   - aarch64 (ARM): glibc version >= 2.35 (Ubuntu 22 and newer)
 
 Both Nix and Alpine have third-party Zed packages available (though they are currently a few weeks out of date). If you'd like to use our builds they do work if you install a glibc compatibility layer. On NixOS you can try [nix-ld](https://github.com/Mic92/nix-ld), and on Alpine [gcompat](https://wiki.alpinelinux.org/wiki/Running_glibc_programs).
@@ -24,7 +24,7 @@ Both Nix and Alpine have third-party Zed packages available (though they are cur
 You will need to build from source for:
 
 - architectures other than 64-bit Intel or 64-bit ARM (for example a 32-bit or RISC-V machine)
-- Amazon Linux 2 on x86_64
+- Amazon Linux
 - Rocky Linux 9.3
 
 ## Other ways to install Zed on Linux

From edf2c192500194192320ff21e86a2846e5089d48 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 19 Sep 2024 15:28:30 -0600
Subject: [PATCH 229/762] Hide GPU problems from Slack (#18087)

Release Notes:

- N/A

---------

Co-authored-by: Marshall <marshall@zed.dev>
Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 crates/collab/src/api/events.rs | 31 +++++++++++++++++++++++++++----
 1 file changed, 27 insertions(+), 4 deletions(-)

diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index 1be8f9c37b4d09..008c76e048b9d9 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -18,8 +18,8 @@ use sha2::{Digest, Sha256};
 use std::sync::{Arc, OnceLock};
 use telemetry_events::{
     ActionEvent, AppEvent, AssistantEvent, CallEvent, CpuEvent, EditEvent, EditorEvent, Event,
-    EventRequestBody, EventWrapper, ExtensionEvent, InlineCompletionEvent, MemoryEvent, ReplEvent,
-    SettingEvent,
+    EventRequestBody, EventWrapper, ExtensionEvent, InlineCompletionEvent, MemoryEvent, Panic,
+    ReplEvent, SettingEvent,
 };
 use uuid::Uuid;
 
@@ -296,10 +296,11 @@ pub async fn post_panic(
         version = %panic.app_version,
         os_name = %panic.os_name,
         os_version = %panic.os_version.clone().unwrap_or_default(),
-        installation_id = %panic.installation_id.unwrap_or_default(),
+        installation_id = %panic.installation_id.clone().unwrap_or_default(),
         description = %panic.payload,
         backtrace = %panic.backtrace.join("\n"),
-        "panic report");
+        "panic report"
+    );
 
     let backtrace = if panic.backtrace.len() > 25 {
         let total = panic.backtrace.len();
@@ -317,6 +318,11 @@ pub async fn post_panic(
     } else {
         panic.backtrace.join("\n")
     };
+
+    if !report_to_slack(&panic) {
+        return Ok(());
+    }
+
     let backtrace_with_summary = panic.payload + "\n" + &backtrace;
 
     if let Some(slack_panics_webhook) = app.config.slack_panics_webhook.clone() {
@@ -357,6 +363,23 @@ pub async fn post_panic(
     Ok(())
 }
 
+fn report_to_slack(panic: &Panic) -> bool {
+    if panic.os_name == "Linux" {
+        if panic.payload.contains("ERROR_SURFACE_LOST_KHR") {
+            return false;
+        }
+
+        if panic
+            .payload
+            .contains("GPU has crashed, and no debug information is available")
+        {
+            return false;
+        }
+    }
+
+    true
+}
+
 pub async fn post_events(
     Extension(app): Extension<Arc<AppState>>,
     TypedHeader(ZedChecksumHeader(checksum)): TypedHeader<ZedChecksumHeader>,

From 740803d745e1fe3b711c3c1a05ce3a2616f123cb Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Thu, 19 Sep 2024 19:43:32 -0400
Subject: [PATCH 230/762] Bump release_notes to v2 endpoint (#18108)

Partially addresses https://github.com/zed-industries/zed/issues/17527

<img width="1608" alt="SCR-20240919-rcik"
src="https://github.com/user-attachments/assets/25057731-7da6-4b36-b51b-021c67e8736b">

Release Notes:

- Enhanced the `auto update: view release notes locally` feature to
display release notes for each patch version associated with the
installed minor version.
---
 crates/auto_update/src/auto_update.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index cfda6d6e584b91..1fe89cce0f9c4e 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -268,7 +268,7 @@ fn view_release_notes_locally(workspace: &mut Workspace, cx: &mut ViewContext<Wo
 
     let client = client::Client::global(cx).http_client();
     let url = client.build_url(&format!(
-        "/api/release_notes/{}/{}",
+        "/api/release_notes/v2/{}/{}",
         release_channel.dev_name(),
         version
     ));

From ae34872f73a99d63b58ec5d91e0c3d9a154c8ffd Mon Sep 17 00:00:00 2001
From: Nathan Sobo <nathan@zed.dev>
Date: Thu, 19 Sep 2024 17:49:22 -0600
Subject: [PATCH 231/762] Fix prompt reloading in dev mode (#18095)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I think I nulled out the repo path to test the non dev mode case and
then forgot to reenable it 🤦‍♂️ .

Release Notes:

- N/A
---
 crates/assistant/src/prompts.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/assistant/src/prompts.rs b/crates/assistant/src/prompts.rs
index 7d99a70d1419c9..3b9f75bac930b6 100644
--- a/crates/assistant/src/prompts.rs
+++ b/crates/assistant/src/prompts.rs
@@ -90,10 +90,9 @@ impl PromptBuilder {
     ///   and application context.
     /// * `handlebars` - An `Arc<Mutex<Handlebars>>` for registering and updating templates.
     fn watch_fs_for_template_overrides(
-        mut params: PromptLoadingParams,
+        params: PromptLoadingParams,
         handlebars: Arc<Mutex<Handlebars<'static>>>,
     ) {
-        params.repo_path = None;
         let templates_dir = paths::prompt_overrides_dir(params.repo_path.as_deref());
         params.cx.background_executor()
             .spawn(async move {

From 15b4130fa551e38841b69f135218ef75cfb010db Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Thu, 19 Sep 2024 17:50:00 -0600
Subject: [PATCH 232/762] Introduce the ability to cycle between alternative
 inline assists (#18098)

Release Notes:

- Added a new `assistant.inline_alternatives` setting to configure
additional models that will be used to perform inline assists in
parallel.

---------

Co-authored-by: Nathan <nathan@zed.dev>
Co-authored-by: Roy <roy@anthropic.com>
Co-authored-by: Adam <wolffiex@anthropic.com>
---
 assets/keymaps/default-linux.json          |   7 +
 assets/keymaps/default-macos.json          |   7 +
 crates/assistant/src/assistant.rs          |  13 +
 crates/assistant/src/assistant_settings.rs |  13 +-
 crates/assistant/src/inline_assistant.rs   | 700 ++++++++++++++++-----
 crates/language_model/src/registry.rs      |  32 +
 crates/multi_buffer/src/multi_buffer.rs    |  20 +
 docs/src/assistant/configuration.md        |  26 +
 8 files changed, 641 insertions(+), 177 deletions(-)

diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index 542f6c2df42b48..f15c4dfe22b6c0 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -520,6 +520,13 @@
       "alt-enter": "editor::Newline"
     }
   },
+  {
+    "context": "PromptEditor",
+    "bindings": {
+      "ctrl-[": "assistant::CyclePreviousInlineAssist",
+      "ctrl-]": "assistant::CycleNextInlineAssist"
+    }
+  },
   {
     "context": "ProjectSearchBar && !in_replace",
     "bindings": {
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index 77fac3254bec17..a58112b3c0b927 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -527,6 +527,13 @@
       "ctrl-enter": "assistant::InlineAssist"
     }
   },
+  {
+    "context": "PromptEditor",
+    "bindings": {
+      "ctrl-[": "assistant::CyclePreviousInlineAssist",
+      "ctrl-]": "assistant::CycleNextInlineAssist"
+    }
+  },
   {
     "context": "ProjectSearchBar && !in_replace",
     "bindings": {
diff --git a/crates/assistant/src/assistant.rs b/crates/assistant/src/assistant.rs
index d7466878c9ce1e..8b9c66ee55848d 100644
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -69,6 +69,8 @@ actions!(
         ConfirmCommand,
         NewContext,
         ToggleModelSelector,
+        CycleNextInlineAssist,
+        CyclePreviousInlineAssist
     ]
 );
 
@@ -359,8 +361,19 @@ fn update_active_language_model_from_settings(cx: &mut AppContext) {
     let settings = AssistantSettings::get_global(cx);
     let provider_name = LanguageModelProviderId::from(settings.default_model.provider.clone());
     let model_id = LanguageModelId::from(settings.default_model.model.clone());
+    let inline_alternatives = settings
+        .inline_alternatives
+        .iter()
+        .map(|alternative| {
+            (
+                LanguageModelProviderId::from(alternative.provider.clone()),
+                LanguageModelId::from(alternative.model.clone()),
+            )
+        })
+        .collect::<Vec<_>>();
     LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
         registry.select_active_model(&provider_name, &model_id, cx);
+        registry.select_inline_alternative_models(inline_alternatives, cx);
     });
 }
 
diff --git a/crates/assistant/src/assistant_settings.rs b/crates/assistant/src/assistant_settings.rs
index e2c6a8eb24f088..5aa379bae3fce9 100644
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -59,6 +59,7 @@ pub struct AssistantSettings {
     pub default_width: Pixels,
     pub default_height: Pixels,
     pub default_model: LanguageModelSelection,
+    pub inline_alternatives: Vec<LanguageModelSelection>,
     pub using_outdated_settings_version: bool,
 }
 
@@ -236,6 +237,7 @@ impl AssistantSettingsContent {
                                 })
                             }
                         }),
+                    inline_alternatives: None,
                 },
                 VersionedAssistantSettingsContent::V2(settings) => settings.clone(),
             },
@@ -254,6 +256,7 @@ impl AssistantSettingsContent {
                         .id()
                         .to_string(),
                 }),
+                inline_alternatives: None,
             },
         }
     }
@@ -369,6 +372,7 @@ impl Default for VersionedAssistantSettingsContent {
             default_width: None,
             default_height: None,
             default_model: None,
+            inline_alternatives: None,
         })
     }
 }
@@ -397,6 +401,8 @@ pub struct AssistantSettingsContentV2 {
     default_height: Option<f32>,
     /// The default model to use when creating new contexts.
     default_model: Option<LanguageModelSelection>,
+    /// Additional models with which to generate alternatives when performing inline assists.
+    inline_alternatives: Option<Vec<LanguageModelSelection>>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
@@ -517,10 +523,8 @@ impl Settings for AssistantSettings {
                 &mut settings.default_height,
                 value.default_height.map(Into::into),
             );
-            merge(
-                &mut settings.default_model,
-                value.default_model.map(Into::into),
-            );
+            merge(&mut settings.default_model, value.default_model);
+            merge(&mut settings.inline_alternatives, value.inline_alternatives);
             // merge(&mut settings.infer_context, value.infer_context); TODO re-enable this once we ship context inference
         }
 
@@ -574,6 +578,7 @@ mod tests {
                                 provider: "test-provider".into(),
                                 model: "gpt-99".into(),
                             }),
+                            inline_alternatives: None,
                             enabled: None,
                             button: None,
                             dock: None,
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index c9360213ae5138..428b33f3bbd92c 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -1,7 +1,7 @@
 use crate::{
     assistant_settings::AssistantSettings, humanize_token_count, prompts::PromptBuilder,
-    AssistantPanel, AssistantPanelEvent, CharOperation, LineDiff, LineOperation, ModelSelector,
-    StreamingDiff,
+    AssistantPanel, AssistantPanelEvent, CharOperation, CycleNextInlineAssist,
+    CyclePreviousInlineAssist, LineDiff, LineOperation, ModelSelector, StreamingDiff,
 };
 use anyhow::{anyhow, Context as _, Result};
 use client::{telemetry::Telemetry, ErrorExt};
@@ -25,13 +25,13 @@ use futures::{
     SinkExt, Stream, StreamExt,
 };
 use gpui::{
-    anchored, deferred, point, AppContext, ClickEvent, EventEmitter, FocusHandle, FocusableView,
-    FontWeight, Global, HighlightStyle, Model, ModelContext, Subscription, Task, TextStyle,
-    UpdateGlobal, View, ViewContext, WeakView, WindowContext,
+    anchored, deferred, point, AnyElement, AppContext, ClickEvent, EventEmitter, FocusHandle,
+    FocusableView, FontWeight, Global, HighlightStyle, Model, ModelContext, Subscription, Task,
+    TextStyle, UpdateGlobal, View, ViewContext, WeakView, WindowContext,
 };
 use language::{Buffer, IndentKind, Point, Selection, TransactionId};
 use language_model::{
-    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
+    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
 };
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
@@ -41,7 +41,7 @@ use smol::future::FutureExt;
 use std::{
     cmp,
     future::{self, Future},
-    mem,
+    iter, mem,
     ops::{Range, RangeInclusive},
     pin::Pin,
     sync::Arc,
@@ -85,7 +85,7 @@ pub struct InlineAssistant {
             async_watch::Receiver<AssistStatus>,
         ),
     >,
-    confirmed_assists: HashMap<InlineAssistId, Model<Codegen>>,
+    confirmed_assists: HashMap<InlineAssistId, Model<CodegenAlternative>>,
     prompt_history: VecDeque<String>,
     prompt_builder: Arc<PromptBuilder>,
     telemetry: Option<Arc<Telemetry>>,
@@ -157,7 +157,7 @@ impl InlineAssistant {
                 if let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade()) {
                     for assist_id in editor_assists.assist_ids.clone() {
                         let assist = &self.assists[&assist_id];
-                        if let CodegenStatus::Done = &assist.codegen.read(cx).status {
+                        if let CodegenStatus::Done = assist.codegen.read(cx).status(cx) {
                             self.finish_assist(assist_id, false, cx)
                         }
                     }
@@ -553,7 +553,7 @@ impl InlineAssistant {
                 let assist_range = assist.range.to_offset(&buffer);
                 if assist_range.contains(&selection.start) && assist_range.contains(&selection.end)
                 {
-                    if matches!(assist.codegen.read(cx).status, CodegenStatus::Pending) {
+                    if matches!(assist.codegen.read(cx).status(cx), CodegenStatus::Pending) {
                         self.dismiss_assist(*assist_id, cx);
                     } else {
                         self.finish_assist(*assist_id, false, cx);
@@ -671,7 +671,7 @@ impl InlineAssistant {
                 for assist_id in editor_assists.assist_ids.clone() {
                     let assist = &self.assists[&assist_id];
                     if matches!(
-                        assist.codegen.read(cx).status,
+                        assist.codegen.read(cx).status(cx),
                         CodegenStatus::Error(_) | CodegenStatus::Done
                     ) {
                         let assist_range = assist.range.to_offset(&snapshot);
@@ -774,7 +774,9 @@ impl InlineAssistant {
             if undo {
                 assist.codegen.update(cx, |codegen, cx| codegen.undo(cx));
             } else {
-                self.confirmed_assists.insert(assist_id, assist.codegen);
+                let confirmed_alternative = assist.codegen.read(cx).active_alternative().clone();
+                self.confirmed_assists
+                    .insert(assist_id, confirmed_alternative);
             }
         }
 
@@ -978,12 +980,7 @@ impl InlineAssistant {
         assist
             .codegen
             .update(cx, |codegen, cx| {
-                codegen.start(
-                    assist.range.clone(),
-                    user_prompt,
-                    assistant_panel_context,
-                    cx,
-                )
+                codegen.start(user_prompt, assistant_panel_context, cx)
             })
             .log_err();
 
@@ -1008,7 +1005,7 @@ impl InlineAssistant {
 
     pub fn assist_status(&self, assist_id: InlineAssistId, cx: &AppContext) -> InlineAssistStatus {
         if let Some(assist) = self.assists.get(&assist_id) {
-            match &assist.codegen.read(cx).status {
+            match assist.codegen.read(cx).status(cx) {
                 CodegenStatus::Idle => InlineAssistStatus::Idle,
                 CodegenStatus::Pending => InlineAssistStatus::Pending,
                 CodegenStatus::Done => InlineAssistStatus::Done,
@@ -1037,16 +1034,16 @@ impl InlineAssistant {
         for assist_id in assist_ids {
             if let Some(assist) = self.assists.get(assist_id) {
                 let codegen = assist.codegen.read(cx);
-                let buffer = codegen.buffer.read(cx).read(cx);
-                foreground_ranges.extend(codegen.last_equal_ranges().iter().cloned());
+                let buffer = codegen.buffer(cx).read(cx).read(cx);
+                foreground_ranges.extend(codegen.last_equal_ranges(cx).iter().cloned());
 
                 let pending_range =
-                    codegen.edit_position.unwrap_or(assist.range.start)..assist.range.end;
+                    codegen.edit_position(cx).unwrap_or(assist.range.start)..assist.range.end;
                 if pending_range.end.to_offset(&buffer) > pending_range.start.to_offset(&buffer) {
                     gutter_pending_ranges.push(pending_range);
                 }
 
-                if let Some(edit_position) = codegen.edit_position {
+                if let Some(edit_position) = codegen.edit_position(cx) {
                     let edited_range = assist.range.start..edit_position;
                     if edited_range.end.to_offset(&buffer) > edited_range.start.to_offset(&buffer) {
                         gutter_transformed_ranges.push(edited_range);
@@ -1054,7 +1051,8 @@ impl InlineAssistant {
                 }
 
                 if assist.decorations.is_some() {
-                    inserted_row_ranges.extend(codegen.diff.inserted_row_ranges.iter().cloned());
+                    inserted_row_ranges
+                        .extend(codegen.diff(cx).inserted_row_ranges.iter().cloned());
                 }
             }
         }
@@ -1125,9 +1123,9 @@ impl InlineAssistant {
         };
 
         let codegen = assist.codegen.read(cx);
-        let old_snapshot = codegen.snapshot.clone();
-        let old_buffer = codegen.old_buffer.clone();
-        let deleted_row_ranges = codegen.diff.deleted_row_ranges.clone();
+        let old_snapshot = codegen.snapshot(cx);
+        let old_buffer = codegen.old_buffer(cx);
+        let deleted_row_ranges = codegen.diff(cx).deleted_row_ranges.clone();
 
         editor.update(cx, |editor, cx| {
             let old_blocks = mem::take(&mut decorations.removed_line_block_ids);
@@ -1406,8 +1404,15 @@ impl EventEmitter<PromptEditorEvent> for PromptEditor {}
 impl Render for PromptEditor {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         let gutter_dimensions = *self.gutter_dimensions.lock();
-        let status = &self.codegen.read(cx).status;
-        let buttons = match status {
+        let codegen = self.codegen.read(cx);
+
+        let mut buttons = Vec::new();
+        if codegen.alternative_count(cx) > 1 {
+            buttons.push(self.render_cycle_controls(cx));
+        }
+
+        let status = codegen.status(cx);
+        buttons.extend(match status {
             CodegenStatus::Idle => {
                 vec![
                     IconButton::new("cancel", IconName::Close)
@@ -1416,14 +1421,16 @@ impl Render for PromptEditor {
                         .tooltip(|cx| Tooltip::for_action("Cancel Assist", &menu::Cancel, cx))
                         .on_click(
                             cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::CancelRequested)),
-                        ),
+                        )
+                        .into_any_element(),
                     IconButton::new("start", IconName::SparkleAlt)
                         .icon_color(Color::Muted)
                         .shape(IconButtonShape::Square)
                         .tooltip(|cx| Tooltip::for_action("Transform", &menu::Confirm, cx))
                         .on_click(
                             cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::StartRequested)),
-                        ),
+                        )
+                        .into_any_element(),
                 ]
             }
             CodegenStatus::Pending => {
@@ -1434,7 +1441,8 @@ impl Render for PromptEditor {
                         .tooltip(|cx| Tooltip::text("Cancel Assist", cx))
                         .on_click(
                             cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::CancelRequested)),
-                        ),
+                        )
+                        .into_any_element(),
                     IconButton::new("stop", IconName::Stop)
                         .icon_color(Color::Error)
                         .shape(IconButtonShape::Square)
@@ -1446,9 +1454,8 @@ impl Render for PromptEditor {
                                 cx,
                             )
                         })
-                        .on_click(
-                            cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::StopRequested)),
-                        ),
+                        .on_click(cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::StopRequested)))
+                        .into_any_element(),
                 ]
             }
             CodegenStatus::Error(_) | CodegenStatus::Done => {
@@ -1459,7 +1466,8 @@ impl Render for PromptEditor {
                         .tooltip(|cx| Tooltip::for_action("Cancel Assist", &menu::Cancel, cx))
                         .on_click(
                             cx.listener(|_, _, cx| cx.emit(PromptEditorEvent::CancelRequested)),
-                        ),
+                        )
+                        .into_any_element(),
                     if self.edited_since_done || matches!(status, CodegenStatus::Error(_)) {
                         IconButton::new("restart", IconName::RotateCw)
                             .icon_color(Color::Info)
@@ -1475,6 +1483,7 @@ impl Render for PromptEditor {
                             .on_click(cx.listener(|_, _, cx| {
                                 cx.emit(PromptEditorEvent::StartRequested);
                             }))
+                            .into_any_element()
                     } else {
                         IconButton::new("confirm", IconName::Check)
                             .icon_color(Color::Info)
@@ -1483,12 +1492,14 @@ impl Render for PromptEditor {
                             .on_click(cx.listener(|_, _, cx| {
                                 cx.emit(PromptEditorEvent::ConfirmRequested);
                             }))
+                            .into_any_element()
                     },
                 ]
             }
-        };
+        });
 
         h_flex()
+            .key_context("PromptEditor")
             .bg(cx.theme().colors().editor_background)
             .border_y_1()
             .border_color(cx.theme().status().info_border)
@@ -1498,6 +1509,8 @@ impl Render for PromptEditor {
             .on_action(cx.listener(Self::cancel))
             .on_action(cx.listener(Self::move_up))
             .on_action(cx.listener(Self::move_down))
+            .capture_action(cx.listener(Self::cycle_prev))
+            .capture_action(cx.listener(Self::cycle_next))
             .child(
                 h_flex()
                     .w(gutter_dimensions.full_width() + (gutter_dimensions.margin / 2.0))
@@ -1532,7 +1545,7 @@ impl Render for PromptEditor {
                         ),
                     )
                     .map(|el| {
-                        let CodegenStatus::Error(error) = &self.codegen.read(cx).status else {
+                        let CodegenStatus::Error(error) = self.codegen.read(cx).status(cx) else {
                             return el;
                         };
 
@@ -1776,7 +1789,7 @@ impl PromptEditor {
     }
 
     fn handle_codegen_changed(&mut self, _: Model<Codegen>, cx: &mut ViewContext<Self>) {
-        match &self.codegen.read(cx).status {
+        match self.codegen.read(cx).status(cx) {
             CodegenStatus::Idle => {
                 self.editor
                     .update(cx, |editor, _| editor.set_read_only(false));
@@ -1807,7 +1820,7 @@ impl PromptEditor {
     }
 
     fn cancel(&mut self, _: &editor::actions::Cancel, cx: &mut ViewContext<Self>) {
-        match &self.codegen.read(cx).status {
+        match self.codegen.read(cx).status(cx) {
             CodegenStatus::Idle | CodegenStatus::Done | CodegenStatus::Error(_) => {
                 cx.emit(PromptEditorEvent::CancelRequested);
             }
@@ -1818,7 +1831,7 @@ impl PromptEditor {
     }
 
     fn confirm(&mut self, _: &menu::Confirm, cx: &mut ViewContext<Self>) {
-        match &self.codegen.read(cx).status {
+        match self.codegen.read(cx).status(cx) {
             CodegenStatus::Idle => {
                 cx.emit(PromptEditorEvent::StartRequested);
             }
@@ -1878,6 +1891,79 @@ impl PromptEditor {
         }
     }
 
+    fn cycle_prev(&mut self, _: &CyclePreviousInlineAssist, cx: &mut ViewContext<Self>) {
+        self.codegen
+            .update(cx, |codegen, cx| codegen.cycle_prev(cx));
+    }
+
+    fn cycle_next(&mut self, _: &CycleNextInlineAssist, cx: &mut ViewContext<Self>) {
+        self.codegen
+            .update(cx, |codegen, cx| codegen.cycle_next(cx));
+    }
+
+    fn render_cycle_controls(&self, cx: &ViewContext<Self>) -> AnyElement {
+        let codegen = self.codegen.read(cx);
+        let disabled = matches!(codegen.status(cx), CodegenStatus::Idle);
+
+        h_flex()
+            .child(
+                IconButton::new("previous", IconName::ChevronLeft)
+                    .icon_color(Color::Muted)
+                    .disabled(disabled)
+                    .shape(IconButtonShape::Square)
+                    .tooltip({
+                        let focus_handle = self.editor.focus_handle(cx);
+                        move |cx| {
+                            Tooltip::for_action_in(
+                                "Previous Alternative",
+                                &CyclePreviousInlineAssist,
+                                &focus_handle,
+                                cx,
+                            )
+                        }
+                    })
+                    .on_click(cx.listener(|this, _, cx| {
+                        this.codegen
+                            .update(cx, |codegen, cx| codegen.cycle_prev(cx))
+                    })),
+            )
+            .child(
+                Label::new(format!(
+                    "{}/{}",
+                    codegen.active_alternative + 1,
+                    codegen.alternative_count(cx)
+                ))
+                .size(LabelSize::Small)
+                .color(if disabled {
+                    Color::Disabled
+                } else {
+                    Color::Muted
+                }),
+            )
+            .child(
+                IconButton::new("next", IconName::ChevronRight)
+                    .icon_color(Color::Muted)
+                    .disabled(disabled)
+                    .shape(IconButtonShape::Square)
+                    .tooltip({
+                        let focus_handle = self.editor.focus_handle(cx);
+                        move |cx| {
+                            Tooltip::for_action_in(
+                                "Next Alternative",
+                                &CycleNextInlineAssist,
+                                &focus_handle,
+                                cx,
+                            )
+                        }
+                    })
+                    .on_click(cx.listener(|this, _, cx| {
+                        this.codegen
+                            .update(cx, |codegen, cx| codegen.cycle_next(cx))
+                    })),
+            )
+            .into_any_element()
+    }
+
     fn render_token_count(&self, cx: &mut ViewContext<Self>) -> Option<impl IntoElement> {
         let model = LanguageModelRegistry::read_global(cx).active_model()?;
         let token_counts = self.token_counts?;
@@ -2124,7 +2210,7 @@ impl InlineAssist {
                                 return;
                             };
 
-                            if let CodegenStatus::Error(error) = &codegen.read(cx).status {
+                            if let CodegenStatus::Error(error) = codegen.read(cx).status(cx) {
                                 if assist.decorations.is_none() {
                                     if let Some(workspace) = assist
                                         .workspace
@@ -2185,12 +2271,9 @@ impl InlineAssist {
             return future::ready(Err(anyhow!("no user prompt"))).boxed();
         };
         let assistant_panel_context = self.assistant_panel_context(cx);
-        self.codegen.read(cx).count_tokens(
-            self.range.clone(),
-            user_prompt,
-            assistant_panel_context,
-            cx,
-        )
+        self.codegen
+            .read(cx)
+            .count_tokens(user_prompt, assistant_panel_context, cx)
     }
 }
 
@@ -2201,19 +2284,216 @@ struct InlineAssistDecorations {
     end_block_id: CustomBlockId,
 }
 
-#[derive(Debug)]
+#[derive(Copy, Clone, Debug)]
 pub enum CodegenEvent {
     Finished,
     Undone,
 }
 
 pub struct Codegen {
+    alternatives: Vec<Model<CodegenAlternative>>,
+    active_alternative: usize,
+    subscriptions: Vec<Subscription>,
+    buffer: Model<MultiBuffer>,
+    range: Range<Anchor>,
+    initial_transaction_id: Option<TransactionId>,
+    telemetry: Option<Arc<Telemetry>>,
+    builder: Arc<PromptBuilder>,
+}
+
+impl Codegen {
+    pub fn new(
+        buffer: Model<MultiBuffer>,
+        range: Range<Anchor>,
+        initial_transaction_id: Option<TransactionId>,
+        telemetry: Option<Arc<Telemetry>>,
+        builder: Arc<PromptBuilder>,
+        cx: &mut ModelContext<Self>,
+    ) -> Self {
+        let codegen = cx.new_model(|cx| {
+            CodegenAlternative::new(
+                buffer.clone(),
+                range.clone(),
+                false,
+                telemetry.clone(),
+                builder.clone(),
+                cx,
+            )
+        });
+        let mut this = Self {
+            alternatives: vec![codegen],
+            active_alternative: 0,
+            subscriptions: Vec::new(),
+            buffer,
+            range,
+            initial_transaction_id,
+            telemetry,
+            builder,
+        };
+        this.activate(0, cx);
+        this
+    }
+
+    fn subscribe_to_alternative(&mut self, cx: &mut ModelContext<Self>) {
+        let codegen = self.active_alternative().clone();
+        self.subscriptions.clear();
+        self.subscriptions
+            .push(cx.observe(&codegen, |_, _, cx| cx.notify()));
+        self.subscriptions
+            .push(cx.subscribe(&codegen, |_, _, event, cx| cx.emit(*event)));
+    }
+
+    fn active_alternative(&self) -> &Model<CodegenAlternative> {
+        &self.alternatives[self.active_alternative]
+    }
+
+    fn status<'a>(&self, cx: &'a AppContext) -> &'a CodegenStatus {
+        &self.active_alternative().read(cx).status
+    }
+
+    fn alternative_count(&self, cx: &AppContext) -> usize {
+        LanguageModelRegistry::read_global(cx)
+            .inline_alternative_models()
+            .len()
+            + 1
+    }
+
+    pub fn cycle_prev(&mut self, cx: &mut ModelContext<Self>) {
+        let next_active_ix = if self.active_alternative == 0 {
+            self.alternatives.len() - 1
+        } else {
+            self.active_alternative - 1
+        };
+        self.activate(next_active_ix, cx);
+    }
+
+    pub fn cycle_next(&mut self, cx: &mut ModelContext<Self>) {
+        let next_active_ix = (self.active_alternative + 1) % self.alternatives.len();
+        self.activate(next_active_ix, cx);
+    }
+
+    fn activate(&mut self, index: usize, cx: &mut ModelContext<Self>) {
+        self.active_alternative()
+            .update(cx, |codegen, cx| codegen.set_active(false, cx));
+        self.active_alternative = index;
+        self.active_alternative()
+            .update(cx, |codegen, cx| codegen.set_active(true, cx));
+        self.subscribe_to_alternative(cx);
+        cx.notify();
+    }
+
+    pub fn start(
+        &mut self,
+        user_prompt: String,
+        assistant_panel_context: Option<LanguageModelRequest>,
+        cx: &mut ModelContext<Self>,
+    ) -> Result<()> {
+        let alternative_models = LanguageModelRegistry::read_global(cx)
+            .inline_alternative_models()
+            .to_vec();
+
+        self.active_alternative()
+            .update(cx, |alternative, cx| alternative.undo(cx));
+        self.activate(0, cx);
+        self.alternatives.truncate(1);
+
+        for _ in 0..alternative_models.len() {
+            self.alternatives.push(cx.new_model(|cx| {
+                CodegenAlternative::new(
+                    self.buffer.clone(),
+                    self.range.clone(),
+                    false,
+                    self.telemetry.clone(),
+                    self.builder.clone(),
+                    cx,
+                )
+            }));
+        }
+
+        let primary_model = LanguageModelRegistry::read_global(cx)
+            .active_model()
+            .context("no active model")?;
+
+        for (model, alternative) in iter::once(primary_model)
+            .chain(alternative_models)
+            .zip(&self.alternatives)
+        {
+            alternative.update(cx, |alternative, cx| {
+                alternative.start(
+                    user_prompt.clone(),
+                    assistant_panel_context.clone(),
+                    model.clone(),
+                    cx,
+                )
+            })?;
+        }
+
+        Ok(())
+    }
+
+    pub fn stop(&mut self, cx: &mut ModelContext<Self>) {
+        for codegen in &self.alternatives {
+            codegen.update(cx, |codegen, cx| codegen.stop(cx));
+        }
+    }
+
+    pub fn undo(&mut self, cx: &mut ModelContext<Self>) {
+        self.active_alternative()
+            .update(cx, |codegen, cx| codegen.undo(cx));
+
+        self.buffer.update(cx, |buffer, cx| {
+            if let Some(transaction_id) = self.initial_transaction_id.take() {
+                buffer.undo_transaction(transaction_id, cx);
+                buffer.refresh_preview(cx);
+            }
+        });
+    }
+
+    pub fn count_tokens(
+        &self,
+        user_prompt: String,
+        assistant_panel_context: Option<LanguageModelRequest>,
+        cx: &AppContext,
+    ) -> BoxFuture<'static, Result<TokenCounts>> {
+        self.active_alternative()
+            .read(cx)
+            .count_tokens(user_prompt, assistant_panel_context, cx)
+    }
+
+    pub fn buffer(&self, cx: &AppContext) -> Model<MultiBuffer> {
+        self.active_alternative().read(cx).buffer.clone()
+    }
+
+    pub fn old_buffer(&self, cx: &AppContext) -> Model<Buffer> {
+        self.active_alternative().read(cx).old_buffer.clone()
+    }
+
+    pub fn snapshot(&self, cx: &AppContext) -> MultiBufferSnapshot {
+        self.active_alternative().read(cx).snapshot.clone()
+    }
+
+    pub fn edit_position(&self, cx: &AppContext) -> Option<Anchor> {
+        self.active_alternative().read(cx).edit_position
+    }
+
+    fn diff<'a>(&self, cx: &'a AppContext) -> &'a Diff {
+        &self.active_alternative().read(cx).diff
+    }
+
+    pub fn last_equal_ranges<'a>(&self, cx: &'a AppContext) -> &'a [Range<Anchor>] {
+        self.active_alternative().read(cx).last_equal_ranges()
+    }
+}
+
+impl EventEmitter<CodegenEvent> for Codegen {}
+
+pub struct CodegenAlternative {
     buffer: Model<MultiBuffer>,
     old_buffer: Model<Buffer>,
     snapshot: MultiBufferSnapshot,
     edit_position: Option<Anchor>,
+    range: Range<Anchor>,
     last_equal_ranges: Vec<Range<Anchor>>,
-    initial_transaction_id: Option<TransactionId>,
     transformation_transaction_id: Option<TransactionId>,
     status: CodegenStatus,
     generation: Task<()>,
@@ -2221,6 +2501,9 @@ pub struct Codegen {
     telemetry: Option<Arc<Telemetry>>,
     _subscription: gpui::Subscription,
     builder: Arc<PromptBuilder>,
+    active: bool,
+    edits: Vec<(Range<Anchor>, String)>,
+    line_operations: Vec<LineOperation>,
 }
 
 enum CodegenStatus {
@@ -2242,13 +2525,13 @@ impl Diff {
     }
 }
 
-impl EventEmitter<CodegenEvent> for Codegen {}
+impl EventEmitter<CodegenEvent> for CodegenAlternative {}
 
-impl Codegen {
+impl CodegenAlternative {
     pub fn new(
         buffer: Model<MultiBuffer>,
         range: Range<Anchor>,
-        initial_transaction_id: Option<TransactionId>,
+        active: bool,
         telemetry: Option<Arc<Telemetry>>,
         builder: Arc<PromptBuilder>,
         cx: &mut ModelContext<Self>,
@@ -2287,8 +2570,33 @@ impl Codegen {
             diff: Diff::default(),
             telemetry,
             _subscription: cx.subscribe(&buffer, Self::handle_buffer_event),
-            initial_transaction_id,
             builder,
+            active,
+            edits: Vec::new(),
+            line_operations: Vec::new(),
+            range,
+        }
+    }
+
+    fn set_active(&mut self, active: bool, cx: &mut ModelContext<Self>) {
+        if active != self.active {
+            self.active = active;
+
+            if self.active {
+                let edits = self.edits.clone();
+                self.apply_edits(edits, cx);
+                if matches!(self.status, CodegenStatus::Pending) {
+                    let line_operations = self.line_operations.clone();
+                    self.reapply_line_based_diff(line_operations, cx);
+                } else {
+                    self.reapply_batch_diff(cx).detach();
+                }
+            } else if let Some(transaction_id) = self.transformation_transaction_id.take() {
+                self.buffer.update(cx, |buffer, cx| {
+                    buffer.undo_transaction(transaction_id, cx);
+                    buffer.forget_transaction(transaction_id, cx);
+                });
+            }
         }
     }
 
@@ -2313,14 +2621,12 @@ impl Codegen {
 
     pub fn count_tokens(
         &self,
-        edit_range: Range<Anchor>,
         user_prompt: String,
         assistant_panel_context: Option<LanguageModelRequest>,
         cx: &AppContext,
     ) -> BoxFuture<'static, Result<TokenCounts>> {
         if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-            let request =
-                self.build_request(user_prompt, assistant_panel_context.clone(), edit_range, cx);
+            let request = self.build_request(user_prompt, assistant_panel_context.clone(), cx);
             match request {
                 Ok(request) => {
                     let total_count = model.count_tokens(request.clone(), cx);
@@ -2345,39 +2651,31 @@ impl Codegen {
 
     pub fn start(
         &mut self,
-        edit_range: Range<Anchor>,
         user_prompt: String,
         assistant_panel_context: Option<LanguageModelRequest>,
+        model: Arc<dyn LanguageModel>,
         cx: &mut ModelContext<Self>,
     ) -> Result<()> {
-        let model = LanguageModelRegistry::read_global(cx)
-            .active_model()
-            .context("no active model")?;
-
         if let Some(transformation_transaction_id) = self.transformation_transaction_id.take() {
             self.buffer.update(cx, |buffer, cx| {
                 buffer.undo_transaction(transformation_transaction_id, cx);
             });
         }
 
-        self.edit_position = Some(edit_range.start.bias_right(&self.snapshot));
+        self.edit_position = Some(self.range.start.bias_right(&self.snapshot));
 
         let telemetry_id = model.telemetry_id();
-        let chunks: LocalBoxFuture<Result<BoxStream<Result<String>>>> = if user_prompt
-            .trim()
-            .to_lowercase()
-            == "delete"
-        {
-            async { Ok(stream::empty().boxed()) }.boxed_local()
-        } else {
-            let request =
-                self.build_request(user_prompt, assistant_panel_context, edit_range.clone(), cx)?;
+        let chunks: LocalBoxFuture<Result<BoxStream<Result<String>>>> =
+            if user_prompt.trim().to_lowercase() == "delete" {
+                async { Ok(stream::empty().boxed()) }.boxed_local()
+            } else {
+                let request = self.build_request(user_prompt, assistant_panel_context, cx)?;
 
-            let chunks =
-                cx.spawn(|_, cx| async move { model.stream_completion_text(request, &cx).await });
-            async move { Ok(chunks.await?.boxed()) }.boxed_local()
-        };
-        self.handle_stream(telemetry_id, edit_range, chunks, cx);
+                let chunks = cx
+                    .spawn(|_, cx| async move { model.stream_completion_text(request, &cx).await });
+                async move { Ok(chunks.await?.boxed()) }.boxed_local()
+            };
+        self.handle_stream(telemetry_id, chunks, cx);
         Ok(())
     }
 
@@ -2385,11 +2683,10 @@ impl Codegen {
         &self,
         user_prompt: String,
         assistant_panel_context: Option<LanguageModelRequest>,
-        edit_range: Range<Anchor>,
         cx: &AppContext,
     ) -> Result<LanguageModelRequest> {
         let buffer = self.buffer.read(cx).snapshot(cx);
-        let language = buffer.language_at(edit_range.start);
+        let language = buffer.language_at(self.range.start);
         let language_name = if let Some(language) = language.as_ref() {
             if Arc::ptr_eq(language, &language::PLAIN_TEXT) {
                 None
@@ -2401,8 +2698,8 @@ impl Codegen {
         };
 
         let language_name = language_name.as_ref();
-        let start = buffer.point_to_buffer_offset(edit_range.start);
-        let end = buffer.point_to_buffer_offset(edit_range.end);
+        let start = buffer.point_to_buffer_offset(self.range.start);
+        let end = buffer.point_to_buffer_offset(self.range.end);
         let (buffer, range) = if let Some((start, end)) = start.zip(end) {
             let (start_buffer, start_buffer_offset) = start;
             let (end_buffer, end_buffer_offset) = end;
@@ -2442,16 +2739,15 @@ impl Codegen {
     pub fn handle_stream(
         &mut self,
         model_telemetry_id: String,
-        edit_range: Range<Anchor>,
         stream: impl 'static + Future<Output = Result<BoxStream<'static, Result<String>>>>,
         cx: &mut ModelContext<Self>,
     ) {
         let snapshot = self.snapshot.clone();
         let selected_text = snapshot
-            .text_for_range(edit_range.start..edit_range.end)
+            .text_for_range(self.range.start..self.range.end)
             .collect::<Rope>();
 
-        let selection_start = edit_range.start.to_point(&snapshot);
+        let selection_start = self.range.start.to_point(&snapshot);
 
         // Start with the indentation of the first line in the selection
         let mut suggested_line_indent = snapshot
@@ -2462,7 +2758,7 @@ impl Codegen {
 
         // If the first line in the selection does not have indentation, check the following lines
         if suggested_line_indent.len == 0 && suggested_line_indent.kind == IndentKind::Space {
-            for row in selection_start.row..=edit_range.end.to_point(&snapshot).row {
+            for row in selection_start.row..=self.range.end.to_point(&snapshot).row {
                 let line_indent = snapshot.indent_size_for_line(MultiBufferRow(row));
                 // Prefer tabs if a line in the selection uses tabs as indentation
                 if line_indent.kind == IndentKind::Tab {
@@ -2475,7 +2771,7 @@ impl Codegen {
         let telemetry = self.telemetry.clone();
         self.diff = Diff::default();
         self.status = CodegenStatus::Pending;
-        let mut edit_start = edit_range.start.to_offset(&snapshot);
+        let mut edit_start = self.range.start.to_offset(&snapshot);
         self.generation = cx.spawn(|codegen, mut cx| {
             async move {
                 let chunks = stream.await;
@@ -2597,68 +2893,42 @@ impl Codegen {
                             Ok(())
                         });
 
-                    while let Some((char_ops, line_diff)) = diff_rx.next().await {
+                    while let Some((char_ops, line_ops)) = diff_rx.next().await {
                         codegen.update(&mut cx, |codegen, cx| {
                             codegen.last_equal_ranges.clear();
 
-                            let transaction = codegen.buffer.update(cx, |buffer, cx| {
-                                // Avoid grouping assistant edits with user edits.
-                                buffer.finalize_last_transaction(cx);
-
-                                buffer.start_transaction(cx);
-                                buffer.edit(
-                                    char_ops
-                                        .into_iter()
-                                        .filter_map(|operation| match operation {
-                                            CharOperation::Insert { text } => {
-                                                let edit_start = snapshot.anchor_after(edit_start);
-                                                Some((edit_start..edit_start, text))
-                                            }
-                                            CharOperation::Delete { bytes } => {
-                                                let edit_end = edit_start + bytes;
-                                                let edit_range = snapshot.anchor_after(edit_start)
-                                                    ..snapshot.anchor_before(edit_end);
-                                                edit_start = edit_end;
-                                                Some((edit_range, String::new()))
-                                            }
-                                            CharOperation::Keep { bytes } => {
-                                                let edit_end = edit_start + bytes;
-                                                let edit_range = snapshot.anchor_after(edit_start)
-                                                    ..snapshot.anchor_before(edit_end);
-                                                edit_start = edit_end;
-                                                codegen.last_equal_ranges.push(edit_range);
-                                                None
-                                            }
-                                        }),
-                                    None,
-                                    cx,
-                                );
-                                codegen.edit_position = Some(snapshot.anchor_after(edit_start));
-
-                                buffer.end_transaction(cx)
-                            });
+                            let edits = char_ops
+                                .into_iter()
+                                .filter_map(|operation| match operation {
+                                    CharOperation::Insert { text } => {
+                                        let edit_start = snapshot.anchor_after(edit_start);
+                                        Some((edit_start..edit_start, text))
+                                    }
+                                    CharOperation::Delete { bytes } => {
+                                        let edit_end = edit_start + bytes;
+                                        let edit_range = snapshot.anchor_after(edit_start)
+                                            ..snapshot.anchor_before(edit_end);
+                                        edit_start = edit_end;
+                                        Some((edit_range, String::new()))
+                                    }
+                                    CharOperation::Keep { bytes } => {
+                                        let edit_end = edit_start + bytes;
+                                        let edit_range = snapshot.anchor_after(edit_start)
+                                            ..snapshot.anchor_before(edit_end);
+                                        edit_start = edit_end;
+                                        codegen.last_equal_ranges.push(edit_range);
+                                        None
+                                    }
+                                })
+                                .collect::<Vec<_>>();
 
-                            if let Some(transaction) = transaction {
-                                if let Some(first_transaction) =
-                                    codegen.transformation_transaction_id
-                                {
-                                    // Group all assistant edits into the first transaction.
-                                    codegen.buffer.update(cx, |buffer, cx| {
-                                        buffer.merge_transactions(
-                                            transaction,
-                                            first_transaction,
-                                            cx,
-                                        )
-                                    });
-                                } else {
-                                    codegen.transformation_transaction_id = Some(transaction);
-                                    codegen.buffer.update(cx, |buffer, cx| {
-                                        buffer.finalize_last_transaction(cx)
-                                    });
-                                }
+                            if codegen.active {
+                                codegen.apply_edits(edits.iter().cloned(), cx);
+                                codegen.reapply_line_based_diff(line_ops.iter().cloned(), cx);
                             }
-
-                            codegen.reapply_line_based_diff(edit_range.clone(), line_diff, cx);
+                            codegen.edits.extend(edits);
+                            codegen.line_operations = line_ops;
+                            codegen.edit_position = Some(snapshot.anchor_after(edit_start));
 
                             cx.notify();
                         })?;
@@ -2667,9 +2937,8 @@ impl Codegen {
                     // Streaming stopped and we have the new text in the buffer, and a line-based diff applied for the whole new buffer.
                     // That diff is not what a regular diff is and might look unexpected, ergo apply a regular diff.
                     // It's fine to apply even if the rest of the line diffing fails, as no more hunks are coming through `diff_rx`.
-                    let batch_diff_task = codegen.update(&mut cx, |codegen, cx| {
-                        codegen.reapply_batch_diff(edit_range.clone(), cx)
-                    })?;
+                    let batch_diff_task =
+                        codegen.update(&mut cx, |codegen, cx| codegen.reapply_batch_diff(cx))?;
                     let (line_based_stream_diff, ()) =
                         join!(line_based_stream_diff, batch_diff_task);
                     line_based_stream_diff?;
@@ -2713,24 +2982,45 @@ impl Codegen {
                 buffer.undo_transaction(transaction_id, cx);
                 buffer.refresh_preview(cx);
             }
+        });
+    }
 
-            if let Some(transaction_id) = self.initial_transaction_id.take() {
-                buffer.undo_transaction(transaction_id, cx);
-                buffer.refresh_preview(cx);
-            }
+    fn apply_edits(
+        &mut self,
+        edits: impl IntoIterator<Item = (Range<Anchor>, String)>,
+        cx: &mut ModelContext<CodegenAlternative>,
+    ) {
+        let transaction = self.buffer.update(cx, |buffer, cx| {
+            // Avoid grouping assistant edits with user edits.
+            buffer.finalize_last_transaction(cx);
+            buffer.start_transaction(cx);
+            buffer.edit(edits, None, cx);
+            buffer.end_transaction(cx)
         });
+
+        if let Some(transaction) = transaction {
+            if let Some(first_transaction) = self.transformation_transaction_id {
+                // Group all assistant edits into the first transaction.
+                self.buffer.update(cx, |buffer, cx| {
+                    buffer.merge_transactions(transaction, first_transaction, cx)
+                });
+            } else {
+                self.transformation_transaction_id = Some(transaction);
+                self.buffer
+                    .update(cx, |buffer, cx| buffer.finalize_last_transaction(cx));
+            }
+        }
     }
 
     fn reapply_line_based_diff(
         &mut self,
-        edit_range: Range<Anchor>,
-        line_operations: Vec<LineOperation>,
+        line_operations: impl IntoIterator<Item = LineOperation>,
         cx: &mut ModelContext<Self>,
     ) {
         let old_snapshot = self.snapshot.clone();
-        let old_range = edit_range.to_point(&old_snapshot);
+        let old_range = self.range.to_point(&old_snapshot);
         let new_snapshot = self.buffer.read(cx).snapshot(cx);
-        let new_range = edit_range.to_point(&new_snapshot);
+        let new_range = self.range.to_point(&new_snapshot);
 
         let mut old_row = old_range.start.row;
         let mut new_row = new_range.start.row;
@@ -2781,15 +3071,11 @@ impl Codegen {
         }
     }
 
-    fn reapply_batch_diff(
-        &mut self,
-        edit_range: Range<Anchor>,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<()> {
+    fn reapply_batch_diff(&mut self, cx: &mut ModelContext<Self>) -> Task<()> {
         let old_snapshot = self.snapshot.clone();
-        let old_range = edit_range.to_point(&old_snapshot);
+        let old_range = self.range.to_point(&old_snapshot);
         let new_snapshot = self.buffer.read(cx).snapshot(cx);
-        let new_range = edit_range.to_point(&new_snapshot);
+        let new_range = self.range.to_point(&new_snapshot);
 
         cx.spawn(|codegen, mut cx| async move {
             let (deleted_row_ranges, inserted_row_ranges) = cx
@@ -3073,10 +3359,10 @@ mod tests {
         });
         let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
         let codegen = cx.new_model(|cx| {
-            Codegen::new(
+            CodegenAlternative::new(
                 buffer.clone(),
                 range.clone(),
-                None,
+                true,
                 None,
                 prompt_builder,
                 cx,
@@ -3087,7 +3373,6 @@ mod tests {
         codegen.update(cx, |codegen, cx| {
             codegen.handle_stream(
                 String::new(),
-                range,
                 future::ready(Ok(chunks_rx.map(Ok).boxed())),
                 cx,
             )
@@ -3145,10 +3430,10 @@ mod tests {
         });
         let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
         let codegen = cx.new_model(|cx| {
-            Codegen::new(
+            CodegenAlternative::new(
                 buffer.clone(),
                 range.clone(),
-                None,
+                true,
                 None,
                 prompt_builder,
                 cx,
@@ -3159,7 +3444,6 @@ mod tests {
         codegen.update(cx, |codegen, cx| {
             codegen.handle_stream(
                 String::new(),
-                range.clone(),
                 future::ready(Ok(chunks_rx.map(Ok).boxed())),
                 cx,
             )
@@ -3220,10 +3504,10 @@ mod tests {
         });
         let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
         let codegen = cx.new_model(|cx| {
-            Codegen::new(
+            CodegenAlternative::new(
                 buffer.clone(),
                 range.clone(),
-                None,
+                true,
                 None,
                 prompt_builder,
                 cx,
@@ -3234,7 +3518,6 @@ mod tests {
         codegen.update(cx, |codegen, cx| {
             codegen.handle_stream(
                 String::new(),
-                range.clone(),
                 future::ready(Ok(chunks_rx.map(Ok).boxed())),
                 cx,
             )
@@ -3294,10 +3577,10 @@ mod tests {
         });
         let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
         let codegen = cx.new_model(|cx| {
-            Codegen::new(
+            CodegenAlternative::new(
                 buffer.clone(),
                 range.clone(),
-                None,
+                true,
                 None,
                 prompt_builder,
                 cx,
@@ -3308,7 +3591,6 @@ mod tests {
         codegen.update(cx, |codegen, cx| {
             codegen.handle_stream(
                 String::new(),
-                range.clone(),
                 future::ready(Ok(chunks_rx.map(Ok).boxed())),
                 cx,
             )
@@ -3338,6 +3620,78 @@ mod tests {
         );
     }
 
+    #[gpui::test]
+    async fn test_inactive_codegen_alternative(cx: &mut TestAppContext) {
+        cx.update(LanguageModelRegistry::test);
+        cx.set_global(cx.update(SettingsStore::test));
+        cx.update(language_settings::init);
+
+        let text = indoc! {"
+            fn main() {
+                let x = 0;
+            }
+        "};
+        let buffer =
+            cx.new_model(|cx| Buffer::local(text, cx).with_language(Arc::new(rust_lang()), cx));
+        let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
+        let range = buffer.read_with(cx, |buffer, cx| {
+            let snapshot = buffer.snapshot(cx);
+            snapshot.anchor_before(Point::new(1, 0))..snapshot.anchor_after(Point::new(1, 14))
+        });
+        let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
+        let codegen = cx.new_model(|cx| {
+            CodegenAlternative::new(
+                buffer.clone(),
+                range.clone(),
+                false,
+                None,
+                prompt_builder,
+                cx,
+            )
+        });
+
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                future::ready(Ok(chunks_rx.map(Ok).boxed())),
+                cx,
+            )
+        });
+
+        chunks_tx
+            .unbounded_send("let mut x = 0;\nx += 1;".to_string())
+            .unwrap();
+        drop(chunks_tx);
+        cx.run_until_parked();
+
+        // The codegen is inactive, so the buffer doesn't get modified.
+        assert_eq!(
+            buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
+            text
+        );
+
+        // Activating the codegen applies the changes.
+        codegen.update(cx, |codegen, cx| codegen.set_active(true, cx));
+        assert_eq!(
+            buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
+            indoc! {"
+                fn main() {
+                    let mut x = 0;
+                    x += 1;
+                }
+            "}
+        );
+
+        // Deactivating the codegen undoes the changes.
+        codegen.update(cx, |codegen, cx| codegen.set_active(false, cx));
+        cx.run_until_parked();
+        assert_eq!(
+            buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()),
+            text
+        );
+    }
+
     #[gpui::test]
     async fn test_strip_invalid_spans_from_codeblock() {
         assert_chunks("Lorem ipsum dolor", "Lorem ipsum dolor").await;
diff --git a/crates/language_model/src/registry.rs b/crates/language_model/src/registry.rs
index b3c8ef5f57cc6b..e1ba1c588695c6 100644
--- a/crates/language_model/src/registry.rs
+++ b/crates/language_model/src/registry.rs
@@ -76,6 +76,7 @@ impl Global for GlobalLanguageModelRegistry {}
 pub struct LanguageModelRegistry {
     active_model: Option<ActiveModel>,
     providers: BTreeMap<LanguageModelProviderId, Arc<dyn LanguageModelProvider>>,
+    inline_alternatives: Vec<Arc<dyn LanguageModel>>,
 }
 
 pub struct ActiveModel {
@@ -229,6 +230,37 @@ impl LanguageModelRegistry {
     pub fn active_model(&self) -> Option<Arc<dyn LanguageModel>> {
         self.active_model.as_ref()?.model.clone()
     }
+
+    /// Selects and sets the inline alternatives for language models based on
+    /// provider name and id.
+    pub fn select_inline_alternative_models(
+        &mut self,
+        alternatives: impl IntoIterator<Item = (LanguageModelProviderId, LanguageModelId)>,
+        cx: &mut ModelContext<Self>,
+    ) {
+        let mut selected_alternatives = Vec::new();
+
+        for (provider_id, model_id) in alternatives {
+            if let Some(provider) = self.providers.get(&provider_id) {
+                if let Some(model) = provider
+                    .provided_models(cx)
+                    .iter()
+                    .find(|m| m.id() == model_id)
+                {
+                    selected_alternatives.push(model.clone());
+                }
+            }
+        }
+
+        self.inline_alternatives = selected_alternatives;
+    }
+
+    /// The models to use for inline assists. Returns the union of the active
+    /// model and all inline alternatives. When there are multiple models, the
+    /// user will be able to cycle through results.
+    pub fn inline_alternative_models(&self) -> &[Arc<dyn LanguageModel>] {
+        &self.inline_alternatives
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index 29bd9a80682a10..c163dbc07a6407 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -1106,6 +1106,26 @@ impl MultiBuffer {
         }
     }
 
+    pub fn forget_transaction(
+        &mut self,
+        transaction_id: TransactionId,
+        cx: &mut ModelContext<Self>,
+    ) {
+        if let Some(buffer) = self.as_singleton() {
+            buffer.update(cx, |buffer, _| {
+                buffer.forget_transaction(transaction_id);
+            });
+        } else if let Some(transaction) = self.history.forget(transaction_id) {
+            for (buffer_id, buffer_transaction_id) in transaction.buffer_transactions {
+                if let Some(state) = self.buffers.borrow_mut().get_mut(&buffer_id) {
+                    state.buffer.update(cx, |buffer, _| {
+                        buffer.forget_transaction(buffer_transaction_id);
+                    });
+                }
+            }
+        }
+    }
+
     pub fn stream_excerpts_with_context_lines(
         &mut self,
         buffer: Model<Buffer>,
diff --git a/docs/src/assistant/configuration.md b/docs/src/assistant/configuration.md
index bcdf461e2c3697..17b52a27d88010 100644
--- a/docs/src/assistant/configuration.md
+++ b/docs/src/assistant/configuration.md
@@ -20,6 +20,7 @@ To further customize providers, you can use `settings.json` to do that as follow
 - [Configuring endpoints](#custom-endpoint)
 - [Configuring timeouts](#provider-timeout)
 - [Configuring default model](#default-model)
+- [Configuring alternative models for inline assists](#alternative-assists)
 
 ### Zed AI {#zed-ai}
 
@@ -264,6 +265,31 @@ You can also manually edit the `default_model` object in your settings:
 }
 ```
 
+#### Configuring alternative models for inline assists {#alternative-assists}
+
+You can configure additional models that will be used to perform inline assists in parallel. When you do this,
+the inline assist UI will surface controls to cycle between the alternatives generated by each model. The models
+you specify here are always used in _addition_ to your default model. For example, the following configuration
+will generate two outputs for every assist. One with Claude 3.5 Sonnet, and one with GPT-4o.
+
+```json
+{
+  "assistant": {
+    "default_model": {
+      "provider": "zed.dev",
+      "model": "claude-3-5-sonnet"
+    },
+    "inline_alternatives": [
+      {
+        "provider": "zed.dev",
+        "model": "gpt-4o"
+      }
+    ],
+    "version": "2"
+  }
+}
+```
+
 #### Common Panel Settings
 
 | key            | type    | default | description                                                                           |

From 8103ac12bfc596f0f32f041239e0e26f9c2ee4cc Mon Sep 17 00:00:00 2001
From: Stanislav Alekseev <43210583+WeetHet@users.noreply.github.com>
Date: Fri, 20 Sep 2024 06:36:50 +0300
Subject: [PATCH 233/762] ssh-remoting: Tidy up the code a bit after #18094
 (#18102)

Release Notes:

- N/A
---
 crates/client/src/client.rs          | 2 +-
 crates/project/src/worktree_store.rs | 7 ++++---
 crates/remote/src/ssh_session.rs     | 2 +-
 crates/rpc/src/proto_client.rs       | 6 +++---
 4 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index a8387f7c5ac9ba..48bd646d8aa70e 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -1622,7 +1622,7 @@ impl ProtoClient for Client {
         &self.handler_set
     }
 
-    fn goes_via_collab(&self) -> bool {
+    fn is_via_collab(&self) -> bool {
         true
     }
 }
diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 7fae8b9e1dbdd7..5c3b2a00a98665 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -313,9 +313,10 @@ impl WorktreeStore {
         })
     }
 
+    #[track_caller]
     pub fn add(&mut self, worktree: &Model<Worktree>, cx: &mut ModelContext<Self>) {
         let worktree_id = worktree.read(cx).id();
-        debug_assert!(!self.worktrees().any(|w| w.read(cx).id() == worktree_id));
+        debug_assert!(self.worktrees().all(|w| w.read(cx).id() != worktree_id));
 
         let push_strong_handle = self.retain_worktrees || worktree.read(cx).is_visible();
         let handle = if push_strong_handle {
@@ -487,7 +488,7 @@ impl WorktreeStore {
         };
 
         // collab has bad concurrency guarantees, so we send requests in serial.
-        let update_project = if downstream_client.goes_via_collab() {
+        let update_project = if downstream_client.is_via_collab() {
             Some(downstream_client.request(update))
         } else {
             downstream_client.send(update).log_err();
@@ -508,7 +509,7 @@ impl WorktreeStore {
                             move |update| {
                                 let client = client.clone();
                                 async move {
-                                    if client.goes_via_collab() {
+                                    if client.is_via_collab() {
                                         client.request(update).map(|result| result.is_ok()).await
                                     } else {
                                         client.send(update).is_ok()
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 10608b74f3593f..2bd18aa37e19d1 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -471,7 +471,7 @@ impl ProtoClient for SshSession {
         &self.state
     }
 
-    fn goes_via_collab(&self) -> bool {
+    fn is_via_collab(&self) -> bool {
         false
     }
 }
diff --git a/crates/rpc/src/proto_client.rs b/crates/rpc/src/proto_client.rs
index 89ef580cdfb3d7..88099102765ed7 100644
--- a/crates/rpc/src/proto_client.rs
+++ b/crates/rpc/src/proto_client.rs
@@ -28,7 +28,7 @@ pub trait ProtoClient: Send + Sync {
 
     fn message_handler_set(&self) -> &parking_lot::Mutex<ProtoMessageHandlerSet>;
 
-    fn goes_via_collab(&self) -> bool;
+    fn is_via_collab(&self) -> bool;
 }
 
 #[derive(Default)]
@@ -141,8 +141,8 @@ impl AnyProtoClient {
         Self(client)
     }
 
-    pub fn goes_via_collab(&self) -> bool {
-        self.0.goes_via_collab()
+    pub fn is_via_collab(&self) -> bool {
+        self.0.is_via_collab()
     }
 
     pub fn request<T: RequestMessage>(

From 579267f399816ae9e54b79c92949384a0ac8455a Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Fri, 20 Sep 2024 08:04:26 +0200
Subject: [PATCH 234/762] docs: Update JavaScript docs and remove TBDs (#17989)

Release Notes:

- N/A
---
 docs/src/languages/javascript.md | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/docs/src/languages/javascript.md b/docs/src/languages/javascript.md
index 8fb84881ada0f8..7e74cbbfaebb41 100644
--- a/docs/src/languages/javascript.md
+++ b/docs/src/languages/javascript.md
@@ -26,17 +26,15 @@ For example, if you have Prettier installed and on your `PATH`, you can use it t
 }
 ```
 
-<!--
 ## JSX
 
-TBD: Mention JSX
+Zed supports JSX syntax highlighting out of the box.
 
-## JSDoc
+In JSX strings, the [`tailwindcss-language-server`](./tailwindcss.md) is used provide autocompletion for Tailwind CSS classes.
 
-TBD: Document JSDoc support in Zed.
+## JSDoc
 
-- Tree Sitter: [tree-sitter/tree-sitter-jsdoc](https://github.com/tree-sitter/tree-sitter-jsdoc)
--->
+Zed supports JSDoc syntax in JavaScript and TypeScript comments that match the JSDoc syntax. Zed uses [tree-sitter/tree-sitter-jsdoc](https://github.com/tree-sitter/tree-sitter-jsdoc) for parsing and highlighting JSDoc.
 
 ## ESLint
 

From 93730983dd31bad1855edd3d5943a617f83f2b40 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Fri, 20 Sep 2024 08:04:49 +0200
Subject: [PATCH 235/762] ssh remoting: Restore items/buffers when opening SSH
 project (#18083)

Demo:


https://github.com/user-attachments/assets/ab79ed0d-13a6-4ae7-8e76-6365fc322ec4



Release Notes:

- N/A

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/editor/src/items.rs        |  8 ++++++--
 crates/workspace/src/workspace.rs | 27 +++++++++++++++++----------
 2 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index e3e8ca604b28c3..3d04eb82d38e39 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -1087,10 +1087,14 @@ impl SerializableItem for Editor {
         let workspace_id = workspace.database_id()?;
 
         let buffer = self.buffer().read(cx).as_singleton()?;
+        let path = buffer
+            .read(cx)
+            .file()
+            .map(|file| file.full_path(cx))
+            .and_then(|full_path| project.read(cx).find_project_path(&full_path, cx))
+            .and_then(|project_path| project.read(cx).absolute_path(&project_path, cx));
 
         let is_dirty = buffer.read(cx).is_dirty();
-        let local_file = buffer.read(cx).file().and_then(|file| file.as_local());
-        let path = local_file.map(|file| file.abs_path(cx));
         let mtime = buffer.read(cx).saved_mtime();
 
         let snapshot = buffer.read(cx).snapshot();
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 5855dcce1e5919..92a85299f47b70 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -1114,18 +1114,16 @@ impl Workspace {
             }
 
             // Get project paths for all of the abs_paths
-            let mut worktree_roots: HashSet<Arc<Path>> = Default::default();
             let mut project_paths: Vec<(PathBuf, Option<ProjectPath>)> =
                 Vec::with_capacity(paths_to_open.len());
             for path in paths_to_open.into_iter() {
-                if let Some((worktree, project_entry)) = cx
+                if let Some((_, project_entry)) = cx
                     .update(|cx| {
                         Workspace::project_path_for_path(project_handle.clone(), &path, true, cx)
                     })?
                     .await
                     .log_err()
                 {
-                    worktree_roots.extend(worktree.update(&mut cx, |tree, _| tree.abs_path()).ok());
                     project_paths.push((path, Some(project_entry)));
                 } else {
                     project_paths.push((path, None));
@@ -5532,12 +5530,13 @@ pub fn open_ssh_project(
         let serialized_workspace =
             persistence::DB.workspace_for_ssh_project(&serialized_ssh_project);
 
-        let workspace_id =
-            if let Some(workspace_id) = serialized_workspace.map(|workspace| workspace.id) {
-                workspace_id
-            } else {
-                persistence::DB.next_id().await?
-            };
+        let workspace_id = if let Some(workspace_id) =
+            serialized_workspace.as_ref().map(|workspace| workspace.id)
+        {
+            workspace_id
+        } else {
+            persistence::DB.next_id().await?
+        };
 
         cx.update_window(window.into(), |_, cx| {
             cx.replace_root_view(|cx| {
@@ -5548,7 +5547,15 @@ pub fn open_ssh_project(
             });
         })?;
 
-        window.update(&mut cx, |_, cx| cx.activate_window())
+        window
+            .update(&mut cx, |_, cx| {
+                cx.activate_window();
+
+                open_items(serialized_workspace, vec![], app_state, cx)
+            })?
+            .await?;
+
+        Ok(())
     })
 }
 

From ace4d5185dbd53023f8b583df781bc96f891b80a Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Fri, 20 Sep 2024 10:53:06 +0200
Subject: [PATCH 236/762] settings: Show notification when user/project
 settings fail to parse (#18122)

Closes #16876

We only ever showed parsing errors, but not if something failed to
deserialize.

Basically, if you had a stray `,` somewhere, we'd show a notification
for user errors, but only squiggly lines if you had a `[]` instead of a
`{}`.

The squiggly lines would only show up when there were schema errors.

In the case of `formatter` settings, for example, if someone put in a
`{}` instead of `[]`, we'd never show anything.

With this change we always show a notification if parsing user or
project settings fails.

(Right now, the error message might still be bad, but that's a separate
change)


Release Notes:

- Added a notification to warn users if their user settings or
project-local settings failed to deserialize.

Demo:


https://github.com/user-attachments/assets/e5c48165-f2f7-4b5c-9c6d-6ea74f678683
---
 crates/language/src/language_settings.rs |  7 ++
 crates/project/src/project.rs            | 26 ++++++-
 crates/project/src/project_settings.rs   | 45 +++++++++--
 crates/settings/src/settings.rs          |  4 +-
 crates/settings/src/settings_store.rs    | 95 ++++++++++++++++--------
 crates/workspace/src/workspace.rs        | 19 ++++-
 crates/zed/src/main.rs                   | 28 ++++---
 7 files changed, 173 insertions(+), 51 deletions(-)

diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index 77c9a1d18cee14..6121cb6a39a2ca 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -1152,6 +1152,13 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_formatter_deserialization_invalid() {
+        let raw_auto = "{\"formatter\": {}}";
+        let result: Result<LanguageSettingsContent, _> = serde_json::from_str(raw_auto);
+        assert!(result.is_err());
+    }
+
     #[test]
     pub fn test_resolve_language_servers() {
         fn language_server_names(names: &[&str]) -> Vec<LanguageServerName> {
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index fcf10d11c2cca7..435c1430243705 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -59,12 +59,14 @@ use node_runtime::NodeRuntime;
 use parking_lot::{Mutex, RwLock};
 use paths::{local_tasks_file_relative_path, local_vscode_tasks_file_relative_path};
 pub use prettier_store::PrettierStore;
-use project_settings::{ProjectSettings, SettingsObserver};
+use project_settings::{ProjectSettings, SettingsObserver, SettingsObserverEvent};
 use remote::SshSession;
 use rpc::{proto::SSH_PROJECT_ID, AnyProtoClient, ErrorCode};
 use search::{SearchInputKind, SearchQuery, SearchResult};
 use search_history::SearchHistory;
-use settings::{watch_config_file, Settings, SettingsLocation, SettingsStore};
+use settings::{
+    watch_config_file, InvalidSettingsError, Settings, SettingsLocation, SettingsStore,
+};
 use smol::channel::Receiver;
 use snippet::Snippet;
 use snippet_provider::SnippetProvider;
@@ -230,6 +232,7 @@ pub enum Event {
     LanguageServerRemoved(LanguageServerId),
     LanguageServerLog(LanguageServerId, LanguageServerLogType, String),
     Notification(String),
+    LocalSettingsUpdated(Result<(), InvalidSettingsError>),
     LanguageServerPrompt(LanguageServerPromptRequest),
     LanguageNotFound(Model<Buffer>),
     ActiveEntryChanged(Option<ProjectEntryId>),
@@ -644,6 +647,8 @@ impl Project {
             let settings_observer = cx.new_model(|cx| {
                 SettingsObserver::new_local(fs.clone(), worktree_store.clone(), cx)
             });
+            cx.subscribe(&settings_observer, Self::on_settings_observer_event)
+                .detach();
 
             let environment = ProjectEnvironment::new(&worktree_store, env, cx);
             let lsp_store = cx.new_model(|cx| {
@@ -729,6 +734,8 @@ impl Project {
             let settings_observer = cx.new_model(|cx| {
                 SettingsObserver::new_ssh(ssh.clone().into(), worktree_store.clone(), cx)
             });
+            cx.subscribe(&settings_observer, Self::on_settings_observer_event)
+                .detach();
 
             let environment = ProjectEnvironment::new(&worktree_store, None, cx);
             let lsp_store = cx.new_model(|cx| {
@@ -913,6 +920,8 @@ impl Project {
             cx.subscribe(&buffer_store, Self::on_buffer_store_event)
                 .detach();
             cx.subscribe(&lsp_store, Self::on_lsp_store_event).detach();
+            cx.subscribe(&settings_observer, Self::on_settings_observer_event)
+                .detach();
 
             let mut this = Self {
                 buffer_ordered_messages_tx: tx,
@@ -2058,6 +2067,19 @@ impl Project {
         }
     }
 
+    fn on_settings_observer_event(
+        &mut self,
+        _: Model<SettingsObserver>,
+        event: &SettingsObserverEvent,
+        cx: &mut ModelContext<Self>,
+    ) {
+        match event {
+            SettingsObserverEvent::LocalSettingsUpdated(error) => {
+                cx.emit(Event::LocalSettingsUpdated(error.clone()))
+            }
+        }
+    }
+
     fn on_worktree_store_event(
         &mut self,
         _: Model<WorktreeStore>,
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index 2eeb8408961186..9a7c80703c734c 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -1,11 +1,11 @@
 use collections::HashMap;
 use fs::Fs;
-use gpui::{AppContext, AsyncAppContext, BorrowAppContext, Model, ModelContext};
+use gpui::{AppContext, AsyncAppContext, BorrowAppContext, EventEmitter, Model, ModelContext};
 use paths::local_settings_file_relative_path;
 use rpc::{proto, AnyProtoClient, TypedEnvelope};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources, SettingsStore};
+use settings::{InvalidSettingsError, Settings, SettingsSources, SettingsStore};
 use std::{
     path::{Path, PathBuf},
     sync::Arc,
@@ -176,6 +176,13 @@ pub enum SettingsObserverMode {
     Remote,
 }
 
+#[derive(Clone, Debug, PartialEq)]
+pub enum SettingsObserverEvent {
+    LocalSettingsUpdated(Result<(), InvalidSettingsError>),
+}
+
+impl EventEmitter<SettingsObserverEvent> for SettingsObserver {}
+
 pub struct SettingsObserver {
     mode: SettingsObserverMode,
     downstream_client: Option<AnyProtoClient>,
@@ -415,11 +422,16 @@ impl SettingsObserver {
     ) {
         let worktree_id = worktree.read(cx).id();
         let remote_worktree_id = worktree.read(cx).id();
-        cx.update_global::<SettingsStore, _>(|store, cx| {
+
+        let result = cx.update_global::<SettingsStore, anyhow::Result<()>>(|store, cx| {
             for (directory, file_content) in settings_contents {
-                store
-                    .set_local_settings(worktree_id, directory.clone(), file_content.as_deref(), cx)
-                    .log_err();
+                store.set_local_settings(
+                    worktree_id,
+                    directory.clone(),
+                    file_content.as_deref(),
+                    cx,
+                )?;
+
                 if let Some(downstream_client) = &self.downstream_client {
                     downstream_client
                         .send(proto::UpdateWorktreeSettings {
@@ -431,6 +443,25 @@ impl SettingsObserver {
                         .log_err();
                 }
             }
-        })
+            anyhow::Ok(())
+        });
+
+        match result {
+            Err(error) => {
+                if let Ok(error) = error.downcast::<InvalidSettingsError>() {
+                    if let InvalidSettingsError::LocalSettings {
+                        ref path,
+                        ref message,
+                    } = error
+                    {
+                        log::error!("Failed to set local settings in {:?}: {:?}", path, message);
+                        cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Err(error)));
+                    }
+                }
+            }
+            Ok(()) => {
+                cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Ok(())));
+            }
+        }
     }
 }
diff --git a/crates/settings/src/settings.rs b/crates/settings/src/settings.rs
index 5ece3f867e4ff4..f1f8591bba4525 100644
--- a/crates/settings/src/settings.rs
+++ b/crates/settings/src/settings.rs
@@ -13,7 +13,9 @@ pub use editable_setting_control::*;
 pub use json_schema::*;
 pub use keymap_file::KeymapFile;
 pub use settings_file::*;
-pub use settings_store::{Settings, SettingsLocation, SettingsSources, SettingsStore};
+pub use settings_store::{
+    InvalidSettingsError, Settings, SettingsLocation, SettingsSources, SettingsStore,
+};
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
 pub struct WorktreeId(usize);
diff --git a/crates/settings/src/settings_store.rs b/crates/settings/src/settings_store.rs
index 3ef8bffe2d3ded..20bf52f2c57ef0 100644
--- a/crates/settings/src/settings_store.rs
+++ b/crates/settings/src/settings_store.rs
@@ -3,6 +3,7 @@ use collections::{btree_map, hash_map, BTreeMap, HashMap};
 use fs::Fs;
 use futures::{channel::mpsc, future::LocalBoxFuture, FutureExt, StreamExt};
 use gpui::{AppContext, AsyncAppContext, BorrowAppContext, Global, Task, UpdateGlobal};
+use paths::local_settings_file_relative_path;
 use schemars::{gen::SchemaGenerator, schema::RootSchema, JsonSchema};
 use serde::{de::DeserializeOwned, Deserialize as _, Serialize};
 use smallvec::SmallVec;
@@ -10,7 +11,7 @@ use std::{
     any::{type_name, Any, TypeId},
     fmt::Debug,
     ops::Range,
-    path::Path,
+    path::{Path, PathBuf},
     str,
     sync::{Arc, LazyLock},
 };
@@ -694,9 +695,14 @@ impl SettingsStore {
                 .deserialize_setting(&self.raw_extension_settings)
                 .log_err();
 
-            let user_settings = setting_value
-                .deserialize_setting(&self.raw_user_settings)
-                .log_err();
+            let user_settings = match setting_value.deserialize_setting(&self.raw_user_settings) {
+                Ok(settings) => Some(settings),
+                Err(error) => {
+                    return Err(anyhow!(InvalidSettingsError::UserSettings {
+                        message: error.to_string()
+                    }));
+                }
+            };
 
             let mut release_channel_settings = None;
             if let Some(release_settings) = &self
@@ -746,34 +752,43 @@ impl SettingsStore {
                     break;
                 }
 
-                if let Some(local_settings) =
-                    setting_value.deserialize_setting(local_settings).log_err()
-                {
-                    paths_stack.push(Some((*root_id, path.as_ref())));
-                    project_settings_stack.push(local_settings);
-
-                    // If a local settings file changed, then avoid recomputing local
-                    // settings for any path outside of that directory.
-                    if changed_local_path.map_or(false, |(changed_root_id, changed_local_path)| {
-                        *root_id != changed_root_id || !path.starts_with(changed_local_path)
-                    }) {
-                        continue;
-                    }
-
-                    if let Some(value) = setting_value
-                        .load_setting(
-                            SettingsSources {
-                                default: &default_settings,
-                                extensions: extension_settings.as_ref(),
-                                user: user_settings.as_ref(),
-                                release_channel: release_channel_settings.as_ref(),
-                                project: &project_settings_stack.iter().collect::<Vec<_>>(),
+                match setting_value.deserialize_setting(local_settings) {
+                    Ok(local_settings) => {
+                        paths_stack.push(Some((*root_id, path.as_ref())));
+                        project_settings_stack.push(local_settings);
+
+                        // If a local settings file changed, then avoid recomputing local
+                        // settings for any path outside of that directory.
+                        if changed_local_path.map_or(
+                            false,
+                            |(changed_root_id, changed_local_path)| {
+                                *root_id != changed_root_id || !path.starts_with(changed_local_path)
                             },
-                            cx,
-                        )
-                        .log_err()
-                    {
-                        setting_value.set_local_value(*root_id, path.clone(), value);
+                        ) {
+                            continue;
+                        }
+
+                        if let Some(value) = setting_value
+                            .load_setting(
+                                SettingsSources {
+                                    default: &default_settings,
+                                    extensions: extension_settings.as_ref(),
+                                    user: user_settings.as_ref(),
+                                    release_channel: release_channel_settings.as_ref(),
+                                    project: &project_settings_stack.iter().collect::<Vec<_>>(),
+                                },
+                                cx,
+                            )
+                            .log_err()
+                        {
+                            setting_value.set_local_value(*root_id, path.clone(), value);
+                        }
+                    }
+                    Err(error) => {
+                        return Err(anyhow!(InvalidSettingsError::LocalSettings {
+                            path: path.join(local_settings_file_relative_path()),
+                            message: error.to_string()
+                        }));
                     }
                 }
             }
@@ -782,6 +797,24 @@ impl SettingsStore {
     }
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub enum InvalidSettingsError {
+    LocalSettings { path: PathBuf, message: String },
+    UserSettings { message: String },
+}
+
+impl std::fmt::Display for InvalidSettingsError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            InvalidSettingsError::LocalSettings { message, .. }
+            | InvalidSettingsError::UserSettings { message } => {
+                write!(f, "{}", message)
+            }
+        }
+    }
+}
+impl std::error::Error for InvalidSettingsError {}
+
 impl Debug for SettingsStore {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("SettingsStore")
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 92a85299f47b70..1fbeab38a2e8b4 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -64,7 +64,7 @@ use project::{
 use remote::{SshConnectionOptions, SshSession};
 use serde::Deserialize;
 use session::AppSession;
-use settings::Settings;
+use settings::{InvalidSettingsError, Settings};
 use shared_screen::SharedScreen;
 use sqlez::{
     bindable::{Bind, Column, StaticColumnCount},
@@ -832,6 +832,23 @@ impl Workspace {
                     }
                 }
 
+                project::Event::LocalSettingsUpdated(result) => {
+                    struct LocalSettingsUpdated;
+                    let id = NotificationId::unique::<LocalSettingsUpdated>();
+
+                    match result {
+                        Err(InvalidSettingsError::LocalSettings { message, path }) => {
+                            let full_message =
+                                format!("Failed to set local settings in {:?}:\n{}", path, message);
+                            this.show_notification(id, cx, |cx| {
+                                cx.new_view(|_| MessageNotification::new(full_message.clone()))
+                            })
+                        }
+                        Err(_) => {}
+                        Ok(_) => this.dismiss_notification(&id, cx),
+                    }
+                }
+
                 project::Event::Notification(message) => {
                     struct ProjectNotification;
 
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 3104001f992726..6ecdbb224f3d91 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -34,7 +34,9 @@ use parking_lot::Mutex;
 use recent_projects::open_ssh_project;
 use release_channel::{AppCommitSha, AppVersion};
 use session::{AppSession, Session};
-use settings::{handle_settings_file_changes, watch_config_file, Settings, SettingsStore};
+use settings::{
+    handle_settings_file_changes, watch_config_file, InvalidSettingsError, Settings, SettingsStore,
+};
 use simplelog::ConfigBuilder;
 use smol::process::Command;
 use std::{
@@ -626,20 +628,28 @@ fn handle_settings_changed(error: Option<anyhow::Error>, cx: &mut AppContext) {
 
     for workspace in workspace::local_workspace_windows(cx) {
         workspace
-            .update(cx, |workspace, cx| match &error {
-                Some(error) => {
-                    workspace.show_notification(id.clone(), cx, |cx| {
-                        cx.new_view(|_| {
-                            MessageNotification::new(format!("Invalid settings file\n{error}"))
+            .update(cx, |workspace, cx| {
+                match error
+                    .as_ref()
+                    .and_then(|error| error.downcast_ref::<InvalidSettingsError>())
+                {
+                    Some(InvalidSettingsError::UserSettings { message }) => {
+                        workspace.show_notification(id.clone(), cx, |cx| {
+                            cx.new_view(|_| {
+                                MessageNotification::new(format!(
+                                    "Invalid user settings file\n{message}"
+                                ))
                                 .with_click_message("Open settings file")
                                 .on_click(|cx| {
                                     cx.dispatch_action(zed_actions::OpenSettings.boxed_clone());
                                     cx.emit(DismissEvent);
                                 })
-                        })
-                    });
+                            })
+                        });
+                    }
+                    None => workspace.dismiss_notification(&id, cx),
+                    _ => {}
                 }
-                None => workspace.dismiss_notification(&id, cx),
             })
             .log_err();
     }

From 97708fdf43bbd15e3b978412d6682502df2f0d70 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Fri, 20 Sep 2024 11:10:19 +0200
Subject: [PATCH 237/762] settings: Follow-up fix to show more errors (#18123)

The condition added in #18122 was too strict.


Release Notes:

- N/A
---
 crates/zed/src/main.rs | 36 +++++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 6ecdbb224f3d91..d3eb97c9aa506e 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -629,26 +629,28 @@ fn handle_settings_changed(error: Option<anyhow::Error>, cx: &mut AppContext) {
     for workspace in workspace::local_workspace_windows(cx) {
         workspace
             .update(cx, |workspace, cx| {
-                match error
-                    .as_ref()
-                    .and_then(|error| error.downcast_ref::<InvalidSettingsError>())
-                {
-                    Some(InvalidSettingsError::UserSettings { message }) => {
-                        workspace.show_notification(id.clone(), cx, |cx| {
-                            cx.new_view(|_| {
-                                MessageNotification::new(format!(
-                                    "Invalid user settings file\n{message}"
-                                ))
-                                .with_click_message("Open settings file")
-                                .on_click(|cx| {
-                                    cx.dispatch_action(zed_actions::OpenSettings.boxed_clone());
-                                    cx.emit(DismissEvent);
+                match error.as_ref() {
+                    Some(error) => {
+                        if let Some(InvalidSettingsError::LocalSettings { .. }) =
+                            error.downcast_ref::<InvalidSettingsError>()
+                        {
+                            // Local settings will be displayed by the projects
+                        } else {
+                            workspace.show_notification(id.clone(), cx, |cx| {
+                                cx.new_view(|_| {
+                                    MessageNotification::new(format!(
+                                        "Invalid user settings file\n{error}"
+                                    ))
+                                    .with_click_message("Open settings file")
+                                    .on_click(|cx| {
+                                        cx.dispatch_action(zed_actions::OpenSettings.boxed_clone());
+                                        cx.emit(DismissEvent);
+                                    })
                                 })
-                            })
-                        });
+                            });
+                        }
                     }
                     None => workspace.dismiss_notification(&id, cx),
-                    _ => {}
                 }
             })
             .log_err();

From ca033e647507ab8b31bc3a4a249f501ccecb0f9c Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 20 Sep 2024 08:35:13 -0400
Subject: [PATCH 238/762] Revert "Update nightly tag every night (#17879)"
 (#18133)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR reverts #17879, as it wasn't working.

When a GitHub Action pushes a tag, it does not trigger workflows for
push events for that tag:

> When you use the repository's `GITHUB_TOKEN` to perform tasks, events
triggered by the `GITHUB_TOKEN`, with the exception of
`workflow_dispatch` and `repository_dispatch`, will not create a new
workflow run. This prevents you from accidentally creating recursive
workflow runs. For example, if a workflow run pushes code using the
repository's `GITHUB_TOKEN`, a new workflow will not run even when the
repository contains a workflow configured to run when `push` events
occur.
>
> —
[source](https://docs.github.com/en/actions/security-for-github-actions/security-guides/automatic-token-authentication#using-the-github_token-in-a-workflow)

This reverts commit 761129e3739efacb7b8763eaa0fa8a109e935447.

Release Notes:

- N/A
---
 .github/workflows/bump_nightly_tag.yml | 23 -----------------------
 .github/workflows/release_nightly.yml  |  3 +++
 2 files changed, 3 insertions(+), 23 deletions(-)
 delete mode 100644 .github/workflows/bump_nightly_tag.yml

diff --git a/.github/workflows/bump_nightly_tag.yml b/.github/workflows/bump_nightly_tag.yml
deleted file mode 100644
index 0959ae9677142c..00000000000000
--- a/.github/workflows/bump_nightly_tag.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: Update Nightly Tag
-
-on:
-  schedule:
-    # Fire every day at 7:00am UTC (Roughly before EU workday and after US workday)
-    - cron: "0 7 * * *"
-
-jobs:
-  update-nightly-tag:
-    if: github.repository_owner == 'zed-industries'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
-        with:
-          fetch-depth: 0
-
-      - name: Update nightly tag
-        run: |
-          git config user.name github-actions
-          git config user.email github-actions@github.com
-          git tag -f nightly
-          git push origin nightly --force
diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml
index 17db66a264bdc0..bcaa60b77589c1 100644
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -1,6 +1,9 @@
 name: Release Nightly
 
 on:
+  schedule:
+    # Fire every day at 7:00am UTC (Roughly before EU workday and after US workday)
+    - cron: "0 7 * * *"
   push:
     tags:
       - "nightly"

From 90a12f55642410e38df65d7f8381d6ecb3d0c1c2 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Fri, 20 Sep 2024 14:35:45 +0200
Subject: [PATCH 239/762] ssh remoting: Do not double-register LspAdapters
 (#18132)

This fixes the bug with hover tooltips appearing multiple times.

Turns out everytime we receive the `CreateLanguageServer` message we'd
add a new adapter but only have a single server running for all of them.

And we send a `CreateLanguageServer` message everytime you open a
buffer.

What this does is to only add a new adapter if it hasn't already been
registered, which is also what we do locally.


Release Notes:

- N/A
---
 crates/language/src/language_registry.rs | 34 ++++++++++++++++--
 crates/project/src/lsp_store.rs          | 44 ++++++++++++------------
 2 files changed, 54 insertions(+), 24 deletions(-)

diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index 17ebef50e8162e..e264517d5b0300 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -326,13 +326,43 @@ impl LanguageRegistry {
         Some(load_lsp_adapter())
     }
 
-    pub fn register_lsp_adapter(&self, language_name: LanguageName, adapter: Arc<dyn LspAdapter>) {
+    pub fn register_lsp_adapter(
+        &self,
+        language_name: LanguageName,
+        adapter: Arc<dyn LspAdapter>,
+    ) -> Arc<CachedLspAdapter> {
+        let cached = CachedLspAdapter::new(adapter);
         self.state
             .write()
             .lsp_adapters
             .entry(language_name)
             .or_default()
-            .push(CachedLspAdapter::new(adapter));
+            .push(cached.clone());
+        cached
+    }
+
+    pub fn get_or_register_lsp_adapter(
+        &self,
+        language_name: LanguageName,
+        server_name: LanguageServerName,
+        build_adapter: impl FnOnce() -> Arc<dyn LspAdapter> + 'static,
+    ) -> Arc<CachedLspAdapter> {
+        let registered = self
+            .state
+            .write()
+            .lsp_adapters
+            .entry(language_name.clone())
+            .or_default()
+            .iter()
+            .find(|cached_adapter| cached_adapter.name == server_name)
+            .cloned();
+
+        if let Some(found) = registered {
+            found
+        } else {
+            let adapter = build_adapter();
+            self.register_lsp_adapter(language_name, adapter)
+        }
     }
 
     /// Register a fake language server and adapter
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 5c32c9030db3ff..92f37f87af4056 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -4475,7 +4475,7 @@ impl LspStore {
         mut cx: AsyncAppContext,
     ) -> Result<proto::Ack> {
         let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
-        let name = LanguageServerName::from_proto(envelope.payload.name);
+        let server_name = LanguageServerName::from_proto(envelope.payload.name);
 
         let binary = envelope
             .payload
@@ -4494,6 +4494,14 @@ impl LspStore {
         let matcher: LanguageMatcher = serde_json::from_str(&language.matcher)?;
 
         this.update(&mut cx, |this, cx| {
+            let Some(worktree) = this
+                .worktree_store
+                .read(cx)
+                .worktree_for_id(worktree_id, cx)
+            else {
+                return Err(anyhow!("worktree not found"));
+            };
+
             this.languages
                 .register_language(language_name.clone(), None, matcher.clone(), {
                     let language_name = language_name.clone();
@@ -4513,28 +4521,20 @@ impl LspStore {
                 .spawn(this.languages.language_for_name(language_name.0.as_ref()))
                 .detach();
 
-            let adapter = Arc::new(SshLspAdapter::new(
-                name,
-                binary,
-                envelope.payload.initialization_options,
-                envelope.payload.code_action_kinds,
-            ));
-
-            this.languages
-                .register_lsp_adapter(language_name.clone(), adapter.clone());
-            let Some(worktree) = this
-                .worktree_store
-                .read(cx)
-                .worktree_for_id(worktree_id, cx)
-            else {
-                return Err(anyhow!("worktree not found"));
-            };
-            this.start_language_server(
-                &worktree,
-                CachedLspAdapter::new(adapter),
-                language_name,
-                cx,
+            let adapter = this.languages.get_or_register_lsp_adapter(
+                language_name.clone(),
+                server_name.clone(),
+                || {
+                    Arc::new(SshLspAdapter::new(
+                        server_name,
+                        binary,
+                        envelope.payload.initialization_options,
+                        envelope.payload.code_action_kinds,
+                    ))
+                },
             );
+
+            this.start_language_server(&worktree, adapter, language_name, cx);
             Ok(())
         })??;
         Ok(proto::Ack {})

From 16d2afc662ae43cd404279c068bb26557306b9c7 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 20 Sep 2024 08:46:23 -0400
Subject: [PATCH 240/762] ci: Bump `nightly` tag on scheduled Nightly builds
 (#18134)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR makes it so after a scheduled Nightly build we also update the
`nightly` tag to keep things in sync.

It's safe to bump the tag within this Action, as it won't trigger
another Nightly build due to GitHub's recursive Action protections:

> When you use the repository's `GITHUB_TOKEN` to perform tasks, events
triggered by the `GITHUB_TOKEN`, with the exception of
`workflow_dispatch` and `repository_dispatch`, will not create a new
workflow run. This prevents you from accidentally creating recursive
workflow runs. For example, if a workflow run pushes code using the
repository's `GITHUB_TOKEN`, a new workflow will not run even when the
repository contains a workflow configured to run when `push` events
occur.
>
> —
[source](https://docs.github.com/en/actions/security-for-github-actions/security-guides/automatic-token-authentication#using-the-github_token-in-a-workflow)

Release Notes:

- N/A
---
 .github/workflows/release_nightly.yml | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml
index bcaa60b77589c1..2b973dcddc3d6f 100644
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -171,3 +171,28 @@ jobs:
 
       - name: Upload Zed Nightly
         run: script/upload-nightly linux-targz
+
+  update-nightly-tag:
+    name: Update nightly tag
+    if: github.repository_owner == 'zed-industries'
+    runs-on: ubuntu-latest
+    needs:
+      - bundle-mac
+      - bundle-linux-x86
+      - bundle-linux-arm
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        with:
+          fetch-depth: 0
+
+      - name: Update nightly tag
+        run: |
+          if [ "$(git rev-parse nightly)" = "$(git rev-parse HEAD)" ]; then
+            echo "Nightly tag already points to current commit. Skipping tagging."
+            exit 0
+          fi
+          git config user.name github-actions
+          git config user.email github-actions@github.com
+          git tag -f nightly
+          git push origin nightly --force

From d6c184b494a0c9a9a46d4ffdb5483ba65967ab0b Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 20 Sep 2024 09:23:11 -0400
Subject: [PATCH 241/762] Detect 'MD' extension as Markdown (#18135)

---
 crates/languages/src/markdown/config.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/languages/src/markdown/config.toml b/crates/languages/src/markdown/config.toml
index 6b518ec8b60401..ce3b294b4efed3 100644
--- a/crates/languages/src/markdown/config.toml
+++ b/crates/languages/src/markdown/config.toml
@@ -1,6 +1,6 @@
 name = "Markdown"
 grammar = "markdown"
-path_suffixes = ["md", "mdx", "mdwn", "markdown"]
+path_suffixes = ["md", "mdx", "mdwn", "markdown", "MD"]
 word_characters = ["-"]
 brackets = [
     { start = "{", end = "}", close = true, newline = true },

From 5f1046b3cd5290112f6dd464e49bc58661fd2179 Mon Sep 17 00:00:00 2001
From: Richard Feldman <oss@rtfeldman.com>
Date: Fri, 20 Sep 2024 10:28:22 -0400
Subject: [PATCH 242/762] Make evals handle failures more gracefully (#18082)

Now when an individual project eval fails, instead of panicking we add
it to a list of failures that we collect and report at the end (and make
the exit code nonzero).

Release Notes:

- N/A
---
 crates/evals/src/eval.rs | 315 ++++++++++++++++++++++++---------------
 1 file changed, 195 insertions(+), 120 deletions(-)

diff --git a/crates/evals/src/eval.rs b/crates/evals/src/eval.rs
index 708cfa7511a402..0580053373c54c 100644
--- a/crates/evals/src/eval.rs
+++ b/crates/evals/src/eval.rs
@@ -12,13 +12,16 @@ use language::LanguageRegistry;
 use node_runtime::FakeNodeRuntime;
 use open_ai::OpenAiEmbeddingModel;
 use project::Project;
-use semantic_index::{OpenAiEmbeddingProvider, ProjectIndex, SemanticDb, Status};
+use semantic_index::{
+    EmbeddingProvider, OpenAiEmbeddingProvider, ProjectIndex, SemanticDb, Status,
+};
 use serde::{Deserialize, Serialize};
 use settings::SettingsStore;
 use smol::channel::bounded;
 use smol::io::AsyncReadExt;
 use smol::Timer;
 use std::ops::RangeInclusive;
+use std::path::PathBuf;
 use std::time::Duration;
 use std::{
     fs,
@@ -237,6 +240,14 @@ async fn fetch_code_search_net_resources(http_client: &dyn HttpClient) -> Result
     Ok(())
 }
 
+#[derive(Default, Debug)]
+struct Counts {
+    covered_results: usize,
+    overlapped_results: usize,
+    covered_files: usize,
+    total_results: usize,
+}
+
 async fn run_evaluation(
     only_repo: Option<String>,
     executor: &BackgroundExecutor,
@@ -297,12 +308,11 @@ async fn run_evaluation(
     cx.update(|cx| languages::init(language_registry.clone(), node_runtime.clone(), cx))
         .unwrap();
 
-    let mut covered_result_count = 0;
-    let mut overlapped_result_count = 0;
-    let mut covered_file_count = 0;
-    let mut total_result_count = 0;
+    let mut counts = Counts::default();
     eprint!("Running evals.");
 
+    let mut failures = Vec::new();
+
     for evaluation_project in evaluations {
         if only_repo
             .as_ref()
@@ -314,27 +324,24 @@ async fn run_evaluation(
         eprint!("\r\x1B[2K");
         eprint!(
             "Running evals. {}/{} covered. {}/{} overlapped. {}/{} files captured. Project: {}...",
-            covered_result_count,
-            total_result_count,
-            overlapped_result_count,
-            total_result_count,
-            covered_file_count,
-            total_result_count,
+            counts.covered_results,
+            counts.total_results,
+            counts.overlapped_results,
+            counts.total_results,
+            counts.covered_files,
+            counts.total_results,
             evaluation_project.repo
         );
 
-        let repo_db_path =
-            db_path.join(format!("{}.db", evaluation_project.repo.replace('/', "_")));
-        let mut semantic_index = SemanticDb::new(repo_db_path, embedding_provider.clone(), cx)
-            .await
-            .unwrap();
-
         let repo_dir = repos_dir.join(&evaluation_project.repo);
         if !repo_dir.exists() || repo_dir.join(SKIP_EVAL_PATH).exists() {
             eprintln!("Skipping {}: directory not found", evaluation_project.repo);
             continue;
         }
 
+        let repo_db_path =
+            db_path.join(format!("{}.db", evaluation_project.repo.replace('/', "_")));
+
         let project = cx
             .update(|cx| {
                 Project::local(
@@ -349,125 +356,193 @@ async fn run_evaluation(
             })
             .unwrap();
 
-        let (worktree, _) = project
-            .update(cx, |project, cx| {
-                project.find_or_create_worktree(repo_dir, true, cx)
-            })?
-            .await?;
+        let repo = evaluation_project.repo.clone();
+        if let Err(err) = run_eval_project(
+            evaluation_project,
+            &user_store,
+            repo_db_path,
+            &repo_dir,
+            &mut counts,
+            project,
+            embedding_provider.clone(),
+            fs.clone(),
+            cx,
+        )
+        .await
+        {
+            eprintln!("{repo} eval failed with error: {:?}", err);
+
+            failures.push((repo, err));
+        }
+    }
 
-        worktree
-            .update(cx, |worktree, _| {
-                worktree.as_local().unwrap().scan_complete()
-            })
-            .unwrap()
-            .await;
+    eprintln!(
+        "Running evals. {}/{} covered. {}/{} overlapped. {}/{} files captured. {} failed.",
+        counts.covered_results,
+        counts.total_results,
+        counts.overlapped_results,
+        counts.total_results,
+        counts.covered_files,
+        counts.total_results,
+        failures.len(),
+    );
 
-        let project_index = cx
-            .update(|cx| semantic_index.create_project_index(project.clone(), cx))
-            .unwrap();
-        wait_for_indexing_complete(&project_index, cx, Some(Duration::from_secs(120))).await;
+    if failures.is_empty() {
+        Ok(())
+    } else {
+        eprintln!("Failures:\n");
 
-        for query in evaluation_project.queries {
-            let results = cx
-                .update(|cx| {
+        for (index, (repo, failure)) in failures.iter().enumerate() {
+            eprintln!("Failure #{} - {repo}\n{:?}", index + 1, failure);
+        }
+
+        Err(anyhow::anyhow!("Some evals failed."))
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn run_eval_project(
+    evaluation_project: EvaluationProject,
+    user_store: &Model<UserStore>,
+    repo_db_path: PathBuf,
+    repo_dir: &Path,
+    counts: &mut Counts,
+    project: Model<Project>,
+    embedding_provider: Arc<dyn EmbeddingProvider>,
+    fs: Arc<dyn Fs>,
+    cx: &mut AsyncAppContext,
+) -> Result<(), anyhow::Error> {
+    let mut semantic_index = SemanticDb::new(repo_db_path, embedding_provider, cx).await?;
+
+    let (worktree, _) = project
+        .update(cx, |project, cx| {
+            project.find_or_create_worktree(repo_dir, true, cx)
+        })?
+        .await?;
+
+    worktree
+        .update(cx, |worktree, _| {
+            worktree.as_local().unwrap().scan_complete()
+        })?
+        .await;
+
+    let project_index = cx.update(|cx| semantic_index.create_project_index(project.clone(), cx))?;
+    wait_for_indexing_complete(&project_index, cx, Some(Duration::from_secs(120))).await;
+
+    for query in evaluation_project.queries {
+        let results = {
+            // Retry search up to 3 times in case of timeout, network failure, etc.
+            let mut retries_remaining = 3;
+            let mut result;
+
+            loop {
+                match cx.update(|cx| {
                     let project_index = project_index.read(cx);
                     project_index.search(query.query.clone(), SEARCH_RESULT_LIMIT, cx)
-                })
-                .unwrap()
-                .await
-                .unwrap();
-
-            let results = SemanticDb::load_results(results, &fs.clone(), &cx)
-                .await
-                .unwrap();
-
-            let mut project_covered_result_count = 0;
-            let mut project_overlapped_result_count = 0;
-            let mut project_covered_file_count = 0;
-            let mut covered_result_indices = Vec::new();
-            for expected_result in &query.expected_results {
-                let mut file_matched = false;
-                let mut range_overlapped = false;
-                let mut range_covered = false;
-
-                for (ix, result) in results.iter().enumerate() {
-                    if result.path.as_ref() == Path::new(&expected_result.file) {
-                        file_matched = true;
-                        let start_matched =
-                            result.row_range.contains(&expected_result.lines.start());
-                        let end_matched = result.row_range.contains(&expected_result.lines.end());
-
-                        if start_matched || end_matched {
-                            range_overlapped = true;
-                        }
-
-                        if start_matched && end_matched {
-                            range_covered = true;
-                            covered_result_indices.push(ix);
+                }) {
+                    Ok(task) => match task.await {
+                        Ok(answer) => {
+                            result = Ok(answer);
                             break;
                         }
+                        Err(err) => {
+                            result = Err(err);
+                        }
+                    },
+                    Err(err) => {
+                        result = Err(err);
                     }
                 }
 
-                if range_covered {
-                    project_covered_result_count += 1
-                };
-                if range_overlapped {
-                    project_overlapped_result_count += 1
-                };
-                if file_matched {
-                    project_covered_file_count += 1
-                };
+                if retries_remaining > 0 {
+                    eprintln!(
+                        "Retrying search after it failed on query {:?} with {:?}",
+                        query, result
+                    );
+                    retries_remaining -= 1;
+                } else {
+                    eprintln!(
+                        "Ran out of retries; giving up on search which failed on query {:?} with {:?}",
+                        query, result
+                    );
+                    break;
+                }
             }
-            let outcome_repo = evaluation_project.repo.clone();
-
-            let query_results = EvaluationQueryOutcome {
-                repo: outcome_repo,
-                query: query.query,
-                total_result_count: query.expected_results.len(),
-                covered_result_count: project_covered_result_count,
-                overlapped_result_count: project_overlapped_result_count,
-                covered_file_count: project_covered_file_count,
-                expected_results: query.expected_results,
-                actual_results: results
-                    .iter()
-                    .map(|result| EvaluationSearchResult {
-                        file: result.path.to_string_lossy().to_string(),
-                        lines: result.row_range.clone(),
-                    })
-                    .collect(),
-                covered_result_indices,
-            };
 
-            overlapped_result_count += query_results.overlapped_result_count;
-            covered_result_count += query_results.covered_result_count;
-            covered_file_count += query_results.covered_file_count;
-            total_result_count += query_results.total_result_count;
+            SemanticDb::load_results(result?, &fs.clone(), &cx).await?
+        };
 
-            println!("{}", serde_json::to_string(&query_results).unwrap());
+        let mut project_covered_result_count = 0;
+        let mut project_overlapped_result_count = 0;
+        let mut project_covered_file_count = 0;
+        let mut covered_result_indices = Vec::new();
+        for expected_result in &query.expected_results {
+            let mut file_matched = false;
+            let mut range_overlapped = false;
+            let mut range_covered = false;
+
+            for (ix, result) in results.iter().enumerate() {
+                if result.path.as_ref() == Path::new(&expected_result.file) {
+                    file_matched = true;
+                    let start_matched = result.row_range.contains(&expected_result.lines.start());
+                    let end_matched = result.row_range.contains(&expected_result.lines.end());
+
+                    if start_matched || end_matched {
+                        range_overlapped = true;
+                    }
+
+                    if start_matched && end_matched {
+                        range_covered = true;
+                        covered_result_indices.push(ix);
+                        break;
+                    }
+                }
+            }
+
+            if range_covered {
+                project_covered_result_count += 1
+            };
+            if range_overlapped {
+                project_overlapped_result_count += 1
+            };
+            if file_matched {
+                project_covered_file_count += 1
+            };
         }
+        let outcome_repo = evaluation_project.repo.clone();
+
+        let query_results = EvaluationQueryOutcome {
+            repo: outcome_repo,
+            query: query.query,
+            total_result_count: query.expected_results.len(),
+            covered_result_count: project_covered_result_count,
+            overlapped_result_count: project_overlapped_result_count,
+            covered_file_count: project_covered_file_count,
+            expected_results: query.expected_results,
+            actual_results: results
+                .iter()
+                .map(|result| EvaluationSearchResult {
+                    file: result.path.to_string_lossy().to_string(),
+                    lines: result.row_range.clone(),
+                })
+                .collect(),
+            covered_result_indices,
+        };
 
-        user_store
-            .update(cx, |_, _| {
-                drop(semantic_index);
-                drop(project);
-                drop(worktree);
-                drop(project_index);
-            })
-            .unwrap();
-    }
+        counts.overlapped_results += query_results.overlapped_result_count;
+        counts.covered_results += query_results.covered_result_count;
+        counts.covered_files += query_results.covered_file_count;
+        counts.total_results += query_results.total_result_count;
 
-    eprint!(
-        "Running evals. {}/{} covered. {}/{} overlapped. {}/{} files captured.",
-        covered_result_count,
-        total_result_count,
-        overlapped_result_count,
-        total_result_count,
-        covered_file_count,
-        total_result_count,
-    );
+        println!("{}", serde_json::to_string(&query_results)?);
+    }
 
-    Ok(())
+    user_store.update(cx, |_, _| {
+        drop(semantic_index);
+        drop(project);
+        drop(worktree);
+        drop(project_index);
+    })
 }
 
 async fn wait_for_indexing_complete(
@@ -524,7 +599,7 @@ async fn fetch_eval_repos(
     let evaluations = fs::read(&evaluations_path).expect("failed to read evaluations.json");
     let evaluations: Vec<EvaluationProject> = serde_json::from_slice(&evaluations).unwrap();
 
-    eprint!("Fetching evaluation repositories...");
+    eprintln!("Fetching evaluation repositories...");
 
     executor
         .scoped(move |scope| {

From ab1d466c5f46fbaf84615dc39f142cfe0c0880e3 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 20 Sep 2024 10:48:27 -0400
Subject: [PATCH 243/762] Remove `replica_id` from `MultiBuffer`s (#18141)

This PR removes the `replica_id` field from the `MultiBuffer` struct.

We were only ever referencing this field to pass when constructing a
`MultiBuffer`, and never used it outside of that.

Release Notes:

- N/A
---
 crates/assistant/src/assistant_panel.rs       |  5 +-
 crates/assistant/src/inline_assistant.rs      |  2 +-
 crates/collab/src/tests/following_tests.rs    |  2 +-
 .../src/copilot_completion_provider.rs        |  4 +-
 crates/diagnostics/src/diagnostics.rs         |  7 +--
 crates/editor/src/display_map/block_map.rs    |  2 +-
 crates/editor/src/editor.rs                   | 22 ++------
 crates/editor/src/editor_tests.rs             | 20 +++----
 crates/editor/src/git.rs                      |  2 +-
 crates/editor/src/hunk_diff.rs                |  2 +-
 crates/editor/src/inlay_hint_cache.rs         |  4 +-
 crates/editor/src/items.rs                    |  3 +-
 crates/editor/src/movement.rs                 |  2 +-
 crates/editor/src/test/editor_test_context.rs |  2 +-
 crates/multi_buffer/src/multi_buffer.rs       | 56 ++++++++-----------
 crates/search/src/project_search.rs           |  3 +-
 16 files changed, 54 insertions(+), 84 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 364c6f9663120c..22237eeb079270 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -2814,9 +2814,8 @@ impl ContextEditor {
         } else {
             // If there are multiple buffers or suggestion groups, create a multibuffer
             let multibuffer = cx.new_model(|cx| {
-                let replica_id = project.read(cx).replica_id();
-                let mut multibuffer = MultiBuffer::new(replica_id, Capability::ReadWrite)
-                    .with_title(resolved_step.title.clone());
+                let mut multibuffer =
+                    MultiBuffer::new(Capability::ReadWrite).with_title(resolved_step.title.clone());
                 for (buffer, groups) in &resolved_step.suggestion_groups {
                     let excerpt_ids = multibuffer.push_excerpts(
                         buffer.clone(),
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index 428b33f3bbd92c..d95b54d3c6a6ac 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -1145,7 +1145,7 @@ impl InlineAssistant {
 
                 let deleted_lines_editor = cx.new_view(|cx| {
                     let multi_buffer = cx.new_model(|_| {
-                        MultiBuffer::without_headers(0, language::Capability::ReadOnly)
+                        MultiBuffer::without_headers(language::Capability::ReadOnly)
                     });
                     multi_buffer.update(cx, |multi_buffer, cx| {
                         multi_buffer.push_excerpts(
diff --git a/crates/collab/src/tests/following_tests.rs b/crates/collab/src/tests/following_tests.rs
index e66b66a1b45893..9a39d6f3eb2e74 100644
--- a/crates/collab/src/tests/following_tests.rs
+++ b/crates/collab/src/tests/following_tests.rs
@@ -289,7 +289,7 @@ async fn test_basic_following(
                 .get_open_buffer(&(worktree_id, "2.txt").into(), cx)
                 .unwrap()
         });
-        let mut result = MultiBuffer::new(0, Capability::ReadWrite);
+        let mut result = MultiBuffer::new(Capability::ReadWrite);
         result.push_excerpts(
             buffer_a1,
             [ExcerptRange {
diff --git a/crates/copilot/src/copilot_completion_provider.rs b/crates/copilot/src/copilot_completion_provider.rs
index c54fefad6fe599..3a3361cda1996d 100644
--- a/crates/copilot/src/copilot_completion_provider.rs
+++ b/crates/copilot/src/copilot_completion_provider.rs
@@ -767,7 +767,7 @@ mod tests {
         let buffer_1 = cx.new_model(|cx| Buffer::local("a = 1\nb = 2\n", cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local("c = 3\nd = 4\n", cx));
         let multibuffer = cx.new_model(|cx| {
-            let mut multibuffer = MultiBuffer::new(0, language::Capability::ReadWrite);
+            let mut multibuffer = MultiBuffer::new(language::Capability::ReadWrite);
             multibuffer.push_excerpts(
                 buffer_1.clone(),
                 [ExcerptRange {
@@ -1018,7 +1018,7 @@ mod tests {
             .unwrap();
 
         let multibuffer = cx.new_model(|cx| {
-            let mut multibuffer = MultiBuffer::new(0, language::Capability::ReadWrite);
+            let mut multibuffer = MultiBuffer::new(language::Capability::ReadWrite);
             multibuffer.push_excerpts(
                 private_buffer.clone(),
                 [ExcerptRange {
diff --git a/crates/diagnostics/src/diagnostics.rs b/crates/diagnostics/src/diagnostics.rs
index eec4f735ec38e5..687638854209ba 100644
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -156,12 +156,7 @@ impl ProjectDiagnosticsEditor {
         cx.on_focus_out(&focus_handle, |this, _event, cx| this.focus_out(cx))
             .detach();
 
-        let excerpts = cx.new_model(|cx| {
-            MultiBuffer::new(
-                project_handle.read(cx).replica_id(),
-                project_handle.read(cx).capability(),
-            )
-        });
+        let excerpts = cx.new_model(|cx| MultiBuffer::new(project_handle.read(cx).capability()));
         let editor = cx.new_view(|cx| {
             let mut editor =
                 Editor::for_multibuffer(excerpts.clone(), Some(project_handle.clone()), false, cx);
diff --git a/crates/editor/src/display_map/block_map.rs b/crates/editor/src/display_map/block_map.rs
index 3a298832dee5ef..efa026a56c6101 100644
--- a/crates/editor/src/display_map/block_map.rs
+++ b/crates/editor/src/display_map/block_map.rs
@@ -1671,7 +1671,7 @@ mod tests {
 
         let mut excerpt_ids = Vec::new();
         let multi_buffer = cx.new_model(|cx| {
-            let mut multi_buffer = MultiBuffer::new(0, Capability::ReadWrite);
+            let mut multi_buffer = MultiBuffer::new(Capability::ReadWrite);
             excerpt_ids.extend(multi_buffer.push_excerpts(
                 buffer1.clone(),
                 [ExcerptRange {
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index f797f82832f0ad..eb2dafc24dc0f3 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -2155,10 +2155,6 @@ impl Editor {
         });
     }
 
-    pub fn replica_id(&self, cx: &AppContext) -> ReplicaId {
-        self.buffer.read(cx).replica_id()
-    }
-
     pub fn leader_peer_id(&self) -> Option<PeerId> {
         self.leader_peer_id
     }
@@ -4758,8 +4754,6 @@ impl Editor {
         title: String,
         mut cx: AsyncWindowContext,
     ) -> Result<()> {
-        let replica_id = this.update(&mut cx, |this, cx| this.replica_id(cx))?;
-
         let mut entries = transaction.0.into_iter().collect::<Vec<_>>();
         cx.update(|cx| {
             entries.sort_unstable_by_key(|(buffer, _)| {
@@ -4802,8 +4796,7 @@ impl Editor {
 
         let mut ranges_to_highlight = Vec::new();
         let excerpt_buffer = cx.new_model(|cx| {
-            let mut multibuffer =
-                MultiBuffer::new(replica_id, Capability::ReadWrite).with_title(title);
+            let mut multibuffer = MultiBuffer::new(Capability::ReadWrite).with_title(title);
             for (buffer_handle, transaction) in &entries {
                 let buffer = buffer_handle.read(cx);
                 ranges_to_highlight.extend(
@@ -9610,7 +9603,6 @@ impl Editor {
                 })
             })
         } else if !definitions.is_empty() {
-            let replica_id = self.replica_id(cx);
             cx.spawn(|editor, mut cx| async move {
                 let (title, location_tasks, workspace) = editor
                     .update(&mut cx, |editor, cx| {
@@ -9663,9 +9655,7 @@ impl Editor {
                 };
                 let opened = workspace
                     .update(&mut cx, |workspace, cx| {
-                        Self::open_locations_in_multibuffer(
-                            workspace, locations, replica_id, title, split, cx,
-                        )
+                        Self::open_locations_in_multibuffer(workspace, locations, title, split, cx)
                     })
                     .ok();
 
@@ -9762,7 +9752,6 @@ impl Editor {
         }
 
         let (buffer, head) = multi_buffer.text_anchor_for_position(head, cx)?;
-        let replica_id = self.replica_id(cx);
         let workspace = self.workspace()?;
         let project = workspace.read(cx).project().clone();
         let references = project.update(cx, |project, cx| project.references(&buffer, head, cx));
@@ -9803,9 +9792,7 @@ impl Editor {
                         )
                     })
                     .unwrap();
-                Self::open_locations_in_multibuffer(
-                    workspace, locations, replica_id, title, false, cx,
-                );
+                Self::open_locations_in_multibuffer(workspace, locations, title, false, cx);
                 Navigated::Yes
             })
         }))
@@ -9815,7 +9802,6 @@ impl Editor {
     pub fn open_locations_in_multibuffer(
         workspace: &mut Workspace,
         mut locations: Vec<Location>,
-        replica_id: ReplicaId,
         title: String,
         split: bool,
         cx: &mut ViewContext<Workspace>,
@@ -9827,7 +9813,7 @@ impl Editor {
         let capability = workspace.project().read(cx).capability();
 
         let excerpt_buffer = cx.new_model(|cx| {
-            let mut multibuffer = MultiBuffer::new(replica_id, capability);
+            let mut multibuffer = MultiBuffer::new(capability);
             while let Some(location) = locations.next() {
                 let buffer = location.buffer.read(cx);
                 let mut ranges_for_buffer = Vec::new();
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index e11b38ba59680d..589673447d7f48 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -2822,7 +2822,7 @@ fn test_indent_outdent_with_excerpts(cx: &mut TestAppContext) {
         Buffer::local("const c: usize = 3;\n", cx).with_language(rust_language, cx)
     });
     let multibuffer = cx.new_model(|cx| {
-        let mut multibuffer = MultiBuffer::new(0, ReadWrite);
+        let mut multibuffer = MultiBuffer::new(ReadWrite);
         multibuffer.push_excerpts(
             toml_buffer.clone(),
             [ExcerptRange {
@@ -6671,7 +6671,7 @@ async fn test_multibuffer_format_during_save(cx: &mut gpui::TestAppContext) {
         .unwrap();
 
     let multi_buffer = cx.new_model(|cx| {
-        let mut multi_buffer = MultiBuffer::new(0, ReadWrite);
+        let mut multi_buffer = MultiBuffer::new(ReadWrite);
         multi_buffer.push_excerpts(
             buffer_1.clone(),
             [
@@ -8614,7 +8614,7 @@ fn test_editing_disjoint_excerpts(cx: &mut TestAppContext) {
 
     let buffer = cx.new_model(|cx| Buffer::local(sample_text(3, 4, 'a'), cx));
     let multibuffer = cx.new_model(|cx| {
-        let mut multibuffer = MultiBuffer::new(0, ReadWrite);
+        let mut multibuffer = MultiBuffer::new(ReadWrite);
         multibuffer.push_excerpts(
             buffer.clone(),
             [
@@ -8698,7 +8698,7 @@ fn test_editing_overlapping_excerpts(cx: &mut TestAppContext) {
     });
     let buffer = cx.new_model(|cx| Buffer::local(initial_text, cx));
     let multibuffer = cx.new_model(|cx| {
-        let mut multibuffer = MultiBuffer::new(0, ReadWrite);
+        let mut multibuffer = MultiBuffer::new(ReadWrite);
         multibuffer.push_excerpts(buffer, excerpt_ranges, cx);
         multibuffer
     });
@@ -8757,7 +8757,7 @@ fn test_refresh_selections(cx: &mut TestAppContext) {
     let buffer = cx.new_model(|cx| Buffer::local(sample_text(3, 4, 'a'), cx));
     let mut excerpt1_id = None;
     let multibuffer = cx.new_model(|cx| {
-        let mut multibuffer = MultiBuffer::new(0, ReadWrite);
+        let mut multibuffer = MultiBuffer::new(ReadWrite);
         excerpt1_id = multibuffer
             .push_excerpts(
                 buffer.clone(),
@@ -8842,7 +8842,7 @@ fn test_refresh_selections_while_selecting_with_mouse(cx: &mut TestAppContext) {
     let buffer = cx.new_model(|cx| Buffer::local(sample_text(3, 4, 'a'), cx));
     let mut excerpt1_id = None;
     let multibuffer = cx.new_model(|cx| {
-        let mut multibuffer = MultiBuffer::new(0, ReadWrite);
+        let mut multibuffer = MultiBuffer::new(ReadWrite);
         excerpt1_id = multibuffer
             .push_excerpts(
                 buffer.clone(),
@@ -9230,7 +9230,7 @@ async fn test_following_with_multiple_excerpts(cx: &mut gpui::TestAppContext) {
     let cx = &mut VisualTestContext::from_window(*workspace.deref(), cx);
 
     let leader = pane.update(cx, |_, cx| {
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(ReadWrite));
         cx.new_view(|cx| build_editor(multibuffer.clone(), cx))
     });
 
@@ -10685,7 +10685,7 @@ async fn test_multibuffer_reverts(cx: &mut gpui::TestAppContext) {
     diff_every_buffer_row(&buffer_3, sample_text_3.clone(), cols, cx);
 
     let multibuffer = cx.new_model(|cx| {
-        let mut multibuffer = MultiBuffer::new(0, ReadWrite);
+        let mut multibuffer = MultiBuffer::new(ReadWrite);
         multibuffer.push_excerpts(
             buffer_1.clone(),
             [
@@ -10825,7 +10825,7 @@ async fn test_mutlibuffer_in_navigation_history(cx: &mut gpui::TestAppContext) {
     let buffer_3 = cx.new_model(|cx| Buffer::local(sample_text_3.clone(), cx));
 
     let multi_buffer = cx.new_model(|cx| {
-        let mut multibuffer = MultiBuffer::new(0, ReadWrite);
+        let mut multibuffer = MultiBuffer::new(ReadWrite);
         multibuffer.push_excerpts(
             buffer_1.clone(),
             [
@@ -11764,7 +11764,7 @@ async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut gpui::TestAppContext)
     });
 
     let multi_buffer = cx.new_model(|cx| {
-        let mut multibuffer = MultiBuffer::new(0, ReadWrite);
+        let mut multibuffer = MultiBuffer::new(ReadWrite);
         multibuffer.push_excerpts(
             buffer_1.clone(),
             [
diff --git a/crates/editor/src/git.rs b/crates/editor/src/git.rs
index 665c649e6e8941..63b083faa89bd5 100644
--- a/crates/editor/src/git.rs
+++ b/crates/editor/src/git.rs
@@ -195,7 +195,7 @@ mod tests {
         cx.background_executor.run_until_parked();
 
         let multibuffer = cx.new_model(|cx| {
-            let mut multibuffer = MultiBuffer::new(0, ReadWrite);
+            let mut multibuffer = MultiBuffer::new(ReadWrite);
             multibuffer.push_excerpts(
                 buffer_1.clone(),
                 [
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index 5dc73634bda774..361ea6246e308b 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -764,7 +764,7 @@ fn editor_with_deleted_text(
     let parent_editor = cx.view().downgrade();
     let editor = cx.new_view(|cx| {
         let multi_buffer =
-            cx.new_model(|_| MultiBuffer::without_headers(0, language::Capability::ReadOnly));
+            cx.new_model(|_| MultiBuffer::without_headers(language::Capability::ReadOnly));
         multi_buffer.update(cx, |multi_buffer, cx| {
             multi_buffer.push_excerpts(
                 diff_base_buffer,
diff --git a/crates/editor/src/inlay_hint_cache.rs b/crates/editor/src/inlay_hint_cache.rs
index 24ccf64c4ca0b2..ca2db70a70c2ad 100644
--- a/crates/editor/src/inlay_hint_cache.rs
+++ b/crates/editor/src/inlay_hint_cache.rs
@@ -2607,7 +2607,7 @@ pub mod tests {
             .await
             .unwrap();
         let multibuffer = cx.new_model(|cx| {
-            let mut multibuffer = MultiBuffer::new(0, Capability::ReadWrite);
+            let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
             multibuffer.push_excerpts(
                 buffer_1.clone(),
                 [
@@ -2957,7 +2957,7 @@ pub mod tests {
             })
             .await
             .unwrap();
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         let (buffer_1_excerpts, buffer_2_excerpts) = multibuffer.update(cx, |multibuffer, cx| {
             let buffer_1_excerpts = multibuffer.push_excerpts(
                 buffer_1.clone(),
diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index 3d04eb82d38e39..1d301f2ee68cd6 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -68,7 +68,6 @@ impl FollowableItem for Editor {
             unreachable!()
         };
 
-        let replica_id = project.read(cx).replica_id();
         let buffer_ids = state
             .excerpts
             .iter()
@@ -92,7 +91,7 @@ impl FollowableItem for Editor {
                     if state.singleton && buffers.len() == 1 {
                         multibuffer = MultiBuffer::singleton(buffers.pop().unwrap(), cx)
                     } else {
-                        multibuffer = MultiBuffer::new(replica_id, project.read(cx).capability());
+                        multibuffer = MultiBuffer::new(project.read(cx).capability());
                         let mut excerpts = state.excerpts.into_iter().peekable();
                         while let Some(excerpt) = excerpts.peek() {
                             let Ok(buffer_id) = BufferId::new(excerpt.buffer_id) else {
diff --git a/crates/editor/src/movement.rs b/crates/editor/src/movement.rs
index a9f27d53a62ef0..19e2a4ea95a676 100644
--- a/crates/editor/src/movement.rs
+++ b/crates/editor/src/movement.rs
@@ -928,7 +928,7 @@ mod tests {
 
             let buffer = cx.new_model(|cx| Buffer::local("abc\ndefg\nhijkl\nmn", cx));
             let multibuffer = cx.new_model(|cx| {
-                let mut multibuffer = MultiBuffer::new(0, Capability::ReadWrite);
+                let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
                 multibuffer.push_excerpts(
                     buffer.clone(),
                     [
diff --git a/crates/editor/src/test/editor_test_context.rs b/crates/editor/src/test/editor_test_context.rs
index 6f8a495895fff9..3e4ef174d422ae 100644
--- a/crates/editor/src/test/editor_test_context.rs
+++ b/crates/editor/src/test/editor_test_context.rs
@@ -75,7 +75,7 @@ impl EditorTestContext {
         cx: &mut gpui::TestAppContext,
         excerpts: [&str; COUNT],
     ) -> EditorTestContext {
-        let mut multibuffer = MultiBuffer::new(0, language::Capability::ReadWrite);
+        let mut multibuffer = MultiBuffer::new(language::Capability::ReadWrite);
         let buffer = cx.new_model(|cx| {
             for excerpt in excerpts.into_iter() {
                 let (text, ranges) = marked_text_ranges(excerpt, false);
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index c163dbc07a6407..f6a61f562a71fc 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -67,7 +67,6 @@ pub struct MultiBuffer {
     subscriptions: Topic,
     /// If true, the multi-buffer only contains a single [`Buffer`] and a single [`Excerpt`]
     singleton: bool,
-    replica_id: ReplicaId,
     history: History,
     title: Option<String>,
     capability: Capability,
@@ -350,7 +349,7 @@ impl std::ops::Deref for MultiBufferIndentGuide {
 }
 
 impl MultiBuffer {
-    pub fn new(replica_id: ReplicaId, capability: Capability) -> Self {
+    pub fn new(capability: Capability) -> Self {
         Self {
             snapshot: RefCell::new(MultiBufferSnapshot {
                 show_headers: true,
@@ -360,7 +359,6 @@ impl MultiBuffer {
             subscriptions: Topic::default(),
             singleton: false,
             capability,
-            replica_id,
             title: None,
             history: History {
                 next_transaction_id: clock::Lamport::default(),
@@ -372,14 +370,13 @@ impl MultiBuffer {
         }
     }
 
-    pub fn without_headers(replica_id: ReplicaId, capability: Capability) -> Self {
+    pub fn without_headers(capability: Capability) -> Self {
         Self {
             snapshot: Default::default(),
             buffers: Default::default(),
             subscriptions: Default::default(),
             singleton: false,
             capability,
-            replica_id,
             history: History {
                 next_transaction_id: Default::default(),
                 undo_stack: Default::default(),
@@ -414,7 +411,6 @@ impl MultiBuffer {
             subscriptions: Default::default(),
             singleton: self.singleton,
             capability: self.capability,
-            replica_id: self.replica_id,
             history: self.history.clone(),
             title: self.title.clone(),
         }
@@ -430,7 +426,7 @@ impl MultiBuffer {
     }
 
     pub fn singleton(buffer: Model<Buffer>, cx: &mut ModelContext<Self>) -> Self {
-        let mut this = Self::new(buffer.read(cx).replica_id(), buffer.read(cx).capability());
+        let mut this = Self::new(buffer.read(cx).capability());
         this.singleton = true;
         this.push_excerpts(
             buffer,
@@ -444,10 +440,6 @@ impl MultiBuffer {
         this
     }
 
-    pub fn replica_id(&self) -> ReplicaId {
-        self.replica_id
-    }
-
     /// Returns an up-to-date snapshot of the MultiBuffer.
     pub fn snapshot(&self, cx: &AppContext) -> MultiBufferSnapshot {
         self.sync(cx);
@@ -2011,7 +2003,7 @@ impl MultiBuffer {
         excerpts: [(&str, Vec<Range<Point>>); COUNT],
         cx: &mut gpui::AppContext,
     ) -> Model<Self> {
-        let multi = cx.new_model(|_| Self::new(0, Capability::ReadWrite));
+        let multi = cx.new_model(|_| Self::new(Capability::ReadWrite));
         for (text, ranges) in excerpts {
             let buffer = cx.new_model(|cx| Buffer::local(text, cx));
             let excerpt_ranges = ranges.into_iter().map(|range| ExcerptRange {
@@ -2032,7 +2024,7 @@ impl MultiBuffer {
 
     pub fn build_random(rng: &mut impl rand::Rng, cx: &mut gpui::AppContext) -> Model<Self> {
         cx.new_model(|cx| {
-            let mut multibuffer = MultiBuffer::new(0, Capability::ReadWrite);
+            let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
             let mutation_count = rng.gen_range(1..=5);
             multibuffer.randomly_edit_excerpts(rng, mutation_count, cx);
             multibuffer
@@ -5063,7 +5055,7 @@ mod tests {
     fn test_excerpt_boundaries_and_clipping(cx: &mut AppContext) {
         let buffer_1 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'a'), cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'g'), cx));
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
 
         let events = Arc::new(RwLock::new(Vec::<Event>::new()));
         multibuffer.update(cx, |_, cx| {
@@ -5306,8 +5298,8 @@ mod tests {
         let buffer_1 = cx.new_model(|cx| Buffer::local(sample_text(10, 3, 'a'), cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local(sample_text(10, 3, 'm'), cx));
 
-        let leader_multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
-        let follower_multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let leader_multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
+        let follower_multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         let follower_edit_event_count = Arc::new(RwLock::new(0));
 
         follower_multibuffer.update(cx, |_, cx| {
@@ -5410,7 +5402,7 @@ mod tests {
     #[gpui::test]
     fn test_expand_excerpts(cx: &mut AppContext) {
         let buffer = cx.new_model(|cx| Buffer::local(sample_text(20, 3, 'a'), cx));
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
 
         multibuffer.update(cx, |multibuffer, cx| {
             multibuffer.push_excerpts_with_context_lines(
@@ -5486,7 +5478,7 @@ mod tests {
     #[gpui::test]
     fn test_push_excerpts_with_context_lines(cx: &mut AppContext) {
         let buffer = cx.new_model(|cx| Buffer::local(sample_text(20, 3, 'a'), cx));
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         let anchor_ranges = multibuffer.update(cx, |multibuffer, cx| {
             multibuffer.push_excerpts_with_context_lines(
                 buffer.clone(),
@@ -5539,7 +5531,7 @@ mod tests {
     #[gpui::test]
     async fn test_stream_excerpts_with_context_lines(cx: &mut TestAppContext) {
         let buffer = cx.new_model(|cx| Buffer::local(sample_text(20, 3, 'a'), cx));
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         let anchor_ranges = multibuffer.update(cx, |multibuffer, cx| {
             let snapshot = buffer.read(cx);
             let ranges = vec![
@@ -5589,7 +5581,7 @@ mod tests {
 
     #[gpui::test]
     fn test_empty_multibuffer(cx: &mut AppContext) {
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
 
         let snapshot = multibuffer.read(cx).snapshot(cx);
         assert_eq!(snapshot.text(), "");
@@ -5628,7 +5620,7 @@ mod tests {
         let buffer_1 = cx.new_model(|cx| Buffer::local("abcd", cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local("efghi", cx));
         let multibuffer = cx.new_model(|cx| {
-            let mut multibuffer = MultiBuffer::new(0, Capability::ReadWrite);
+            let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
             multibuffer.push_excerpts(
                 buffer_1.clone(),
                 [ExcerptRange {
@@ -5685,7 +5677,7 @@ mod tests {
     fn test_resolving_anchors_after_replacing_their_excerpts(cx: &mut AppContext) {
         let buffer_1 = cx.new_model(|cx| Buffer::local("abcd", cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local("ABCDEFGHIJKLMNOP", cx));
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
 
         // Create an insertion id in buffer 1 that doesn't exist in buffer 2.
         // Add an excerpt from buffer 1 that spans this new insertion.
@@ -5819,7 +5811,7 @@ mod tests {
             .unwrap_or(10);
 
         let mut buffers: Vec<Model<Buffer>> = Vec::new();
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         let mut excerpt_ids = Vec::<ExcerptId>::new();
         let mut expected_excerpts = Vec::<(Model<Buffer>, Range<text::Anchor>)>::new();
         let mut anchors = Vec::new();
@@ -6283,7 +6275,7 @@ mod tests {
 
         let buffer_1 = cx.new_model(|cx| Buffer::local("1234", cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local("5678", cx));
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         let group_interval = multibuffer.read(cx).history.group_interval;
         multibuffer.update(cx, |multibuffer, cx| {
             multibuffer.push_excerpts(
@@ -6418,7 +6410,7 @@ mod tests {
     fn test_excerpts_in_ranges_no_ranges(cx: &mut AppContext) {
         let buffer_1 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'a'), cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'g'), cx));
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         multibuffer.update(cx, |multibuffer, cx| {
             multibuffer.push_excerpts(
                 buffer_1.clone(),
@@ -6496,7 +6488,7 @@ mod tests {
         let buffer_1 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'a'), cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'g'), cx));
         let buffer_len = buffer_1.read(cx).len();
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         let mut expected_excerpt_id = ExcerptId(0);
 
         multibuffer.update(cx, |multibuffer, cx| {
@@ -6557,7 +6549,7 @@ mod tests {
         let buffer_1 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'a'), cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'g'), cx));
         let buffer_len = buffer_1.read(cx).len();
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         let mut excerpt_1_id = ExcerptId(0);
         let mut excerpt_2_id = ExcerptId(0);
 
@@ -6623,7 +6615,7 @@ mod tests {
         let buffer_2 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'g'), cx));
         let buffer_3 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'r'), cx));
         let buffer_len = buffer_1.read(cx).len();
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         let mut excerpt_1_id = ExcerptId(0);
         let mut excerpt_2_id = ExcerptId(0);
         let mut excerpt_3_id = ExcerptId(0);
@@ -6698,7 +6690,7 @@ mod tests {
         let buffer_1 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'a'), cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'g'), cx));
         let buffer_len = buffer_1.read(cx).len();
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         let mut excerpt_1_id = ExcerptId(0);
         let mut excerpt_2_id = ExcerptId(0);
 
@@ -6764,7 +6756,7 @@ mod tests {
         let buffer_1 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'a'), cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'g'), cx));
         let buffer_len = buffer_1.read(cx).len();
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         let mut excerpt_1_id = ExcerptId(0);
         let mut excerpt_2_id = ExcerptId(0);
 
@@ -6829,7 +6821,7 @@ mod tests {
     fn test_split_ranges(cx: &mut AppContext) {
         let buffer_1 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'a'), cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'g'), cx));
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         multibuffer.update(cx, |multibuffer, cx| {
             multibuffer.push_excerpts(
                 buffer_1.clone(),
@@ -6885,7 +6877,7 @@ mod tests {
         let buffer_1 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'a'), cx));
         let buffer_2 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'g'), cx));
         let buffer_3 = cx.new_model(|cx| Buffer::local(sample_text(6, 6, 'm'), cx));
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
         multibuffer.update(cx, |multibuffer, cx| {
             multibuffer.push_excerpts(
                 buffer_1.clone(),
diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs
index c43d4ed4544e4f..fac3c55bf45506 100644
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -176,12 +176,11 @@ pub struct ProjectSearchBar {
 
 impl ProjectSearch {
     pub fn new(project: Model<Project>, cx: &mut ModelContext<Self>) -> Self {
-        let replica_id = project.read(cx).replica_id();
         let capability = project.read(cx).capability();
 
         Self {
             project,
-            excerpts: cx.new_model(|_| MultiBuffer::new(replica_id, capability)),
+            excerpts: cx.new_model(|_| MultiBuffer::new(capability)),
             pending_search: Default::default(),
             match_ranges: Default::default(),
             active_query: None,

From 759646e0a35a2c4586817b79028cb347e3749de4 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 20 Sep 2024 11:45:03 -0400
Subject: [PATCH 244/762] editor: Improve rewrapping when working with comments
 at different indentation levels (#18146)

This PR improves the `editor::Rewrap` command when working with comments
that were not all at the same indentation level.

We now use a heuristic of finding the most common indentation level for
each line, using the deepest indent in the event of a tie.

It also removes an `.unwrap()` that would previously lead to a panic in
this case. Instead of unwrapping we now log an error to the logs and
skip rewrapping for that selection.

Release Notes:

- Improved the behavior of `editor: rewrap` when working with a
selection that contained comments at different indentation levels.
---
 crates/editor/src/editor.rs       | 46 ++++++++++++++++---
 crates/editor/src/editor_tests.rs | 74 +++++++++++++++++++++++++++++++
 crates/language/src/buffer.rs     |  4 +-
 3 files changed, 116 insertions(+), 8 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index eb2dafc24dc0f3..33eb51cb0ecb77 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -6736,9 +6736,31 @@ impl Editor {
                 }
             }
 
-            let row = selection.head().row;
-            let indent_size = buffer.indent_size_for_line(MultiBufferRow(row));
-            let indent_end = Point::new(row, indent_size.len);
+            // Since not all lines in the selection may be at the same indent
+            // level, choose the indent size that is the most common between all
+            // of the lines.
+            //
+            // If there is a tie, we use the deepest indent.
+            let (indent_size, indent_end) = {
+                let mut indent_size_occurrences = HashMap::default();
+                let mut rows_by_indent_size = HashMap::<IndentSize, Vec<u32>>::default();
+
+                for row in start_row..=end_row {
+                    let indent = buffer.indent_size_for_line(MultiBufferRow(row));
+                    rows_by_indent_size.entry(indent).or_default().push(row);
+                    *indent_size_occurrences.entry(indent).or_insert(0) += 1;
+                }
+
+                let indent_size = indent_size_occurrences
+                    .into_iter()
+                    .max_by_key(|(indent, count)| (*count, indent.len))
+                    .map(|(indent, _)| indent)
+                    .unwrap_or_default();
+                let row = rows_by_indent_size[&indent_size][0];
+                let indent_end = Point::new(row, indent_size.len);
+
+                (indent_size, indent_end)
+            };
 
             let mut line_prefix = indent_size.chars().collect::<String>();
 
@@ -6788,10 +6810,22 @@ impl Editor {
             let start = Point::new(start_row, 0);
             let end = Point::new(end_row, buffer.line_len(MultiBufferRow(end_row)));
             let selection_text = buffer.text_for_range(start..end).collect::<String>();
-            let unwrapped_text = selection_text
+            let Some(lines_without_prefixes) = selection_text
                 .lines()
-                .map(|line| line.strip_prefix(&line_prefix).unwrap())
-                .join(" ");
+                .map(|line| {
+                    line.strip_prefix(&line_prefix)
+                        .or_else(|| line.trim_start().strip_prefix(&line_prefix.trim_start()))
+                        .ok_or_else(|| {
+                            anyhow!("line did not start with prefix {line_prefix:?}: {line:?}")
+                        })
+                })
+                .collect::<Result<Vec<_>, _>>()
+                .log_err()
+            else {
+                continue;
+            };
+
+            let unwrapped_text = lines_without_prefixes.join(" ");
             let wrap_column = buffer
                 .settings_at(Point::new(start_row, 0), cx)
                 .preferred_line_length as usize;
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 589673447d7f48..85684db8181333 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -4249,6 +4249,80 @@ async fn test_rewrap(cx: &mut TestAppContext) {
         cx.update_editor(|e, cx| e.rewrap(&Rewrap, cx));
         cx.assert_editor_state(wrapped_text);
     }
+
+    // Test rewrapping unaligned comments in a selection.
+    {
+        let language = Arc::new(Language::new(
+            LanguageConfig {
+                line_comments: vec!["// ".into(), "/// ".into()],
+                ..LanguageConfig::default()
+            },
+            Some(tree_sitter_rust::LANGUAGE.into()),
+        ));
+        cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx));
+
+        let unwrapped_text = indoc! {"
+            fn foo() {
+                if true {
+            «        // Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit purus, a ornare lacus gravida vitae.
+            // Praesent semper egestas tellus id dignissim.ˇ»
+                    do_something();
+                } else {
+                    //
+                }
+
+            }
+        "};
+
+        let wrapped_text = indoc! {"
+            fn foo() {
+                if true {
+                    // Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus
+                    // mollis elit purus, a ornare lacus gravida vitae. Praesent semper
+                    // egestas tellus id dignissim.ˇ
+                    do_something();
+                } else {
+                    //
+                }
+
+            }
+        "};
+
+        cx.set_state(unwrapped_text);
+        cx.update_editor(|e, cx| e.rewrap(&Rewrap, cx));
+        cx.assert_editor_state(wrapped_text);
+
+        let unwrapped_text = indoc! {"
+            fn foo() {
+                if true {
+            «ˇ        // Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit purus, a ornare lacus gravida vitae.
+            // Praesent semper egestas tellus id dignissim.»
+                    do_something();
+                } else {
+                    //
+                }
+
+            }
+        "};
+
+        let wrapped_text = indoc! {"
+            fn foo() {
+                if true {
+                    // Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus
+                    // mollis elit purus, a ornare lacus gravida vitae. Praesent semper
+                    // egestas tellus id dignissim.ˇ
+                    do_something();
+                } else {
+                    //
+                }
+
+            }
+        "};
+
+        cx.set_state(unwrapped_text);
+        cx.update_editor(|e, cx| e.rewrap(&Rewrap, cx));
+        cx.assert_editor_state(wrapped_text);
+    }
 }
 
 #[gpui::test]
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 08fc1ccdb45d5b..acb57273e30eed 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -144,7 +144,7 @@ pub struct BufferSnapshot {
 
 /// The kind and amount of indentation in a particular line. For now,
 /// assumes that indentation is all the same character.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Default)]
 pub struct IndentSize {
     /// The number of bytes that comprise the indentation.
     pub len: u32,
@@ -153,7 +153,7 @@ pub struct IndentSize {
 }
 
 /// A whitespace character that's used for indentation.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Default)]
 pub enum IndentKind {
     /// An ASCII space character.
     #[default]

From f8195c41e0019b77a56a2eb96c346b601a6c8b89 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 20 Sep 2024 11:52:57 -0400
Subject: [PATCH 245/762] docs: Switch proxy example to socks5h not socks5
 (#18142)

Very rarely when you have a SOCKS proxy configured do you want local DNS.
`socks5` does local DNS. `socks5h` does remote DNS.
---
 assets/settings/default.json |  2 +-
 docs/src/configuring-zed.md  | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index a9e18652580be3..537ad120829b59 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -1029,7 +1029,7 @@
   // environment variables.
   //
   // Examples:
-  //   - "proxy": "socks5://localhost:10808"
+  //   - "proxy": "socks5h://localhost:10808"
   //   - "proxy": "http://127.0.0.1:10809"
   "proxy": null,
   // Set to configure aliases for the command palette.
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 1befa7d93abb7e..de7433bf5dbad3 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -1127,10 +1127,10 @@ The following URI schemes are supported:
 
 - `http`
 - `https`
-- `socks4`
-- `socks4a`
-- `socks5`
-- `socks5h`
+- `socks4` - SOCKS4 proxy with local DNS
+- `socks4a` - SOCKS4 proxy with remote DNS
+- `socks5` - SOCKS5 proxy with local DNS
+- `socks5h` - SOCKS5 proxy with remote DNS
 
 `http` will be used when no scheme is specified.
 
@@ -1148,7 +1148,7 @@ Or to set a `socks5` proxy:
 
 ```json
 {
-  "proxy": "socks5://localhost:10808"
+  "proxy": "socks5h://localhost:10808"
 }
 ```
 

From 99bef273009a62b416300daa22b9a14910b5ca91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8B=90=E7=8B=B8?=
 <134658521+Huliiiiii@users.noreply.github.com>
Date: Sat, 21 Sep 2024 00:20:14 +0800
Subject: [PATCH 246/762] Add escape string highlights to JSON and JSONC files
 (#18138)

Release Notes:

- Added escape string highlights to JSON and JSONC files
---
 crates/languages/src/json/highlights.scm  | 1 +
 crates/languages/src/jsonc/highlights.scm | 1 +
 2 files changed, 2 insertions(+)

diff --git a/crates/languages/src/json/highlights.scm b/crates/languages/src/json/highlights.scm
index 71168051094a39..8cf7a6d20dc6c7 100644
--- a/crates/languages/src/json/highlights.scm
+++ b/crates/languages/src/json/highlights.scm
@@ -1,6 +1,7 @@
 (comment) @comment
 
 (string) @string
+(escape_sequence) @string.escape
 
 (pair
   key: (string) @property.json_key)
diff --git a/crates/languages/src/jsonc/highlights.scm b/crates/languages/src/jsonc/highlights.scm
index 71168051094a39..8cf7a6d20dc6c7 100644
--- a/crates/languages/src/jsonc/highlights.scm
+++ b/crates/languages/src/jsonc/highlights.scm
@@ -1,6 +1,7 @@
 (comment) @comment
 
 (string) @string
+(escape_sequence) @string.escape
 
 (pair
   key: (string) @property.json_key)

From d97427f69eb46b62b4decac7ee88f5890a8a575c Mon Sep 17 00:00:00 2001
From: jvmncs <7891333+jvmncs@users.noreply.github.com>
Date: Fri, 20 Sep 2024 12:48:48 -0400
Subject: [PATCH 247/762] chore: Update flake inputs (#18150)

Release Notes:

- N/A
---
 flake.lock | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/flake.lock b/flake.lock
index 2b421a9efb8b99..a5b7a7a6ae9c46 100644
--- a/flake.lock
+++ b/flake.lock
@@ -23,11 +23,11 @@
         "rust-analyzer-src": "rust-analyzer-src"
       },
       "locked": {
-        "lastModified": 1726554553,
-        "narHash": "sha256-xakDhIS1c1VgJc/NMOLj05yBsTdlXKMEYz6wC8Hdshc=",
+        "lastModified": 1726813972,
+        "narHash": "sha256-t6turZgoSAVgj7hn5mxzNlLOeVeZvymFo8+ymB52q34=",
         "owner": "nix-community",
         "repo": "fenix",
-        "rev": "1f59d7585aa06d2c327960d397bea4067d8fee98",
+        "rev": "251caeafc75b710282ee7e375800f75f4c8c5727",
         "type": "github"
       },
       "original": {
@@ -53,11 +53,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1726463316,
-        "narHash": "sha256-gI9kkaH0ZjakJOKrdjaI/VbaMEo9qBbSUl93DnU7f4c=",
+        "lastModified": 1726642912,
+        "narHash": "sha256-wiZzKGHRAhItEuoE599Wm3ic+Lg/NykuBvhb+awf7N8=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "99dc8785f6a0adac95f5e2ab05cc2e1bf666d172",
+        "rev": "395c52d142ec1df377acd67db6d4a22950b02a98",
         "type": "github"
       },
       "original": {

From 9f6ff29a54aeeb1fac22e3d5315d47705d47cb31 Mon Sep 17 00:00:00 2001
From: jvmncs <7891333+jvmncs@users.noreply.github.com>
Date: Fri, 20 Sep 2024 12:57:35 -0400
Subject: [PATCH 248/762] Reuse OpenAI low_speed_timeout setting for zed.dev
 provider (#18144)

Release Notes:

- N/A
---
 Cargo.lock                                  |  1 +
 crates/language_model/Cargo.toml            |  1 +
 crates/language_model/src/provider/cloud.rs | 22 +++++++++++++++++++--
 crates/language_model/src/settings.rs       |  9 +++++++++
 4 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 26b8847041ba60..a19506829eeabf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6285,6 +6285,7 @@ dependencies = [
  "http_client",
  "image",
  "inline_completion_button",
+ "isahc",
  "language",
  "log",
  "menu",
diff --git a/crates/language_model/Cargo.toml b/crates/language_model/Cargo.toml
index ef273ac44fca39..b63428c544369b 100644
--- a/crates/language_model/Cargo.toml
+++ b/crates/language_model/Cargo.toml
@@ -32,6 +32,7 @@ futures.workspace = true
 google_ai = { workspace = true, features = ["schemars"] }
 gpui.workspace = true
 http_client.workspace = true
+isahc.workspace = true
 inline_completion_button.workspace = true
 log.workspace = true
 menu.workspace = true
diff --git a/crates/language_model/src/provider/cloud.rs b/crates/language_model/src/provider/cloud.rs
index f8f64ff3b84988..58efb4cfe1b308 100644
--- a/crates/language_model/src/provider/cloud.rs
+++ b/crates/language_model/src/provider/cloud.rs
@@ -19,6 +19,7 @@ use gpui::{
     Subscription, Task,
 };
 use http_client::{AsyncBody, HttpClient, Method, Response};
+use isahc::config::Configurable;
 use schemars::JsonSchema;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use serde_json::value::RawValue;
@@ -27,6 +28,7 @@ use smol::{
     io::{AsyncReadExt, BufReader},
     lock::{RwLock, RwLockUpgradableReadGuard, RwLockWriteGuard},
 };
+use std::time::Duration;
 use std::{
     future,
     sync::{Arc, LazyLock},
@@ -56,6 +58,7 @@ fn zed_cloud_provider_additional_models() -> &'static [AvailableModel] {
 #[derive(Default, Clone, Debug, PartialEq)]
 pub struct ZedDotDevSettings {
     pub available_models: Vec<AvailableModel>,
+    pub low_speed_timeout: Option<Duration>,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
@@ -380,6 +383,7 @@ impl CloudLanguageModel {
         client: Arc<Client>,
         llm_api_token: LlmApiToken,
         body: PerformCompletionParams,
+        low_speed_timeout: Option<Duration>,
     ) -> Result<Response<AsyncBody>> {
         let http_client = &client.http_client();
 
@@ -387,7 +391,11 @@ impl CloudLanguageModel {
         let mut did_retry = false;
 
         let response = loop {
-            let request = http_client::Request::builder()
+            let mut request_builder = http_client::Request::builder();
+            if let Some(low_speed_timeout) = low_speed_timeout {
+                request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
+            };
+            let request = request_builder
                 .method(Method::POST)
                 .uri(http_client.build_zed_llm_url("/completion", &[])?.as_ref())
                 .header("Content-Type", "application/json")
@@ -501,8 +509,11 @@ impl LanguageModel for CloudLanguageModel {
     fn stream_completion(
         &self,
         request: LanguageModelRequest,
-        _cx: &AsyncAppContext,
+        cx: &AsyncAppContext,
     ) -> BoxFuture<'static, Result<BoxStream<'static, Result<LanguageModelCompletionEvent>>>> {
+        let openai_low_speed_timeout =
+            AllLanguageModelSettings::try_read_global(cx, |s| s.openai.low_speed_timeout.unwrap());
+
         match &self.model {
             CloudModel::Anthropic(model) => {
                 let request = request.into_anthropic(model.id().into(), model.max_output_tokens());
@@ -519,6 +530,7 @@ impl LanguageModel for CloudLanguageModel {
                                 &request,
                             )?)?,
                         },
+                        None,
                     )
                     .await?;
                     Ok(map_to_language_model_completion_events(Box::pin(
@@ -542,6 +554,7 @@ impl LanguageModel for CloudLanguageModel {
                                 &request,
                             )?)?,
                         },
+                        openai_low_speed_timeout,
                     )
                     .await?;
                     Ok(open_ai::extract_text_from_events(response_lines(response)))
@@ -569,6 +582,7 @@ impl LanguageModel for CloudLanguageModel {
                                 &request,
                             )?)?,
                         },
+                        None,
                     )
                     .await?;
                     Ok(google_ai::extract_text_from_events(response_lines(
@@ -599,6 +613,7 @@ impl LanguageModel for CloudLanguageModel {
                                 &request,
                             )?)?,
                         },
+                        None,
                     )
                     .await?;
                     Ok(open_ai::extract_text_from_events(response_lines(response)))
@@ -650,6 +665,7 @@ impl LanguageModel for CloudLanguageModel {
                                     &request,
                                 )?)?,
                             },
+                            None,
                         )
                         .await?;
 
@@ -694,6 +710,7 @@ impl LanguageModel for CloudLanguageModel {
                                     &request,
                                 )?)?,
                             },
+                            None,
                         )
                         .await?;
 
@@ -741,6 +758,7 @@ impl LanguageModel for CloudLanguageModel {
                                     &request,
                                 )?)?,
                             },
+                            None,
                         )
                         .await?;
 
diff --git a/crates/language_model/src/settings.rs b/crates/language_model/src/settings.rs
index 80749c0bdb3736..8888d51e11c255 100644
--- a/crates/language_model/src/settings.rs
+++ b/crates/language_model/src/settings.rs
@@ -231,6 +231,7 @@ pub struct GoogleSettingsContent {
 #[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
 pub struct ZedDotDevSettingsContent {
     available_models: Option<Vec<cloud::AvailableModel>>,
+    pub low_speed_timeout_in_seconds: Option<u64>,
 }
 
 #[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
@@ -333,6 +334,14 @@ impl settings::Settings for AllLanguageModelSettings {
                     .as_ref()
                     .and_then(|s| s.available_models.clone()),
             );
+            if let Some(low_speed_timeout_in_seconds) = value
+                .zed_dot_dev
+                .as_ref()
+                .and_then(|s| s.low_speed_timeout_in_seconds)
+            {
+                settings.zed_dot_dev.low_speed_timeout =
+                    Some(Duration::from_secs(low_speed_timeout_in_seconds));
+            }
 
             merge(
                 &mut settings.google.api_url,

From 8bd624b5db035862ecb89a4cf126167f572712af Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 20 Sep 2024 13:06:43 -0400
Subject: [PATCH 249/762] editor: Remove unneeded blank lines in rewrap test
 cases (#18152)

This PR removes some unneeded blank lines from some of the test cases
for `editor::Rewrap`.

These weren't meaningful to the test, and their presence could be
confusing.

Release Notes:

- N/A
---
 crates/editor/src/editor_tests.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 85684db8181333..5927c22cb08439 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -4270,7 +4270,6 @@ async fn test_rewrap(cx: &mut TestAppContext) {
                 } else {
                     //
                 }
-
             }
         "};
 
@@ -4284,7 +4283,6 @@ async fn test_rewrap(cx: &mut TestAppContext) {
                 } else {
                     //
                 }
-
             }
         "};
 

From 601090511bde0cd39985f670d7d2acc895f2594c Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Fri, 20 Sep 2024 13:25:06 -0400
Subject: [PATCH 250/762] Remove `system_id` from all events but
 `editor_events` (#18154)

Release Notes:

- N/A
---
 crates/collab/src/api/events.rs | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index 008c76e048b9d9..f8ae53201304fb 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -905,7 +905,6 @@ impl AssistantEventRow {
 
 #[derive(Debug, clickhouse::Row, Serialize)]
 pub struct CpuEventRow {
-    system_id: Option<String>,
     installation_id: Option<String>,
     session_id: Option<String>,
     is_staff: Option<bool>,
@@ -944,7 +943,6 @@ impl CpuEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
-            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,
@@ -968,7 +966,6 @@ pub struct MemoryEventRow {
     os_version: String,
 
     // ClientEventBase
-    system_id: Option<String>,
     installation_id: Option<String>,
     session_id: Option<String>,
     is_staff: Option<bool>,
@@ -1000,7 +997,6 @@ impl MemoryEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
-            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,
@@ -1024,7 +1020,6 @@ pub struct AppEventRow {
     os_version: String,
 
     // ClientEventBase
-    system_id: Option<String>,
     installation_id: Option<String>,
     session_id: Option<String>,
     is_staff: Option<bool>,
@@ -1055,7 +1050,6 @@ impl AppEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
-            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,
@@ -1078,7 +1072,6 @@ pub struct SettingEventRow {
     os_version: String,
 
     // ClientEventBase
-    system_id: Option<String>,
     installation_id: Option<String>,
     session_id: Option<String>,
     is_staff: Option<bool>,
@@ -1109,7 +1102,6 @@ impl SettingEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
-            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,
@@ -1133,7 +1125,6 @@ pub struct ExtensionEventRow {
     os_version: String,
 
     // ClientEventBase
-    system_id: Option<String>,
     installation_id: Option<String>,
     session_id: Option<String>,
     is_staff: Option<bool>,
@@ -1169,7 +1160,6 @@ impl ExtensionEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
-            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,
@@ -1260,7 +1250,6 @@ pub struct EditEventRow {
     os_version: String,
 
     // ClientEventBase
-    system_id: Option<String>,
     installation_id: Option<String>,
     // Note: This column name has a typo in the ClickHouse table.
     #[serde(rename = "sesssion_id")]
@@ -1298,7 +1287,6 @@ impl EditEventRow {
             release_channel: body.release_channel.clone().unwrap_or_default(),
             os_name: body.os_name.clone(),
             os_version: body.os_version.clone().unwrap_or_default(),
-            system_id: body.system_id.clone(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
             is_staff: body.is_staff,

From 5d12e3ce3a318577ff09811bdf57c91674b1beea Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Fri, 20 Sep 2024 14:43:26 -0400
Subject: [PATCH 251/762] preview tabs: Toggle preview tab when saving (#18158)

Release Notes:

- Saving a preview tab will now mark it as a permanent tab
---
 crates/workspace/src/pane.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index a5f83f961f0400..82300690e7dbe1 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -1595,8 +1595,13 @@ impl Pane {
             }
 
             if can_save {
-                pane.update(cx, |_, cx| item.save(should_format, project, cx))?
-                    .await?;
+                pane.update(cx, |pane, cx| {
+                    if pane.is_active_preview_item(item.item_id()) {
+                        pane.set_preview_item_id(None, cx);
+                    }
+                    item.save(should_format, project, cx)
+                })?
+                .await?;
             } else if can_save_as {
                 let abs_path = pane.update(cx, |pane, cx| {
                     pane.workspace

From 7dac5594cdb02259c455cee90f57fb610b8c6162 Mon Sep 17 00:00:00 2001
From: Daste <stefankar1000@gmail.com>
Date: Fri, 20 Sep 2024 20:44:13 +0200
Subject: [PATCH 252/762] file_finder: Display file icons (#18091)

This PR adds file icons (like in tabs, the project panel and tab
switcher) to the file finder popup.

It's similar to [tab_switcher
icons](https://github.com/zed-industries/zed/pull/17115), but simpler,
because we're only dealing with actual files.

Release Notes:

- Added icons to the file finder.

Screenshot:

![image](https://github.com/user-attachments/assets/bd6a54c1-cdbd-415a-9a82-0cc7a0bb6ca2)

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 Cargo.lock                                    |  3 +++
 assets/settings/default.json                  |  5 ++++
 crates/file_finder/Cargo.toml                 |  3 +++
 crates/file_finder/src/file_finder.rs         | 21 +++++++++++++--
 .../file_finder/src/file_finder_settings.rs   | 27 +++++++++++++++++++
 5 files changed, 57 insertions(+), 2 deletions(-)
 create mode 100644 crates/file_finder/src/file_finder_settings.rs

diff --git a/Cargo.lock b/Cargo.lock
index a19506829eeabf..dd07dfa1cf0843 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4326,6 +4326,7 @@ dependencies = [
  "ctor",
  "editor",
  "env_logger",
+ "file_icons",
  "futures 0.3.30",
  "fuzzy",
  "gpui",
@@ -4333,7 +4334,9 @@ dependencies = [
  "menu",
  "picker",
  "project",
+ "schemars",
  "serde",
+ "serde_derive",
  "serde_json",
  "settings",
  "text",
diff --git a/assets/settings/default.json b/assets/settings/default.json
index 537ad120829b59..8424c5733d81bc 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -496,6 +496,11 @@
     // Whether a preview tab gets replaced when code navigation is used to navigate away from the tab.
     "enable_preview_from_code_navigation": false
   },
+  // Settings related to the file finder.
+  "file_finder": {
+    // Whether to show file icons in the file finder.
+    "file_icons": true
+  },
   // Whether or not to remove any trailing whitespace from lines of a buffer
   // before saving it.
   "remove_trailing_whitespace_on_save": true,
diff --git a/crates/file_finder/Cargo.toml b/crates/file_finder/Cargo.toml
index 8f17b191a53073..2b4aa5fe3080cf 100644
--- a/crates/file_finder/Cargo.toml
+++ b/crates/file_finder/Cargo.toml
@@ -16,14 +16,17 @@ doctest = false
 anyhow.workspace = true
 collections.workspace = true
 editor.workspace = true
+file_icons.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
 menu.workspace = true
 picker.workspace = true
 project.workspace = true
+schemars.workspace = true
 settings.workspace = true
 serde.workspace = true
+serde_derive.workspace = true
 text.workspace = true
 theme.workspace = true
 ui.workspace = true
diff --git a/crates/file_finder/src/file_finder.rs b/crates/file_finder/src/file_finder.rs
index 50a14b62dbb4d1..e1e0998f8aa3b6 100644
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -1,11 +1,14 @@
 #[cfg(test)]
 mod file_finder_tests;
 
+mod file_finder_settings;
 mod new_path_prompt;
 mod open_path_prompt;
 
 use collections::HashMap;
 use editor::{scroll::Autoscroll, Bias, Editor};
+use file_finder_settings::FileFinderSettings;
+use file_icons::FileIcons;
 use fuzzy::{CharBag, PathMatch, PathMatchCandidate};
 use gpui::{
     actions, rems, Action, AnyElement, AppContext, DismissEvent, EventEmitter, FocusHandle,
@@ -39,7 +42,12 @@ pub struct FileFinder {
     init_modifiers: Option<Modifiers>,
 }
 
+pub fn init_settings(cx: &mut AppContext) {
+    FileFinderSettings::register(cx);
+}
+
 pub fn init(cx: &mut AppContext) {
+    init_settings(cx);
     cx.observe_new_views(FileFinder::register).detach();
     cx.observe_new_views(NewPathPrompt::register).detach();
     cx.observe_new_views(OpenPathPrompt::register).detach();
@@ -1041,12 +1049,14 @@ impl PickerDelegate for FileFinderDelegate {
         selected: bool,
         cx: &mut ViewContext<Picker<Self>>,
     ) -> Option<Self::ListItem> {
+        let settings = FileFinderSettings::get_global(cx);
+
         let path_match = self
             .matches
             .get(ix)
             .expect("Invalid matches state: no element for index {ix}");
 
-        let icon = match &path_match {
+        let history_icon = match &path_match {
             Match::History { .. } => Icon::new(IconName::HistoryRerun)
                 .color(Color::Muted)
                 .size(IconSize::Small)
@@ -1059,10 +1069,17 @@ impl PickerDelegate for FileFinderDelegate {
         let (file_name, file_name_positions, full_path, full_path_positions) =
             self.labels_for_match(path_match, cx, ix);
 
+        let file_icon = if settings.file_icons {
+            FileIcons::get_icon(Path::new(&file_name), cx).map(Icon::from_path)
+        } else {
+            None
+        };
+
         Some(
             ListItem::new(ix)
                 .spacing(ListItemSpacing::Sparse)
-                .end_slot::<AnyElement>(Some(icon))
+                .start_slot::<Icon>(file_icon)
+                .end_slot::<AnyElement>(history_icon)
                 .inset(true)
                 .selected(selected)
                 .child(
diff --git a/crates/file_finder/src/file_finder_settings.rs b/crates/file_finder/src/file_finder_settings.rs
new file mode 100644
index 00000000000000..c02008c917b7fb
--- /dev/null
+++ b/crates/file_finder/src/file_finder_settings.rs
@@ -0,0 +1,27 @@
+use anyhow::Result;
+use schemars::JsonSchema;
+use serde_derive::{Deserialize, Serialize};
+use settings::{Settings, SettingsSources};
+
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq)]
+pub struct FileFinderSettings {
+    pub file_icons: bool,
+}
+
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
+pub struct FileFinderSettingsContent {
+    /// Whether to show file icons in the file finder.
+    ///
+    /// Default: true
+    pub file_icons: Option<bool>,
+}
+
+impl Settings for FileFinderSettings {
+    const KEY: Option<&'static str> = Some("file_finder");
+
+    type FileContent = FileFinderSettingsContent;
+
+    fn load(sources: SettingsSources<Self::FileContent>, _: &mut gpui::AppContext) -> Result<Self> {
+        sources.json_merge()
+    }
+}

From 45388805ad4bc5e27c0fcdd6936fb5bce687a8ff Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Fri, 20 Sep 2024 13:02:39 -0600
Subject: [PATCH 253/762] vim: gq (#18156)

Closes #ISSUE

Release Notes:

- vim: Added gq/gw for rewrapping lines
---
 assets/keymaps/vim.json           |  13 +++-
 crates/editor/src/editor.rs       |   6 +-
 crates/vim/src/normal.rs          |  30 +++++++-
 crates/vim/src/rewrap.rs          | 114 ++++++++++++++++++++++++++++++
 crates/vim/src/state.rs           |   3 +
 crates/vim/src/vim.rs             |   2 +
 crates/vim/test_data/test_gq.json |  12 ++++
 7 files changed, 177 insertions(+), 3 deletions(-)
 create mode 100644 crates/vim/src/rewrap.rs
 create mode 100644 crates/vim/test_data/test_gq.json

diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index 18b38384ef81ce..8d933f19afb1dd 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -124,7 +124,6 @@
       "g i": "vim::InsertAtPrevious",
       "g ,": "vim::ChangeListNewer",
       "g ;": "vim::ChangeListOlder",
-      "g q": "editor::Rewrap",
       "shift-h": "vim::WindowTop",
       "shift-m": "vim::WindowMiddle",
       "shift-l": "vim::WindowBottom",
@@ -240,6 +239,8 @@
       "g shift-u": ["vim::PushOperator", "Uppercase"],
       "g ~": ["vim::PushOperator", "OppositeCase"],
       "\"": ["vim::PushOperator", "Register"],
+      "g q": ["vim::PushOperator", "Rewrap"],
+      "g w": ["vim::PushOperator", "Rewrap"],
       "q": "vim::ToggleRecord",
       "shift-q": "vim::ReplayLastRecording",
       "@": ["vim::PushOperator", "ReplayRegister"],
@@ -301,6 +302,7 @@
       "i": ["vim::PushOperator", { "Object": { "around": false } }],
       "a": ["vim::PushOperator", { "Object": { "around": true } }],
       "g c": "vim::ToggleComments",
+      "g q": "vim::Rewrap",
       "\"": ["vim::PushOperator", "Register"],
       // tree-sitter related commands
       "[ x": "editor::SelectLargerSyntaxNode",
@@ -428,6 +430,15 @@
       "~": "vim::CurrentLine"
     }
   },
+  {
+    "context": "vim_operator == gq",
+    "bindings": {
+      "g q": "vim::CurrentLine",
+      "q": "vim::CurrentLine",
+      "g w": "vim::CurrentLine",
+      "w": "vim::CurrentLine"
+    }
+  },
   {
     "context": "vim_operator == y",
     "bindings": {
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 33eb51cb0ecb77..1f4a9376d22fa5 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -6705,6 +6705,10 @@ impl Editor {
     }
 
     pub fn rewrap(&mut self, _: &Rewrap, cx: &mut ViewContext<Self>) {
+        self.rewrap_impl(true, cx)
+    }
+
+    pub fn rewrap_impl(&mut self, only_text: bool, cx: &mut ViewContext<Self>) {
         let buffer = self.buffer.read(cx).snapshot(cx);
         let selections = self.selections.all::<Point>(cx);
         let mut selections = selections.iter().peekable();
@@ -6725,7 +6729,7 @@ impl Editor {
                 continue;
             }
 
-            let mut should_rewrap = false;
+            let mut should_rewrap = !only_text;
 
             if let Some(language_scope) = buffer.language_scope_at(selection.head()) {
                 match language_scope.language_name().0.as_ref() {
diff --git a/crates/vim/src/normal.rs b/crates/vim/src/normal.rs
index 741e09f178ff3e..10bf3c8e8d73b4 100644
--- a/crates/vim/src/normal.rs
+++ b/crates/vim/src/normal.rs
@@ -168,6 +168,7 @@ impl Vim {
             Some(Operator::Yank) => self.yank_motion(motion, times, cx),
             Some(Operator::AddSurrounds { target: None }) => {}
             Some(Operator::Indent) => self.indent_motion(motion, times, IndentDirection::In, cx),
+            Some(Operator::Rewrap) => self.rewrap_motion(motion, times, cx),
             Some(Operator::Outdent) => self.indent_motion(motion, times, IndentDirection::Out, cx),
             Some(Operator::Lowercase) => {
                 self.change_case_motion(motion, times, CaseTarget::Lowercase, cx)
@@ -199,6 +200,7 @@ impl Vim {
                 Some(Operator::Outdent) => {
                     self.indent_object(object, around, IndentDirection::Out, cx)
                 }
+                Some(Operator::Rewrap) => self.rewrap_object(object, around, cx),
                 Some(Operator::Lowercase) => {
                     self.change_case_object(object, around, CaseTarget::Lowercase, cx)
                 }
@@ -478,8 +480,9 @@ impl Vim {
 }
 #[cfg(test)]
 mod test {
-    use gpui::{KeyBinding, TestAppContext};
+    use gpui::{KeyBinding, TestAppContext, UpdateGlobal};
     use indoc::indoc;
+    use language::language_settings::AllLanguageSettings;
     use settings::SettingsStore;
 
     use crate::{
@@ -1386,4 +1389,29 @@ mod test {
         cx.simulate_shared_keystrokes("2 0 r - ").await;
         cx.shared_state().await.assert_eq("ˇhello world\n");
     }
+
+    #[gpui::test]
+    async fn test_gq(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+        cx.set_neovim_option("textwidth=5").await;
+
+        cx.update(|cx| {
+            SettingsStore::update_global(cx, |settings, cx| {
+                settings.update_user_settings::<AllLanguageSettings>(cx, |settings| {
+                    settings.defaults.preferred_line_length = Some(5);
+                });
+            })
+        });
+
+        cx.set_shared_state("ˇth th th th th th\n").await;
+        cx.simulate_shared_keystrokes("g q q").await;
+        cx.shared_state().await.assert_eq("th th\nth th\nˇth th\n");
+
+        cx.set_shared_state("ˇth th th th th th\nth th th th th th\n")
+            .await;
+        cx.simulate_shared_keystrokes("v j g q").await;
+        cx.shared_state()
+            .await
+            .assert_eq("th th\nth th\nth th\nth th\nth th\nˇth th\n");
+    }
 }
diff --git a/crates/vim/src/rewrap.rs b/crates/vim/src/rewrap.rs
new file mode 100644
index 00000000000000..3e61b3c3a181b3
--- /dev/null
+++ b/crates/vim/src/rewrap.rs
@@ -0,0 +1,114 @@
+use crate::{motion::Motion, object::Object, state::Mode, Vim};
+use collections::HashMap;
+use editor::{display_map::ToDisplayPoint, scroll::Autoscroll, Bias, Editor};
+use gpui::actions;
+use language::SelectionGoal;
+use ui::ViewContext;
+
+actions!(vim, [Rewrap]);
+
+pub(crate) fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {
+    Vim::action(editor, cx, |vim, _: &Rewrap, cx| {
+        vim.record_current_action(cx);
+        vim.take_count(cx);
+        vim.store_visual_marks(cx);
+        vim.update_editor(cx, |vim, editor, cx| {
+            editor.transact(cx, |editor, cx| {
+                let mut positions = vim.save_selection_starts(editor, cx);
+                editor.rewrap_impl(false, cx);
+                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                    s.move_with(|map, selection| {
+                        if let Some(anchor) = positions.remove(&selection.id) {
+                            let mut point = anchor.to_display_point(map);
+                            *point.column_mut() = 0;
+                            selection.collapse_to(point, SelectionGoal::None);
+                        }
+                    });
+                });
+            });
+        });
+        if vim.mode.is_visual() {
+            vim.switch_mode(Mode::Normal, true, cx)
+        }
+    });
+}
+
+impl Vim {
+    pub(crate) fn rewrap_motion(
+        &mut self,
+        motion: Motion,
+        times: Option<usize>,
+        cx: &mut ViewContext<Self>,
+    ) {
+        self.stop_recording(cx);
+        self.update_editor(cx, |_, editor, cx| {
+            let text_layout_details = editor.text_layout_details(cx);
+            editor.transact(cx, |editor, cx| {
+                let mut selection_starts: HashMap<_, _> = Default::default();
+                editor.change_selections(None, cx, |s| {
+                    s.move_with(|map, selection| {
+                        let anchor = map.display_point_to_anchor(selection.head(), Bias::Right);
+                        selection_starts.insert(selection.id, anchor);
+                        motion.expand_selection(map, selection, times, false, &text_layout_details);
+                    });
+                });
+                editor.rewrap_impl(false, cx);
+                editor.change_selections(None, cx, |s| {
+                    s.move_with(|map, selection| {
+                        let anchor = selection_starts.remove(&selection.id).unwrap();
+                        let mut point = anchor.to_display_point(map);
+                        *point.column_mut() = 0;
+                        selection.collapse_to(point, SelectionGoal::None);
+                    });
+                });
+            });
+        });
+    }
+
+    pub(crate) fn rewrap_object(
+        &mut self,
+        object: Object,
+        around: bool,
+        cx: &mut ViewContext<Self>,
+    ) {
+        self.stop_recording(cx);
+        self.update_editor(cx, |_, editor, cx| {
+            editor.transact(cx, |editor, cx| {
+                let mut original_positions: HashMap<_, _> = Default::default();
+                editor.change_selections(None, cx, |s| {
+                    s.move_with(|map, selection| {
+                        let anchor = map.display_point_to_anchor(selection.head(), Bias::Right);
+                        original_positions.insert(selection.id, anchor);
+                        object.expand_selection(map, selection, around);
+                    });
+                });
+                editor.rewrap_impl(false, cx);
+                editor.change_selections(None, cx, |s| {
+                    s.move_with(|map, selection| {
+                        let anchor = original_positions.remove(&selection.id).unwrap();
+                        let mut point = anchor.to_display_point(map);
+                        *point.column_mut() = 0;
+                        selection.collapse_to(point, SelectionGoal::None);
+                    });
+                });
+            });
+        });
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::test::NeovimBackedTestContext;
+
+    #[gpui::test]
+    async fn test_indent_gv(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+        cx.set_neovim_option("shiftwidth=4").await;
+
+        cx.set_shared_state("ˇhello\nworld\n").await;
+        cx.simulate_shared_keystrokes("v j > g v").await;
+        cx.shared_state()
+            .await
+            .assert_eq("«    hello\n ˇ»   world\n");
+    }
+}
diff --git a/crates/vim/src/state.rs b/crates/vim/src/state.rs
index 1d642e990f83bd..b61cb405e1104e 100644
--- a/crates/vim/src/state.rs
+++ b/crates/vim/src/state.rs
@@ -72,6 +72,7 @@ pub enum Operator {
     Jump { line: bool },
     Indent,
     Outdent,
+    Rewrap,
     Lowercase,
     Uppercase,
     OppositeCase,
@@ -454,6 +455,7 @@ impl Operator {
             Operator::Jump { line: true } => "'",
             Operator::Jump { line: false } => "`",
             Operator::Indent => ">",
+            Operator::Rewrap => "gq",
             Operator::Outdent => "<",
             Operator::Uppercase => "gU",
             Operator::Lowercase => "gu",
@@ -482,6 +484,7 @@ impl Operator {
             Operator::Change
             | Operator::Delete
             | Operator::Yank
+            | Operator::Rewrap
             | Operator::Indent
             | Operator::Outdent
             | Operator::Lowercase
diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs
index a4b77b1a7a3ef8..701972c19bb614 100644
--- a/crates/vim/src/vim.rs
+++ b/crates/vim/src/vim.rs
@@ -13,6 +13,7 @@ mod motion;
 mod normal;
 mod object;
 mod replace;
+mod rewrap;
 mod state;
 mod surrounds;
 mod visual;
@@ -291,6 +292,7 @@ impl Vim {
             command::register(editor, cx);
             replace::register(editor, cx);
             indent::register(editor, cx);
+            rewrap::register(editor, cx);
             object::register(editor, cx);
             visual::register(editor, cx);
             change_list::register(editor, cx);
diff --git a/crates/vim/test_data/test_gq.json b/crates/vim/test_data/test_gq.json
new file mode 100644
index 00000000000000..08cdb1231541e4
--- /dev/null
+++ b/crates/vim/test_data/test_gq.json
@@ -0,0 +1,12 @@
+{"SetOption":{"value":"textwidth=5"}}
+{"Put":{"state":"ˇth th th th th th\n"}}
+{"Key":"g"}
+{"Key":"q"}
+{"Key":"q"}
+{"Get":{"state":"th th\nth th\nˇth th\n","mode":"Normal"}}
+{"Put":{"state":"ˇth th th th th th\nth th th th th th\n"}}
+{"Key":"v"}
+{"Key":"j"}
+{"Key":"g"}
+{"Key":"q"}
+{"Get":{"state":"th th\nth th\nth th\nth th\nth th\nˇth th\n","mode":"Normal"}}

From 7d62fda5a38d1199e79c30177828dfac2a1ce4b3 Mon Sep 17 00:00:00 2001
From: CharlesChen0823 <yongchen0823@gmail.com>
Date: Sat, 21 Sep 2024 03:49:40 +0800
Subject: [PATCH 254/762] file_finder: Notify user when picker an non-utf8 file
 (#18136)

notify user when using file finder picker an file which cannot open.

Release Notes:

- N/A
---
 crates/file_finder/src/file_finder.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/file_finder/src/file_finder.rs b/crates/file_finder/src/file_finder.rs
index e1e0998f8aa3b6..4c3f92d3c156a0 100644
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -31,7 +31,7 @@ use std::{
 use text::Point;
 use ui::{prelude::*, HighlightedLabel, ListItem, ListItemSpacing};
 use util::{paths::PathWithPosition, post_inc, ResultExt};
-use workspace::{item::PreviewTabsSettings, ModalView, Workspace};
+use workspace::{item::PreviewTabsSettings, notifications::NotifyResultExt, ModalView, Workspace};
 
 actions!(file_finder, [SelectPrev]);
 
@@ -1011,7 +1011,7 @@ impl PickerDelegate for FileFinderDelegate {
                 let finder = self.file_finder.clone();
 
                 cx.spawn(|_, mut cx| async move {
-                    let item = open_task.await.log_err()?;
+                    let item = open_task.await.notify_async_err(&mut cx)?;
                     if let Some(row) = row {
                         if let Some(active_editor) = item.downcast::<Editor>() {
                             active_editor

From 5905fbb9accdc5d34b7fec0fe021022a5b38420e Mon Sep 17 00:00:00 2001
From: Roy Williams <roy@anthropic.com>
Date: Fri, 20 Sep 2024 16:59:12 -0400
Subject: [PATCH 255/762] Allow Anthropic custom models to override temperature
 (#18160)

Release Notes:

- Allow Anthropic custom models to override "temperature"

This also centralized the defaulting of "temperature" to be inside of
each model's `into_x` call instead of being sprinkled around the code.
---
 crates/anthropic/src/anthropic.rs                | 14 ++++++++++++++
 crates/assistant/src/context.rs                  |  2 +-
 crates/assistant/src/inline_assistant.rs         |  2 +-
 crates/assistant/src/prompt_library.rs           |  2 +-
 .../assistant/src/slash_command/auto_command.rs  |  2 +-
 .../assistant/src/terminal_inline_assistant.rs   |  2 +-
 crates/language_model/src/provider/anthropic.rs  | 10 ++++++++--
 crates/language_model/src/provider/cloud.rs      | 16 +++++++++++++---
 crates/language_model/src/provider/ollama.rs     |  2 +-
 crates/language_model/src/request.rs             | 15 ++++++++++-----
 crates/language_model/src/settings.rs            |  2 ++
 crates/semantic_index/src/summary_index.rs       |  2 +-
 12 files changed, 54 insertions(+), 17 deletions(-)

diff --git a/crates/anthropic/src/anthropic.rs b/crates/anthropic/src/anthropic.rs
index f960dc541a2866..91b6723e90be97 100644
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -49,6 +49,7 @@ pub enum Model {
         /// Indicates whether this custom model supports caching.
         cache_configuration: Option<AnthropicModelCacheConfiguration>,
         max_output_tokens: Option<u32>,
+        default_temperature: Option<f32>,
     },
 }
 
@@ -124,6 +125,19 @@ impl Model {
         }
     }
 
+    pub fn default_temperature(&self) -> f32 {
+        match self {
+            Self::Claude3_5Sonnet
+            | Self::Claude3Opus
+            | Self::Claude3Sonnet
+            | Self::Claude3Haiku => 1.0,
+            Self::Custom {
+                default_temperature,
+                ..
+            } => default_temperature.unwrap_or(1.0),
+        }
+    }
+
     pub fn tool_model_id(&self) -> &str {
         if let Self::Custom {
             tool_override: Some(tool_override),
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index 830c0980491f7c..97a5b3ea988bcc 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -2180,7 +2180,7 @@ impl Context {
             messages: Vec::new(),
             tools: Vec::new(),
             stop: Vec::new(),
-            temperature: 1.0,
+            temperature: None,
         };
         for message in self.messages(cx) {
             if message.status != MessageStatus::Done {
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index d95b54d3c6a6ac..f2428c3a2e94cf 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -2732,7 +2732,7 @@ impl CodegenAlternative {
             messages,
             tools: Vec::new(),
             stop: Vec::new(),
-            temperature: 1.,
+            temperature: None,
         })
     }
 
diff --git a/crates/assistant/src/prompt_library.rs b/crates/assistant/src/prompt_library.rs
index 76ee95d5070b82..24e20a18a799a6 100644
--- a/crates/assistant/src/prompt_library.rs
+++ b/crates/assistant/src/prompt_library.rs
@@ -796,7 +796,7 @@ impl PromptLibrary {
                                     }],
                                     tools: Vec::new(),
                                     stop: Vec::new(),
-                                    temperature: 1.,
+                                    temperature: None,
                                 },
                                 cx,
                             )
diff --git a/crates/assistant/src/slash_command/auto_command.rs b/crates/assistant/src/slash_command/auto_command.rs
index e1f20c311bd36e..14cee296820989 100644
--- a/crates/assistant/src/slash_command/auto_command.rs
+++ b/crates/assistant/src/slash_command/auto_command.rs
@@ -216,7 +216,7 @@ async fn commands_for_summaries(
         }],
         tools: Vec::new(),
         stop: Vec::new(),
-        temperature: 1.0,
+        temperature: None,
     };
 
     while let Some(current_summaries) = stack.pop() {
diff --git a/crates/assistant/src/terminal_inline_assistant.rs b/crates/assistant/src/terminal_inline_assistant.rs
index caf819bae535ee..e1a26d851003eb 100644
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -284,7 +284,7 @@ impl TerminalInlineAssistant {
             messages,
             tools: Vec::new(),
             stop: Vec::new(),
-            temperature: 1.0,
+            temperature: None,
         })
     }
 
diff --git a/crates/language_model/src/provider/anthropic.rs b/crates/language_model/src/provider/anthropic.rs
index 1e3d2750949f16..86538bec49172d 100644
--- a/crates/language_model/src/provider/anthropic.rs
+++ b/crates/language_model/src/provider/anthropic.rs
@@ -51,6 +51,7 @@ pub struct AvailableModel {
     /// Configuration of Anthropic's caching API.
     pub cache_configuration: Option<LanguageModelCacheConfiguration>,
     pub max_output_tokens: Option<u32>,
+    pub default_temperature: Option<f32>,
 }
 
 pub struct AnthropicLanguageModelProvider {
@@ -200,6 +201,7 @@ impl LanguageModelProvider for AnthropicLanguageModelProvider {
                         }
                     }),
                     max_output_tokens: model.max_output_tokens,
+                    default_temperature: model.default_temperature,
                 },
             );
         }
@@ -375,8 +377,11 @@ impl LanguageModel for AnthropicModel {
         request: LanguageModelRequest,
         cx: &AsyncAppContext,
     ) -> BoxFuture<'static, Result<BoxStream<'static, Result<LanguageModelCompletionEvent>>>> {
-        let request =
-            request.into_anthropic(self.model.id().into(), self.model.max_output_tokens());
+        let request = request.into_anthropic(
+            self.model.id().into(),
+            self.model.default_temperature(),
+            self.model.max_output_tokens(),
+        );
         let request = self.stream_completion(request, cx);
         let future = self.request_limiter.stream(async move {
             let response = request.await.map_err(|err| anyhow!(err))?;
@@ -405,6 +410,7 @@ impl LanguageModel for AnthropicModel {
     ) -> BoxFuture<'static, Result<BoxStream<'static, Result<String>>>> {
         let mut request = request.into_anthropic(
             self.model.tool_model_id().into(),
+            self.model.default_temperature(),
             self.model.max_output_tokens(),
         );
         request.tool_choice = Some(anthropic::ToolChoice::Tool {
diff --git a/crates/language_model/src/provider/cloud.rs b/crates/language_model/src/provider/cloud.rs
index 58efb4cfe1b308..606a6fbacec7b0 100644
--- a/crates/language_model/src/provider/cloud.rs
+++ b/crates/language_model/src/provider/cloud.rs
@@ -87,6 +87,8 @@ pub struct AvailableModel {
     pub tool_override: Option<String>,
     /// Indicates whether this custom model supports caching.
     pub cache_configuration: Option<LanguageModelCacheConfiguration>,
+    /// The default temperature to use for this model.
+    pub default_temperature: Option<f32>,
 }
 
 pub struct CloudLanguageModelProvider {
@@ -255,6 +257,7 @@ impl LanguageModelProvider for CloudLanguageModelProvider {
                             min_total_token: config.min_total_token,
                         }
                     }),
+                    default_temperature: model.default_temperature,
                     max_output_tokens: model.max_output_tokens,
                 }),
                 AvailableProvider::OpenAi => CloudModel::OpenAi(open_ai::Model::Custom {
@@ -516,7 +519,11 @@ impl LanguageModel for CloudLanguageModel {
 
         match &self.model {
             CloudModel::Anthropic(model) => {
-                let request = request.into_anthropic(model.id().into(), model.max_output_tokens());
+                let request = request.into_anthropic(
+                    model.id().into(),
+                    model.default_temperature(),
+                    model.max_output_tokens(),
+                );
                 let client = self.client.clone();
                 let llm_api_token = self.llm_api_token.clone();
                 let future = self.request_limiter.stream(async move {
@@ -642,8 +649,11 @@ impl LanguageModel for CloudLanguageModel {
 
         match &self.model {
             CloudModel::Anthropic(model) => {
-                let mut request =
-                    request.into_anthropic(model.tool_model_id().into(), model.max_output_tokens());
+                let mut request = request.into_anthropic(
+                    model.tool_model_id().into(),
+                    model.default_temperature(),
+                    model.max_output_tokens(),
+                );
                 request.tool_choice = Some(anthropic::ToolChoice::Tool {
                     name: tool_name.clone(),
                 });
diff --git a/crates/language_model/src/provider/ollama.rs b/crates/language_model/src/provider/ollama.rs
index 6a3190dee7c229..a29ff3cf6a7a1a 100644
--- a/crates/language_model/src/provider/ollama.rs
+++ b/crates/language_model/src/provider/ollama.rs
@@ -235,7 +235,7 @@ impl OllamaLanguageModel {
             options: Some(ChatOptions {
                 num_ctx: Some(self.model.max_tokens),
                 stop: Some(request.stop),
-                temperature: Some(request.temperature),
+                temperature: request.temperature.or(Some(1.0)),
                 ..Default::default()
             }),
             tools: vec![],
diff --git a/crates/language_model/src/request.rs b/crates/language_model/src/request.rs
index dd480b8aaf38c2..06dde1862ab37e 100644
--- a/crates/language_model/src/request.rs
+++ b/crates/language_model/src/request.rs
@@ -236,7 +236,7 @@ pub struct LanguageModelRequest {
     pub messages: Vec<LanguageModelRequestMessage>,
     pub tools: Vec<LanguageModelRequestTool>,
     pub stop: Vec<String>,
-    pub temperature: f32,
+    pub temperature: Option<f32>,
 }
 
 impl LanguageModelRequest {
@@ -262,7 +262,7 @@ impl LanguageModelRequest {
                 .collect(),
             stream,
             stop: self.stop,
-            temperature: self.temperature,
+            temperature: self.temperature.unwrap_or(1.0),
             max_tokens: max_output_tokens,
             tools: Vec::new(),
             tool_choice: None,
@@ -290,7 +290,7 @@ impl LanguageModelRequest {
                 candidate_count: Some(1),
                 stop_sequences: Some(self.stop),
                 max_output_tokens: None,
-                temperature: Some(self.temperature as f64),
+                temperature: self.temperature.map(|t| t as f64).or(Some(1.0)),
                 top_p: None,
                 top_k: None,
             }),
@@ -298,7 +298,12 @@ impl LanguageModelRequest {
         }
     }
 
-    pub fn into_anthropic(self, model: String, max_output_tokens: u32) -> anthropic::Request {
+    pub fn into_anthropic(
+        self,
+        model: String,
+        default_temperature: f32,
+        max_output_tokens: u32,
+    ) -> anthropic::Request {
         let mut new_messages: Vec<anthropic::Message> = Vec::new();
         let mut system_message = String::new();
 
@@ -400,7 +405,7 @@ impl LanguageModelRequest {
             tool_choice: None,
             metadata: None,
             stop_sequences: Vec::new(),
-            temperature: Some(self.temperature),
+            temperature: self.temperature.or(Some(default_temperature)),
             top_k: None,
             top_p: None,
         }
diff --git a/crates/language_model/src/settings.rs b/crates/language_model/src/settings.rs
index 8888d51e11c255..2bf8deb04238c2 100644
--- a/crates/language_model/src/settings.rs
+++ b/crates/language_model/src/settings.rs
@@ -99,6 +99,7 @@ impl AnthropicSettingsContent {
                                     tool_override,
                                     cache_configuration,
                                     max_output_tokens,
+                                    default_temperature,
                                 } => Some(provider::anthropic::AvailableModel {
                                     name,
                                     display_name,
@@ -112,6 +113,7 @@ impl AnthropicSettingsContent {
                                         },
                                     ),
                                     max_output_tokens,
+                                    default_temperature,
                                 }),
                                 _ => None,
                             })
diff --git a/crates/semantic_index/src/summary_index.rs b/crates/semantic_index/src/summary_index.rs
index 08f25ae0287fa2..f4c6d4726c508b 100644
--- a/crates/semantic_index/src/summary_index.rs
+++ b/crates/semantic_index/src/summary_index.rs
@@ -562,7 +562,7 @@ impl SummaryIndex {
             }],
             tools: Vec::new(),
             stop: Vec::new(),
-            temperature: 1.0,
+            temperature: None,
         };
 
         let code_len = code.len();

From e309fbda2a95a55a043ad41ead97c568c7aeef19 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Fri, 20 Sep 2024 15:09:18 -0700
Subject: [PATCH 256/762] Add a slash command for automatically retrieving
 relevant context (#17972)

* [x] put this slash command behind a feature flag until we release
embedding access to the general population
* [x] choose a name for this slash command and name the rust module to
match

Release Notes:

- N/A

---------

Co-authored-by: Jason <jason@zed.dev>
Co-authored-by: Richard <richard@zed.dev>
Co-authored-by: Jason Mancuso <7891333+jvmncs@users.noreply.github.com>
Co-authored-by: Richard Feldman <oss@rtfeldman.com>
---
 assets/prompts/project_slash_command.hbs      |   8 +
 crates/assistant/src/assistant.rs             |  32 ++-
 crates/assistant/src/context.rs               |   5 +-
 crates/assistant/src/prompts.rs               |  15 +
 crates/assistant/src/slash_command.rs         |   2 +-
 .../slash_command/cargo_workspace_command.rs  | 153 ++++++++++
 .../src/slash_command/project_command.rs      | 259 +++++++++--------
 .../src/slash_command/search_command.rs       |  63 +++--
 .../assistant/src/slash_command_settings.rs   |  10 +-
 crates/evals/src/eval.rs                      |   2 +-
 crates/semantic_index/examples/index.rs       |   2 +-
 crates/semantic_index/src/embedding.rs        |  23 +-
 crates/semantic_index/src/project_index.rs    |  61 ++--
 crates/semantic_index/src/semantic_index.rs   | 265 +++++++++++++++---
 14 files changed, 680 insertions(+), 220 deletions(-)
 create mode 100644 assets/prompts/project_slash_command.hbs
 create mode 100644 crates/assistant/src/slash_command/cargo_workspace_command.rs

diff --git a/assets/prompts/project_slash_command.hbs b/assets/prompts/project_slash_command.hbs
new file mode 100644
index 00000000000000..6c63f71d895274
--- /dev/null
+++ b/assets/prompts/project_slash_command.hbs
@@ -0,0 +1,8 @@
+A software developer is asking a question about their project. The source files in their project have been indexed into a database of semantic text embeddings.
+Your task is to generate a list of 4 diverse search queries that can be run on this embedding database, in order to retrieve a list of code snippets
+that are relevant to the developer's question. Redundant search queries will be heavily penalized, so only include another query if it's sufficiently
+distinct from previous ones.
+
+Here is the question that's been asked, together with context that the developer has added manually:
+
+{{{context_buffer}}}
diff --git a/crates/assistant/src/assistant.rs b/crates/assistant/src/assistant.rs
index 8b9c66ee55848d..9cc63af5a1adee 100644
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -41,9 +41,10 @@ use semantic_index::{CloudEmbeddingProvider, SemanticDb};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings, SettingsStore};
 use slash_command::{
-    auto_command, context_server_command, default_command, delta_command, diagnostics_command,
-    docs_command, fetch_command, file_command, now_command, project_command, prompt_command,
-    search_command, symbols_command, tab_command, terminal_command, workflow_command,
+    auto_command, cargo_workspace_command, context_server_command, default_command, delta_command,
+    diagnostics_command, docs_command, fetch_command, file_command, now_command, project_command,
+    prompt_command, search_command, symbols_command, tab_command, terminal_command,
+    workflow_command,
 };
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -384,20 +385,33 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
     slash_command_registry.register_command(delta_command::DeltaSlashCommand, true);
     slash_command_registry.register_command(symbols_command::OutlineSlashCommand, true);
     slash_command_registry.register_command(tab_command::TabSlashCommand, true);
-    slash_command_registry.register_command(project_command::ProjectSlashCommand, true);
+    slash_command_registry
+        .register_command(cargo_workspace_command::CargoWorkspaceSlashCommand, true);
     slash_command_registry.register_command(prompt_command::PromptSlashCommand, true);
     slash_command_registry.register_command(default_command::DefaultSlashCommand, false);
     slash_command_registry.register_command(terminal_command::TerminalSlashCommand, true);
     slash_command_registry.register_command(now_command::NowSlashCommand, false);
     slash_command_registry.register_command(diagnostics_command::DiagnosticsSlashCommand, true);
+    slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
 
     if let Some(prompt_builder) = prompt_builder {
         slash_command_registry.register_command(
             workflow_command::WorkflowSlashCommand::new(prompt_builder.clone()),
             true,
         );
+        cx.observe_flag::<project_command::ProjectSlashCommandFeatureFlag, _>({
+            let slash_command_registry = slash_command_registry.clone();
+            move |is_enabled, _cx| {
+                if is_enabled {
+                    slash_command_registry.register_command(
+                        project_command::ProjectSlashCommand::new(prompt_builder.clone()),
+                        true,
+                    );
+                }
+            }
+        })
+        .detach();
     }
-    slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
 
     cx.observe_flag::<auto_command::AutoSlashCommandFeatureFlag, _>({
         let slash_command_registry = slash_command_registry.clone();
@@ -435,10 +449,12 @@ fn update_slash_commands_from_settings(cx: &mut AppContext) {
         slash_command_registry.unregister_command(docs_command::DocsSlashCommand);
     }
 
-    if settings.project.enabled {
-        slash_command_registry.register_command(project_command::ProjectSlashCommand, true);
+    if settings.cargo_workspace.enabled {
+        slash_command_registry
+            .register_command(cargo_workspace_command::CargoWorkspaceSlashCommand, true);
     } else {
-        slash_command_registry.unregister_command(project_command::ProjectSlashCommand);
+        slash_command_registry
+            .unregister_command(cargo_workspace_command::CargoWorkspaceSlashCommand);
     }
 }
 
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index 97a5b3ea988bcc..1cac47831f52dc 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -1967,8 +1967,9 @@ impl Context {
     }
 
     pub fn assist(&mut self, cx: &mut ModelContext<Self>) -> Option<MessageAnchor> {
-        let provider = LanguageModelRegistry::read_global(cx).active_provider()?;
-        let model = LanguageModelRegistry::read_global(cx).active_model()?;
+        let model_registry = LanguageModelRegistry::read_global(cx);
+        let provider = model_registry.active_provider()?;
+        let model = model_registry.active_model()?;
         let last_message_id = self.get_last_valid_message_id(cx)?;
 
         if !provider.is_authenticated(cx) {
diff --git a/crates/assistant/src/prompts.rs b/crates/assistant/src/prompts.rs
index 3b9f75bac930b6..106935cb882695 100644
--- a/crates/assistant/src/prompts.rs
+++ b/crates/assistant/src/prompts.rs
@@ -40,6 +40,11 @@ pub struct TerminalAssistantPromptContext {
     pub user_prompt: String,
 }
 
+#[derive(Serialize)]
+pub struct ProjectSlashCommandPromptContext {
+    pub context_buffer: String,
+}
+
 /// Context required to generate a workflow step resolution prompt.
 #[derive(Debug, Serialize)]
 pub struct StepResolutionContext {
@@ -317,4 +322,14 @@ impl PromptBuilder {
     pub fn generate_workflow_prompt(&self) -> Result<String, RenderError> {
         self.handlebars.lock().render("edit_workflow", &())
     }
+
+    pub fn generate_project_slash_command_prompt(
+        &self,
+        context_buffer: String,
+    ) -> Result<String, RenderError> {
+        self.handlebars.lock().render(
+            "project_slash_command",
+            &ProjectSlashCommandPromptContext { context_buffer },
+        )
+    }
 }
diff --git a/crates/assistant/src/slash_command.rs b/crates/assistant/src/slash_command.rs
index cf957a15c67d9d..e430e35622a222 100644
--- a/crates/assistant/src/slash_command.rs
+++ b/crates/assistant/src/slash_command.rs
@@ -18,8 +18,8 @@ use std::{
 };
 use ui::ActiveTheme;
 use workspace::Workspace;
-
 pub mod auto_command;
+pub mod cargo_workspace_command;
 pub mod context_server_command;
 pub mod default_command;
 pub mod delta_command;
diff --git a/crates/assistant/src/slash_command/cargo_workspace_command.rs b/crates/assistant/src/slash_command/cargo_workspace_command.rs
new file mode 100644
index 00000000000000..baf16d7f014cb2
--- /dev/null
+++ b/crates/assistant/src/slash_command/cargo_workspace_command.rs
@@ -0,0 +1,153 @@
+use super::{SlashCommand, SlashCommandOutput};
+use anyhow::{anyhow, Context, Result};
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
+use fs::Fs;
+use gpui::{AppContext, Model, Task, WeakView};
+use language::{BufferSnapshot, LspAdapterDelegate};
+use project::{Project, ProjectPath};
+use std::{
+    fmt::Write,
+    path::Path,
+    sync::{atomic::AtomicBool, Arc},
+};
+use ui::prelude::*;
+use workspace::Workspace;
+
+pub(crate) struct CargoWorkspaceSlashCommand;
+
+impl CargoWorkspaceSlashCommand {
+    async fn build_message(fs: Arc<dyn Fs>, path_to_cargo_toml: &Path) -> Result<String> {
+        let buffer = fs.load(path_to_cargo_toml).await?;
+        let cargo_toml: cargo_toml::Manifest = toml::from_str(&buffer)?;
+
+        let mut message = String::new();
+        writeln!(message, "You are in a Rust project.")?;
+
+        if let Some(workspace) = cargo_toml.workspace {
+            writeln!(
+                message,
+                "The project is a Cargo workspace with the following members:"
+            )?;
+            for member in workspace.members {
+                writeln!(message, "- {member}")?;
+            }
+
+            if !workspace.default_members.is_empty() {
+                writeln!(message, "The default members are:")?;
+                for member in workspace.default_members {
+                    writeln!(message, "- {member}")?;
+                }
+            }
+
+            if !workspace.dependencies.is_empty() {
+                writeln!(
+                    message,
+                    "The following workspace dependencies are installed:"
+                )?;
+                for dependency in workspace.dependencies.keys() {
+                    writeln!(message, "- {dependency}")?;
+                }
+            }
+        } else if let Some(package) = cargo_toml.package {
+            writeln!(
+                message,
+                "The project name is \"{name}\".",
+                name = package.name
+            )?;
+
+            let description = package
+                .description
+                .as_ref()
+                .and_then(|description| description.get().ok().cloned());
+            if let Some(description) = description.as_ref() {
+                writeln!(message, "It describes itself as \"{description}\".")?;
+            }
+
+            if !cargo_toml.dependencies.is_empty() {
+                writeln!(message, "The following dependencies are installed:")?;
+                for dependency in cargo_toml.dependencies.keys() {
+                    writeln!(message, "- {dependency}")?;
+                }
+            }
+        }
+
+        Ok(message)
+    }
+
+    fn path_to_cargo_toml(project: Model<Project>, cx: &mut AppContext) -> Option<Arc<Path>> {
+        let worktree = project.read(cx).worktrees(cx).next()?;
+        let worktree = worktree.read(cx);
+        let entry = worktree.entry_for_path("Cargo.toml")?;
+        let path = ProjectPath {
+            worktree_id: worktree.id(),
+            path: entry.path.clone(),
+        };
+        Some(Arc::from(
+            project.read(cx).absolute_path(&path, cx)?.as_path(),
+        ))
+    }
+}
+
+impl SlashCommand for CargoWorkspaceSlashCommand {
+    fn name(&self) -> String {
+        "cargo-workspace".into()
+    }
+
+    fn description(&self) -> String {
+        "insert project workspace metadata".into()
+    }
+
+    fn menu_text(&self) -> String {
+        "Insert Project Workspace Metadata".into()
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        _arguments: &[String],
+        _cancel: Arc<AtomicBool>,
+        _workspace: Option<WeakView<Workspace>>,
+        _cx: &mut WindowContext,
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        Task::ready(Err(anyhow!("this command does not require argument")))
+    }
+
+    fn requires_argument(&self) -> bool {
+        false
+    }
+
+    fn run(
+        self: Arc<Self>,
+        _arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
+        workspace: WeakView<Workspace>,
+        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let output = workspace.update(cx, |workspace, cx| {
+            let project = workspace.project().clone();
+            let fs = workspace.project().read(cx).fs().clone();
+            let path = Self::path_to_cargo_toml(project, cx);
+            let output = cx.background_executor().spawn(async move {
+                let path = path.with_context(|| "Cargo.toml not found")?;
+                Self::build_message(fs, &path).await
+            });
+
+            cx.foreground_executor().spawn(async move {
+                let text = output.await?;
+                let range = 0..text.len();
+                Ok(SlashCommandOutput {
+                    text,
+                    sections: vec![SlashCommandOutputSection {
+                        range,
+                        icon: IconName::FileTree,
+                        label: "Project".into(),
+                        metadata: None,
+                    }],
+                    run_commands_in_text: false,
+                })
+            })
+        });
+        output.unwrap_or_else(|error| Task::ready(Err(error)))
+    }
+}
diff --git a/crates/assistant/src/slash_command/project_command.rs b/crates/assistant/src/slash_command/project_command.rs
index 3e8596d942bf61..197e91d91addac 100644
--- a/crates/assistant/src/slash_command/project_command.rs
+++ b/crates/assistant/src/slash_command/project_command.rs
@@ -1,90 +1,39 @@
-use super::{SlashCommand, SlashCommandOutput};
-use anyhow::{anyhow, Context, Result};
+use super::{
+    create_label_for_command, search_command::add_search_result_section, SlashCommand,
+    SlashCommandOutput,
+};
+use crate::PromptBuilder;
+use anyhow::{anyhow, Result};
 use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
-use fs::Fs;
-use gpui::{AppContext, Model, Task, WeakView};
-use language::{BufferSnapshot, LspAdapterDelegate};
-use project::{Project, ProjectPath};
+use feature_flags::FeatureFlag;
+use gpui::{AppContext, Task, WeakView, WindowContext};
+use language::{Anchor, CodeLabel, LspAdapterDelegate};
+use language_model::{LanguageModelRegistry, LanguageModelTool};
+use schemars::JsonSchema;
+use semantic_index::SemanticDb;
+use serde::Deserialize;
+
+pub struct ProjectSlashCommandFeatureFlag;
+
+impl FeatureFlag for ProjectSlashCommandFeatureFlag {
+    const NAME: &'static str = "project-slash-command";
+}
+
 use std::{
-    fmt::Write,
-    path::Path,
+    fmt::Write as _,
+    ops::DerefMut,
     sync::{atomic::AtomicBool, Arc},
 };
-use ui::prelude::*;
+use ui::{BorrowAppContext as _, IconName};
 use workspace::Workspace;
 
-pub(crate) struct ProjectSlashCommand;
+pub struct ProjectSlashCommand {
+    prompt_builder: Arc<PromptBuilder>,
+}
 
 impl ProjectSlashCommand {
-    async fn build_message(fs: Arc<dyn Fs>, path_to_cargo_toml: &Path) -> Result<String> {
-        let buffer = fs.load(path_to_cargo_toml).await?;
-        let cargo_toml: cargo_toml::Manifest = toml::from_str(&buffer)?;
-
-        let mut message = String::new();
-        writeln!(message, "You are in a Rust project.")?;
-
-        if let Some(workspace) = cargo_toml.workspace {
-            writeln!(
-                message,
-                "The project is a Cargo workspace with the following members:"
-            )?;
-            for member in workspace.members {
-                writeln!(message, "- {member}")?;
-            }
-
-            if !workspace.default_members.is_empty() {
-                writeln!(message, "The default members are:")?;
-                for member in workspace.default_members {
-                    writeln!(message, "- {member}")?;
-                }
-            }
-
-            if !workspace.dependencies.is_empty() {
-                writeln!(
-                    message,
-                    "The following workspace dependencies are installed:"
-                )?;
-                for dependency in workspace.dependencies.keys() {
-                    writeln!(message, "- {dependency}")?;
-                }
-            }
-        } else if let Some(package) = cargo_toml.package {
-            writeln!(
-                message,
-                "The project name is \"{name}\".",
-                name = package.name
-            )?;
-
-            let description = package
-                .description
-                .as_ref()
-                .and_then(|description| description.get().ok().cloned());
-            if let Some(description) = description.as_ref() {
-                writeln!(message, "It describes itself as \"{description}\".")?;
-            }
-
-            if !cargo_toml.dependencies.is_empty() {
-                writeln!(message, "The following dependencies are installed:")?;
-                for dependency in cargo_toml.dependencies.keys() {
-                    writeln!(message, "- {dependency}")?;
-                }
-            }
-        }
-
-        Ok(message)
-    }
-
-    fn path_to_cargo_toml(project: Model<Project>, cx: &mut AppContext) -> Option<Arc<Path>> {
-        let worktree = project.read(cx).worktrees(cx).next()?;
-        let worktree = worktree.read(cx);
-        let entry = worktree.entry_for_path("Cargo.toml")?;
-        let path = ProjectPath {
-            worktree_id: worktree.id(),
-            path: entry.path.clone(),
-        };
-        Some(Arc::from(
-            project.read(cx).absolute_path(&path, cx)?.as_path(),
-        ))
+    pub fn new(prompt_builder: Arc<PromptBuilder>) -> Self {
+        Self { prompt_builder }
     }
 }
 
@@ -93,12 +42,20 @@ impl SlashCommand for ProjectSlashCommand {
         "project".into()
     }
 
+    fn label(&self, cx: &AppContext) -> CodeLabel {
+        create_label_for_command("project", &[], cx)
+    }
+
     fn description(&self) -> String {
-        "insert project metadata".into()
+        "Generate semantic searches based on the current context".into()
     }
 
     fn menu_text(&self) -> String {
-        "Insert Project Metadata".into()
+        "Project Context".into()
+    }
+
+    fn requires_argument(&self) -> bool {
+        false
     }
 
     fn complete_argument(
@@ -108,46 +65,126 @@ impl SlashCommand for ProjectSlashCommand {
         _workspace: Option<WeakView<Workspace>>,
         _cx: &mut WindowContext,
     ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        Task::ready(Err(anyhow!("this command does not require argument")))
-    }
-
-    fn requires_argument(&self) -> bool {
-        false
+        Task::ready(Ok(Vec::new()))
     }
 
     fn run(
         self: Arc<Self>,
         _arguments: &[String],
-        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
-        _context_buffer: BufferSnapshot,
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<Anchor>],
+        context_buffer: language::BufferSnapshot,
         workspace: WeakView<Workspace>,
         _delegate: Option<Arc<dyn LspAdapterDelegate>>,
         cx: &mut WindowContext,
     ) -> Task<Result<SlashCommandOutput>> {
-        let output = workspace.update(cx, |workspace, cx| {
-            let project = workspace.project().clone();
-            let fs = workspace.project().read(cx).fs().clone();
-            let path = Self::path_to_cargo_toml(project, cx);
-            let output = cx.background_executor().spawn(async move {
-                let path = path.with_context(|| "Cargo.toml not found")?;
-                Self::build_message(fs, &path).await
-            });
-
-            cx.foreground_executor().spawn(async move {
-                let text = output.await?;
-                let range = 0..text.len();
-                Ok(SlashCommandOutput {
-                    text,
-                    sections: vec![SlashCommandOutputSection {
-                        range,
-                        icon: IconName::FileTree,
-                        label: "Project".into(),
+        let model_registry = LanguageModelRegistry::read_global(cx);
+        let current_model = model_registry.active_model();
+        let prompt_builder = self.prompt_builder.clone();
+
+        let Some(workspace) = workspace.upgrade() else {
+            return Task::ready(Err(anyhow::anyhow!("workspace was dropped")));
+        };
+        let project = workspace.read(cx).project().clone();
+        let fs = project.read(cx).fs().clone();
+        let Some(project_index) =
+            cx.update_global(|index: &mut SemanticDb, cx| index.project_index(project, cx))
+        else {
+            return Task::ready(Err(anyhow::anyhow!("no project indexer")));
+        };
+
+        cx.spawn(|mut cx| async move {
+            let current_model = current_model.ok_or_else(|| anyhow!("no model selected"))?;
+
+            let prompt =
+                prompt_builder.generate_project_slash_command_prompt(context_buffer.text())?;
+
+            let search_queries = current_model
+                .use_tool::<SearchQueries>(
+                    language_model::LanguageModelRequest {
+                        messages: vec![language_model::LanguageModelRequestMessage {
+                            role: language_model::Role::User,
+                            content: vec![language_model::MessageContent::Text(prompt)],
+                            cache: false,
+                        }],
+                        tools: vec![],
+                        stop: vec![],
+                        temperature: None,
+                    },
+                    cx.deref_mut(),
+                )
+                .await?
+                .search_queries;
+
+            let results = project_index
+                .read_with(&cx, |project_index, cx| {
+                    project_index.search(search_queries.clone(), 25, cx)
+                })?
+                .await?;
+
+            let results = SemanticDb::load_results(results, &fs, &cx).await?;
+
+            cx.background_executor()
+                .spawn(async move {
+                    let mut output = "Project context:\n".to_string();
+                    let mut sections = Vec::new();
+
+                    for (ix, query) in search_queries.into_iter().enumerate() {
+                        let start_ix = output.len();
+                        writeln!(&mut output, "Results for {query}:").unwrap();
+                        let mut has_results = false;
+                        for result in &results {
+                            if result.query_index == ix {
+                                add_search_result_section(result, &mut output, &mut sections);
+                                has_results = true;
+                            }
+                        }
+                        if has_results {
+                            sections.push(SlashCommandOutputSection {
+                                range: start_ix..output.len(),
+                                icon: IconName::MagnifyingGlass,
+                                label: query.into(),
+                                metadata: None,
+                            });
+                            output.push('\n');
+                        } else {
+                            output.truncate(start_ix);
+                        }
+                    }
+
+                    sections.push(SlashCommandOutputSection {
+                        range: 0..output.len(),
+                        icon: IconName::Book,
+                        label: "Project context".into(),
                         metadata: None,
-                    }],
-                    run_commands_in_text: false,
+                    });
+
+                    Ok(SlashCommandOutput {
+                        text: output,
+                        sections,
+                        run_commands_in_text: true,
+                    })
                 })
-            })
-        });
-        output.unwrap_or_else(|error| Task::ready(Err(error)))
+                .await
+        })
+    }
+}
+
+#[derive(JsonSchema, Deserialize)]
+struct SearchQueries {
+    /// An array of semantic search queries.
+    ///
+    /// These queries will be used to search the user's codebase.
+    /// The function can only accept 4 queries, otherwise it will error.
+    /// As such, it's important that you limit the length of the search_queries array to 5 queries or less.
+    search_queries: Vec<String>,
+}
+
+impl LanguageModelTool for SearchQueries {
+    fn name() -> String {
+        "search_queries".to_string()
+    }
+
+    fn description() -> String {
+        "Generate semantic search queries based on context".to_string()
     }
 }
diff --git a/crates/assistant/src/slash_command/search_command.rs b/crates/assistant/src/slash_command/search_command.rs
index 7e408cad396a45..f0f3ee3d25c660 100644
--- a/crates/assistant/src/slash_command/search_command.rs
+++ b/crates/assistant/src/slash_command/search_command.rs
@@ -7,7 +7,7 @@ use anyhow::Result;
 use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use feature_flags::FeatureFlag;
 use gpui::{AppContext, Task, WeakView};
-use language::{CodeLabel, LineEnding, LspAdapterDelegate};
+use language::{CodeLabel, LspAdapterDelegate};
 use semantic_index::{LoadedSearchResult, SemanticDb};
 use std::{
     fmt::Write,
@@ -101,7 +101,7 @@ impl SlashCommand for SearchSlashCommand {
         cx.spawn(|cx| async move {
             let results = project_index
                 .read_with(&cx, |project_index, cx| {
-                    project_index.search(query.clone(), limit.unwrap_or(5), cx)
+                    project_index.search(vec![query.clone()], limit.unwrap_or(5), cx)
                 })?
                 .await?;
 
@@ -112,31 +112,8 @@ impl SlashCommand for SearchSlashCommand {
                 .spawn(async move {
                     let mut text = format!("Search results for {query}:\n");
                     let mut sections = Vec::new();
-                    for LoadedSearchResult {
-                        path,
-                        range,
-                        full_path,
-                        file_content,
-                        row_range,
-                    } in loaded_results
-                    {
-                        let section_start_ix = text.len();
-                        text.push_str(&codeblock_fence_for_path(
-                            Some(&path),
-                            Some(row_range.clone()),
-                        ));
-
-                        let mut excerpt = file_content[range].to_string();
-                        LineEnding::normalize(&mut excerpt);
-                        text.push_str(&excerpt);
-                        writeln!(text, "\n```\n").unwrap();
-                        let section_end_ix = text.len() - 1;
-                        sections.push(build_entry_output_section(
-                            section_start_ix..section_end_ix,
-                            Some(&full_path),
-                            false,
-                            Some(row_range.start() + 1..row_range.end() + 1),
-                        ));
+                    for loaded_result in &loaded_results {
+                        add_search_result_section(loaded_result, &mut text, &mut sections);
                     }
 
                     let query = SharedString::from(query);
@@ -159,3 +136,35 @@ impl SlashCommand for SearchSlashCommand {
         })
     }
 }
+
+pub fn add_search_result_section(
+    loaded_result: &LoadedSearchResult,
+    text: &mut String,
+    sections: &mut Vec<SlashCommandOutputSection<usize>>,
+) {
+    let LoadedSearchResult {
+        path,
+        full_path,
+        excerpt_content,
+        row_range,
+        ..
+    } = loaded_result;
+    let section_start_ix = text.len();
+    text.push_str(&codeblock_fence_for_path(
+        Some(&path),
+        Some(row_range.clone()),
+    ));
+
+    text.push_str(&excerpt_content);
+    if !text.ends_with('\n') {
+        text.push('\n');
+    }
+    writeln!(text, "```\n").unwrap();
+    let section_end_ix = text.len() - 1;
+    sections.push(build_entry_output_section(
+        section_start_ix..section_end_ix,
+        Some(&full_path),
+        false,
+        Some(row_range.start() + 1..row_range.end() + 1),
+    ));
+}
diff --git a/crates/assistant/src/slash_command_settings.rs b/crates/assistant/src/slash_command_settings.rs
index eda950b6a222cf..c524b37803edea 100644
--- a/crates/assistant/src/slash_command_settings.rs
+++ b/crates/assistant/src/slash_command_settings.rs
@@ -10,9 +10,9 @@ pub struct SlashCommandSettings {
     /// Settings for the `/docs` slash command.
     #[serde(default)]
     pub docs: DocsCommandSettings,
-    /// Settings for the `/project` slash command.
+    /// Settings for the `/cargo-workspace` slash command.
     #[serde(default)]
-    pub project: ProjectCommandSettings,
+    pub cargo_workspace: CargoWorkspaceCommandSettings,
 }
 
 /// Settings for the `/docs` slash command.
@@ -23,10 +23,10 @@ pub struct DocsCommandSettings {
     pub enabled: bool,
 }
 
-/// Settings for the `/project` slash command.
+/// Settings for the `/cargo-workspace` slash command.
 #[derive(Deserialize, Serialize, Debug, Default, Clone, JsonSchema)]
-pub struct ProjectCommandSettings {
-    /// Whether `/project` is enabled.
+pub struct CargoWorkspaceCommandSettings {
+    /// Whether `/cargo-workspace` is enabled.
     #[serde(default)]
     pub enabled: bool,
 }
diff --git a/crates/evals/src/eval.rs b/crates/evals/src/eval.rs
index 0580053373c54c..e2c8b42644a31d 100644
--- a/crates/evals/src/eval.rs
+++ b/crates/evals/src/eval.rs
@@ -438,7 +438,7 @@ async fn run_eval_project(
             loop {
                 match cx.update(|cx| {
                     let project_index = project_index.read(cx);
-                    project_index.search(query.query.clone(), SEARCH_RESULT_LIMIT, cx)
+                    project_index.search(vec![query.query.clone()], SEARCH_RESULT_LIMIT, cx)
                 }) {
                     Ok(task) => match task.await {
                         Ok(answer) => {
diff --git a/crates/semantic_index/examples/index.rs b/crates/semantic_index/examples/index.rs
index 0cc3f9f317b08f..c5c2c633a10603 100644
--- a/crates/semantic_index/examples/index.rs
+++ b/crates/semantic_index/examples/index.rs
@@ -98,7 +98,7 @@ fn main() {
                 .update(|cx| {
                     let project_index = project_index.read(cx);
                     let query = "converting an anchor to a point";
-                    project_index.search(query.into(), 4, cx)
+                    project_index.search(vec![query.into()], 4, cx)
                 })
                 .unwrap()
                 .await
diff --git a/crates/semantic_index/src/embedding.rs b/crates/semantic_index/src/embedding.rs
index b05c4ac9da0ef2..1e1e0f0be71816 100644
--- a/crates/semantic_index/src/embedding.rs
+++ b/crates/semantic_index/src/embedding.rs
@@ -42,14 +42,23 @@ impl Embedding {
         self.0.len()
     }
 
-    pub fn similarity(self, other: &Embedding) -> f32 {
-        debug_assert_eq!(self.0.len(), other.0.len());
-        self.0
+    pub fn similarity(&self, others: &[Embedding]) -> (f32, usize) {
+        debug_assert!(others.iter().all(|other| self.0.len() == other.0.len()));
+        others
             .iter()
-            .copied()
-            .zip(other.0.iter().copied())
-            .map(|(a, b)| a * b)
-            .sum()
+            .enumerate()
+            .map(|(index, other)| {
+                let dot_product: f32 = self
+                    .0
+                    .iter()
+                    .copied()
+                    .zip(other.0.iter().copied())
+                    .map(|(a, b)| a * b)
+                    .sum();
+                (dot_product, index)
+            })
+            .max_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal))
+            .unwrap_or((0.0, 0))
     }
 }
 
diff --git a/crates/semantic_index/src/project_index.rs b/crates/semantic_index/src/project_index.rs
index 5c35c93fa943a7..21c036d60a9bcb 100644
--- a/crates/semantic_index/src/project_index.rs
+++ b/crates/semantic_index/src/project_index.rs
@@ -31,20 +31,23 @@ pub struct SearchResult {
     pub path: Arc<Path>,
     pub range: Range<usize>,
     pub score: f32,
+    pub query_index: usize,
 }
 
+#[derive(Debug, PartialEq, Eq)]
 pub struct LoadedSearchResult {
     pub path: Arc<Path>,
-    pub range: Range<usize>,
     pub full_path: PathBuf,
-    pub file_content: String,
+    pub excerpt_content: String,
     pub row_range: RangeInclusive<u32>,
+    pub query_index: usize,
 }
 
 pub struct WorktreeSearchResult {
     pub worktree_id: WorktreeId,
     pub path: Arc<Path>,
     pub range: Range<usize>,
+    pub query_index: usize,
     pub score: f32,
 }
 
@@ -227,7 +230,7 @@ impl ProjectIndex {
 
     pub fn search(
         &self,
-        query: String,
+        queries: Vec<String>,
         limit: usize,
         cx: &AppContext,
     ) -> Task<Result<Vec<SearchResult>>> {
@@ -275,15 +278,18 @@ impl ProjectIndex {
         cx.spawn(|cx| async move {
             #[cfg(debug_assertions)]
             let embedding_query_start = std::time::Instant::now();
-            log::info!("Searching for {query}");
-
-            let query_embeddings = embedding_provider
-                .embed(&[TextToEmbed::new(&query)])
-                .await?;
-            let query_embedding = query_embeddings
-                .into_iter()
-                .next()
-                .ok_or_else(|| anyhow!("no embedding for query"))?;
+            log::info!("Searching for {queries:?}");
+            let queries: Vec<TextToEmbed> = queries
+                .iter()
+                .map(|s| TextToEmbed::new(s.as_str()))
+                .collect();
+
+            let query_embeddings = embedding_provider.embed(&queries[..]).await?;
+            if query_embeddings.len() != queries.len() {
+                return Err(anyhow!(
+                    "The number of query embeddings does not match the number of queries"
+                ));
+            }
 
             let mut results_by_worker = Vec::new();
             for _ in 0..cx.background_executor().num_cpus() {
@@ -292,28 +298,34 @@ impl ProjectIndex {
 
             #[cfg(debug_assertions)]
             let search_start = std::time::Instant::now();
-
             cx.background_executor()
                 .scoped(|cx| {
                     for results in results_by_worker.iter_mut() {
                         cx.spawn(async {
                             while let Ok((worktree_id, path, chunk)) = chunks_rx.recv().await {
-                                let score = chunk.embedding.similarity(&query_embedding);
+                                let (score, query_index) =
+                                    chunk.embedding.similarity(&query_embeddings);
+
                                 let ix = match results.binary_search_by(|probe| {
                                     score.partial_cmp(&probe.score).unwrap_or(Ordering::Equal)
                                 }) {
                                     Ok(ix) | Err(ix) => ix,
                                 };
-                                results.insert(
-                                    ix,
-                                    WorktreeSearchResult {
-                                        worktree_id,
-                                        path: path.clone(),
-                                        range: chunk.chunk.range.clone(),
-                                        score,
-                                    },
-                                );
-                                results.truncate(limit);
+                                if ix < limit {
+                                    results.insert(
+                                        ix,
+                                        WorktreeSearchResult {
+                                            worktree_id,
+                                            path: path.clone(),
+                                            range: chunk.chunk.range.clone(),
+                                            query_index,
+                                            score,
+                                        },
+                                    );
+                                    if results.len() > limit {
+                                        results.pop();
+                                    }
+                                }
                             }
                         });
                     }
@@ -333,6 +345,7 @@ impl ProjectIndex {
                             path: result.path,
                             range: result.range,
                             score: result.score,
+                            query_index: result.query_index,
                         })
                     }));
                 }
diff --git a/crates/semantic_index/src/semantic_index.rs b/crates/semantic_index/src/semantic_index.rs
index 6c97ece024c7fe..332b4271a003cf 100644
--- a/crates/semantic_index/src/semantic_index.rs
+++ b/crates/semantic_index/src/semantic_index.rs
@@ -12,8 +12,13 @@ use anyhow::{Context as _, Result};
 use collections::HashMap;
 use fs::Fs;
 use gpui::{AppContext, AsyncAppContext, BorrowAppContext, Context, Global, Model, WeakModel};
-use project::Project;
-use std::{path::PathBuf, sync::Arc};
+use language::LineEnding;
+use project::{Project, Worktree};
+use std::{
+    cmp::Ordering,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 use ui::ViewContext;
 use util::ResultExt as _;
 use workspace::Workspace;
@@ -77,46 +82,127 @@ impl SemanticDb {
     }
 
     pub async fn load_results(
-        results: Vec<SearchResult>,
+        mut results: Vec<SearchResult>,
         fs: &Arc<dyn Fs>,
         cx: &AsyncAppContext,
     ) -> Result<Vec<LoadedSearchResult>> {
-        let mut loaded_results = Vec::new();
+        let mut max_scores_by_path = HashMap::<_, (f32, usize)>::default();
+        for result in &results {
+            let (score, query_index) = max_scores_by_path
+                .entry((result.worktree.clone(), result.path.clone()))
+                .or_default();
+            if result.score > *score {
+                *score = result.score;
+                *query_index = result.query_index;
+            }
+        }
+
+        results.sort_by(|a, b| {
+            let max_score_a = max_scores_by_path[&(a.worktree.clone(), a.path.clone())].0;
+            let max_score_b = max_scores_by_path[&(b.worktree.clone(), b.path.clone())].0;
+            max_score_b
+                .partial_cmp(&max_score_a)
+                .unwrap_or(Ordering::Equal)
+                .then_with(|| a.worktree.entity_id().cmp(&b.worktree.entity_id()))
+                .then_with(|| a.path.cmp(&b.path))
+                .then_with(|| a.range.start.cmp(&b.range.start))
+        });
+
+        let mut last_loaded_file: Option<(Model<Worktree>, Arc<Path>, PathBuf, String)> = None;
+        let mut loaded_results = Vec::<LoadedSearchResult>::new();
         for result in results {
-            let (full_path, file_content) = result.worktree.read_with(cx, |worktree, _cx| {
-                let entry_abs_path = worktree.abs_path().join(&result.path);
-                let mut entry_full_path = PathBuf::from(worktree.root_name());
-                entry_full_path.push(&result.path);
-                let file_content = async {
-                    let entry_abs_path = entry_abs_path;
-                    fs.load(&entry_abs_path).await
+            let full_path;
+            let file_content;
+            if let Some(last_loaded_file) =
+                last_loaded_file
+                    .as_ref()
+                    .filter(|(last_worktree, last_path, _, _)| {
+                        last_worktree == &result.worktree && last_path == &result.path
+                    })
+            {
+                full_path = last_loaded_file.2.clone();
+                file_content = &last_loaded_file.3;
+            } else {
+                let output = result.worktree.read_with(cx, |worktree, _cx| {
+                    let entry_abs_path = worktree.abs_path().join(&result.path);
+                    let mut entry_full_path = PathBuf::from(worktree.root_name());
+                    entry_full_path.push(&result.path);
+                    let file_content = async {
+                        let entry_abs_path = entry_abs_path;
+                        fs.load(&entry_abs_path).await
+                    };
+                    (entry_full_path, file_content)
+                })?;
+                full_path = output.0;
+                let Some(content) = output.1.await.log_err() else {
+                    continue;
                 };
-                (entry_full_path, file_content)
-            })?;
-            if let Some(file_content) = file_content.await.log_err() {
-                let range_start = result.range.start.min(file_content.len());
-                let range_end = result.range.end.min(file_content.len());
-
-                let start_row = file_content[0..range_start].matches('\n').count() as u32;
-                let end_row = file_content[0..range_end].matches('\n').count() as u32;
-                let start_line_byte_offset = file_content[0..range_start]
-                    .rfind('\n')
-                    .map(|pos| pos + 1)
-                    .unwrap_or_default();
-                let end_line_byte_offset = file_content[range_end..]
+                last_loaded_file = Some((
+                    result.worktree.clone(),
+                    result.path.clone(),
+                    full_path.clone(),
+                    content,
+                ));
+                file_content = &last_loaded_file.as_ref().unwrap().3;
+            };
+
+            let query_index = max_scores_by_path[&(result.worktree.clone(), result.path.clone())].1;
+
+            let mut range_start = result.range.start.min(file_content.len());
+            let mut range_end = result.range.end.min(file_content.len());
+            while !file_content.is_char_boundary(range_start) {
+                range_start += 1;
+            }
+            while !file_content.is_char_boundary(range_end) {
+                range_end += 1;
+            }
+
+            let start_row = file_content[0..range_start].matches('\n').count() as u32;
+            let mut end_row = file_content[0..range_end].matches('\n').count() as u32;
+            let start_line_byte_offset = file_content[0..range_start]
+                .rfind('\n')
+                .map(|pos| pos + 1)
+                .unwrap_or_default();
+            let mut end_line_byte_offset = range_end;
+            if file_content[..end_line_byte_offset].ends_with('\n') {
+                end_row -= 1;
+            } else {
+                end_line_byte_offset = file_content[range_end..]
                     .find('\n')
-                    .map(|pos| range_end + pos)
+                    .map(|pos| range_end + pos + 1)
                     .unwrap_or_else(|| file_content.len());
+            }
+            let mut excerpt_content =
+                file_content[start_line_byte_offset..end_line_byte_offset].to_string();
+            LineEnding::normalize(&mut excerpt_content);
+
+            if let Some(prev_result) = loaded_results.last_mut() {
+                if prev_result.full_path == full_path {
+                    if *prev_result.row_range.end() + 1 == start_row {
+                        prev_result.row_range = *prev_result.row_range.start()..=end_row;
+                        prev_result.excerpt_content.push_str(&excerpt_content);
+                        continue;
+                    }
+                }
+            }
 
-                loaded_results.push(LoadedSearchResult {
-                    path: result.path,
-                    range: start_line_byte_offset..end_line_byte_offset,
-                    full_path,
-                    file_content,
-                    row_range: start_row..=end_row,
-                });
+            loaded_results.push(LoadedSearchResult {
+                path: result.path,
+                full_path,
+                excerpt_content,
+                row_range: start_row..=end_row,
+                query_index,
+            });
+        }
+
+        for result in &mut loaded_results {
+            while result.excerpt_content.ends_with("\n\n") {
+                result.excerpt_content.pop();
+                result.row_range =
+                    *result.row_range.start()..=result.row_range.end().saturating_sub(1)
             }
         }
+
         Ok(loaded_results)
     }
 
@@ -312,7 +398,7 @@ mod tests {
             .update(|cx| {
                 let project_index = project_index.read(cx);
                 let query = "garbage in, garbage out";
-                project_index.search(query.into(), 4, cx)
+                project_index.search(vec![query.into()], 4, cx)
             })
             .await
             .unwrap();
@@ -426,4 +512,117 @@ mod tests {
             ],
         );
     }
+
+    #[gpui::test]
+    async fn test_load_search_results(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let fs = FakeFs::new(cx.executor());
+        let project_path = Path::new("/fake_project");
+
+        let file1_content = "one\ntwo\nthree\nfour\nfive\n";
+        let file2_content = "aaa\nbbb\nccc\nddd\neee\n";
+
+        fs.insert_tree(
+            project_path,
+            json!({
+                "file1.txt": file1_content,
+                "file2.txt": file2_content,
+            }),
+        )
+        .await;
+
+        let fs = fs as Arc<dyn Fs>;
+        let project = Project::test(fs.clone(), [project_path], cx).await;
+        let worktree = project.read_with(cx, |project, cx| project.worktrees(cx).next().unwrap());
+
+        // chunk that is already newline-aligned
+        let search_results = vec![SearchResult {
+            worktree: worktree.clone(),
+            path: Path::new("file1.txt").into(),
+            range: 0..file1_content.find("four").unwrap(),
+            score: 0.5,
+            query_index: 0,
+        }];
+        assert_eq!(
+            SemanticDb::load_results(search_results, &fs, &cx.to_async())
+                .await
+                .unwrap(),
+            &[LoadedSearchResult {
+                path: Path::new("file1.txt").into(),
+                full_path: "fake_project/file1.txt".into(),
+                excerpt_content: "one\ntwo\nthree\n".into(),
+                row_range: 0..=2,
+                query_index: 0,
+            }]
+        );
+
+        // chunk that is *not* newline-aligned
+        let search_results = vec![SearchResult {
+            worktree: worktree.clone(),
+            path: Path::new("file1.txt").into(),
+            range: file1_content.find("two").unwrap() + 1..file1_content.find("four").unwrap() + 2,
+            score: 0.5,
+            query_index: 0,
+        }];
+        assert_eq!(
+            SemanticDb::load_results(search_results, &fs, &cx.to_async())
+                .await
+                .unwrap(),
+            &[LoadedSearchResult {
+                path: Path::new("file1.txt").into(),
+                full_path: "fake_project/file1.txt".into(),
+                excerpt_content: "two\nthree\nfour\n".into(),
+                row_range: 1..=3,
+                query_index: 0,
+            }]
+        );
+
+        // chunks that are adjacent
+
+        let search_results = vec![
+            SearchResult {
+                worktree: worktree.clone(),
+                path: Path::new("file1.txt").into(),
+                range: file1_content.find("two").unwrap()..file1_content.len(),
+                score: 0.6,
+                query_index: 0,
+            },
+            SearchResult {
+                worktree: worktree.clone(),
+                path: Path::new("file1.txt").into(),
+                range: 0..file1_content.find("two").unwrap(),
+                score: 0.5,
+                query_index: 1,
+            },
+            SearchResult {
+                worktree: worktree.clone(),
+                path: Path::new("file2.txt").into(),
+                range: 0..file2_content.len(),
+                score: 0.8,
+                query_index: 1,
+            },
+        ];
+        assert_eq!(
+            SemanticDb::load_results(search_results, &fs, &cx.to_async())
+                .await
+                .unwrap(),
+            &[
+                LoadedSearchResult {
+                    path: Path::new("file2.txt").into(),
+                    full_path: "fake_project/file2.txt".into(),
+                    excerpt_content: file2_content.into(),
+                    row_range: 0..=4,
+                    query_index: 1,
+                },
+                LoadedSearchResult {
+                    path: Path::new("file1.txt").into(),
+                    full_path: "fake_project/file1.txt".into(),
+                    excerpt_content: file1_content.into(),
+                    row_range: 0..=4,
+                    query_index: 0,
+                }
+            ]
+        );
+    }
 }

From 743feb98bcae8e00c8399be03fb27dc2b925bcdb Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Fri, 20 Sep 2024 15:28:50 -0700
Subject: [PATCH 257/762] Add the ability to propose changes to a set of
 buffers (#18170)

This PR introduces functionality for creating *branches* of buffers that
can be used to preview and edit change sets that haven't yet been
applied to the buffers themselves.

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
Co-authored-by: Marshall <marshall@zed.dev>
---
 Cargo.lock                                   |   1 -
 crates/assistant/src/context.rs              |   9 +-
 crates/channel/src/channel_buffer.rs         |   5 +-
 crates/clock/src/clock.rs                    |  83 ++++++----
 crates/editor/src/actions.rs                 |   1 +
 crates/editor/src/editor.rs                  |  78 ++++++++--
 crates/editor/src/element.rs                 |   5 +-
 crates/editor/src/git.rs                     |  24 +--
 crates/editor/src/hunk_diff.rs               |  24 +--
 crates/editor/src/proposed_changes_editor.rs | 125 +++++++++++++++
 crates/editor/src/test.rs                    |   6 +-
 crates/git/src/diff.rs                       |  70 ++++-----
 crates/language/src/buffer.rs                | 154 ++++++++++++++-----
 crates/language/src/buffer_tests.rs          | 146 ++++++++++++++++--
 crates/multi_buffer/Cargo.toml               |   1 -
 crates/multi_buffer/src/multi_buffer.rs      |  46 +++---
 crates/project/src/project.rs                |   7 +-
 crates/project/src/project_tests.rs          |   2 +-
 crates/remote_server/src/headless_project.rs |   7 +-
 crates/text/src/text.rs                      |  14 ++
 20 files changed, 622 insertions(+), 186 deletions(-)
 create mode 100644 crates/editor/src/proposed_changes_editor.rs

diff --git a/Cargo.lock b/Cargo.lock
index dd07dfa1cf0843..c0f6751b895e28 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7055,7 +7055,6 @@ dependencies = [
  "ctor",
  "env_logger",
  "futures 0.3.30",
- "git",
  "gpui",
  "itertools 0.13.0",
  "language",
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index 1cac47831f52dc..4f1f885b33fe67 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -1006,9 +1006,12 @@ impl Context {
         cx: &mut ModelContext<Self>,
     ) {
         match event {
-            language::BufferEvent::Operation(operation) => cx.emit(ContextEvent::Operation(
-                ContextOperation::BufferOperation(operation.clone()),
-            )),
+            language::BufferEvent::Operation {
+                operation,
+                is_local: true,
+            } => cx.emit(ContextEvent::Operation(ContextOperation::BufferOperation(
+                operation.clone(),
+            ))),
             language::BufferEvent::Edited => {
                 self.count_remaining_tokens(cx);
                 self.reparse(cx);
diff --git a/crates/channel/src/channel_buffer.rs b/crates/channel/src/channel_buffer.rs
index 755e7400e1b66e..0a4a259648bb74 100644
--- a/crates/channel/src/channel_buffer.rs
+++ b/crates/channel/src/channel_buffer.rs
@@ -175,7 +175,10 @@ impl ChannelBuffer {
         cx: &mut ModelContext<Self>,
     ) {
         match event {
-            language::BufferEvent::Operation(operation) => {
+            language::BufferEvent::Operation {
+                operation,
+                is_local: true,
+            } => {
                 if *ZED_ALWAYS_ACTIVE {
                     if let language::Operation::UpdateSelections { selections, .. } = operation {
                         if selections.is_empty() {
diff --git a/crates/clock/src/clock.rs b/crates/clock/src/clock.rs
index f7d36ed4a87b9d..2b45e4a8fad850 100644
--- a/crates/clock/src/clock.rs
+++ b/crates/clock/src/clock.rs
@@ -9,6 +9,8 @@ use std::{
 
 pub use system_clock::*;
 
+pub const LOCAL_BRANCH_REPLICA_ID: u16 = u16::MAX;
+
 /// A unique identifier for each distributed node.
 pub type ReplicaId = u16;
 
@@ -25,7 +27,10 @@ pub struct Lamport {
 
 /// A [vector clock](https://en.wikipedia.org/wiki/Vector_clock).
 #[derive(Clone, Default, Hash, Eq, PartialEq)]
-pub struct Global(SmallVec<[u32; 8]>);
+pub struct Global {
+    values: SmallVec<[u32; 8]>,
+    local_branch_value: u32,
+}
 
 impl Global {
     pub fn new() -> Self {
@@ -33,41 +38,51 @@ impl Global {
     }
 
     pub fn get(&self, replica_id: ReplicaId) -> Seq {
-        self.0.get(replica_id as usize).copied().unwrap_or(0) as Seq
+        if replica_id == LOCAL_BRANCH_REPLICA_ID {
+            self.local_branch_value
+        } else {
+            self.values.get(replica_id as usize).copied().unwrap_or(0) as Seq
+        }
     }
 
     pub fn observe(&mut self, timestamp: Lamport) {
         if timestamp.value > 0 {
-            let new_len = timestamp.replica_id as usize + 1;
-            if new_len > self.0.len() {
-                self.0.resize(new_len, 0);
+            if timestamp.replica_id == LOCAL_BRANCH_REPLICA_ID {
+                self.local_branch_value = cmp::max(self.local_branch_value, timestamp.value);
+            } else {
+                let new_len = timestamp.replica_id as usize + 1;
+                if new_len > self.values.len() {
+                    self.values.resize(new_len, 0);
+                }
+
+                let entry = &mut self.values[timestamp.replica_id as usize];
+                *entry = cmp::max(*entry, timestamp.value);
             }
-
-            let entry = &mut self.0[timestamp.replica_id as usize];
-            *entry = cmp::max(*entry, timestamp.value);
         }
     }
 
     pub fn join(&mut self, other: &Self) {
-        if other.0.len() > self.0.len() {
-            self.0.resize(other.0.len(), 0);
+        if other.values.len() > self.values.len() {
+            self.values.resize(other.values.len(), 0);
         }
 
-        for (left, right) in self.0.iter_mut().zip(&other.0) {
+        for (left, right) in self.values.iter_mut().zip(&other.values) {
             *left = cmp::max(*left, *right);
         }
+
+        self.local_branch_value = cmp::max(self.local_branch_value, other.local_branch_value);
     }
 
     pub fn meet(&mut self, other: &Self) {
-        if other.0.len() > self.0.len() {
-            self.0.resize(other.0.len(), 0);
+        if other.values.len() > self.values.len() {
+            self.values.resize(other.values.len(), 0);
         }
 
         let mut new_len = 0;
         for (ix, (left, right)) in self
-            .0
+            .values
             .iter_mut()
-            .zip(other.0.iter().chain(iter::repeat(&0)))
+            .zip(other.values.iter().chain(iter::repeat(&0)))
             .enumerate()
         {
             if *left == 0 {
@@ -80,7 +95,8 @@ impl Global {
                 new_len = ix + 1;
             }
         }
-        self.0.resize(new_len, 0);
+        self.values.resize(new_len, 0);
+        self.local_branch_value = cmp::min(self.local_branch_value, other.local_branch_value);
     }
 
     pub fn observed(&self, timestamp: Lamport) -> bool {
@@ -88,34 +104,44 @@ impl Global {
     }
 
     pub fn observed_any(&self, other: &Self) -> bool {
-        self.0
+        self.values
             .iter()
-            .zip(other.0.iter())
+            .zip(other.values.iter())
             .any(|(left, right)| *right > 0 && left >= right)
+            || (other.local_branch_value > 0 && self.local_branch_value >= other.local_branch_value)
     }
 
     pub fn observed_all(&self, other: &Self) -> bool {
-        let mut rhs = other.0.iter();
-        self.0.iter().all(|left| match rhs.next() {
+        let mut rhs = other.values.iter();
+        self.values.iter().all(|left| match rhs.next() {
             Some(right) => left >= right,
             None => true,
         }) && rhs.next().is_none()
+            && self.local_branch_value >= other.local_branch_value
     }
 
     pub fn changed_since(&self, other: &Self) -> bool {
-        self.0.len() > other.0.len()
+        self.values.len() > other.values.len()
             || self
-                .0
+                .values
                 .iter()
-                .zip(other.0.iter())
+                .zip(other.values.iter())
                 .any(|(left, right)| left > right)
+            || self.local_branch_value > other.local_branch_value
     }
 
     pub fn iter(&self) -> impl Iterator<Item = Lamport> + '_ {
-        self.0.iter().enumerate().map(|(replica_id, seq)| Lamport {
-            replica_id: replica_id as ReplicaId,
-            value: *seq,
-        })
+        self.values
+            .iter()
+            .enumerate()
+            .map(|(replica_id, seq)| Lamport {
+                replica_id: replica_id as ReplicaId,
+                value: *seq,
+            })
+            .chain((self.local_branch_value > 0).then_some(Lamport {
+                replica_id: LOCAL_BRANCH_REPLICA_ID,
+                value: self.local_branch_value,
+            }))
     }
 }
 
@@ -192,6 +218,9 @@ impl fmt::Debug for Global {
             }
             write!(f, "{}: {}", timestamp.replica_id, timestamp.value)?;
         }
+        if self.local_branch_value > 0 {
+            write!(f, "<branch>: {}", self.local_branch_value)?;
+        }
         write!(f, "}}")
     }
 }
diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs
index 93c83af1950ec5..2383c7f71af8a9 100644
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -273,6 +273,7 @@ gpui::actions!(
         NextScreen,
         OpenExcerpts,
         OpenExcerptsSplit,
+        OpenProposedChangesEditor,
         OpenFile,
         OpenPermalinkToLine,
         OpenUrl,
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 1f4a9376d22fa5..b1a3d95a0da780 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -35,6 +35,7 @@ mod lsp_ext;
 mod mouse_context_menu;
 pub mod movement;
 mod persistence;
+mod proposed_changes_editor;
 mod rust_analyzer_ext;
 pub mod scroll;
 mod selections_collection;
@@ -46,7 +47,7 @@ mod signature_help;
 #[cfg(any(test, feature = "test-support"))]
 pub mod test;
 
-use ::git::diff::{DiffHunk, DiffHunkStatus};
+use ::git::diff::DiffHunkStatus;
 use ::git::{parse_git_remote_url, BuildPermalinkParams, GitHostingProviderRegistry};
 pub(crate) use actions::*;
 use aho_corasick::AhoCorasick;
@@ -98,6 +99,7 @@ use language::{
 };
 use language::{point_to_lsp, BufferRow, CharClassifier, Runnable, RunnableRange};
 use linked_editing_ranges::refresh_linked_ranges;
+use proposed_changes_editor::{ProposedChangesBuffer, ProposedChangesEditor};
 use similar::{ChangeTag, TextDiff};
 use task::{ResolvedTask, TaskTemplate, TaskVariables};
 
@@ -113,7 +115,9 @@ pub use multi_buffer::{
     Anchor, AnchorRangeExt, ExcerptId, ExcerptRange, MultiBuffer, MultiBufferSnapshot, ToOffset,
     ToPoint,
 };
-use multi_buffer::{ExpandExcerptDirection, MultiBufferPoint, MultiBufferRow, ToOffsetUtf16};
+use multi_buffer::{
+    ExpandExcerptDirection, MultiBufferDiffHunk, MultiBufferPoint, MultiBufferRow, ToOffsetUtf16,
+};
 use ordered_float::OrderedFloat;
 use parking_lot::{Mutex, RwLock};
 use project::project_settings::{GitGutterSetting, ProjectSettings};
@@ -6152,7 +6156,7 @@ impl Editor {
     pub fn prepare_revert_change(
         revert_changes: &mut HashMap<BufferId, Vec<(Range<text::Anchor>, Rope)>>,
         multi_buffer: &Model<MultiBuffer>,
-        hunk: &DiffHunk<MultiBufferRow>,
+        hunk: &MultiBufferDiffHunk,
         cx: &AppContext,
     ) -> Option<()> {
         let buffer = multi_buffer.read(cx).buffer(hunk.buffer_id)?;
@@ -9338,7 +9342,7 @@ impl Editor {
         snapshot: &DisplaySnapshot,
         initial_point: Point,
         is_wrapped: bool,
-        hunks: impl Iterator<Item = DiffHunk<MultiBufferRow>>,
+        hunks: impl Iterator<Item = MultiBufferDiffHunk>,
         cx: &mut ViewContext<Editor>,
     ) -> bool {
         let display_point = initial_point.to_display_point(snapshot);
@@ -11885,6 +11889,52 @@ impl Editor {
         self.searchable
     }
 
+    fn open_proposed_changes_editor(
+        &mut self,
+        _: &OpenProposedChangesEditor,
+        cx: &mut ViewContext<Self>,
+    ) {
+        let Some(workspace) = self.workspace() else {
+            cx.propagate();
+            return;
+        };
+
+        let buffer = self.buffer.read(cx);
+        let mut new_selections_by_buffer = HashMap::default();
+        for selection in self.selections.all::<usize>(cx) {
+            for (buffer, mut range, _) in
+                buffer.range_to_buffer_ranges(selection.start..selection.end, cx)
+            {
+                if selection.reversed {
+                    mem::swap(&mut range.start, &mut range.end);
+                }
+                let mut range = range.to_point(buffer.read(cx));
+                range.start.column = 0;
+                range.end.column = buffer.read(cx).line_len(range.end.row);
+                new_selections_by_buffer
+                    .entry(buffer)
+                    .or_insert(Vec::new())
+                    .push(range)
+            }
+        }
+
+        let proposed_changes_buffers = new_selections_by_buffer
+            .into_iter()
+            .map(|(buffer, ranges)| ProposedChangesBuffer { buffer, ranges })
+            .collect::<Vec<_>>();
+        let proposed_changes_editor = cx.new_view(|cx| {
+            ProposedChangesEditor::new(proposed_changes_buffers, self.project.clone(), cx)
+        });
+
+        cx.window_context().defer(move |cx| {
+            workspace.update(cx, |workspace, cx| {
+                workspace.active_pane().update(cx, |pane, cx| {
+                    pane.add_item(Box::new(proposed_changes_editor), true, true, None, cx);
+                });
+            });
+        });
+    }
+
     fn open_excerpts_in_split(&mut self, _: &OpenExcerptsSplit, cx: &mut ViewContext<Self>) {
         self.open_excerpts_common(true, cx)
     }
@@ -12399,7 +12449,7 @@ impl Editor {
 fn hunks_for_selections(
     multi_buffer_snapshot: &MultiBufferSnapshot,
     selections: &[Selection<Anchor>],
-) -> Vec<DiffHunk<MultiBufferRow>> {
+) -> Vec<MultiBufferDiffHunk> {
     let buffer_rows_for_selections = selections.iter().map(|selection| {
         let head = selection.head();
         let tail = selection.tail();
@@ -12418,7 +12468,7 @@ fn hunks_for_selections(
 pub fn hunks_for_rows(
     rows: impl Iterator<Item = Range<MultiBufferRow>>,
     multi_buffer_snapshot: &MultiBufferSnapshot,
-) -> Vec<DiffHunk<MultiBufferRow>> {
+) -> Vec<MultiBufferDiffHunk> {
     let mut hunks = Vec::new();
     let mut processed_buffer_rows: HashMap<BufferId, HashSet<Range<text::Anchor>>> =
         HashMap::default();
@@ -12430,14 +12480,14 @@ pub fn hunks_for_rows(
             // when the caret is just above or just below the deleted hunk.
             let allow_adjacent = hunk_status(&hunk) == DiffHunkStatus::Removed;
             let related_to_selection = if allow_adjacent {
-                hunk.associated_range.overlaps(&query_rows)
-                    || hunk.associated_range.start == query_rows.end
-                    || hunk.associated_range.end == query_rows.start
+                hunk.row_range.overlaps(&query_rows)
+                    || hunk.row_range.start == query_rows.end
+                    || hunk.row_range.end == query_rows.start
             } else {
                 // `selected_multi_buffer_rows` are inclusive (e.g. [2..2] means 2nd row is selected)
-                // `hunk.associated_range` is exclusive (e.g. [2..3] means 2nd row is selected)
-                hunk.associated_range.overlaps(&selected_multi_buffer_rows)
-                    || selected_multi_buffer_rows.end == hunk.associated_range.start
+                // `hunk.row_range` is exclusive (e.g. [2..3] means 2nd row is selected)
+                hunk.row_range.overlaps(&selected_multi_buffer_rows)
+                    || selected_multi_buffer_rows.end == hunk.row_range.start
             };
             if related_to_selection {
                 if !processed_buffer_rows
@@ -13738,10 +13788,10 @@ impl RowRangeExt for Range<DisplayRow> {
     }
 }
 
-fn hunk_status(hunk: &DiffHunk<MultiBufferRow>) -> DiffHunkStatus {
+fn hunk_status(hunk: &MultiBufferDiffHunk) -> DiffHunkStatus {
     if hunk.diff_base_byte_range.is_empty() {
         DiffHunkStatus::Added
-    } else if hunk.associated_range.is_empty() {
+    } else if hunk.row_range.is_empty() {
         DiffHunkStatus::Removed
     } else {
         DiffHunkStatus::Modified
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 47107b97546871..d4075431ff602b 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -346,6 +346,7 @@ impl EditorElement {
         register_action(view, cx, Editor::toggle_code_actions);
         register_action(view, cx, Editor::open_excerpts);
         register_action(view, cx, Editor::open_excerpts_in_split);
+        register_action(view, cx, Editor::open_proposed_changes_editor);
         register_action(view, cx, Editor::toggle_soft_wrap);
         register_action(view, cx, Editor::toggle_tab_bar);
         register_action(view, cx, Editor::toggle_line_numbers);
@@ -3710,11 +3711,11 @@ impl EditorElement {
                                     )
                                     .map(|hunk| {
                                         let start_display_row =
-                                            MultiBufferPoint::new(hunk.associated_range.start.0, 0)
+                                            MultiBufferPoint::new(hunk.row_range.start.0, 0)
                                                 .to_display_point(&snapshot.display_snapshot)
                                                 .row();
                                         let mut end_display_row =
-                                            MultiBufferPoint::new(hunk.associated_range.end.0, 0)
+                                            MultiBufferPoint::new(hunk.row_range.end.0, 0)
                                                 .to_display_point(&snapshot.display_snapshot)
                                                 .row();
                                         if end_display_row != start_display_row {
diff --git a/crates/editor/src/git.rs b/crates/editor/src/git.rs
index 63b083faa89bd5..79b78d5d148488 100644
--- a/crates/editor/src/git.rs
+++ b/crates/editor/src/git.rs
@@ -2,9 +2,9 @@ pub mod blame;
 
 use std::ops::Range;
 
-use git::diff::{DiffHunk, DiffHunkStatus};
+use git::diff::DiffHunkStatus;
 use language::Point;
-use multi_buffer::{Anchor, MultiBufferRow};
+use multi_buffer::{Anchor, MultiBufferDiffHunk};
 
 use crate::{
     display_map::{DisplaySnapshot, ToDisplayPoint},
@@ -49,25 +49,25 @@ impl DisplayDiffHunk {
 }
 
 pub fn diff_hunk_to_display(
-    hunk: &DiffHunk<MultiBufferRow>,
+    hunk: &MultiBufferDiffHunk,
     snapshot: &DisplaySnapshot,
 ) -> DisplayDiffHunk {
-    let hunk_start_point = Point::new(hunk.associated_range.start.0, 0);
-    let hunk_start_point_sub = Point::new(hunk.associated_range.start.0.saturating_sub(1), 0);
+    let hunk_start_point = Point::new(hunk.row_range.start.0, 0);
+    let hunk_start_point_sub = Point::new(hunk.row_range.start.0.saturating_sub(1), 0);
     let hunk_end_point_sub = Point::new(
-        hunk.associated_range
+        hunk.row_range
             .end
             .0
             .saturating_sub(1)
-            .max(hunk.associated_range.start.0),
+            .max(hunk.row_range.start.0),
         0,
     );
 
     let status = hunk_status(hunk);
     let is_removal = status == DiffHunkStatus::Removed;
 
-    let folds_start = Point::new(hunk.associated_range.start.0.saturating_sub(2), 0);
-    let folds_end = Point::new(hunk.associated_range.end.0 + 2, 0);
+    let folds_start = Point::new(hunk.row_range.start.0.saturating_sub(2), 0);
+    let folds_end = Point::new(hunk.row_range.end.0 + 2, 0);
     let folds_range = folds_start..folds_end;
 
     let containing_fold = snapshot.folds_in_range(folds_range).find(|fold| {
@@ -87,7 +87,7 @@ pub fn diff_hunk_to_display(
     } else {
         let start = hunk_start_point.to_display_point(snapshot).row();
 
-        let hunk_end_row = hunk.associated_range.end.max(hunk.associated_range.start);
+        let hunk_end_row = hunk.row_range.end.max(hunk.row_range.start);
         let hunk_end_point = Point::new(hunk_end_row.0, 0);
 
         let multi_buffer_start = snapshot.buffer_snapshot.anchor_after(hunk_start_point);
@@ -288,7 +288,7 @@ mod tests {
         assert_eq!(
             snapshot
                 .git_diff_hunks_in_range(MultiBufferRow(0)..MultiBufferRow(12))
-                .map(|hunk| (hunk_status(&hunk), hunk.associated_range))
+                .map(|hunk| (hunk_status(&hunk), hunk.row_range))
                 .collect::<Vec<_>>(),
             &expected,
         );
@@ -296,7 +296,7 @@ mod tests {
         assert_eq!(
             snapshot
                 .git_diff_hunks_in_range_rev(MultiBufferRow(0)..MultiBufferRow(12))
-                .map(|hunk| (hunk_status(&hunk), hunk.associated_range))
+                .map(|hunk| (hunk_status(&hunk), hunk.row_range))
                 .collect::<Vec<_>>(),
             expected
                 .iter()
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index 361ea6246e308b..917d07ec4ee85b 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -4,11 +4,12 @@ use std::{
 };
 
 use collections::{hash_map, HashMap, HashSet};
-use git::diff::{DiffHunk, DiffHunkStatus};
+use git::diff::DiffHunkStatus;
 use gpui::{Action, AppContext, CursorStyle, Hsla, Model, MouseButton, Subscription, Task, View};
 use language::Buffer;
 use multi_buffer::{
-    Anchor, AnchorRangeExt, ExcerptRange, MultiBuffer, MultiBufferRow, MultiBufferSnapshot, ToPoint,
+    Anchor, AnchorRangeExt, ExcerptRange, MultiBuffer, MultiBufferDiffHunk, MultiBufferRow,
+    MultiBufferSnapshot, ToPoint,
 };
 use settings::SettingsStore;
 use text::{BufferId, Point};
@@ -190,9 +191,9 @@ impl Editor {
             .buffer_snapshot
             .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
             .filter(|hunk| {
-                let hunk_display_row_range = Point::new(hunk.associated_range.start.0, 0)
+                let hunk_display_row_range = Point::new(hunk.row_range.start.0, 0)
                     .to_display_point(&snapshot.display_snapshot)
-                    ..Point::new(hunk.associated_range.end.0, 0)
+                    ..Point::new(hunk.row_range.end.0, 0)
                         .to_display_point(&snapshot.display_snapshot);
                 let row_range_end =
                     display_rows_with_expanded_hunks.get(&hunk_display_row_range.start.row());
@@ -203,7 +204,7 @@ impl Editor {
 
     fn toggle_hunks_expanded(
         &mut self,
-        hunks_to_toggle: Vec<DiffHunk<MultiBufferRow>>,
+        hunks_to_toggle: Vec<MultiBufferDiffHunk>,
         cx: &mut ViewContext<Self>,
     ) {
         let previous_toggle_task = self.expanded_hunks.hunk_update_tasks.remove(&None);
@@ -274,8 +275,8 @@ impl Editor {
                     });
                     for remaining_hunk in hunks_to_toggle {
                         let remaining_hunk_point_range =
-                            Point::new(remaining_hunk.associated_range.start.0, 0)
-                                ..Point::new(remaining_hunk.associated_range.end.0, 0);
+                            Point::new(remaining_hunk.row_range.start.0, 0)
+                                ..Point::new(remaining_hunk.row_range.end.0, 0);
                         hunks_to_expand.push(HoveredHunk {
                             status: hunk_status(&remaining_hunk),
                             multi_buffer_range: remaining_hunk_point_range
@@ -705,7 +706,7 @@ impl Editor {
 fn to_diff_hunk(
     hovered_hunk: &HoveredHunk,
     multi_buffer_snapshot: &MultiBufferSnapshot,
-) -> Option<DiffHunk<MultiBufferRow>> {
+) -> Option<MultiBufferDiffHunk> {
     let buffer_id = hovered_hunk
         .multi_buffer_range
         .start
@@ -716,9 +717,8 @@ fn to_diff_hunk(
     let point_range = hovered_hunk
         .multi_buffer_range
         .to_point(multi_buffer_snapshot);
-    Some(DiffHunk {
-        associated_range: MultiBufferRow(point_range.start.row)
-            ..MultiBufferRow(point_range.end.row),
+    Some(MultiBufferDiffHunk {
+        row_range: MultiBufferRow(point_range.start.row)..MultiBufferRow(point_range.end.row),
         buffer_id,
         buffer_range,
         diff_base_byte_range: hovered_hunk.diff_base_byte_range.clone(),
@@ -868,7 +868,7 @@ fn editor_with_deleted_text(
 fn buffer_diff_hunk(
     buffer_snapshot: &MultiBufferSnapshot,
     row_range: Range<Point>,
-) -> Option<DiffHunk<MultiBufferRow>> {
+) -> Option<MultiBufferDiffHunk> {
     let mut hunks = buffer_snapshot.git_diff_hunks_in_range(
         MultiBufferRow(row_range.start.row)..MultiBufferRow(row_range.end.row),
     );
diff --git a/crates/editor/src/proposed_changes_editor.rs b/crates/editor/src/proposed_changes_editor.rs
new file mode 100644
index 00000000000000..3979e558a42364
--- /dev/null
+++ b/crates/editor/src/proposed_changes_editor.rs
@@ -0,0 +1,125 @@
+use crate::{Editor, EditorEvent};
+use collections::HashSet;
+use futures::{channel::mpsc, future::join_all};
+use gpui::{AppContext, EventEmitter, FocusableView, Model, Render, Subscription, Task, View};
+use language::{Buffer, BufferEvent, Capability};
+use multi_buffer::{ExcerptRange, MultiBuffer};
+use project::Project;
+use smol::stream::StreamExt;
+use std::{ops::Range, time::Duration};
+use text::ToOffset;
+use ui::prelude::*;
+use workspace::Item;
+
+pub struct ProposedChangesEditor {
+    editor: View<Editor>,
+    _subscriptions: Vec<Subscription>,
+    _recalculate_diffs_task: Task<Option<()>>,
+    recalculate_diffs_tx: mpsc::UnboundedSender<Model<Buffer>>,
+}
+
+pub struct ProposedChangesBuffer<T> {
+    pub buffer: Model<Buffer>,
+    pub ranges: Vec<Range<T>>,
+}
+
+impl ProposedChangesEditor {
+    pub fn new<T: ToOffset>(
+        buffers: Vec<ProposedChangesBuffer<T>>,
+        project: Option<Model<Project>>,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
+        let mut subscriptions = Vec::new();
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
+
+        for buffer in buffers {
+            let branch_buffer = buffer.buffer.update(cx, |buffer, cx| buffer.branch(cx));
+            subscriptions.push(cx.subscribe(&branch_buffer, Self::on_buffer_event));
+
+            multibuffer.update(cx, |multibuffer, cx| {
+                multibuffer.push_excerpts(
+                    branch_buffer,
+                    buffer.ranges.into_iter().map(|range| ExcerptRange {
+                        context: range,
+                        primary: None,
+                    }),
+                    cx,
+                );
+            });
+        }
+
+        let (recalculate_diffs_tx, mut recalculate_diffs_rx) = mpsc::unbounded();
+
+        Self {
+            editor: cx
+                .new_view(|cx| Editor::for_multibuffer(multibuffer.clone(), project, true, cx)),
+            recalculate_diffs_tx,
+            _recalculate_diffs_task: cx.spawn(|_, mut cx| async move {
+                let mut buffers_to_diff = HashSet::default();
+                while let Some(buffer) = recalculate_diffs_rx.next().await {
+                    buffers_to_diff.insert(buffer);
+
+                    loop {
+                        cx.background_executor()
+                            .timer(Duration::from_millis(250))
+                            .await;
+                        let mut had_further_changes = false;
+                        while let Ok(next_buffer) = recalculate_diffs_rx.try_next() {
+                            buffers_to_diff.insert(next_buffer?);
+                            had_further_changes = true;
+                        }
+                        if !had_further_changes {
+                            break;
+                        }
+                    }
+
+                    join_all(buffers_to_diff.drain().filter_map(|buffer| {
+                        buffer
+                            .update(&mut cx, |buffer, cx| buffer.recalculate_diff(cx))
+                            .ok()?
+                    }))
+                    .await;
+                }
+                None
+            }),
+            _subscriptions: subscriptions,
+        }
+    }
+
+    fn on_buffer_event(
+        &mut self,
+        buffer: Model<Buffer>,
+        event: &BufferEvent,
+        _cx: &mut ViewContext<Self>,
+    ) {
+        if let BufferEvent::Edited = event {
+            self.recalculate_diffs_tx.unbounded_send(buffer).ok();
+        }
+    }
+}
+
+impl Render for ProposedChangesEditor {
+    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+        self.editor.clone()
+    }
+}
+
+impl FocusableView for ProposedChangesEditor {
+    fn focus_handle(&self, cx: &AppContext) -> gpui::FocusHandle {
+        self.editor.focus_handle(cx)
+    }
+}
+
+impl EventEmitter<EditorEvent> for ProposedChangesEditor {}
+
+impl Item for ProposedChangesEditor {
+    type Event = EditorEvent;
+
+    fn tab_icon(&self, _cx: &ui::WindowContext) -> Option<Icon> {
+        Some(Icon::new(IconName::Pencil))
+    }
+
+    fn tab_content_text(&self, _cx: &WindowContext) -> Option<SharedString> {
+        Some("Proposed changes".into())
+    }
+}
diff --git a/crates/editor/src/test.rs b/crates/editor/src/test.rs
index fcbd3bd42314d3..50214cd723ee31 100644
--- a/crates/editor/src/test.rs
+++ b/crates/editor/src/test.rs
@@ -108,16 +108,16 @@ pub fn editor_hunks(
         .buffer_snapshot
         .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
         .map(|hunk| {
-            let display_range = Point::new(hunk.associated_range.start.0, 0)
+            let display_range = Point::new(hunk.row_range.start.0, 0)
                 .to_display_point(snapshot)
                 .row()
-                ..Point::new(hunk.associated_range.end.0, 0)
+                ..Point::new(hunk.row_range.end.0, 0)
                     .to_display_point(snapshot)
                     .row();
             let (_, buffer, _) = editor
                 .buffer()
                 .read(cx)
-                .excerpt_containing(Point::new(hunk.associated_range.start.0, 0), cx)
+                .excerpt_containing(Point::new(hunk.row_range.start.0, 0), cx)
                 .expect("no excerpt for expanded buffer's hunk start");
             let diff_base = buffer
                 .read(cx)
diff --git a/crates/git/src/diff.rs b/crates/git/src/diff.rs
index 8cc7ee186350c5..1f7930ce1442da 100644
--- a/crates/git/src/diff.rs
+++ b/crates/git/src/diff.rs
@@ -1,7 +1,7 @@
 use rope::Rope;
 use std::{iter, ops::Range};
 use sum_tree::SumTree;
-use text::{Anchor, BufferId, BufferSnapshot, OffsetRangeExt, Point};
+use text::{Anchor, BufferSnapshot, OffsetRangeExt, Point};
 
 pub use git2 as libgit;
 use libgit::{DiffLineType as GitDiffLineType, DiffOptions as GitOptions, Patch as GitPatch};
@@ -13,29 +13,30 @@ pub enum DiffHunkStatus {
     Removed,
 }
 
-/// A diff hunk, representing a range of consequent lines in a singleton buffer, associated with a generic range.
+/// A diff hunk resolved to rows in the buffer.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct DiffHunk<T> {
-    /// E.g. a range in multibuffer, that has an excerpt added, singleton buffer for which has this diff hunk.
-    /// Consider a singleton buffer with 10 lines, all of them are modified — so a corresponding diff hunk would have a range 0..10.
-    /// And a multibuffer with the excerpt of lines 2-6 from the singleton buffer.
-    /// If the multibuffer is searched for diff hunks, the associated range would be multibuffer rows, corresponding to rows 2..6 from the singleton buffer.
-    /// But the hunk range would be 0..10, same for any other excerpts from the same singleton buffer.
-    pub associated_range: Range<T>,
-    /// Singleton buffer ID this hunk belongs to.
-    pub buffer_id: BufferId,
-    /// A consequent range of lines in the singleton buffer, that were changed and produced this diff hunk.
+pub struct DiffHunk {
+    /// The buffer range, expressed in terms of rows.
+    pub row_range: Range<u32>,
+    /// The range in the buffer to which this hunk corresponds.
     pub buffer_range: Range<Anchor>,
-    /// Original singleton buffer text before the change, that was instead of the `buffer_range`.
+    /// The range in the buffer's diff base text to which this hunk corresponds.
     pub diff_base_byte_range: Range<usize>,
 }
 
-impl sum_tree::Item for DiffHunk<Anchor> {
+/// We store [`InternalDiffHunk`]s internally so we don't need to store the additional row range.
+#[derive(Debug, Clone)]
+struct InternalDiffHunk {
+    buffer_range: Range<Anchor>,
+    diff_base_byte_range: Range<usize>,
+}
+
+impl sum_tree::Item for InternalDiffHunk {
     type Summary = DiffHunkSummary;
 
     fn summary(&self) -> Self::Summary {
         DiffHunkSummary {
-            buffer_range: self.associated_range.clone(),
+            buffer_range: self.buffer_range.clone(),
         }
     }
 }
@@ -64,7 +65,7 @@ impl sum_tree::Summary for DiffHunkSummary {
 #[derive(Debug, Clone)]
 pub struct BufferDiff {
     last_buffer_version: Option<clock::Global>,
-    tree: SumTree<DiffHunk<Anchor>>,
+    tree: SumTree<InternalDiffHunk>,
 }
 
 impl BufferDiff {
@@ -79,11 +80,12 @@ impl BufferDiff {
         self.tree.is_empty()
     }
 
+    #[cfg(any(test, feature = "test-support"))]
     pub fn hunks_in_row_range<'a>(
         &'a self,
         range: Range<u32>,
         buffer: &'a BufferSnapshot,
-    ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
+    ) -> impl 'a + Iterator<Item = DiffHunk> {
         let start = buffer.anchor_before(Point::new(range.start, 0));
         let end = buffer.anchor_after(Point::new(range.end, 0));
 
@@ -94,7 +96,7 @@ impl BufferDiff {
         &'a self,
         range: Range<Anchor>,
         buffer: &'a BufferSnapshot,
-    ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
+    ) -> impl 'a + Iterator<Item = DiffHunk> {
         let mut cursor = self
             .tree
             .filter::<_, DiffHunkSummary>(buffer, move |summary| {
@@ -109,11 +111,8 @@ impl BufferDiff {
         })
         .flat_map(move |hunk| {
             [
-                (
-                    &hunk.associated_range.start,
-                    hunk.diff_base_byte_range.start,
-                ),
-                (&hunk.associated_range.end, hunk.diff_base_byte_range.end),
+                (&hunk.buffer_range.start, hunk.diff_base_byte_range.start),
+                (&hunk.buffer_range.end, hunk.diff_base_byte_range.end),
             ]
             .into_iter()
         });
@@ -129,10 +128,9 @@ impl BufferDiff {
             }
 
             Some(DiffHunk {
-                associated_range: start_point.row..end_point.row,
+                row_range: start_point.row..end_point.row,
                 diff_base_byte_range: start_base..end_base,
                 buffer_range: buffer.anchor_before(start_point)..buffer.anchor_after(end_point),
-                buffer_id: buffer.remote_id(),
             })
         })
     }
@@ -141,7 +139,7 @@ impl BufferDiff {
         &'a self,
         range: Range<Anchor>,
         buffer: &'a BufferSnapshot,
-    ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
+    ) -> impl 'a + Iterator<Item = DiffHunk> {
         let mut cursor = self
             .tree
             .filter::<_, DiffHunkSummary>(buffer, move |summary| {
@@ -154,7 +152,7 @@ impl BufferDiff {
             cursor.prev(buffer);
 
             let hunk = cursor.item()?;
-            let range = hunk.associated_range.to_point(buffer);
+            let range = hunk.buffer_range.to_point(buffer);
             let end_row = if range.end.column > 0 {
                 range.end.row + 1
             } else {
@@ -162,10 +160,9 @@ impl BufferDiff {
             };
 
             Some(DiffHunk {
-                associated_range: range.start.row..end_row,
+                row_range: range.start.row..end_row,
                 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
                 buffer_range: hunk.buffer_range.clone(),
-                buffer_id: hunk.buffer_id,
             })
         })
     }
@@ -196,7 +193,7 @@ impl BufferDiff {
     }
 
     #[cfg(test)]
-    fn hunks<'a>(&'a self, text: &'a BufferSnapshot) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
+    fn hunks<'a>(&'a self, text: &'a BufferSnapshot) -> impl 'a + Iterator<Item = DiffHunk> {
         let start = text.anchor_before(Point::new(0, 0));
         let end = text.anchor_after(Point::new(u32::MAX, u32::MAX));
         self.hunks_intersecting_range(start..end, text)
@@ -229,7 +226,7 @@ impl BufferDiff {
         hunk_index: usize,
         buffer: &text::BufferSnapshot,
         buffer_row_divergence: &mut i64,
-    ) -> DiffHunk<Anchor> {
+    ) -> InternalDiffHunk {
         let line_item_count = patch.num_lines_in_hunk(hunk_index).unwrap();
         assert!(line_item_count > 0);
 
@@ -284,11 +281,9 @@ impl BufferDiff {
         let start = Point::new(buffer_row_range.start, 0);
         let end = Point::new(buffer_row_range.end, 0);
         let buffer_range = buffer.anchor_before(start)..buffer.anchor_before(end);
-        DiffHunk {
-            associated_range: buffer_range.clone(),
+        InternalDiffHunk {
             buffer_range,
             diff_base_byte_range,
-            buffer_id: buffer.remote_id(),
         }
     }
 }
@@ -302,17 +297,16 @@ pub fn assert_hunks<Iter>(
     diff_base: &str,
     expected_hunks: &[(Range<u32>, &str, &str)],
 ) where
-    Iter: Iterator<Item = DiffHunk<u32>>,
+    Iter: Iterator<Item = DiffHunk>,
 {
     let actual_hunks = diff_hunks
         .map(|hunk| {
             (
-                hunk.associated_range.clone(),
+                hunk.row_range.clone(),
                 &diff_base[hunk.diff_base_byte_range],
                 buffer
                     .text_for_range(
-                        Point::new(hunk.associated_range.start, 0)
-                            ..Point::new(hunk.associated_range.end, 0),
+                        Point::new(hunk.row_range.start, 0)..Point::new(hunk.row_range.end, 0),
                     )
                     .collect::<String>(),
             )
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index acb57273e30eed..5735ee961651ab 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -21,8 +21,8 @@ use async_watch as watch;
 pub use clock::ReplicaId;
 use futures::channel::oneshot;
 use gpui::{
-    AnyElement, AppContext, EventEmitter, HighlightStyle, ModelContext, Pixels, Task, TaskLabel,
-    WindowContext,
+    AnyElement, AppContext, Context as _, EventEmitter, HighlightStyle, Model, ModelContext,
+    Pixels, Task, TaskLabel, WindowContext,
 };
 use lsp::LanguageServerId;
 use parking_lot::Mutex;
@@ -84,11 +84,17 @@ pub enum Capability {
 
 pub type BufferRow = u32;
 
+#[derive(Clone)]
+enum BufferDiffBase {
+    Git(Rope),
+    PastBufferVersion(Model<Buffer>, BufferSnapshot),
+}
+
 /// An in-memory representation of a source code file, including its text,
 /// syntax trees, git status, and diagnostics.
 pub struct Buffer {
     text: TextBuffer,
-    diff_base: Option<Rope>,
+    diff_base: Option<BufferDiffBase>,
     git_diff: git::diff::BufferDiff,
     file: Option<Arc<dyn File>>,
     /// The mtime of the file when this buffer was last loaded from
@@ -121,6 +127,7 @@ pub struct Buffer {
     /// Memoize calls to has_changes_since(saved_version).
     /// The contents of a cell are (self.version, has_changes) at the time of a last call.
     has_unsaved_edits: Cell<(clock::Global, bool)>,
+    _subscriptions: Vec<gpui::Subscription>,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -308,7 +315,10 @@ pub enum Operation {
 pub enum BufferEvent {
     /// The buffer was changed in a way that must be
     /// propagated to its other replicas.
-    Operation(Operation),
+    Operation {
+        operation: Operation,
+        is_local: bool,
+    },
     /// The buffer was edited.
     Edited,
     /// The buffer's `dirty` bit changed.
@@ -644,7 +654,7 @@ impl Buffer {
             id: self.remote_id().into(),
             file: self.file.as_ref().map(|f| f.to_proto(cx)),
             base_text: self.base_text().to_string(),
-            diff_base: self.diff_base.as_ref().map(|h| h.to_string()),
+            diff_base: self.diff_base().as_ref().map(|h| h.to_string()),
             line_ending: proto::serialize_line_ending(self.line_ending()) as i32,
             saved_version: proto::serialize_version(&self.saved_version),
             saved_mtime: self.saved_mtime.map(|time| time.into()),
@@ -734,12 +744,10 @@ impl Buffer {
             was_dirty_before_starting_transaction: None,
             has_unsaved_edits: Cell::new((buffer.version(), false)),
             text: buffer,
-            diff_base: diff_base
-                .map(|mut raw_diff_base| {
-                    LineEnding::normalize(&mut raw_diff_base);
-                    raw_diff_base
-                })
-                .map(Rope::from),
+            diff_base: diff_base.map(|mut raw_diff_base| {
+                LineEnding::normalize(&mut raw_diff_base);
+                BufferDiffBase::Git(Rope::from(raw_diff_base))
+            }),
             diff_base_version: 0,
             git_diff,
             file,
@@ -759,6 +767,7 @@ impl Buffer {
             completion_triggers_timestamp: Default::default(),
             deferred_ops: OperationQueue::new(),
             has_conflict: false,
+            _subscriptions: Vec::new(),
         }
     }
 
@@ -782,6 +791,52 @@ impl Buffer {
         }
     }
 
+    pub fn branch(&mut self, cx: &mut ModelContext<Self>) -> Model<Self> {
+        let this = cx.handle();
+        cx.new_model(|cx| {
+            let mut branch = Self {
+                diff_base: Some(BufferDiffBase::PastBufferVersion(
+                    this.clone(),
+                    self.snapshot(),
+                )),
+                language: self.language.clone(),
+                has_conflict: self.has_conflict,
+                has_unsaved_edits: Cell::new(self.has_unsaved_edits.get_mut().clone()),
+                _subscriptions: vec![cx.subscribe(&this, |branch: &mut Self, _, event, cx| {
+                    if let BufferEvent::Operation { operation, .. } = event {
+                        branch.apply_ops([operation.clone()], cx);
+                        branch.diff_base_version += 1;
+                    }
+                })],
+                ..Self::build(
+                    self.text.branch(),
+                    None,
+                    self.file.clone(),
+                    self.capability(),
+                )
+            };
+            if let Some(language_registry) = self.language_registry() {
+                branch.set_language_registry(language_registry);
+            }
+
+            branch
+        })
+    }
+
+    pub fn merge(&mut self, branch: &Model<Self>, cx: &mut ModelContext<Self>) {
+        let branch = branch.read(cx);
+        let edits = branch
+            .edits_since::<usize>(&self.version)
+            .map(|edit| {
+                (
+                    edit.old,
+                    branch.text_for_range(edit.new).collect::<String>(),
+                )
+            })
+            .collect::<Vec<_>>();
+        self.edit(edits, None, cx);
+    }
+
     #[cfg(test)]
     pub(crate) fn as_text_snapshot(&self) -> &text::BufferSnapshot {
         &self.text
@@ -961,20 +1016,23 @@ impl Buffer {
 
     /// Returns the current diff base, see [Buffer::set_diff_base].
     pub fn diff_base(&self) -> Option<&Rope> {
-        self.diff_base.as_ref()
+        match self.diff_base.as_ref()? {
+            BufferDiffBase::Git(rope) => Some(rope),
+            BufferDiffBase::PastBufferVersion(_, buffer_snapshot) => {
+                Some(buffer_snapshot.as_rope())
+            }
+        }
     }
 
     /// Sets the text that will be used to compute a Git diff
     /// against the buffer text.
     pub fn set_diff_base(&mut self, diff_base: Option<String>, cx: &mut ModelContext<Self>) {
-        self.diff_base = diff_base
-            .map(|mut raw_diff_base| {
-                LineEnding::normalize(&mut raw_diff_base);
-                raw_diff_base
-            })
-            .map(Rope::from);
+        self.diff_base = diff_base.map(|mut raw_diff_base| {
+            LineEnding::normalize(&mut raw_diff_base);
+            BufferDiffBase::Git(Rope::from(raw_diff_base))
+        });
         self.diff_base_version += 1;
-        if let Some(recalc_task) = self.git_diff_recalc(cx) {
+        if let Some(recalc_task) = self.recalculate_diff(cx) {
             cx.spawn(|buffer, mut cx| async move {
                 recalc_task.await;
                 buffer
@@ -992,14 +1050,21 @@ impl Buffer {
         self.diff_base_version
     }
 
-    /// Recomputes the Git diff status.
-    pub fn git_diff_recalc(&mut self, cx: &mut ModelContext<Self>) -> Option<Task<()>> {
-        let diff_base = self.diff_base.clone()?;
+    /// Recomputes the diff.
+    pub fn recalculate_diff(&mut self, cx: &mut ModelContext<Self>) -> Option<Task<()>> {
+        let diff_base_rope = match self.diff_base.as_mut()? {
+            BufferDiffBase::Git(rope) => rope.clone(),
+            BufferDiffBase::PastBufferVersion(base_buffer, base_buffer_snapshot) => {
+                let new_base_snapshot = base_buffer.read(cx).snapshot();
+                *base_buffer_snapshot = new_base_snapshot;
+                base_buffer_snapshot.as_rope().clone()
+            }
+        };
         let snapshot = self.snapshot();
 
         let mut diff = self.git_diff.clone();
         let diff = cx.background_executor().spawn(async move {
-            diff.update(&diff_base, &snapshot).await;
+            diff.update(&diff_base_rope, &snapshot).await;
             diff
         });
 
@@ -1169,7 +1234,7 @@ impl Buffer {
             lamport_timestamp,
         };
         self.apply_diagnostic_update(server_id, diagnostics, lamport_timestamp, cx);
-        self.send_operation(op, cx);
+        self.send_operation(op, true, cx);
     }
 
     fn request_autoindent(&mut self, cx: &mut ModelContext<Self>) {
@@ -1743,6 +1808,7 @@ impl Buffer {
                 lamport_timestamp,
                 cursor_shape,
             },
+            true,
             cx,
         );
         self.non_text_state_update_count += 1;
@@ -1889,7 +1955,7 @@ impl Buffer {
         }
 
         self.end_transaction(cx);
-        self.send_operation(Operation::Buffer(edit_operation), cx);
+        self.send_operation(Operation::Buffer(edit_operation), true, cx);
         Some(edit_id)
     }
 
@@ -1991,6 +2057,9 @@ impl Buffer {
                 }
             })
             .collect::<Vec<_>>();
+        for operation in buffer_ops.iter() {
+            self.send_operation(Operation::Buffer(operation.clone()), false, cx);
+        }
         self.text.apply_ops(buffer_ops);
         self.deferred_ops.insert(deferred_ops);
         self.flush_deferred_ops(cx);
@@ -2114,8 +2183,16 @@ impl Buffer {
         }
     }
 
-    fn send_operation(&mut self, operation: Operation, cx: &mut ModelContext<Self>) {
-        cx.emit(BufferEvent::Operation(operation));
+    fn send_operation(
+        &mut self,
+        operation: Operation,
+        is_local: bool,
+        cx: &mut ModelContext<Self>,
+    ) {
+        cx.emit(BufferEvent::Operation {
+            operation,
+            is_local,
+        });
     }
 
     /// Removes the selections for a given peer.
@@ -2130,7 +2207,7 @@ impl Buffer {
         let old_version = self.version.clone();
 
         if let Some((transaction_id, operation)) = self.text.undo() {
-            self.send_operation(Operation::Buffer(operation), cx);
+            self.send_operation(Operation::Buffer(operation), true, cx);
             self.did_edit(&old_version, was_dirty, cx);
             Some(transaction_id)
         } else {
@@ -2147,7 +2224,7 @@ impl Buffer {
         let was_dirty = self.is_dirty();
         let old_version = self.version.clone();
         if let Some(operation) = self.text.undo_transaction(transaction_id) {
-            self.send_operation(Operation::Buffer(operation), cx);
+            self.send_operation(Operation::Buffer(operation), true, cx);
             self.did_edit(&old_version, was_dirty, cx);
             true
         } else {
@@ -2167,7 +2244,7 @@ impl Buffer {
         let operations = self.text.undo_to_transaction(transaction_id);
         let undone = !operations.is_empty();
         for operation in operations {
-            self.send_operation(Operation::Buffer(operation), cx);
+            self.send_operation(Operation::Buffer(operation), true, cx);
         }
         if undone {
             self.did_edit(&old_version, was_dirty, cx)
@@ -2181,7 +2258,7 @@ impl Buffer {
         let old_version = self.version.clone();
 
         if let Some((transaction_id, operation)) = self.text.redo() {
-            self.send_operation(Operation::Buffer(operation), cx);
+            self.send_operation(Operation::Buffer(operation), true, cx);
             self.did_edit(&old_version, was_dirty, cx);
             Some(transaction_id)
         } else {
@@ -2201,7 +2278,7 @@ impl Buffer {
         let operations = self.text.redo_to_transaction(transaction_id);
         let redone = !operations.is_empty();
         for operation in operations {
-            self.send_operation(Operation::Buffer(operation), cx);
+            self.send_operation(Operation::Buffer(operation), true, cx);
         }
         if redone {
             self.did_edit(&old_version, was_dirty, cx)
@@ -2218,6 +2295,7 @@ impl Buffer {
                 triggers,
                 lamport_timestamp: self.completion_triggers_timestamp,
             },
+            true,
             cx,
         );
         cx.notify();
@@ -2297,7 +2375,7 @@ impl Buffer {
         let ops = self.text.randomly_undo_redo(rng);
         if !ops.is_empty() {
             for op in ops {
-                self.send_operation(Operation::Buffer(op), cx);
+                self.send_operation(Operation::Buffer(op), true, cx);
                 self.did_edit(&old_version, was_dirty, cx);
             }
         }
@@ -3638,12 +3716,12 @@ impl BufferSnapshot {
         !self.git_diff.is_empty()
     }
 
-    /// Returns all the Git diff hunks intersecting the given
-    /// row range.
+    /// Returns all the Git diff hunks intersecting the given row range.
+    #[cfg(any(test, feature = "test-support"))]
     pub fn git_diff_hunks_in_row_range(
         &self,
         range: Range<BufferRow>,
-    ) -> impl '_ + Iterator<Item = git::diff::DiffHunk<u32>> {
+    ) -> impl '_ + Iterator<Item = git::diff::DiffHunk> {
         self.git_diff.hunks_in_row_range(range, self)
     }
 
@@ -3652,7 +3730,7 @@ impl BufferSnapshot {
     pub fn git_diff_hunks_intersecting_range(
         &self,
         range: Range<Anchor>,
-    ) -> impl '_ + Iterator<Item = git::diff::DiffHunk<u32>> {
+    ) -> impl '_ + Iterator<Item = git::diff::DiffHunk> {
         self.git_diff.hunks_intersecting_range(range, self)
     }
 
@@ -3661,7 +3739,7 @@ impl BufferSnapshot {
     pub fn git_diff_hunks_intersecting_range_rev(
         &self,
         range: Range<Anchor>,
-    ) -> impl '_ + Iterator<Item = git::diff::DiffHunk<u32>> {
+    ) -> impl '_ + Iterator<Item = git::diff::DiffHunk> {
         self.git_diff.hunks_intersecting_range_rev(range, self)
     }
 
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index 23faa33316da79..1335a94dd0313f 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -6,6 +6,7 @@ use crate::Buffer;
 use clock::ReplicaId;
 use collections::BTreeMap;
 use futures::FutureExt as _;
+use git::diff::assert_hunks;
 use gpui::{AppContext, BorrowAppContext, Model};
 use gpui::{Context, TestAppContext};
 use indoc::indoc;
@@ -275,13 +276,19 @@ fn test_edit_events(cx: &mut gpui::AppContext) {
         |buffer, cx| {
             let buffer_1_events = buffer_1_events.clone();
             cx.subscribe(&buffer1, move |_, _, event, _| match event.clone() {
-                BufferEvent::Operation(op) => buffer1_ops.lock().push(op),
+                BufferEvent::Operation {
+                    operation,
+                    is_local: true,
+                } => buffer1_ops.lock().push(operation),
                 event => buffer_1_events.lock().push(event),
             })
             .detach();
             let buffer_2_events = buffer_2_events.clone();
-            cx.subscribe(&buffer2, move |_, _, event, _| {
-                buffer_2_events.lock().push(event.clone())
+            cx.subscribe(&buffer2, move |_, _, event, _| match event.clone() {
+                BufferEvent::Operation {
+                    is_local: false, ..
+                } => {}
+                event => buffer_2_events.lock().push(event),
             })
             .detach();
 
@@ -2370,6 +2377,118 @@ async fn test_find_matching_indent(cx: &mut TestAppContext) {
     );
 }
 
+#[gpui::test]
+fn test_branch_and_merge(cx: &mut TestAppContext) {
+    cx.update(|cx| init_settings(cx, |_| {}));
+
+    let base_buffer = cx.new_model(|cx| Buffer::local("one\ntwo\nthree\n", cx));
+
+    // Create a remote replica of the base buffer.
+    let base_buffer_replica = cx.new_model(|cx| {
+        Buffer::from_proto(
+            1,
+            Capability::ReadWrite,
+            base_buffer.read(cx).to_proto(cx),
+            None,
+        )
+        .unwrap()
+    });
+    base_buffer.update(cx, |_buffer, cx| {
+        cx.subscribe(&base_buffer_replica, |this, _, event, cx| {
+            if let BufferEvent::Operation {
+                operation,
+                is_local: true,
+            } = event
+            {
+                this.apply_ops([operation.clone()], cx);
+            }
+        })
+        .detach();
+    });
+
+    // Create a branch, which initially has the same state as the base buffer.
+    let branch_buffer = base_buffer.update(cx, |buffer, cx| buffer.branch(cx));
+    branch_buffer.read_with(cx, |buffer, _| {
+        assert_eq!(buffer.text(), "one\ntwo\nthree\n");
+    });
+
+    // Edits to the branch are not applied to the base.
+    branch_buffer.update(cx, |buffer, cx| {
+        buffer.edit(
+            [(Point::new(1, 0)..Point::new(1, 0), "ONE_POINT_FIVE\n")],
+            None,
+            cx,
+        )
+    });
+    branch_buffer.read_with(cx, |branch_buffer, cx| {
+        assert_eq!(base_buffer.read(cx).text(), "one\ntwo\nthree\n");
+        assert_eq!(branch_buffer.text(), "one\nONE_POINT_FIVE\ntwo\nthree\n");
+    });
+
+    // Edits to the base are applied to the branch.
+    base_buffer.update(cx, |buffer, cx| {
+        buffer.edit([(Point::new(0, 0)..Point::new(0, 0), "ZERO\n")], None, cx)
+    });
+    branch_buffer.read_with(cx, |branch_buffer, cx| {
+        assert_eq!(base_buffer.read(cx).text(), "ZERO\none\ntwo\nthree\n");
+        assert_eq!(
+            branch_buffer.text(),
+            "ZERO\none\nONE_POINT_FIVE\ntwo\nthree\n"
+        );
+    });
+
+    assert_diff_hunks(&branch_buffer, cx, &[(2..3, "", "ONE_POINT_FIVE\n")]);
+
+    // Edits to any replica of the base are applied to the branch.
+    base_buffer_replica.update(cx, |buffer, cx| {
+        buffer.edit(
+            [(Point::new(2, 0)..Point::new(2, 0), "TWO_POINT_FIVE\n")],
+            None,
+            cx,
+        )
+    });
+    branch_buffer.read_with(cx, |branch_buffer, cx| {
+        assert_eq!(
+            base_buffer.read(cx).text(),
+            "ZERO\none\ntwo\nTWO_POINT_FIVE\nthree\n"
+        );
+        assert_eq!(
+            branch_buffer.text(),
+            "ZERO\none\nONE_POINT_FIVE\ntwo\nTWO_POINT_FIVE\nthree\n"
+        );
+    });
+
+    // Merging the branch applies all of its changes to the base.
+    base_buffer.update(cx, |base_buffer, cx| {
+        base_buffer.merge(&branch_buffer, cx);
+        assert_eq!(
+            base_buffer.text(),
+            "ZERO\none\nONE_POINT_FIVE\ntwo\nTWO_POINT_FIVE\nthree\n"
+        );
+    });
+}
+
+fn assert_diff_hunks(
+    buffer: &Model<Buffer>,
+    cx: &mut TestAppContext,
+    expected_hunks: &[(Range<u32>, &str, &str)],
+) {
+    buffer
+        .update(cx, |buffer, cx| buffer.recalculate_diff(cx).unwrap())
+        .detach();
+    cx.executor().run_until_parked();
+
+    buffer.read_with(cx, |buffer, _| {
+        let snapshot = buffer.snapshot();
+        assert_hunks(
+            snapshot.git_diff_hunks_intersecting_range(Anchor::MIN..Anchor::MAX),
+            &snapshot,
+            &buffer.diff_base().unwrap().to_string(),
+            expected_hunks,
+        );
+    });
+}
+
 #[gpui::test(iterations = 100)]
 fn test_random_collaboration(cx: &mut AppContext, mut rng: StdRng) {
     let min_peers = env::var("MIN_PEERS")
@@ -2407,10 +2526,15 @@ fn test_random_collaboration(cx: &mut AppContext, mut rng: StdRng) {
             buffer.set_group_interval(Duration::from_millis(rng.gen_range(0..=200)));
             let network = network.clone();
             cx.subscribe(&cx.handle(), move |buffer, _, event, _| {
-                if let BufferEvent::Operation(op) = event {
-                    network
-                        .lock()
-                        .broadcast(buffer.replica_id(), vec![proto::serialize_operation(op)]);
+                if let BufferEvent::Operation {
+                    operation,
+                    is_local: true,
+                } = event
+                {
+                    network.lock().broadcast(
+                        buffer.replica_id(),
+                        vec![proto::serialize_operation(operation)],
+                    );
                 }
             })
             .detach();
@@ -2533,10 +2657,14 @@ fn test_random_collaboration(cx: &mut AppContext, mut rng: StdRng) {
                     new_buffer.set_group_interval(Duration::from_millis(rng.gen_range(0..=200)));
                     let network = network.clone();
                     cx.subscribe(&cx.handle(), move |buffer, _, event, _| {
-                        if let BufferEvent::Operation(op) = event {
+                        if let BufferEvent::Operation {
+                            operation,
+                            is_local: true,
+                        } = event
+                        {
                             network.lock().broadcast(
                                 buffer.replica_id(),
-                                vec![proto::serialize_operation(op)],
+                                vec![proto::serialize_operation(operation)],
                             );
                         }
                     })
diff --git a/crates/multi_buffer/Cargo.toml b/crates/multi_buffer/Cargo.toml
index acd0c89f8ee4ad..444fe3c75c6cfb 100644
--- a/crates/multi_buffer/Cargo.toml
+++ b/crates/multi_buffer/Cargo.toml
@@ -27,7 +27,6 @@ collections.workspace = true
 ctor.workspace = true
 env_logger.workspace = true
 futures.workspace = true
-git.workspace = true
 gpui.workspace = true
 itertools.workspace = true
 language.workspace = true
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index f6a61f562a71fc..d406f9bfaf6ac2 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -5,7 +5,6 @@ use anyhow::{anyhow, Result};
 use clock::ReplicaId;
 use collections::{BTreeMap, Bound, HashMap, HashSet};
 use futures::{channel::mpsc, SinkExt};
-use git::diff::DiffHunk;
 use gpui::{AppContext, EntityId, EventEmitter, Model, ModelContext};
 use itertools::Itertools;
 use language::{
@@ -110,6 +109,19 @@ pub enum Event {
     DiagnosticsUpdated,
 }
 
+/// A diff hunk, representing a range of consequent lines in a multibuffer.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MultiBufferDiffHunk {
+    /// The row range in the multibuffer where this diff hunk appears.
+    pub row_range: Range<MultiBufferRow>,
+    /// The buffer ID that this hunk belongs to.
+    pub buffer_id: BufferId,
+    /// The range of the underlying buffer that this hunk corresponds to.
+    pub buffer_range: Range<text::Anchor>,
+    /// The range within the buffer's diff base that this hunk corresponds to.
+    pub diff_base_byte_range: Range<usize>,
+}
+
 pub type MultiBufferPoint = Point;
 
 #[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq, serde::Deserialize)]
@@ -1711,7 +1723,7 @@ impl MultiBuffer {
             }
 
             //
-            language::BufferEvent::Operation(_) => return,
+            language::BufferEvent::Operation { .. } => return,
         });
     }
 
@@ -3561,7 +3573,7 @@ impl MultiBufferSnapshot {
     pub fn git_diff_hunks_in_range_rev(
         &self,
         row_range: Range<MultiBufferRow>,
-    ) -> impl Iterator<Item = DiffHunk<MultiBufferRow>> + '_ {
+    ) -> impl Iterator<Item = MultiBufferDiffHunk> + '_ {
         let mut cursor = self.excerpts.cursor::<Point>(&());
 
         cursor.seek(&Point::new(row_range.end.0, 0), Bias::Left, &());
@@ -3599,22 +3611,19 @@ impl MultiBufferSnapshot {
                 .git_diff_hunks_intersecting_range_rev(buffer_start..buffer_end)
                 .map(move |hunk| {
                     let start = multibuffer_start.row
-                        + hunk
-                            .associated_range
-                            .start
-                            .saturating_sub(excerpt_start_point.row);
+                        + hunk.row_range.start.saturating_sub(excerpt_start_point.row);
                     let end = multibuffer_start.row
                         + hunk
-                            .associated_range
+                            .row_range
                             .end
                             .min(excerpt_end_point.row + 1)
                             .saturating_sub(excerpt_start_point.row);
 
-                    DiffHunk {
-                        associated_range: MultiBufferRow(start)..MultiBufferRow(end),
+                    MultiBufferDiffHunk {
+                        row_range: MultiBufferRow(start)..MultiBufferRow(end),
                         diff_base_byte_range: hunk.diff_base_byte_range.clone(),
                         buffer_range: hunk.buffer_range.clone(),
-                        buffer_id: hunk.buffer_id,
+                        buffer_id: excerpt.buffer_id,
                     }
                 });
 
@@ -3628,7 +3637,7 @@ impl MultiBufferSnapshot {
     pub fn git_diff_hunks_in_range(
         &self,
         row_range: Range<MultiBufferRow>,
-    ) -> impl Iterator<Item = DiffHunk<MultiBufferRow>> + '_ {
+    ) -> impl Iterator<Item = MultiBufferDiffHunk> + '_ {
         let mut cursor = self.excerpts.cursor::<Point>(&());
 
         cursor.seek(&Point::new(row_range.start.0, 0), Bias::Left, &());
@@ -3673,23 +3682,20 @@ impl MultiBufferSnapshot {
                         MultiBufferRow(0)..MultiBufferRow(1)
                     } else {
                         let start = multibuffer_start.row
-                            + hunk
-                                .associated_range
-                                .start
-                                .saturating_sub(excerpt_rows.start);
+                            + hunk.row_range.start.saturating_sub(excerpt_rows.start);
                         let end = multibuffer_start.row
                             + hunk
-                                .associated_range
+                                .row_range
                                 .end
                                 .min(excerpt_rows.end + 1)
                                 .saturating_sub(excerpt_rows.start);
                         MultiBufferRow(start)..MultiBufferRow(end)
                     };
-                    DiffHunk {
-                        associated_range: buffer_range,
+                    MultiBufferDiffHunk {
+                        row_range: buffer_range,
                         diff_base_byte_range: hunk.diff_base_byte_range.clone(),
                         buffer_range: hunk.buffer_range.clone(),
-                        buffer_id: hunk.buffer_id,
+                        buffer_id: excerpt.buffer_id,
                     }
                 });
 
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 435c1430243705..bd9c17ecb29b99 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -2182,7 +2182,10 @@ impl Project {
 
         let buffer_id = buffer.read(cx).remote_id();
         match event {
-            BufferEvent::Operation(operation) => {
+            BufferEvent::Operation {
+                operation,
+                is_local: true,
+            } => {
                 let operation = language::proto::serialize_operation(operation);
 
                 if let Some(ssh) = &self.ssh_session {
@@ -2267,7 +2270,7 @@ impl Project {
                 .filter_map(|buffer| {
                     let buffer = buffer.upgrade()?;
                     buffer
-                        .update(&mut cx, |buffer, cx| buffer.git_diff_recalc(cx))
+                        .update(&mut cx, |buffer, cx| buffer.recalculate_diff(cx))
                         .ok()
                         .flatten()
                 })
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index 72a38ccba7d781..d0d67f0cda4a40 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -3288,7 +3288,7 @@ async fn test_buffer_is_dirty(cx: &mut gpui::TestAppContext) {
         cx.subscribe(&buffer1, {
             let events = events.clone();
             move |_, _, event, _| match event {
-                BufferEvent::Operation(_) => {}
+                BufferEvent::Operation { .. } => {}
                 _ => events.lock().push(event.clone()),
             }
         })
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 54f48e36269baf..9d5c26d6c7ce1a 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -146,12 +146,15 @@ impl HeadlessProject {
         cx: &mut ModelContext<Self>,
     ) {
         match event {
-            BufferEvent::Operation(op) => cx
+            BufferEvent::Operation {
+                operation,
+                is_local: true,
+            } => cx
                 .background_executor()
                 .spawn(self.session.request(proto::UpdateBuffer {
                     project_id: SSH_PROJECT_ID,
                     buffer_id: buffer.read(cx).remote_id().to_proto(),
-                    operations: vec![serialize_operation(op)],
+                    operations: vec![serialize_operation(operation)],
                 }))
                 .detach(),
             _ => {}
diff --git a/crates/text/src/text.rs b/crates/text/src/text.rs
index 8d2cd97aacaaee..8bdc9fdb03d89b 100644
--- a/crates/text/src/text.rs
+++ b/crates/text/src/text.rs
@@ -13,6 +13,7 @@ mod undo_map;
 pub use anchor::*;
 use anyhow::{anyhow, Context as _, Result};
 pub use clock::ReplicaId;
+use clock::LOCAL_BRANCH_REPLICA_ID;
 use collections::{HashMap, HashSet};
 use locator::Locator;
 use operation_queue::OperationQueue;
@@ -715,6 +716,19 @@ impl Buffer {
         self.snapshot.clone()
     }
 
+    pub fn branch(&self) -> Self {
+        Self {
+            snapshot: self.snapshot.clone(),
+            history: History::new(self.base_text().clone()),
+            deferred_ops: OperationQueue::new(),
+            deferred_replicas: HashSet::default(),
+            lamport_clock: clock::Lamport::new(LOCAL_BRANCH_REPLICA_ID),
+            subscriptions: Default::default(),
+            edit_id_resolvers: Default::default(),
+            wait_for_version_txs: Default::default(),
+        }
+    }
+
     pub fn replica_id(&self) -> ReplicaId {
         self.lamport_clock.replica_id
     }

From 4f227fd3bf19fe7393d278545edfa06343dc5958 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Fri, 20 Sep 2024 18:51:34 -0600
Subject: [PATCH 258/762] Use LanguageServerName in more places (#18167)

This pushes the new LanguageServerName type to more places.

As both languages and language servers were identified by Arc<str>, it
was
sometimes hard to tell which was intended.

Release Notes:

- N/A
---
 .../src/activity_indicator.rs                 |  7 ++-
 .../remote_editing_collaboration_tests.rs     |  2 +-
 .../src/wasm_host/wit/since_v0_1_0.rs         |  4 +-
 .../src/wasm_host/wit/since_v0_2_0.rs         |  4 +-
 crates/gpui/src/shared_string.rs              |  7 +++
 crates/language/src/language.rs               | 57 ++++++++++++++++---
 crates/language/src/language_settings.rs      | 32 ++++++-----
 crates/language_tools/src/lsp_log.rs          |  2 +-
 crates/languages/src/c.rs                     |  7 ++-
 crates/languages/src/go.rs                    |  7 ++-
 crates/languages/src/python.rs                | 21 ++++---
 crates/languages/src/rust.rs                  |  8 +--
 crates/languages/src/tailwind.rs              |  9 +--
 crates/languages/src/typescript.rs            | 13 +++--
 crates/languages/src/vtsls.rs                 |  8 +--
 crates/languages/src/yaml.rs                  |  8 +--
 crates/project/src/lsp_store.rs               | 24 ++++----
 crates/project/src/prettier_store.rs          |  4 +-
 crates/project/src/project_settings.rs        |  3 +-
 .../remote_server/src/remote_editing_tests.rs |  8 +--
 20 files changed, 150 insertions(+), 85 deletions(-)

diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs
index 3f567c9e802b80..a9ae7d075d10c2 100644
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -19,7 +19,10 @@ use workspace::{item::ItemHandle, StatusItemView, Workspace};
 actions!(activity_indicator, [ShowErrorMessage]);
 
 pub enum Event {
-    ShowError { lsp_name: Arc<str>, error: String },
+    ShowError {
+        lsp_name: LanguageServerName,
+        error: String,
+    },
 }
 
 pub struct ActivityIndicator {
@@ -123,7 +126,7 @@ impl ActivityIndicator {
         self.statuses.retain(|status| {
             if let LanguageServerBinaryStatus::Failed { error } = &status.status {
                 cx.emit(Event::ShowError {
-                    lsp_name: status.name.0.clone(),
+                    lsp_name: status.name.clone(),
                     error: error.clone(),
                 });
                 false
diff --git a/crates/collab/src/tests/remote_editing_collaboration_tests.rs b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
index c4410fd776be7d..cdcf69cf7e9ace 100644
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -102,7 +102,7 @@ async fn test_sharing_an_ssh_remote_project(
             all_language_settings(file, cx)
                 .language(Some(&("Rust".into())))
                 .language_servers,
-            ["override-rust-analyzer".into()]
+            ["override-rust-analyzer".to_string()]
         )
     });
 
diff --git a/crates/extension/src/wasm_host/wit/since_v0_1_0.rs b/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
index 50547b6371c697..3835f58f885290 100644
--- a/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
+++ b/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
@@ -9,10 +9,10 @@ use futures::{io::BufReader, FutureExt as _};
 use futures::{lock::Mutex, AsyncReadExt};
 use indexed_docs::IndexedDocsDatabase;
 use isahc::config::{Configurable, RedirectPolicy};
-use language::LanguageName;
 use language::{
     language_settings::AllLanguageSettings, LanguageServerBinaryStatus, LspAdapterDelegate,
 };
+use language::{LanguageName, LanguageServerName};
 use project::project_settings::ProjectSettings;
 use semantic_version::SemanticVersion;
 use std::{
@@ -366,7 +366,7 @@ impl ExtensionImports for WasmState {
                             .and_then(|key| {
                                 ProjectSettings::get(location, cx)
                                     .lsp
-                                    .get(&Arc::<str>::from(key))
+                                    .get(&LanguageServerName(key.into()))
                             })
                             .cloned()
                             .unwrap_or_default();
diff --git a/crates/extension/src/wasm_host/wit/since_v0_2_0.rs b/crates/extension/src/wasm_host/wit/since_v0_2_0.rs
index 7fa79c2544475b..eb6e1a09a2ae99 100644
--- a/crates/extension/src/wasm_host/wit/since_v0_2_0.rs
+++ b/crates/extension/src/wasm_host/wit/since_v0_2_0.rs
@@ -9,10 +9,10 @@ use futures::{io::BufReader, FutureExt as _};
 use futures::{lock::Mutex, AsyncReadExt};
 use indexed_docs::IndexedDocsDatabase;
 use isahc::config::{Configurable, RedirectPolicy};
-use language::LanguageName;
 use language::{
     language_settings::AllLanguageSettings, LanguageServerBinaryStatus, LspAdapterDelegate,
 };
+use language::{LanguageName, LanguageServerName};
 use project::project_settings::ProjectSettings;
 use semantic_version::SemanticVersion;
 use std::{
@@ -412,7 +412,7 @@ impl ExtensionImports for WasmState {
                             .and_then(|key| {
                                 ProjectSettings::get(location, cx)
                                     .lsp
-                                    .get(&Arc::<str>::from(key))
+                                    .get(&LanguageServerName::from_proto(key))
                             })
                             .cloned()
                             .unwrap_or_default();
diff --git a/crates/gpui/src/shared_string.rs b/crates/gpui/src/shared_string.rs
index a4ed36ec211176..f5aef6adf80be6 100644
--- a/crates/gpui/src/shared_string.rs
+++ b/crates/gpui/src/shared_string.rs
@@ -9,6 +9,13 @@ use util::arc_cow::ArcCow;
 #[derive(Deref, DerefMut, Eq, PartialEq, PartialOrd, Ord, Hash, Clone)]
 pub struct SharedString(ArcCow<'static, str>);
 
+impl SharedString {
+    /// creates a static SharedString
+    pub const fn new_static(s: &'static str) -> Self {
+        Self(ArcCow::Borrowed(s))
+    }
+}
+
 impl Default for SharedString {
     fn default() -> Self {
         Self(ArcCow::Owned(Arc::default()))
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index 309a67a1a96a41..29a7ac1860b0c5 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -139,11 +139,52 @@ pub trait ToLspPosition {
 
 /// A name of a language server.
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize)]
-pub struct LanguageServerName(pub Arc<str>);
+pub struct LanguageServerName(pub SharedString);
 
+impl std::fmt::Display for LanguageServerName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl AsRef<str> for LanguageServerName {
+    fn as_ref(&self) -> &str {
+        self.0.as_ref()
+    }
+}
+
+impl AsRef<OsStr> for LanguageServerName {
+    fn as_ref(&self) -> &OsStr {
+        self.0.as_ref().as_ref()
+    }
+}
+
+impl JsonSchema for LanguageServerName {
+    fn schema_name() -> String {
+        "LanguageServerName".into()
+    }
+
+    fn json_schema(_: &mut SchemaGenerator) -> Schema {
+        SchemaObject {
+            instance_type: Some(InstanceType::String.into()),
+            ..Default::default()
+        }
+        .into()
+    }
+}
 impl LanguageServerName {
+    pub const fn new_static(s: &'static str) -> Self {
+        Self(SharedString::new_static(s))
+    }
+
     pub fn from_proto(s: String) -> Self {
-        Self(Arc::from(s))
+        Self(s.into())
+    }
+}
+
+impl<'a> From<&'a str> for LanguageServerName {
+    fn from(str: &'a str) -> LanguageServerName {
+        LanguageServerName(str.to_string().into())
     }
 }
 
@@ -202,8 +243,8 @@ impl CachedLspAdapter {
         })
     }
 
-    pub fn name(&self) -> Arc<str> {
-        self.adapter.name().0.clone()
+    pub fn name(&self) -> LanguageServerName {
+        self.adapter.name().clone()
     }
 
     pub async fn get_language_server_command(
@@ -594,7 +635,7 @@ pub struct LanguageConfig {
     pub block_comment: Option<(Arc<str>, Arc<str>)>,
     /// A list of language servers that are allowed to run on subranges of a given language.
     #[serde(default)]
-    pub scope_opt_in_language_servers: Vec<String>,
+    pub scope_opt_in_language_servers: Vec<LanguageServerName>,
     #[serde(default)]
     pub overrides: HashMap<String, LanguageConfigOverride>,
     /// A list of characters that Zed should treat as word characters for the
@@ -658,7 +699,7 @@ pub struct LanguageConfigOverride {
     #[serde(default)]
     pub word_characters: Override<HashSet<char>>,
     #[serde(default)]
-    pub opt_into_language_servers: Vec<String>,
+    pub opt_into_language_servers: Vec<LanguageServerName>,
 }
 
 #[derive(Clone, Deserialize, Debug, Serialize, JsonSchema)]
@@ -1479,9 +1520,9 @@ impl LanguageScope {
     pub fn language_allowed(&self, name: &LanguageServerName) -> bool {
         let config = &self.language.config;
         let opt_in_servers = &config.scope_opt_in_language_servers;
-        if opt_in_servers.iter().any(|o| *o == *name.0) {
+        if opt_in_servers.iter().any(|o| *o == *name) {
             if let Some(over) = self.config_override() {
-                over.opt_into_language_servers.iter().any(|o| *o == *name.0)
+                over.opt_into_language_servers.iter().any(|o| *o == *name)
             } else {
                 false
             }
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index 6121cb6a39a2ca..82d4208aae6eb7 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -99,7 +99,7 @@ pub struct LanguageSettings {
     /// special tokens:
     /// - `"!<language_server_id>"` - A language server ID prefixed with a `!` will be disabled.
     /// - `"..."` - A placeholder to refer to the **rest** of the registered language servers for this language.
-    pub language_servers: Vec<Arc<str>>,
+    pub language_servers: Vec<String>,
     /// Controls whether inline completions are shown immediately (true)
     /// or manually by triggering `editor::ShowInlineCompletion` (false).
     pub show_inline_completions: bool,
@@ -137,22 +137,24 @@ impl LanguageSettings {
     }
 
     pub(crate) fn resolve_language_servers(
-        configured_language_servers: &[Arc<str>],
+        configured_language_servers: &[String],
         available_language_servers: &[LanguageServerName],
     ) -> Vec<LanguageServerName> {
-        let (disabled_language_servers, enabled_language_servers): (Vec<Arc<str>>, Vec<Arc<str>>) =
-            configured_language_servers.iter().partition_map(
-                |language_server| match language_server.strip_prefix('!') {
-                    Some(disabled) => Either::Left(disabled.into()),
-                    None => Either::Right(language_server.clone()),
-                },
-            );
+        let (disabled_language_servers, enabled_language_servers): (
+            Vec<LanguageServerName>,
+            Vec<LanguageServerName>,
+        ) = configured_language_servers.iter().partition_map(
+            |language_server| match language_server.strip_prefix('!') {
+                Some(disabled) => Either::Left(LanguageServerName(disabled.to_string().into())),
+                None => Either::Right(LanguageServerName(language_server.clone().into())),
+            },
+        );
 
         let rest = available_language_servers
             .iter()
             .filter(|&available_language_server| {
-                !disabled_language_servers.contains(&available_language_server.0)
-                    && !enabled_language_servers.contains(&available_language_server.0)
+                !disabled_language_servers.contains(&available_language_server)
+                    && !enabled_language_servers.contains(&available_language_server)
             })
             .cloned()
             .collect::<Vec<_>>();
@@ -160,10 +162,10 @@ impl LanguageSettings {
         enabled_language_servers
             .into_iter()
             .flat_map(|language_server| {
-                if language_server.as_ref() == Self::REST_OF_LANGUAGE_SERVERS {
+                if language_server.0.as_ref() == Self::REST_OF_LANGUAGE_SERVERS {
                     rest.clone()
                 } else {
-                    vec![LanguageServerName(language_server.clone())]
+                    vec![language_server.clone()]
                 }
             })
             .collect::<Vec<_>>()
@@ -295,7 +297,7 @@ pub struct LanguageSettingsContent {
     ///
     /// Default: ["..."]
     #[serde(default)]
-    pub language_servers: Option<Vec<Arc<str>>>,
+    pub language_servers: Option<Vec<String>>,
     /// Controls whether inline completions are shown immediately (true)
     /// or manually by triggering `editor::ShowInlineCompletion` (false).
     ///
@@ -1165,7 +1167,7 @@ mod tests {
             names
                 .iter()
                 .copied()
-                .map(|name| LanguageServerName(name.into()))
+                .map(|name| LanguageServerName(name.to_string().into()))
                 .collect::<Vec<_>>()
         }
 
diff --git a/crates/language_tools/src/lsp_log.rs b/crates/language_tools/src/lsp_log.rs
index 53def5eb2a1195..bde5fe9b199e8d 100644
--- a/crates/language_tools/src/lsp_log.rs
+++ b/crates/language_tools/src/lsp_log.rs
@@ -236,7 +236,7 @@ impl LogStore {
                             ));
                         this.add_language_server(
                             LanguageServerKind::Global {
-                                name: LanguageServerName(Arc::from("copilot")),
+                                name: LanguageServerName::new_static("copilot"),
                             },
                             server.server_id(),
                             Some(server.clone()),
diff --git a/crates/languages/src/c.rs b/crates/languages/src/c.rs
index 4ebb4569ef1406..8a04e0aae6f4ef 100644
--- a/crates/languages/src/c.rs
+++ b/crates/languages/src/c.rs
@@ -13,13 +13,13 @@ use util::{fs::remove_matching, maybe, ResultExt};
 pub struct CLspAdapter;
 
 impl CLspAdapter {
-    const SERVER_NAME: &'static str = "clangd";
+    const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("clangd");
 }
 
 #[async_trait(?Send)]
 impl super::LspAdapter for CLspAdapter {
     fn name(&self) -> LanguageServerName {
-        LanguageServerName(Self::SERVER_NAME.into())
+        Self::SERVER_NAME.clone()
     }
 
     async fn check_if_user_installed(
@@ -28,7 +28,8 @@ impl super::LspAdapter for CLspAdapter {
         cx: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx.update(|cx| {
-            language_server_settings(delegate, Self::SERVER_NAME, cx).and_then(|s| s.binary.clone())
+            language_server_settings(delegate, &Self::SERVER_NAME, cx)
+                .and_then(|s| s.binary.clone())
         });
 
         match configured_binary {
diff --git a/crates/languages/src/go.rs b/crates/languages/src/go.rs
index a103c4783cffad..a1a996c066ee4b 100644
--- a/crates/languages/src/go.rs
+++ b/crates/languages/src/go.rs
@@ -33,7 +33,7 @@ fn server_binary_arguments() -> Vec<OsString> {
 pub struct GoLspAdapter;
 
 impl GoLspAdapter {
-    const SERVER_NAME: &'static str = "gopls";
+    const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("gopls");
 }
 
 static GOPLS_VERSION_REGEX: LazyLock<Regex> =
@@ -46,7 +46,7 @@ static GO_ESCAPE_SUBTEST_NAME_REGEX: LazyLock<Regex> = LazyLock::new(|| {
 #[async_trait(?Send)]
 impl super::LspAdapter for GoLspAdapter {
     fn name(&self) -> LanguageServerName {
-        LanguageServerName(Self::SERVER_NAME.into())
+        Self::SERVER_NAME.clone()
     }
 
     async fn fetch_latest_server_version(
@@ -71,7 +71,8 @@ impl super::LspAdapter for GoLspAdapter {
         cx: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx.update(|cx| {
-            language_server_settings(delegate, Self::SERVER_NAME, cx).and_then(|s| s.binary.clone())
+            language_server_settings(delegate, &Self::SERVER_NAME, cx)
+                .and_then(|s| s.binary.clone())
         });
 
         match configured_binary {
diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs
index ee127c00cca846..0dce8fb6617616 100644
--- a/crates/languages/src/python.rs
+++ b/crates/languages/src/python.rs
@@ -30,7 +30,7 @@ pub struct PythonLspAdapter {
 }
 
 impl PythonLspAdapter {
-    const SERVER_NAME: &'static str = "pyright";
+    const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("pyright");
 
     pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
         PythonLspAdapter { node }
@@ -40,7 +40,7 @@ impl PythonLspAdapter {
 #[async_trait(?Send)]
 impl LspAdapter for PythonLspAdapter {
     fn name(&self) -> LanguageServerName {
-        LanguageServerName(Self::SERVER_NAME.into())
+        Self::SERVER_NAME.clone()
     }
 
     async fn fetch_latest_server_version(
@@ -49,7 +49,7 @@ impl LspAdapter for PythonLspAdapter {
     ) -> Result<Box<dyn 'static + Any + Send>> {
         Ok(Box::new(
             self.node
-                .npm_package_latest_version(Self::SERVER_NAME)
+                .npm_package_latest_version(Self::SERVER_NAME.as_ref())
                 .await?,
         ) as Box<_>)
     }
@@ -62,16 +62,23 @@ impl LspAdapter for PythonLspAdapter {
     ) -> Result<LanguageServerBinary> {
         let latest_version = latest_version.downcast::<String>().unwrap();
         let server_path = container_dir.join(SERVER_PATH);
-        let package_name = Self::SERVER_NAME;
 
         let should_install_language_server = self
             .node
-            .should_install_npm_package(package_name, &server_path, &container_dir, &latest_version)
+            .should_install_npm_package(
+                Self::SERVER_NAME.as_ref(),
+                &server_path,
+                &container_dir,
+                &latest_version,
+            )
             .await;
 
         if should_install_language_server {
             self.node
-                .npm_install_packages(&container_dir, &[(package_name, latest_version.as_str())])
+                .npm_install_packages(
+                    &container_dir,
+                    &[(Self::SERVER_NAME.as_ref(), latest_version.as_str())],
+                )
                 .await?;
         }
 
@@ -182,7 +189,7 @@ impl LspAdapter for PythonLspAdapter {
         cx: &mut AsyncAppContext,
     ) -> Result<Value> {
         cx.update(|cx| {
-            language_server_settings(adapter.as_ref(), Self::SERVER_NAME, cx)
+            language_server_settings(adapter.as_ref(), &Self::SERVER_NAME, cx)
                 .and_then(|s| s.settings.clone())
                 .unwrap_or_default()
         })
diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs
index a32ffe50f519f1..eebd573a7e25fa 100644
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -25,13 +25,13 @@ use util::{fs::remove_matching, maybe, ResultExt};
 pub struct RustLspAdapter;
 
 impl RustLspAdapter {
-    const SERVER_NAME: &'static str = "rust-analyzer";
+    const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("rust-analyzer");
 }
 
 #[async_trait(?Send)]
 impl LspAdapter for RustLspAdapter {
     fn name(&self) -> LanguageServerName {
-        LanguageServerName(Self::SERVER_NAME.into())
+        Self::SERVER_NAME.clone()
     }
 
     async fn check_if_user_installed(
@@ -41,7 +41,7 @@ impl LspAdapter for RustLspAdapter {
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx
             .update(|cx| {
-                language_server_settings(delegate, Self::SERVER_NAME, cx)
+                language_server_settings(delegate, &Self::SERVER_NAME, cx)
                     .and_then(|s| s.binary.clone())
             })
             .ok()?;
@@ -60,7 +60,7 @@ impl LspAdapter for RustLspAdapter {
                 path_lookup: None,
                 ..
             }) => {
-                let path = delegate.which(Self::SERVER_NAME.as_ref()).await;
+                let path = delegate.which("rust-analyzer".as_ref()).await;
                 let env = delegate.shell_env().await;
 
                 if let Some(path) = path {
diff --git a/crates/languages/src/tailwind.rs b/crates/languages/src/tailwind.rs
index 9a053dbd8739ce..e3e17a8fa72eb4 100644
--- a/crates/languages/src/tailwind.rs
+++ b/crates/languages/src/tailwind.rs
@@ -32,7 +32,8 @@ pub struct TailwindLspAdapter {
 }
 
 impl TailwindLspAdapter {
-    const SERVER_NAME: &'static str = "tailwindcss-language-server";
+    const SERVER_NAME: LanguageServerName =
+        LanguageServerName::new_static("tailwindcss-language-server");
 
     pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
         TailwindLspAdapter { node }
@@ -42,7 +43,7 @@ impl TailwindLspAdapter {
 #[async_trait(?Send)]
 impl LspAdapter for TailwindLspAdapter {
     fn name(&self) -> LanguageServerName {
-        LanguageServerName(Self::SERVER_NAME.into())
+        Self::SERVER_NAME.clone()
     }
 
     async fn check_if_user_installed(
@@ -52,7 +53,7 @@ impl LspAdapter for TailwindLspAdapter {
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx
             .update(|cx| {
-                language_server_settings(delegate, Self::SERVER_NAME, cx)
+                language_server_settings(delegate, &Self::SERVER_NAME, cx)
                     .and_then(|s| s.binary.clone())
             })
             .ok()??;
@@ -152,7 +153,7 @@ impl LspAdapter for TailwindLspAdapter {
         cx: &mut AsyncAppContext,
     ) -> Result<Value> {
         let tailwind_user_settings = cx.update(|cx| {
-            language_server_settings(delegate.as_ref(), Self::SERVER_NAME, cx)
+            language_server_settings(delegate.as_ref(), &Self::SERVER_NAME, cx)
                 .and_then(|s| s.settings.clone())
                 .unwrap_or_default()
         })?;
diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs
index c65b74aa9bb14e..b09216c9703698 100644
--- a/crates/languages/src/typescript.rs
+++ b/crates/languages/src/typescript.rs
@@ -71,7 +71,8 @@ pub struct TypeScriptLspAdapter {
 impl TypeScriptLspAdapter {
     const OLD_SERVER_PATH: &'static str = "node_modules/typescript-language-server/lib/cli.js";
     const NEW_SERVER_PATH: &'static str = "node_modules/typescript-language-server/lib/cli.mjs";
-    const SERVER_NAME: &'static str = "typescript-language-server";
+    const SERVER_NAME: LanguageServerName =
+        LanguageServerName::new_static("typescript-language-server");
     pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
         TypeScriptLspAdapter { node }
     }
@@ -97,7 +98,7 @@ struct TypeScriptVersions {
 #[async_trait(?Send)]
 impl LspAdapter for TypeScriptLspAdapter {
     fn name(&self) -> LanguageServerName {
-        LanguageServerName(Self::SERVER_NAME.into())
+        Self::SERVER_NAME.clone()
     }
 
     async fn fetch_latest_server_version(
@@ -239,7 +240,7 @@ impl LspAdapter for TypeScriptLspAdapter {
         cx: &mut AsyncAppContext,
     ) -> Result<Value> {
         let override_options = cx.update(|cx| {
-            language_server_settings(delegate.as_ref(), Self::SERVER_NAME, cx)
+            language_server_settings(delegate.as_ref(), &Self::SERVER_NAME, cx)
                 .and_then(|s| s.settings.clone())
         })?;
         if let Some(options) = override_options {
@@ -304,7 +305,7 @@ impl EsLintLspAdapter {
     const GITHUB_ASSET_KIND: AssetKind = AssetKind::Zip;
 
     const SERVER_PATH: &'static str = "vscode-eslint/server/out/eslintServer.js";
-    const SERVER_NAME: &'static str = "eslint";
+    const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("eslint");
 
     const FLAT_CONFIG_FILE_NAMES: &'static [&'static str] =
         &["eslint.config.js", "eslint.config.mjs", "eslint.config.cjs"];
@@ -331,7 +332,7 @@ impl LspAdapter for EsLintLspAdapter {
         let workspace_root = delegate.worktree_root_path();
 
         let eslint_user_settings = cx.update(|cx| {
-            language_server_settings(delegate.as_ref(), Self::SERVER_NAME, cx)
+            language_server_settings(delegate.as_ref(), &Self::SERVER_NAME, cx)
                 .and_then(|s| s.settings.clone())
                 .unwrap_or_default()
         })?;
@@ -403,7 +404,7 @@ impl LspAdapter for EsLintLspAdapter {
     }
 
     fn name(&self) -> LanguageServerName {
-        LanguageServerName(Self::SERVER_NAME.into())
+        Self::SERVER_NAME.clone()
     }
 
     async fn fetch_latest_server_version(
diff --git a/crates/languages/src/vtsls.rs b/crates/languages/src/vtsls.rs
index 9499b5c54fbeba..5ec31213840bb1 100644
--- a/crates/languages/src/vtsls.rs
+++ b/crates/languages/src/vtsls.rs
@@ -48,11 +48,11 @@ struct TypeScriptVersions {
     server_version: String,
 }
 
-const SERVER_NAME: &str = "vtsls";
+const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("vtsls");
 #[async_trait(?Send)]
 impl LspAdapter for VtslsLspAdapter {
     fn name(&self) -> LanguageServerName {
-        LanguageServerName(SERVER_NAME.into())
+        SERVER_NAME.clone()
     }
 
     async fn fetch_latest_server_version(
@@ -74,7 +74,7 @@ impl LspAdapter for VtslsLspAdapter {
         cx: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx.update(|cx| {
-            language_server_settings(delegate, SERVER_NAME, cx).and_then(|s| s.binary.clone())
+            language_server_settings(delegate, &SERVER_NAME, cx).and_then(|s| s.binary.clone())
         });
 
         match configured_binary {
@@ -267,7 +267,7 @@ impl LspAdapter for VtslsLspAdapter {
         cx: &mut AsyncAppContext,
     ) -> Result<Value> {
         let override_options = cx.update(|cx| {
-            language_server_settings(delegate.as_ref(), SERVER_NAME, cx)
+            language_server_settings(delegate.as_ref(), &SERVER_NAME, cx)
                 .and_then(|s| s.settings.clone())
         })?;
 
diff --git a/crates/languages/src/yaml.rs b/crates/languages/src/yaml.rs
index 06360847acc803..583961f4b1c0e9 100644
--- a/crates/languages/src/yaml.rs
+++ b/crates/languages/src/yaml.rs
@@ -30,7 +30,7 @@ pub struct YamlLspAdapter {
 }
 
 impl YamlLspAdapter {
-    const SERVER_NAME: &'static str = "yaml-language-server";
+    const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("yaml-language-server");
     pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
         YamlLspAdapter { node }
     }
@@ -39,7 +39,7 @@ impl YamlLspAdapter {
 #[async_trait(?Send)]
 impl LspAdapter for YamlLspAdapter {
     fn name(&self) -> LanguageServerName {
-        LanguageServerName(Self::SERVER_NAME.into())
+        Self::SERVER_NAME.clone()
     }
 
     async fn check_if_user_installed(
@@ -49,7 +49,7 @@ impl LspAdapter for YamlLspAdapter {
     ) -> Option<LanguageServerBinary> {
         let configured_binary = cx
             .update(|cx| {
-                language_server_settings(delegate, Self::SERVER_NAME, cx)
+                language_server_settings(delegate, &Self::SERVER_NAME, cx)
                     .and_then(|s| s.binary.clone())
             })
             .ok()??;
@@ -145,7 +145,7 @@ impl LspAdapter for YamlLspAdapter {
         let mut options = serde_json::json!({"[yaml]": {"editor.tabSize": tab_size}});
 
         let project_options = cx.update(|cx| {
-            language_server_settings(delegate.as_ref(), Self::SERVER_NAME, cx)
+            language_server_settings(delegate.as_ref(), &Self::SERVER_NAME, cx)
                 .and_then(|s| s.settings.clone())
         })?;
         if let Some(override_options) = project_options {
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 92f37f87af4056..6a3788c8793161 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -103,7 +103,7 @@ pub struct LocalLspStore {
     supplementary_language_servers:
         HashMap<LanguageServerId, (LanguageServerName, Arc<LanguageServer>)>,
     prettier_store: Model<PrettierStore>,
-    current_lsp_settings: HashMap<Arc<str>, LspSettings>,
+    current_lsp_settings: HashMap<LanguageServerName, LspSettings>,
     _subscription: gpui::Subscription,
 }
 
@@ -138,7 +138,7 @@ impl RemoteLspStore {}
 
 pub struct SshLspStore {
     upstream_client: AnyProtoClient,
-    current_lsp_settings: HashMap<Arc<str>, LspSettings>,
+    current_lsp_settings: HashMap<LanguageServerName, LspSettings>,
 }
 
 #[allow(clippy::large_enum_variant)]
@@ -316,8 +316,8 @@ impl LspStore {
 
     pub fn swap_current_lsp_settings(
         &mut self,
-        new_settings: HashMap<Arc<str>, LspSettings>,
-    ) -> Option<HashMap<Arc<str>, LspSettings>> {
+        new_settings: HashMap<LanguageServerName, LspSettings>,
+    ) -> Option<HashMap<LanguageServerName, LspSettings>> {
         match &mut self.mode {
             LspStoreMode::Ssh(SshLspStore {
                 current_lsp_settings,
@@ -933,7 +933,7 @@ impl LspStore {
                 if !language_settings(Some(language), file.as_ref(), cx).enable_language_server {
                     language_servers_to_stop.push((worktree_id, started_lsp_name.clone()));
                 } else if let Some(worktree) = worktree {
-                    let server_name = &adapter.name.0;
+                    let server_name = &adapter.name;
                     match (
                         current_lsp_settings.get(server_name),
                         new_lsp_settings.get(server_name),
@@ -4765,7 +4765,7 @@ impl LspStore {
         let project_id = self.project_id;
         let worktree_id = worktree.read(cx).id().to_proto();
         let upstream_client = ssh.upstream_client.clone();
-        let name = adapter.name().to_string();
+        let name = adapter.name();
 
         let Some(available_language) = self.languages.available_language_for_name(&language) else {
             log::error!("failed to find available language {language}");
@@ -4783,7 +4783,7 @@ impl LspStore {
                 }
             };
 
-            let name = adapter.name().to_string();
+            let name = adapter.name();
             let code_action_kinds = adapter
                 .adapter
                 .code_action_kinds()
@@ -4809,7 +4809,7 @@ impl LspStore {
                 .request(proto::CreateLanguageServer {
                     project_id,
                     worktree_id,
-                    name,
+                    name: name.0.to_string(),
                     binary: Some(language_server_command),
                     initialization_options,
                     code_action_kinds,
@@ -4892,7 +4892,7 @@ impl LspStore {
         );
 
         // We need some on the SSH client, and some on SSH host
-        let lsp = project_settings.lsp.get(&adapter.name.0);
+        let lsp = project_settings.lsp.get(&adapter.name);
         let override_options = lsp.and_then(|s| s.initialization_options.clone());
 
         let server_id = pending_server.server_id;
@@ -5078,7 +5078,7 @@ impl LspStore {
 
     async fn shutdown_language_server(
         server_state: Option<LanguageServerState>,
-        name: Arc<str>,
+        name: LanguageServerName,
         cx: AsyncAppContext,
     ) {
         let server = match server_state {
@@ -5123,7 +5123,7 @@ impl LspStore {
         let key = (worktree_id, adapter_name);
         if self.mode.is_local() {
             if let Some(server_id) = self.language_server_ids.remove(&key) {
-                let name = key.1 .0;
+                let name = key.1;
                 log::info!("stopping language server {name}");
 
                 // Remove other entries for this language server as well
@@ -7168,7 +7168,7 @@ impl LspAdapter for SshLspAdapter {
 }
 pub fn language_server_settings<'a, 'b: 'a>(
     delegate: &'a dyn LspAdapterDelegate,
-    language: &str,
+    language: &LanguageServerName,
     cx: &'b AppContext,
 ) -> Option<&'a LspSettings> {
     ProjectSettings::get(
diff --git a/crates/project/src/prettier_store.rs b/crates/project/src/prettier_store.rs
index 29101917fb9aa5..75d70c1d3f72f1 100644
--- a/crates/project/src/prettier_store.rs
+++ b/crates/project/src/prettier_store.rs
@@ -338,7 +338,7 @@ impl PrettierStore {
             prettier_store
                 .update(cx, |prettier_store, cx| {
                     let name = if is_default {
-                        LanguageServerName(Arc::from("prettier (default)"))
+                        LanguageServerName("prettier (default)".to_string().into())
                     } else {
                         let worktree_path = worktree_id
                             .and_then(|id| {
@@ -366,7 +366,7 @@ impl PrettierStore {
                             }
                             None => format!("prettier ({})", prettier_dir.display()),
                         };
-                        LanguageServerName(Arc::from(name))
+                        LanguageServerName(name.into())
                     };
                     cx.emit(PrettierStoreEvent::LanguageServerAdded {
                         new_server_id,
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index 9a7c80703c734c..904efe0a6b01f0 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -1,6 +1,7 @@
 use collections::HashMap;
 use fs::Fs;
 use gpui::{AppContext, AsyncAppContext, BorrowAppContext, EventEmitter, Model, ModelContext};
+use language::LanguageServerName;
 use paths::local_settings_file_relative_path;
 use rpc::{proto, AnyProtoClient, TypedEnvelope};
 use schemars::JsonSchema;
@@ -27,7 +28,7 @@ pub struct ProjectSettings {
     /// name to the lsp value.
     /// Default: null
     #[serde(default)]
-    pub lsp: HashMap<Arc<str>, LspSettings>,
+    pub lsp: HashMap<LanguageServerName, LspSettings>,
 
     /// Configuration for Git-related features
     #[serde(default)]
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index b7fc56d3c60262..b5ab1c40070a09 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -205,7 +205,7 @@ async fn test_remote_settings(cx: &mut TestAppContext, server_cx: &mut TestAppCo
             AllLanguageSettings::get_global(cx)
                 .language(Some(&"Rust".into()))
                 .language_servers,
-            ["custom-rust-analyzer".into()]
+            ["custom-rust-analyzer".to_string()]
         )
     });
 
@@ -264,7 +264,7 @@ async fn test_remote_settings(cx: &mut TestAppContext, server_cx: &mut TestAppCo
             )
             .language(Some(&"Rust".into()))
             .language_servers,
-            ["override-rust-analyzer".into()]
+            ["override-rust-analyzer".to_string()]
         )
     });
 
@@ -274,7 +274,7 @@ async fn test_remote_settings(cx: &mut TestAppContext, server_cx: &mut TestAppCo
             all_language_settings(file, cx)
                 .language(Some(&"Rust".into()))
                 .language_servers,
-            ["override-rust-analyzer".into()]
+            ["override-rust-analyzer".to_string()]
         )
     });
 }
@@ -357,7 +357,7 @@ async fn test_remote_lsp(cx: &mut TestAppContext, server_cx: &mut TestAppContext
             all_language_settings(file, cx)
                 .language(Some(&"Rust".into()))
                 .language_servers,
-            ["rust-analyzer".into()]
+            ["rust-analyzer".to_string()]
         )
     });
 

From 3ca18af40b8a7cb83d8303a8131e90ca997f09ca Mon Sep 17 00:00:00 2001
From: Junseong Park <junseongpark.dev@gmail.com>
Date: Sat, 21 Sep 2024 21:01:29 +0900
Subject: [PATCH 259/762] docs: Fix typo in `configuring-zed.md` (#18178)

Fix typo in `configuring-zed.md`

Release Notes:

- N/A
---
 docs/src/configuring-zed.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index de7433bf5dbad3..7cc6a4a8cb02ce 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -313,10 +313,10 @@ List of `string` values
 "cursor_shape": "block"
 ```
 
-3. An underline that runs along the following character:
+3. An underscore that runs along the following character:
 
 ```json
-"cursor_shape": "underline"
+"cursor_shape": "underscore"
 ```
 
 4. An box drawn around the following character:

From 1f35c8d09df9612e23d62a472d49c7021202711d Mon Sep 17 00:00:00 2001
From: Junseong Park <junseongpark.dev@gmail.com>
Date: Sun, 22 Sep 2024 17:47:07 +0900
Subject: [PATCH 260/762] Fix tooltip of `always_treat_brackets_as_autoclosed`
 (#18191)

Fixed a bug where the `always_treat_brackets_as_autoclosed` option would
not display the message in the tooltip that appears when hovering.

Release Notes:

- N/A
---
 crates/language/src/language_settings.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index 82d4208aae6eb7..735a9a60f87fa6 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -325,11 +325,11 @@ pub struct LanguageSettingsContent {
     ///
     /// Default: true
     pub use_auto_surround: Option<bool>,
-    // Controls how the editor handles the autoclosed characters.
-    // When set to `false`(default), skipping over and auto-removing of the closing characters
-    // happen only for auto-inserted characters.
-    // Otherwise(when `true`), the closing characters are always skipped over and auto-removed
-    // no matter how they were inserted.
+    /// Controls how the editor handles the autoclosed characters.
+    /// When set to `false`(default), skipping over and auto-removing of the closing characters
+    /// happen only for auto-inserted characters.
+    /// Otherwise(when `true`), the closing characters are always skipped over and auto-removed
+    /// no matter how they were inserted.
     ///
     /// Default: false
     pub always_treat_brackets_as_autoclosed: Option<bool>,

From e7fcf83ce8d88ca36d2aa7fe8fc017c308aaf138 Mon Sep 17 00:00:00 2001
From: Junseong Park <junseongpark.dev@gmail.com>
Date: Sun, 22 Sep 2024 17:48:52 +0900
Subject: [PATCH 261/762] docs: Fix misordered headings (#18192)

1. Raised the `Indent Guides` heading to level 2, which is completely
unrelated to `Git`.
2. the `Git` heading now only contains `Git Gutter` and `Inline Git
Blame` as subheadings.
3. The `Indent Guides` heading is now located directly after the `Git`
heading.

Release Notes:

- N/A
---
 docs/src/configuring-zed.md | 88 ++++++++++++++++++-------------------
 1 file changed, 44 insertions(+), 44 deletions(-)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 7cc6a4a8cb02ce..518dbb7f38a833 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -857,7 +857,50 @@ To interpret all `.c` files as C++, files called `MyLockFile` as TOML and files
 }
 ```
 
-### Indent Guides
+### Inline Git Blame
+
+- Description: Whether or not to show git blame information inline, on the currently focused line.
+- Setting: `inline_blame`
+- Default:
+
+```json
+{
+  "git": {
+    "inline_blame": {
+      "enabled": true
+    }
+  }
+}
+```
+
+**Options**
+
+1. Disable inline git blame:
+
+```json
+{
+  "git": {
+    "inline_blame": {
+      "enabled": false
+    }
+  }
+}
+```
+
+2. Only show inline git blame after a delay (that starts after cursor stops moving):
+
+```json
+{
+  "git": {
+    "inline_blame": {
+      "enabled": true,
+      "delay_ms": 500
+    }
+  }
+}
+```
+
+## Indent Guides
 
 - Description: Configuration related to indent guides. Indent guides can be configured separately for each language.
 - Setting: `indent_guides`
@@ -926,49 +969,6 @@ To interpret all `.c` files as C++, files called `MyLockFile` as TOML and files
 }
 ```
 
-### Inline Git Blame
-
-- Description: Whether or not to show git blame information inline, on the currently focused line.
-- Setting: `inline_blame`
-- Default:
-
-```json
-{
-  "git": {
-    "inline_blame": {
-      "enabled": true
-    }
-  }
-}
-```
-
-**Options**
-
-1. Disable inline git blame:
-
-```json
-{
-  "git": {
-    "inline_blame": {
-      "enabled": false
-    }
-  }
-}
-```
-
-2. Only show inline git blame after a delay (that starts after cursor stops moving):
-
-```json
-{
-  "git": {
-    "inline_blame": {
-      "enabled": true,
-      "delay_ms": 500
-    }
-  }
-}
-```
-
 ## Hard Tabs
 
 - Description: Whether to indent lines using tab characters or multiple spaces.

From 37c93d8fead2f33ed444c1ee8efd303a2b5a4c8c Mon Sep 17 00:00:00 2001
From: Junseong Park <junseongpark.dev@gmail.com>
Date: Sun, 22 Sep 2024 18:09:35 +0900
Subject: [PATCH 262/762] docs: Add missing `base_keymap` option in
 `configuring-zed.md` (#18190)

Added `base_keymap`, an option that works in the editor but is missing
from the documentation.

Release Notes:

- N/A
---
 assets/settings/default.json |  8 ++++--
 docs/src/configuring-zed.md  | 56 ++++++++++++++++++++++++++++++++++++
 2 files changed, 61 insertions(+), 3 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 8424c5733d81bc..e04ab90f217cdf 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -15,9 +15,11 @@
   // text editor:
   //
   // 1. "VSCode"
-  // 2. "JetBrains"
-  // 3. "SublimeText"
-  // 4. "Atom"
+  // 2. "Atom"
+  // 3. "JetBrains"
+  // 4. "None"
+  // 5. "SublimeText"
+  // 6. "TextMate"
   "base_keymap": "VSCode",
   // Features that can be globally enabled or disabled
   "features": {
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 518dbb7f38a833..5d9a2843edf4a7 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -93,6 +93,62 @@ Extensions that provide language servers may also provide default settings for t
 
 `boolean` values
 
+## Base Keymap
+
+- Description: Base key bindings scheme. Base keymaps can be overridden with user keymaps.
+- Setting: `base_keymap`
+- Default: `VSCode`
+
+**Options**
+
+1. VSCode
+
+```json
+{
+  "base_keymap": "VSCode"
+}
+```
+
+2. Atom
+
+```json
+{
+  "base_keymap": "Atom"
+}
+```
+
+3. JetBrains
+
+```json
+{
+  "base_keymap": "JetBrains"
+}
+```
+
+4. None
+
+```json
+{
+  "base_keymap": "None"
+}
+```
+
+5. SublimeText
+
+```json
+{
+  "base_keymap": "SublimeText"
+}
+```
+
+6. TextMate
+
+```json
+{
+  "base_keymap": "TextMate"
+}
+```
+
 ## Buffer Font Family
 
 - Description: The name of a font to use for rendering text in the editor.

From 0f4ebdfbca721614f3cadafc3b44e4fbf099afda Mon Sep 17 00:00:00 2001
From: Junseong Park <junseongpark.dev@gmail.com>
Date: Sun, 22 Sep 2024 18:15:13 +0900
Subject: [PATCH 263/762] docs: Add missing `ui_font_size` option in
 `configuring-zed.md` (#18189)

Added `ui_font_size`, an option that works in the editor but is missing
from the documentation.

Release Notes:

- N/A
---
 docs/src/configuring-zed.md | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 5d9a2843edf4a7..c0aa4c513a5f3d 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -215,7 +215,7 @@ For example, to use `Nerd Font` as a fallback, add the following to your setting
 
 **Options**
 
-`integer` values
+`integer` values from `6` to `100` pixels (inclusive)
 
 ## Buffer Font Weight
 
@@ -2184,6 +2184,16 @@ Float values between `0.0` and `0.9`, where:
 }
 ```
 
+## UI Font Size
+
+- Description: The default font size for text in the UI.
+- Setting: `ui_font_size`
+- Default: `16`
+
+**Options**
+
+`integer` values from `6` to `100` pixels (inclusive)
+
 ## An example configuration:
 
 ```json

From 75cb199a54666032e7a62dfb64739283556ae96c Mon Sep 17 00:00:00 2001
From: CharlesChen0823 <yongchen0823@gmail.com>
Date: Mon, 23 Sep 2024 00:50:51 +0800
Subject: [PATCH 264/762] project: Fix typo error cause remove worktree not
 stop lsp (#18198)

Release Notes:

- N/A
---
 crates/project/src/project.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index bd9c17ecb29b99..78584cbae0c65f 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -2006,7 +2006,7 @@ impl Project {
                 cx.emit(Event::LanguageServerAdded(*language_server_id))
             }
             LspStoreEvent::LanguageServerRemoved(language_server_id) => {
-                cx.emit(Event::LanguageServerAdded(*language_server_id))
+                cx.emit(Event::LanguageServerRemoved(*language_server_id))
             }
             LspStoreEvent::LanguageServerLog(server_id, log_type, string) => cx.emit(
                 Event::LanguageServerLog(*server_id, log_type.clone(), string.clone()),

From bb7d9d35256825c9b022a3c89c556c1521664c8d Mon Sep 17 00:00:00 2001
From: Junseong Park <junseongpark.dev@gmail.com>
Date: Mon, 23 Sep 2024 12:26:01 +0900
Subject: [PATCH 265/762] docs: Remove `default_dock_anchor` in
 `configuring-zed.md` (#18210)

Removed the deprecated option `default_dock_anchor` in
`configuring-zed.md`

Note: https://zed.dev/blog/new-panel-system

Release Notes:

- N/A
---
 docs/src/configuring-zed.md | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index c0aa4c513a5f3d..7837044a60a669 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -381,12 +381,6 @@ List of `string` values
 "cursor_shape": "hollow"
 ```
 
-## Default Dock Anchor
-
-- Description: The default anchor for new docks.
-- Setting: `default_dock_anchor`
-- Default: `bottom`
-
 **Options**
 
 1. Position the dock attached to the bottom of the workspace: `bottom`

From 05d18321db59539b56520d25f2ee95850ad911fd Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Mon, 23 Sep 2024 12:53:57 +0300
Subject: [PATCH 266/762] Resolve completions properly (#18212)

Related to https://github.com/rust-lang/rust-analyzer/pull/18167

* Declare more completion item fields in the client completion resolve
capabilities
* Do resolve completions even if their docs are present
* Instead, do not resolve completions that could not be resolved when
handling the remote client resolve requests
* Do replace the old lsp completion data with the resolved one

Release Notes:

- Improved completion resolve mechanism
---
 crates/lsp/src/lsp.rs           |  8 ++++++-
 crates/project/src/lsp_store.rs | 37 ++++++++++++++++++++++++---------
 crates/proto/proto/zed.proto    |  1 +
 3 files changed, 35 insertions(+), 11 deletions(-)

diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs
index 21671cd0b13265..c2a5951de72101 100644
--- a/crates/lsp/src/lsp.rs
+++ b/crates/lsp/src/lsp.rs
@@ -615,8 +615,14 @@ impl LanguageServer {
                             snippet_support: Some(true),
                             resolve_support: Some(CompletionItemCapabilityResolveSupport {
                                 properties: vec![
-                                    "documentation".to_string(),
                                     "additionalTextEdits".to_string(),
+                                    "command".to_string(),
+                                    "detail".to_string(),
+                                    "documentation".to_string(),
+                                    "filterText".to_string(),
+                                    "labelDetails".to_string(),
+                                    "tags".to_string(),
+                                    "textEdit".to_string(),
                                 ],
                             }),
                             insert_replace_support: Some(true),
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 6a3788c8793161..95ca84236001ce 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -1615,10 +1615,6 @@ impl LspStore {
                     let (server_id, completion) = {
                         let completions_guard = completions.read();
                         let completion = &completions_guard[completion_index];
-                        if completion.documentation.is_some() {
-                            continue;
-                        }
-
                         did_resolve = true;
                         let server_id = completion.server_id;
                         let completion = completion.lsp_completion.clone();
@@ -1643,10 +1639,6 @@ impl LspStore {
                     let (server_id, completion) = {
                         let completions_guard = completions.read();
                         let completion = &completions_guard[completion_index];
-                        if completion.documentation.is_some() {
-                            continue;
-                        }
-
                         let server_id = completion.server_id;
                         let completion = completion.lsp_completion.clone();
 
@@ -1743,6 +1735,10 @@ impl LspStore {
                 completion.lsp_completion.insert_text_format = completion_item.insert_text_format;
             }
         }
+
+        let mut completions = completions.write();
+        let completion = &mut completions[completion_index];
+        completion.lsp_completion = completion_item;
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -1771,6 +1767,10 @@ impl LspStore {
         else {
             return;
         };
+        let Some(lsp_completion) = serde_json::from_slice(&response.lsp_completion).log_err()
+        else {
+            return;
+        };
 
         let documentation = if response.documentation.is_empty() {
             Documentation::Undocumented
@@ -1787,6 +1787,7 @@ impl LspStore {
         let mut completions = completions.write();
         let completion = &mut completions[completion_index];
         completion.documentation = Some(documentation);
+        completion.lsp_completion = lsp_completion;
 
         let old_range = response
             .old_start
@@ -4192,17 +4193,32 @@ impl LspStore {
         let lsp_completion = serde_json::from_slice(&envelope.payload.lsp_completion)?;
 
         let completion = this
-            .read_with(&cx, |this, _| {
+            .read_with(&cx, |this, cx| {
                 let id = LanguageServerId(envelope.payload.language_server_id as usize);
                 let Some(server) = this.language_server_for_id(id) else {
                     return Err(anyhow!("No language server {id}"));
                 };
 
-                Ok(server.request::<lsp::request::ResolveCompletionItem>(lsp_completion))
+                Ok(cx.background_executor().spawn(async move {
+                    let can_resolve = server
+                        .capabilities()
+                        .completion_provider
+                        .as_ref()
+                        .and_then(|options| options.resolve_provider)
+                        .unwrap_or(false);
+                    if can_resolve {
+                        server
+                            .request::<lsp::request::ResolveCompletionItem>(lsp_completion)
+                            .await
+                    } else {
+                        anyhow::Ok(lsp_completion)
+                    }
+                }))
             })??
             .await?;
 
         let mut documentation_is_markdown = false;
+        let lsp_completion = serde_json::to_string(&completion)?.into_bytes();
         let documentation = match completion.documentation {
             Some(lsp::Documentation::String(text)) => text,
 
@@ -4244,6 +4260,7 @@ impl LspStore {
             old_start,
             old_end,
             new_text,
+            lsp_completion,
         })
     }
 
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index a886b2185556f3..a18bbe8ecf5141 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -1219,6 +1219,7 @@ message ResolveCompletionDocumentationResponse {
     Anchor old_start = 3;
     Anchor old_end = 4;
     string new_text = 5;
+    bytes lsp_completion = 6;
 }
 
 message ResolveInlayHint {

From 8a36278c9590664e881dda454ccfa7685eb5b761 Mon Sep 17 00:00:00 2001
From: moshyfawn <email@moshyfawn.dev>
Date: Mon, 23 Sep 2024 08:59:45 -0400
Subject: [PATCH 267/762] docs: Fix long code blocks overflow (#18208)

Closes #18207

Release Notes:

- N/A

| Before | After |
|--------|-------|
| <img width="1640" alt="image"
src="https://github.com/user-attachments/assets/b7c76ec9-85bd-4001-b19f-6a8e26d04254">
| <img width="1640" alt="image"
src="https://github.com/user-attachments/assets/cd932e33-0429-43b1-9b4b-25df5890a3cf">
|
---
 docs/theme/highlight.css | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/theme/highlight.css b/docs/theme/highlight.css
index 9d8f39d9030b23..9bd80f351612a8 100644
--- a/docs/theme/highlight.css
+++ b/docs/theme/highlight.css
@@ -12,6 +12,7 @@
 .hljs {
   color: #24292e;
   background: #ffffff;
+  overflow-x: auto;
 }
 
 .hljs-doctag,

From d784e720274b2a9ced94aa6fcc703f53db132163 Mon Sep 17 00:00:00 2001
From: Charlie Egan <git@charlieegan3.com>
Date: Mon, 23 Sep 2024 14:38:54 +0100
Subject: [PATCH 268/762] docs: Add Rego language (#18217)

Release Notes:

- N/A

---------

Signed-off-by: Charlie Egan <charlieegan3@users.noreply.github.com>
Co-authored-by: Charlie Egan <charlieegan3@users.noreply.github.com>
Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 docs/src/SUMMARY.md        |  1 +
 docs/src/languages.md      |  1 +
 docs/src/languages/rego.md | 38 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 40 insertions(+)
 create mode 100644 docs/src/languages/rego.md

diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
index 8bb8035c617437..bb0c9d79f590c5 100644
--- a/docs/src/SUMMARY.md
+++ b/docs/src/SUMMARY.md
@@ -93,6 +93,7 @@
 - [PureScript](./languages/purescript.md)
 - [Python](./languages/python.md)
 - [R](./languages/r.md)
+- [Rego](./languages/rego.md)
 - [ReStructuredText](./languages/rst.md)
 - [Racket](./languages/racket.md)
 - [Roc](./languages/roc.md)
diff --git a/docs/src/languages.md b/docs/src/languages.md
index 7ec586f1f598f7..4bc6e7d3d732a5 100644
--- a/docs/src/languages.md
+++ b/docs/src/languages.md
@@ -45,6 +45,7 @@ Zed supports hundreds of programming languages and text formats. Some work out-o
 - [PureScript](./languages/purescript.md)
 - [Python](./languages/python.md)
 - [R](./languages/r.md)
+- [Rego](./languages/rego.md)
 - [ReStructuredText](./languages/rst.md)
 - [Racket](./languages/racket.md)
 - [Roc](./languages/roc.md)
diff --git a/docs/src/languages/rego.md b/docs/src/languages/rego.md
new file mode 100644
index 00000000000000..3709c6a1feeb2e
--- /dev/null
+++ b/docs/src/languages/rego.md
@@ -0,0 +1,38 @@
+# Rego
+
+Rego language support in Zed is provided by the community-maintained [Rego extension](https://github.com/StyraInc/zed-rego).
+
+- Tree Sitter: [FallenAngel97/tree-sitter-rego](https://github.com/FallenAngel97/tree-sitter-rego)
+- Language Server: [StyraInc/regal](https://github.com/StyraInc/regal)
+
+## Installation
+
+The extensions is largely based on the [Regal](https://docs.styra.com/regal/language-server) language server which should be installed to make use of the extension. Read the [getting started](https://docs.styra.com/regal#getting-started) instructions for more information.
+
+## Configuration
+
+The extension's behavior is configured in the `.regal/config.yaml` file. The following is an example configuration which disables the `todo-comment` rule, customizes the `line-length` rule, and ignores test files for the `opa-fmt` rule:
+
+```yaml
+rules:
+  style:
+    todo-comment:
+      # don't report on todo comments
+      level: ignore
+    line-length:
+      # custom rule configuration
+      max-line-length: 100
+      # warn on too long lines, but don't fail
+      level: warning
+    opa-fmt:
+      # not needed as error is the default, but
+      # being explicit won't hurt
+      level: error
+      # files can be ignored for any individual rule
+      # in this example, test files are ignored
+      ignore:
+        files:
+          - "*_test.rego"
+```
+
+Read Regal's [configuration documentation](https://docs.styra.com/regal#configuration) for more information.

From 2ff8dde925b75d62f030755843cd93c402a41022 Mon Sep 17 00:00:00 2001
From: jvmncs <7891333+jvmncs@users.noreply.github.com>
Date: Mon, 23 Sep 2024 10:16:15 -0400
Subject: [PATCH 269/762] Use fenix toolchain in nix shell (#18227)

In #17974 we explicitly depend on rustc/cargo for the nix devShell,
however the fenix overlay that contains the latest stable versions was
not being applied to that shell. This led to the shell inheriting
whatever rustc/cargo was on nixos-unstable from nixpkgs, which sometimes
lags behind. This change fixes that, and also restructures the flake to
ensure that all outputs rely on the overlaid `pkgs`.

Release Notes:

- N/A
---
 flake.lock    | 18 ++++++++---------
 flake.nix     | 56 +++++++++++++++++++++++++++------------------------
 nix/shell.nix |  3 +--
 3 files changed, 40 insertions(+), 37 deletions(-)

diff --git a/flake.lock b/flake.lock
index a5b7a7a6ae9c46..5666e73569f7dc 100644
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
   "nodes": {
     "crane": {
       "locked": {
-        "lastModified": 1725409566,
-        "narHash": "sha256-PrtLmqhM6UtJP7v7IGyzjBFhbG4eOAHT6LPYOFmYfbk=",
+        "lastModified": 1727060013,
+        "narHash": "sha256-/fC5YlJy4IoAW9GhkJiwyzk0K/gQd9Qi4rRcoweyG9E=",
         "owner": "ipetkov",
         "repo": "crane",
-        "rev": "7e4586bad4e3f8f97a9271def747cf58c4b68f3c",
+        "rev": "6b40cc876c929bfe1e3a24bf538ce3b5622646ba",
         "type": "github"
       },
       "original": {
@@ -23,11 +23,11 @@
         "rust-analyzer-src": "rust-analyzer-src"
       },
       "locked": {
-        "lastModified": 1726813972,
-        "narHash": "sha256-t6turZgoSAVgj7hn5mxzNlLOeVeZvymFo8+ymB52q34=",
+        "lastModified": 1727073227,
+        "narHash": "sha256-1kmkEQmFfGVuPBasqSZrNThqyMDV1SzTalQdRZxtDRs=",
         "owner": "nix-community",
         "repo": "fenix",
-        "rev": "251caeafc75b710282ee7e375800f75f4c8c5727",
+        "rev": "88cc292eb3c689073c784d6aecc0edbd47e12881",
         "type": "github"
       },
       "original": {
@@ -53,11 +53,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1726642912,
-        "narHash": "sha256-wiZzKGHRAhItEuoE599Wm3ic+Lg/NykuBvhb+awf7N8=",
+        "lastModified": 1726937504,
+        "narHash": "sha256-bvGoiQBvponpZh8ClUcmJ6QnsNKw0EMrCQJARK3bI1c=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "395c52d142ec1df377acd67db6d4a22950b02a98",
+        "rev": "9357f4f23713673f310988025d9dc261c20e70c6",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index 7d1410ac7c20b7..2ee86c446685fc 100644
--- a/flake.nix
+++ b/flake.nix
@@ -17,27 +17,34 @@
     fenix,
     ...
   }: let
-    forAllSystems = function:
-      nixpkgs.lib.genAttrs [
-        "x86_64-linux"
-        "aarch64-linux"
-      ] (system:
-        function (import nixpkgs {
-          inherit system;
-          overlays = [fenix.overlays.default];
-        }));
-  in {
-    packages = forAllSystems (pkgs: let
-      craneLib = (crane.mkLib pkgs).overrideToolchain (p: p.fenix.stable.toolchain);
-      rustPlatform = pkgs.makeRustPlatform {
-        inherit (pkgs.fenix.stable.toolchain) cargo rustc;
+    systems = ["x86_64-linux" "aarch64-linux"];
+
+    overlays = {
+      fenix = fenix.overlays.default;
+      rust-toolchain = final: prev: {
+        rustToolchain = final.fenix.stable.toolchain;
       };
-      nightlyBuild = pkgs.callPackage ./nix/build.nix {
-        inherit craneLib rustPlatform;
+      zed-editor = final: prev: {
+        zed-editor = final.callPackage ./nix/build.nix {
+          craneLib = (crane.mkLib final).overrideToolchain final.rustToolchain;
+          rustPlatform = final.makeRustPlatform {
+            inherit (final.rustToolchain) cargo rustc;
+          };
+        };
+      };
+    };
+
+    mkPkgs = system:
+      import nixpkgs {
+        inherit system;
+        overlays = builtins.attrValues overlays;
       };
-    in {
-      zed-editor = nightlyBuild;
-      default = nightlyBuild;
+
+    forAllSystems = f: nixpkgs.lib.genAttrs systems (system: f (mkPkgs system));
+  in {
+    packages = forAllSystems (pkgs: {
+      zed-editor = pkgs.zed-editor;
+      default = pkgs.zed-editor;
     });
 
     devShells = forAllSystems (pkgs: {
@@ -46,13 +53,10 @@
 
     formatter = forAllSystems (pkgs: pkgs.alejandra);
 
-    overlays.default = final: prev: {
-      zed-editor = final.callPackage ./nix/build.nix {
-        craneLib = (crane.mkLib final).overrideToolchain (p: p.fenix.stable.toolchain);
-        rustPlatform = final.makeRustPlatform {
-          inherit (final.fenix.stable.toolchain) cargo rustc;
-        };
+    overlays =
+      overlays
+      // {
+        default = nixpkgs.lib.composeManyExtensions (builtins.attrValues overlays);
       };
-    };
   };
 }
diff --git a/nix/shell.nix b/nix/shell.nix
index 476374b67ef091..e0b4018778c87d 100644
--- a/nix/shell.nix
+++ b/nix/shell.nix
@@ -20,8 +20,7 @@ in
       wayland
       xorg.libxcb
       vulkan-loader
-      rustc
-      cargo
+      rustToolchain
     ];
   in
     pkgs.mkShell.override {inherit stdenv;} {

From 35a80f07e02054b281a946ead549d24499dcfcec Mon Sep 17 00:00:00 2001
From: Nathan Lovato <12694995+NathanLovato@users.noreply.github.com>
Date: Mon, 23 Sep 2024 17:01:32 +0200
Subject: [PATCH 270/762] docs: Split vim mode documentation into two pages,
 edit for clarity (#17614)

Closes #17215

Release Notes:

- N/A

---

This PR builds upon the vim mode documentation page and aims bring the
following improvements:

- Separate vim mode-specific configuration from introducing vim mode.
- Reformat some lists of provided commands and keymaps from code blocks
to sub-sections containing tables.
- Flesh out the text a little bit to make it more explicit in some
parts.
- Generally format notes and a couple of other things closer to some
other docs pages.

Checking the diff doesn't give a good idea of the changes, so here are
some before after images for quick examples of the kinds of changes
brought by this PR.

**Introducing the key differences of Zed's vim mode**

Before


![2024-09-09_22-12](https://github.com/user-attachments/assets/447418cb-a6e6-4f9c-8d4b-6d941126979e)

After


![2024-09-09_22-16](https://github.com/user-attachments/assets/be69f2d9-c3ae-4b34-978a-344130bee37c)

---

**Zed-specific vim key bindings**

Before


![2024-09-09_22-17](https://github.com/user-attachments/assets/88fdc512-a50b-487d-85d1-5988f15c2a6f)

After


![2024-09-09_22-18](https://github.com/user-attachments/assets/3b77c2f6-0ffa-4afc-a86d-1210ac706c8c)
---
 docs/src/SUMMARY.md |   2 +-
 docs/src/vim.md     | 607 ++++++++++++++++++++++++++------------------
 2 files changed, 366 insertions(+), 243 deletions(-)

diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
index bb0c9d79f590c5..f0e4784f89cd92 100644
--- a/docs/src/SUMMARY.md
+++ b/docs/src/SUMMARY.md
@@ -17,7 +17,7 @@
 - [Snippets](./snippets.md)
 - [Themes](./themes.md)
 <!-- - [Fonts](./fonts.md) -->
-- [Vim](./vim.md)
+- [Vim Mode](./vim.md)
 
 # Using Zed
 
diff --git a/docs/src/vim.md b/docs/src/vim.md
index 777534813f9657..8bfa6aa73f6121 100644
--- a/docs/src/vim.md
+++ b/docs/src/vim.md
@@ -1,14 +1,35 @@
 # Vim Mode
 
-Zed includes a Vim emulation layer known as "vim mode". On this page, you will learn how to turn Zed's vim mode on or off, what tools and commands are available, and how to customize keybindings.
+Zed includes a Vim emulation layer known as "vim mode". On this page, you will learn how to turn Zed's vim mode on or off, what tools and commands Zed provides to help you navigate and edit your code, and generally how to make the most of vim mode in Zed.
 
-## Philosophy
+You'll learn how to:
 
-Vim mode tries to offer a familiar experience to Vim users: it replicates the behavior of motions and commands precisely when it makes sense and uses Zed-specific functionality to provide an editing experience that "just works" without requiring configuration on your part. This includes support for semantic navigation, multiple cursors, or other features usually provided by plugins like surrounding text.
+- Understand the core differences between Zed's vim mode and traditional Vim
+- Enable or disable vim mode
+- Make the most of Zed-specific features within vim mode
+- Customize vim mode key bindings
+- Configure vim mode settings
+
+Whether you're new to vim mode or an experienced Vim user looking to optimize your Zed experience, this guide will help you harness the full power of modal editing in Zed.
+
+## Zed's vim mode design
+
+Vim mode tries to offer a familiar experience to Vim users: it replicates the behavior of motions and commands precisely when it makes sense and uses Zed-specific functionality to provide an editing experience that "just works" without requiring configuration on your part.
+
+This includes support for semantic navigation, multiple cursors, or other features usually provided by plugins like surrounding text.
 
 So, Zed's vim mode does not replicate Vim one-to-one, but it meshes Vim's modal design with Zed's modern features to provide a more fluid experience. It's also configurable, so you can add your own key bindings or override the defaults.
 
-> **Note:** The foundations of Zed's vim mode should already cover many use cases, and we're always looking to improve it. If you find missing features that you rely on in your workflow, please [file an issue](https://github.com/zed-industries/zed/issues).
+### Core differences
+
+There are four types of features in vim mode that use Zed's core functionality, leading to some differences in behavior:
+
+1. **Motions**: vim mode uses Zed's semantic parsing to tune the behavior of motions per language. For example, in Rust, jumping to matching bracket with `%` works with the pipe character `|`. In JavaScript, `w` considers `$` to be a word character.
+2. **Visual block selections**: vim mode uses Zed's multiple cursor to emulate visual block selections, making block selections a lot more flexible. For example, anything you insert after a block selection updates on every line in real-time, and you can add or remove cursors anytime.
+3. **Macros**: vim mode uses Zed's recording system for vim macros. So, you can capture and replay more complex actions, like autocompletion.
+4. **Search and replace**: vim mode uses Zed's search system, so, the syntax for regular expressions is slightly different compared to Vim. [Head to the Regex differences section](#regex-differences) for details.
+
+> **Note:** The foundations of Zed's vim mode should already cover many use cases, and we're always looking to improve it. If you find missing features that you rely on in your workflow, please [file an issue on GitHub](https://github.com/zed-industries/zed/issues).
 
 ## Enabling and disabling vim mode
 
@@ -16,136 +37,351 @@ When you first open Zed, you'll see a checkbox on the welcome screen that allows
 
 If you missed this, you can toggle vim mode on or off anytime by opening the command palette and using the workspace command `toggle vim mode`.
 
+> **Note**: This command toggles the following property in your user settings:
+>
+> ```json
+> {
+>   "vim_mode": true
+> }
+> ```
+
 ## Zed-specific features
 
 Zed is built on a modern foundation that (among other things) uses tree-sitter and language servers to understand the content of the file you're editing and supports multiple cursors out of the box.
 
 Vim mode has several "core Zed" key bindings that will help you make the most of Zed's specific feature set.
 
+### Language server
+
+The following commands use the language server to help you navigate and refactor your code.
+
+| Command                                  | Default Shortcut |
+| ---------------------------------------- | ---------------- |
+| Go to definition                         | `g d`            |
+| Go to declaration                        | `g D`            |
+| Go to type definition                    | `g y`            |
+| Go to implementation                     | `g I`            |
+| Rename (change definition)               | `c d`            |
+| Go to All references to the current word | `g A`            |
+| Find symbol in current file              | `g s`            |
+| Find symbol in entire project            | `g S`            |
+| Go to next diagnostic                    | `g ]` or `] d`   |
+| Go to previous diagnostic                | `g [` or `[ d`   |
+| Show inline error (hover)                | `g h`            |
+| Open the code actions menu               | `g .`            |
+
+### Git
+
+| Command                   | Default Shortcut |
+| ------------------------- | ---------------- |
+| Go to next git change     | `] c`            |
+| Go to previous git change | `[ c`            |
+
+### Treesitter
+
+Treesitter is a powerful tool that Zed uses to understand the structure of your code. These commands help you navigate your code semantically.
+
+| Command                      | Default Shortcut |
+| ---------------------------- | ---------------- |
+| Select a smaller syntax node | `] x`            |
+| Select a larger syntax node  | `[ x`            |
+
+### Multi cursor
+
+These commands help you manage multiple cursors in Zed.
+
+| Command                                                      | Default Shortcut |
+| ------------------------------------------------------------ | ---------------- |
+| Add a cursor selecting the next copy of the current word     | `g l`            |
+| Add a cursor selecting the previous copy of the current word | `g L`            |
+| Skip latest word selection, and add next                     | `g >`            |
+| Skip latest word selection, and add previous                 | `g <`            |
+| Add a visual selection for every copy of the current word    | `g a`            |
+
+### Pane management
+
+These commands open new panes or jump to specific panes.
+
+| Command                                    | Default Shortcut   |
+| ------------------------------------------ | ------------------ |
+| Open a project-wide search                 | `g /`              |
+| Open the current search excerpt            | `g <space>`        |
+| Open the current search excerpt in a split | `<ctrl-w> <space>` |
+| Go to definition in a split                | `<ctrl-w> g d`     |
+| Go to type definition in a split           | `<ctrl-w> g D`     |
+
+### In insert mode
+
+The following commands help you bring up Zed's completion menu, request a suggestion from GitHub Copilot, or open the inline AI assistant without leaving insert mode.
+
+| Command                                                                      | Default Shortcut |
+| ---------------------------------------------------------------------------- | ---------------- |
+| Open the completion menu                                                     | `ctrl-x ctrl-o`  |
+| Request GitHub Copilot suggestion (requires GitHub Copilot to be configured) | `ctrl-x ctrl-c`  |
+| Open the inline AI assistant (requires a configured assistant)               | `ctrl-x ctrl-a`  |
+| Open the code actions menu                                                   | `ctrl-x ctrl-l`  |
+| Hides all suggestions                                                        | `ctrl-x ctrl-z`  |
+
+### Supported plugins
+
+Zed's vim mode includes some features that are usually provided by very popular plugins in the Vim ecosystem:
+
+- You can surround text objects with `ys` (yank surround), change surrounding with `cs`, and delete surrounding with `ds`.
+- You can comment and uncomment selections with `gc` in visual mode and `gcc` in normal mode.
+- The project panel supports many shortcuts modeled after the Vim plugin `netrw`: navigation with `hjkl`, open file with `o`, open file in a new tab with `t`, etc.
+- You can add key bindings to your keymap to navigate "camelCase" names. [Head down to the Optional key bindings](#optional-key-bindings) section to learn how.
+
+## Command palette
+
+Vim mode allows you to open Zed's command palette with `:`. You can then type to access any usual Zed command. Additionally, vim mode adds aliases for popular Vim commands to ensure your muscle memory transfers to Zed. For example, you can write `:w` or `:write` to save the file.
+
+Below, you'll find tables listing the commands you can use in the command palette. We put optional characters in square brackets to indicate that you can omit them.
+
+> **Note**: We don't emulate the full power of Vim's command line yet. In particular, commands currently do not support arguments. Please [file issues on GitHub](https://github.com/zed-industries/zed) as you find things that are missing from the command palette.
+
+### File and window management
+
+This table shows commands for managing windows, tabs, and panes. As commands don't support arguments currently, you cannot specify a filename when saving or creating a new file.
+
+| Command        | Description                                          |
+| -------------- | ---------------------------------------------------- |
+| `:w[rite][!]`  | Save the current file                                |
+| `:wq[!]`       | Save the file and close the buffer                   |
+| `:q[uit][!]`   | Close the buffer                                     |
+| `:wa[ll][!]`   | Save all open files                                  |
+| `:wqa[ll][!]`  | Save all open files and close all buffers            |
+| `:qa[ll][!]`   | Close all buffers                                    |
+| `:[e]x[it][!]` | Close the buffer                                     |
+| `:up[date]`    | Save the current file                                |
+| `:cq`          | Quit completely (close all running instances of Zed) |
+| `:vs[plit]`    | Split the pane vertically                            |
+| `:sp[lit]`     | Split the pane horizontally                          |
+| `:new`         | Create a new file in a horizontal split              |
+| `:vne[w]`      | Create a new file in a vertical split                |
+| `:tabedit`     | Create a new file in a new tab                       |
+| `:tabnew`      | Create a new file in a new tab                       |
+| `:tabn[ext]`   | Go to the next tab                                   |
+| `:tabp[rev]`   | Go to previous tab                                   |
+| `:tabc[lose]`  | Close the current tab                                |
+
+> **Note:** The `!` character is used to force the command to execute without saving changes or prompting before overwriting a file.
+
+### Ex commands
+
+These ex commands open Zed's various panels and windows.
+
+| Command                      | Default Shortcut |
+| ---------------------------- | ---------------- |
+| Open the project panel       | `:E[xplore]`     |
+| Open the collaboration panel | `:C[ollab]`      |
+| Open the chat panel          | `:Ch[at]`        |
+| Open the AI panel            | `:A[I]`          |
+| Open the notifications panel | `:No[tif]`       |
+| Open the feedback window     | `:fe[edback]`    |
+| Open the diagnostics window  | `:cl[ist]`       |
+| Open the terminal            | `:te[rm]`        |
+| Open the extensions window   | `:Ext[ensions]`  |
+
+### Navigating diagnostics
+
+These commands navigate diagnostics.
+
+| Command                  | Description                    |
+| ------------------------ | ------------------------------ |
+| `:cn[ext]` or `:ln[ext]` | Go to the next diagnostic      |
+| `:cp[rev]` or `:lp[rev]` | Go to the previous diagnostics |
+| `:cc` or `:ll`           | Open the errors page           |
+
+### Git
+
+These commands interact with the version control system git.
+
+| Command         | Description                                             |
+| --------------- | ------------------------------------------------------- |
+| `:dif[fupdate]` | View the diff under the cursor (`d o` in normal mode)   |
+| `:rev[ert]`     | Revert the diff under the cursor (`d p` in normal mode) |
+
+### Jump
+
+These commands jump to specific positions in the file.
+
+| Command             | Description                         |
+| ------------------- | ----------------------------------- |
+| `:<number>`         | Jump to a line number               |
+| `:$`                | Jump to the end of the file         |
+| `:/foo` and `:?foo` | Jump to next/prev line matching foo |
+
+### Replacement
+
+This command replaces text. It emulates the substitute command in vim. The substitute command uses regular expressions, and Zed uses a slightly different syntax than vim. You can learn more about Zed's syntax below, [in the regex differences section](#regex-differences). Also, by default, Zed always replaces all occurrences of the search pattern in the current line.
+
+| Command              | Description                       |
+| -------------------- | --------------------------------- |
+| `:[range]s/foo/bar/` | Replace instances of foo with bar |
+
+### Editing
+
+These commands help you edit text.
+
+| Command           | Description                                             |
+| ----------------- | ------------------------------------------------------- |
+| `:j[oin]`         | Join the current line                                   |
+| `:d[elete][l][p]` | Delete the current line                                 |
+| `:s[ort] [i]`     | Sort the current selection (with i, case-insensitively) |
+| `:y[ank]`         | Yank (copy) the current selection or line               |
+
+### Command mnemonics
+
+As any Zed command is available, you may find that it's helpful to remember mnemonics that run the correct command. For example:
+
+- `:diffs` for "toggle all hunk diffs"
+- `:cpp` for "copy path to file"
+- `:crp` for "copy relative path"
+- `:reveal` for "reveal in finder"
+- `:zlog` for "open zed log"
+- `:clank` for "cancel language server work"
+
+## Customizing key bindings
+
+In this section, we'll learn how to customize the key bindings of Zed's vim mode. You'll learn:
+
+- How to select the correct context for your new key bindings.
+- Useful contexts for vim mode key bindings.
+- Common key bindings to customize for extra productivity.
+
+### Selecting the correct context
+
+Zed's key bindings are evaluated only when the `"context"` property matches your location in the editor. For example, if you add key bindings to the `"Editor"` context, they will only work when you're editing a file. If you add key bindings to the `"Workspace"` context, they will work everywhere in Zed. Here's an example of a key binding that saves when you're editing a file:
+
+```json
+{
+  "context": "Editor",
+  "bindings": {
+    "ctrl-s": "file::Save"
+  }
+}
 ```
-# Language server
-g d     Go to definition
-g D     Go to declaration
-g y     Go to type definition
-g I     Go to implementation
-
-c d     Rename (change definition)
-g A     Go to All references to the current word
-
-g s   Find symbol in current file
-g S   Find symbol in entire project
-
-g ]   Go to next diagnostic
-g [   Go to previous diagnostic
-] d   Go to next diagnostic
-[ d   Go to previous diagnostic
-g h   Show inline error (hover)
-g .   Open the code actions menu
-
-# Git
-] c   Go to next git change
-[ c   Go to previous git change
-
-# Treesitter
-] x   Select a smaller syntax node
-[ x   Select a larger syntax node
-
-# Multi cursor
-g l   Add a visual selection for the next copy of the current word
-g L   The same, but backwards
-g >   Skip latest word selection, and add next.
-g <   The same, but backwards
-g a   Add a visual selection for every copy of the current word
-
-# Pane management
-g /        Open a project-wide search
-g <space>  Open the current search excerpt
-<ctrl-w> <space>  Open the current search excerpt in a split
-<ctrl-w> g d      Go to definition in a split
-<ctrl-w> g D      Go to type definition in a split
-
-# Insert mode
-ctrl-x ctrl-o  Open the completion menu
-ctrl-x ctrl-c  Request GitHub Copilot suggestion (if configured)
-ctrl-x ctrl-a  Open the inline AI assistant (if configured)
-ctrl-x ctrl-l  Open the code actions menu
-ctrl-x ctrl-z  Hides all suggestions
-
-# Ex commands
-:E[xplore]    Open the project panel
-:C[ollab]     Open the collaboration panel
-:Ch[at]       Open the chat panel
-:A[I]         Open the AI panel
-:No[tif]      Open the notifications panel
-:fe[edback]   Open the feedback window
-:cl[ist]      Open the diagnostics window
-:te[rm]       Open the terminal
-:Ext[ensions] Open the extensions window
+
+Contexts are nested, so when you're editing a file, the context is the `"Editor"` context, which is inside the `"Pane"` context, which is inside the `"Workspace"` context. That's why any key bindings you add to the `"Workspace"` context will work when you're editing a file. Here's an example:
+
+```json
+// This key binding will work when you're editing a file. It comes built into Zed by default as the workspace: save command.
+{
+  "context": "Workspace",
+  "bindings": {
+    "ctrl-s": "file::Save"
+  }
+}
 ```
 
-Vim mode uses Zed to define concepts like "brackets" (for the `%` key) and "words" (for motions like `w` and `e`). This does lead to some differences, but they are mostly positive. For example `%` considers `|` to be a bracket in languages like Rust; and `w` considers `$` to be a word-character in languages like JavaScript.
+Contexts are expressions. They support boolean operators like `&&` (and) and `||` (or). For example, you can use the context `"Editor && vim_mode == normal"` to create key bindings that only work when you're editing a file _and_ you're in vim's normal mode.
 
-Vim mode emulates visual block mode using Zed's multiple cursor support. This again leads to some differences, but is much more powerful.
+Vim mode adds several contexts to the `"Editor"` context:
 
-Vim's macro support (`q` and `@`) is implemented using Zed's actions. This lets us support recording and replaying of autocompleted code, etc. Unlike Vim, Zed does not re-use the yank registers for recording macros, they are two separate namespaces.
+| Operator             | Description                                                                                                                                                                        |
+| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| VimControl           | Indicates that vim keybindings should work. Currently an alias for `vim_mode == normal \|\| vim_mode == visual \|\| vim_mode == operator`, but the definition may change over time |
+| vim_mode == normal   | Normal mode                                                                                                                                                                        |
+| vim_mode == visual   | Visual mode                                                                                                                                                                        |
+| vim_mode == insert   | Insert mode                                                                                                                                                                        |
+| vim_mode == replace  | Replace mode                                                                                                                                                                       |
+| vim_mode == waiting  | Waiting for an arbitrary key (e.g., after typing `f` or `t`)                                                                                                                       |
+| vim_mode == operator | Waiting for another binding to trigger (e.g., after typing `c` or `d`)                                                                                                             |
+| vim_operator         | Set to `none` unless `vim_mode == operator`, in which case it is set to the current operator's default keybinding (e.g., after typing `d`, `vim_operator == d`)                    |
 
-Finally, vim mode's search and replace functionality is backed by Zed's. This means that the pattern syntax is slightly different, see the section on [Regex differences](#regex-differences) for details.
+> **Note**: Contexts are matched only on one level at a time. So it is possible to use the expression `"Editor && vim_mode == normal"`, but `"Workspace && vim_mode == normal"` will never match because we set the vim context at the `"Editor"` level.
 
-## Custom key bindings
+### Useful contexts for vim mode key bindings
 
-You can edit your personal key bindings with `:keymap`.
-For vim-specific shortcuts, you may find the following template a good place to start.
+Here's a template with useful vim mode contexts to help you customize your vim mode key bindings. You can copy it and integrate it into your user keymap.
 
 ```json
 [
   {
     "context": "VimControl && !menu",
     "bindings": {
-      // put key-bindings here if you want them to work in normal & visual mode
+      // Put key bindings here if you want them to work in normal & visual mode.
     }
   },
   {
     "context": "vim_mode == normal && !menu",
     "bindings": {
-      // "shift-y": ["workspace::SendKeystrokes", "y $"] // use nvim's Y behavior
+      // "shift-y": ["workspace::SendKeystrokes", "y $"] // Use neovim's yank behavior: yank to end of line.
     }
   },
   {
     "context": "vim_mode == insert",
     "bindings": {
-      // "j k": "vim::NormalBefore" // remap jk in insert mode to escape.
+      // "j k": "vim::NormalBefore" // In insert mode, make jk escape to normal mode.
     }
   },
   {
     "context": "EmptyPane || SharedScreen",
     "bindings": {
-      // put key-bindings here (in addition to above) if you want them to
-      // work when no editor exists
+      // Put key bindings here (in addition to the context above) if you want them to
+      // work when no editor exists.
       // "space f": "file_finder::Toggle"
     }
   }
 ]
 ```
 
-If you would like to emulate vim's `map` (`nmap` etc.) commands you can bind to the [`workspace::SendKeystrokes`](./key-bindings.md#remapping-keys) action in the correct context.
+> **Note**: If you would like to emulate Vim's `map` commands (`nmap`, etc.), you can use the action `workspace::SendKeystrokes` in the correct context.
 
-Check out the [bindings that are enabled by default in vim mode](https://github.com/zed-industries/zed/blob/main/assets/keymaps/vim.json).
+### Optional key bindings
 
-### Contexts
+By default, you can navigate between the different files open in the editor with shortcuts like `ctrl+w` followed by one of `hjkl` to move to the left, down, up, or right, respectively.
 
-Zed's keyboard bindings are evaluated only when the `"context"` matches the location you are in on the screen. Locations are nested, so when you're editing, you're in the `"Workspace"` location, which is at the top, containing a `"Pane"` that contains an `"Editor"`.
+But you cannot use the same shortcuts to move between all the editor docks (the terminal, project panel, assistant panel, ...). If you want to use the same shortcuts to navigate to the docks, you can add the following key bindings to your user keymap.
 
-Contexts are matched only on one level at a time. So, it is possible to combine `Editor && vim_mode == normal`, but `Workspace && vim_mode == normal` will never match because we set the vim context at the `Editor` level.
+```json
+{
+  "context": "Dock",
+  "bindings": {
+    "ctrl-w h": ["workspace::ActivatePaneInDirection", "Left"],
+    "ctrl-w l": ["workspace::ActivatePaneInDirection", "Right"],
+    "ctrl-w k": ["workspace::ActivatePaneInDirection", "Up"],
+    "ctrl-w j": ["workspace::ActivatePaneInDirection", "Down"]
+    // ... or other keybindings
+  }
+}
+```
 
-Vim mode adds several contexts to the `Editor`:
+Subword motion, which allows you to navigate and select individual words in camelCase or snake_case, is not enabled by default. To enable it, add these bindings to your keymap.
 
-- `vim_mode` is similar to, but not identical to, the current mode. It starts as one of `normal`, `visual`, `insert` or `replace` (depending on your mode). If you are mid-way through typing a sequence, `vim_mode` will be either `waiting` if it's waiting for an arbitrary key (for example after typing `f` or `t`), or `operator` if it's waiting for another binding to trigger (for example after typing `c` or `d`).
-- `vim_operator` is set to `none` unless `vim_mode == operator` in which case it is set to the current operator's default keybinding (for example after typing `d`, `vim_operator == d`).
-- `"VimControl"` indicates that vim keybindings should work. It is currently an alias for `vim_mode == normal || vim_mode == visual || vim_mode == operator`, but the definition may change over time.
+```json
+[
+  {
+    "context": "VimControl && !menu && vim_mode != operator",
+    "bindings": {
+      "w": "vim::NextSubwordStart",
+      "b": "vim::PreviousSubwordStart",
+      "e": "vim::NextSubwordEnd",
+      "g e": "vim::PreviousSubwordEnd"
+    }
+  }
+]
+```
+
+Vim mode comes with shortcuts to surround the selection in normal mode (`ys`), but it doesn't have a shortcut to add surrounds in visual mode. By default, `shift-s` substitutes the selection (erases the text and enters insert mode). To use `shift-s` to add surrounds in visual mode, you can add the following object to your keymap.
+
+```json
+{
+  "context": "vim_mode == visual",
+  "bindings": {
+    "shift-s": [
+      "vim::PushOperator",
+      {
+        "AddSurrounds": {}
+      }
+    ]
+  }
+}
+```
 
 ### Restoring common text editing keybindings
 
-If you're using vim mode on Linux or Windows, you may find it overrides keybindings you can't live without: <kbd>Ctrl</kbd>+<kbd>v</kbd> to copy, <kbd>Ctrl</kbd>+<kbd>f</kbd> to search, etc. You can restore them by copying this data into your keymap:
+If you're using vim mode on Linux or Windows, you may find it overrides keybindings you can't live without: `ctrl+v` to copy, `ctrl+f` to search, etc. You can restore them by copying this data into your keymap:
 
 ```json
 {
@@ -162,109 +398,39 @@ If you're using vim mode on Linux or Windows, you may find it overrides keybindi
 },
 ```
 
-## Command palette
-
-Vim mode allows you to enable Zed’s command palette with `:`. This means that you can use vim's command palette to run any action that Zed supports.
-
-Additionally, vim mode contains a number of aliases for popular Vim commands to ensure that muscle memory works. For example, `:w<enter>` will save the file.
-
-We do not (yet) emulate the full power of Vim’s command line, in particular, we do not support arguments to commands yet. Please [file issues on GitHub](https://github.com/zed-industries/zed) as you find things that are missing from the command palette.
-
-As mentioned above, one thing to be aware of is that the regex engine is slightly different from vim's in `:%s/a/b`.
-
-Currently supported Vim-specific commands:
+## Changing vim mode settings
 
-```
-# window management
-:w[rite][!], :wq[!], :q[uit][!], :wa[ll][!], :wqa[ll][!], :qa[ll][!], :[e]x[it][!], :up[date]
-    to save/close tab(s) and pane(s) (no filename is supported yet)
-:cq
-    to quit completely.
-:vs[plit], :sp[lit]
-    to split vertically/horizontally (no filename is supported yet)
-:new, :vne[w]
-    to create a new file in a new pane above or to the left
-:tabedit, :tabnew
-    to create a new file in a new tab.
-:tabn[ext], :tabp[rev]
-    to go to previous/next tabs
-:tabc[lose]
-    to close the current tab
-
-# navigating diagnostics
-:cn[ext], :cp[rev], :ln[ext], :lp[rev]
-    to go to the next/prev diagnostics
-:cc, :ll
-    to open the errors page
-
-# handling git diff
-:dif[fupdate]
-    to view the diff under the cursor ("d o" in normal mode)
-:rev[ert]
-    to revert the diff under the cursor ("d p" in normal mode)
-
-# jump to position
-:<number>
-    to jump to a line number
-:$
-    to jump to the end of the file
-:/foo and :?foo
-    to jump to next/prev line matching foo
-
-# replacement (/g is always assumed and Zed uses different regex syntax to vim)
-:[range]s/foo/bar/
-  to replace instances of foo with bar
-
-# editing
-:j[oin]
-    to join the current line (no range is yet supported)
-:d[elete][l][p]
-    to delete the current line (no range is yet supported)
-:s[ort] [i]
-    to sort the current selection (with i, case-insensitively)
-:y[ank]
-```
-
-As any Zed command is available, you may find that it's helpful to remember mnemonics that run the correct command. For example:
+You can change the following settings to modify vim mode's behavior:
 
-```
-:diffs  Toggle all Hunk [Diffs]
-:cpp    [C]o[p]y [P]ath to file
-:crp    [C]opy [r]elative [P]ath
-:reveal [Reveal] in finder
-:zlog   Open [Z]ed Log
-:clank  [C]ancel [lan]guage server work[k]
-```
+| Property                     | Description                                                                                                                                                                                   | Default Value |
+| ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------- |
+| use_system_clipboard         | Determines how system clipboard is used:<br><ul><li>"always": use for all operations</li><li>"never": only use when explicitly specified</li><li>"on_yank": use for yank operations</li></ul> | "always"      |
+| use_multiline_find           | If `true`, `f` and `t` motions extend across multiple lines.                                                                                                                                  | false         |
+| use_smartcase_find           | If `true`, `f` and `t` motions are case-insensitive when the target letter is lowercase.                                                                                                      | false         |
+| toggle_relative_line_numbers | If `true`, line numbers are relative in normal mode and absolute in insert mode, giving you the best of both options.                                                                         | false         |
+| custom_digraphs              | An object that allows you to add custom digraphs. Read below for an example.                                                                                                                  | {}            |
 
-## Settings
-
-Vim mode is not enabled by default. To enable vim mode, you need to add the following configuration to your settings file:
+Here's an example of adding a digraph for the zombie emoji. This allows you to type `ctrl-k f z` to insert a zombie emoji. You can add as many digraphs as you like.
 
 ```json
 {
-  "vim_mode": true
+  "vim": {
+    "custom_digraphs": {
+      "fz": "🧟‍♀️"
+    }
+  }
 }
 ```
 
-Alternatively, you can enable vim mode by running the `toggle vim mode` command from the command palette.
-
-Some vim settings are available to modify the default vim behavior:
+Here's an example of these settings changed:
 
 ```json
 {
   "vim": {
-    // "always": use system clipboard when no register is specified
-    // "never": don't use system clipboard unless "+ or "* is specified
-    // "on_yank": use system clipboard for yank operations when no register is specified
-    "use_system_clipboard": "always",
-    // Let `f` and `t` motions extend across multiple lines
+    "use_system_clipboard": "never",
     "use_multiline_find": true,
-    // Let `f` and `t` motions match case insensitively if the target is lowercase
     "use_smartcase_find": true,
-    // Use relative line numbers in normal mode, absolute in insert mode
-    // c.f. https://github.com/jeffkreeftmeijer/vim-numbertoggle
     "toggle_relative_line_numbers": true,
-    // Add custom digraphs (e.g. ctrl-k f z will insert a zombie emoji)
     "custom_digraphs": {
       "fz": "🧟‍♀️"
     }
@@ -272,22 +438,36 @@ Some vim settings are available to modify the default vim behavior:
 }
 ```
 
-There are also a few Zed settings that you may also enjoy if you use vim mode:
+## Useful core Zed settings for vim mode
+
+Here are a few general Zed settings that can help you fine-tune your Vim experience:
+
+| Property                | Description                                                                                                                                                   | Default Value          |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
+| cursor_blink            | If `true`, the cursor blinks.                                                                                                                                 | `true`                 |
+| relative_line_numbers   | If `true`, line numbers in the left gutter are relative to the cursor.                                                                                        | `true`                 |
+| scrollbar               | Object that controls the scrollbar display. Set to `{ "show": "never" }` to hide the scroll bar.                                                              | `{ "show": "always" }` |
+| scroll_beyond_last_line | If set to `"one_page"`, allows scrolling up to one page beyond the last line. Set to `"off"` to prevent this behavior.                                        | `"one_page"`           |
+| vertical_scroll_margin  | The number of lines to keep above or below the cursor when scrolling. Set to `0` to allow the cursor to go up to the edges of the screen vertically.          | `3`                    |
+| gutter.line_numbers     | Controls the display of line numbers in the gutter. Set the `"line_numbers"` property to `false` to hide line numbers.                                        | `true`                 |
+| command_aliases         | Object that defines aliases for commands in the command palette. You can use it to define shortcut names for commands you use often. Read below for examples. | `{}`                   |
+
+Here's an example of these settings changed:
 
 ```json
 {
-  // disable cursor blink
+  // Disable cursor blink
   "cursor_blink": false,
-  // use relative line numbers
+  // Use relative line numbers
   "relative_line_numbers": true,
-  // hide the scroll bar
+  // Hide the scroll bar
   "scrollbar": { "show": "never" },
-  // prevent the buffer from scrolling beyond the last line
+  // Prevent the buffer from scrolling beyond the last line
   "scroll_beyond_last_line": "off",
-  // allow cursor to reach edges of screen
+  // Allow the cursor to reach the edges of the screen
   "vertical_scroll_margin": 0,
   "gutter": {
-    // disable line numbers completely:
+    // Disable line numbers completely:
     "line_numbers": false
   },
   "command_aliases": {
@@ -298,74 +478,17 @@ There are also a few Zed settings that you may also enjoy if you use vim mode:
 }
 ```
 
-If you want to navigate between the editor and docks (terminal, project panel, AI assistant panel, etc...), just like you navigate between splits, you can use the following key bindings:
-
-```json
-{
-  "context": "Dock",
-  "bindings": {
-    "ctrl-w h": ["workspace::ActivatePaneInDirection", "Left"],
-    "ctrl-w l": ["workspace::ActivatePaneInDirection", "Right"],
-    "ctrl-w k": ["workspace::ActivatePaneInDirection", "Up"],
-    "ctrl-w j": ["workspace::ActivatePaneInDirection", "Down"]
-    // ... or other keybindings
-  }
-}
-```
-
-Subword motion is not enabled by default. To enable it, add these bindings to your keymap.
-
-```json
-[
-  {
-    "context": "VimControl && !menu && vim_mode != operator",
-    "bindings": {
-      "w": "vim::NextSubwordStart",
-      "b": "vim::PreviousSubwordStart",
-      "e": "vim::NextSubwordEnd",
-      "g e": "vim::PreviousSubwordEnd"
-    }
-  }
-]
-```
-
-Surrounding the selection in visual mode is also not enabled by default (`shift-s` normally behaves like `c`). To enable it, add the following to your keymap.
-
-```json
-{
-  "context": "vim_mode == visual",
-  "bindings": {
-    "shift-s": [
-      "vim::PushOperator",
-      {
-        "AddSurrounds": {}
-      }
-    ]
-  }
-}
-```
-
-## Supported plugins
-
-Zed has nascent support for some Vim plugins:
-
-- From `vim-surround`, `ys`, `cs` and `ds` work. Though you cannot add new HTML tags yet.
-- From `vim-commentary`, `gc` in visual mode and `gcc` in normal mode. Though you cannot operate on arbitrary objects yet.
-- From `netrw`, most keybindings are supported in the project panel.
-- From `vim-spider`/`CamelCaseMotion` you can use subword motions as described above.
+The `command_aliases` property is a single object that maps keys or key sequences to vim mode commands. The example above defines multiple aliases: `W` for `w`, `Wq` for `wq`, and `Q` for `q`.
 
 ## Regex differences
 
-Zed uses a different regular expression engine from Vim. This means that you will have to use a different syntax for some things.
-
-Notably:
+Zed uses a different regular expression engine from Vim. This means that you will have to use a different syntax in some cases. Here are the most common differences:
 
-- Vim uses `\(` and `\)` to represent capture groups, in Zed these are `(` and `)`.
-- On the flip side, `(` and `)` represent literal parentheses, but in Zed these must be escaped to `\(` and `\)`.
-- When replacing, Vim uses `\0` to represent the entire match, in Zed this is `$0`, same for numbered capture groups `\1` -> `$1`.
-- Vim uses `/g` to indicate "all matches on one line", in Zed this is implied
-- Vim uses `/i` to indicate "case-insensitive", in Zed you can either use `(?i)` at the start of the pattern or toggle case-sensitivity with `cmd-option-c`.
+- **Capture groups**: Vim uses `\(` and `\)` to represent capture groups, in Zed these are `(` and `)`. On the flip side, in Vim, `(` and `)` represent literal parentheses, but in Zed these must be escaped to `\(` and `\)`.
+- **Matches**: When replacing, Vim uses the backslash character followed by a number to represent a matched capture group. For example, `\1`. Zed uses the dollar sign instead. So, when in Vim you use `\0` to represent the entire match, in Zed the syntax is `$0` instead. Same for numbered capture groups: `\1` in Vim is `$1` in Zed.
+- **Global option**: By default, in Vim, regex searches only match the first occurrence on a line, and you append `/g` at the end of your query to find all matches. In Zed, regex searches are global by default.
+- **Case sensitivity**: Vim uses `/i` to indicate a case-insensitive search. In Zed you can either write `(?i)` at the start of the pattern or toggle case-sensitivity with the shortcut {#kb search::ToggleCaseSensitive}.
 
-To help with the transition, the command palette will fix parentheses and replace groups for you when you run `:%s//`. So `%s:/\(a\)(b)/\1/` will be converted into a search for "(a)\(b\)" and a replacement of "$1".
+> **Note**: To help with the transition, the command palette will fix parentheses and replace groups for you when you write a Vim-style substitute command, `:%s//`. So, Zed will convert `%s:/\(a\)(b)/\1/` into a search for "(a)\(b\)" and a replacement of "$1".
 
 For the full syntax supported by Zed's regex engine [see the regex crate documentation](https://docs.rs/regex/latest/regex/#syntax).

From a36706aed6e7f582f731a4f33ef3b056dac25f36 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Mon, 23 Sep 2024 09:11:58 -0600
Subject: [PATCH 271/762] Fix up/down project_id confusion (#18099)

Release Notes:

- ssh remoting: Fix LSP queries run over collab
---
 crates/project/src/lsp_store.rs              | 137 +++++++++++--------
 crates/project/src/project.rs                |  19 +--
 crates/project/src/worktree_store.rs         | 103 +++++++++-----
 crates/remote_server/src/headless_project.rs |   2 +-
 4 files changed, 161 insertions(+), 100 deletions(-)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 95ca84236001ce..4506fcc6feb430 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -50,7 +50,7 @@ use parking_lot::{Mutex, RwLock};
 use postage::watch;
 use rand::prelude::*;
 
-use rpc::AnyProtoClient;
+use rpc::{proto::SSH_PROJECT_ID, AnyProtoClient};
 use serde::Serialize;
 use settings::{Settings, SettingsLocation, SettingsStore};
 use sha2::{Digest, Sha256};
@@ -132,6 +132,7 @@ impl LocalLspStore {
 
 pub struct RemoteLspStore {
     upstream_client: AnyProtoClient,
+    upstream_project_id: u64,
 }
 
 impl RemoteLspStore {}
@@ -164,8 +165,7 @@ impl LspStoreMode {
 
 pub struct LspStore {
     mode: LspStoreMode,
-    downstream_client: Option<AnyProtoClient>,
-    project_id: u64,
+    downstream_client: Option<(AnyProtoClient, u64)>,
     nonce: u128,
     buffer_store: Model<BufferStore>,
     worktree_store: Model<WorktreeStore>,
@@ -302,14 +302,16 @@ impl LspStore {
         }
     }
 
-    pub fn upstream_client(&self) -> Option<AnyProtoClient> {
+    pub fn upstream_client(&self) -> Option<(AnyProtoClient, u64)> {
         match &self.mode {
             LspStoreMode::Ssh(SshLspStore {
                 upstream_client, ..
-            })
-            | LspStoreMode::Remote(RemoteLspStore {
-                upstream_client, ..
-            }) => Some(upstream_client.clone()),
+            }) => Some((upstream_client.clone(), SSH_PROJECT_ID)),
+            LspStoreMode::Remote(RemoteLspStore {
+                upstream_client,
+                upstream_project_id,
+                ..
+            }) => Some((upstream_client.clone(), *upstream_project_id)),
             LspStoreMode::Local(_) => None,
         }
     }
@@ -374,7 +376,6 @@ impl LspStore {
                 }),
             }),
             downstream_client: None,
-            project_id: 0,
             buffer_store,
             worktree_store,
             languages: languages.clone(),
@@ -395,10 +396,11 @@ impl LspStore {
         &self,
         buffer: Model<Buffer>,
         client: AnyProtoClient,
+        upstream_project_id: u64,
         request: R,
         cx: &mut ModelContext<'_, LspStore>,
     ) -> Task<anyhow::Result<<R as LspCommand>::Response>> {
-        let message = request.to_proto(self.project_id, buffer.read(cx));
+        let message = request.to_proto(upstream_project_id, buffer.read(cx));
         cx.spawn(move |this, cx| async move {
             let response = client.request(message).await?;
             let this = this.upgrade().context("project dropped")?;
@@ -413,7 +415,6 @@ impl LspStore {
         worktree_store: Model<WorktreeStore>,
         languages: Arc<LanguageRegistry>,
         upstream_client: AnyProtoClient,
-        project_id: u64,
         cx: &mut ModelContext<Self>,
     ) -> Self {
         cx.subscribe(&buffer_store, Self::on_buffer_store_event)
@@ -429,7 +430,6 @@ impl LspStore {
                 current_lsp_settings: Default::default(),
             }),
             downstream_client: None,
-            project_id,
             buffer_store,
             worktree_store,
             languages: languages.clone(),
@@ -461,9 +461,11 @@ impl LspStore {
             .detach();
 
         Self {
-            mode: LspStoreMode::Remote(RemoteLspStore { upstream_client }),
+            mode: LspStoreMode::Remote(RemoteLspStore {
+                upstream_client,
+                upstream_project_id: project_id,
+            }),
             downstream_client: None,
-            project_id,
             buffer_store,
             worktree_store,
             languages: languages.clone(),
@@ -768,13 +770,13 @@ impl LspStore {
     }
 
     pub(crate) fn send_diagnostic_summaries(&self, worktree: &mut Worktree) {
-        if let Some(client) = self.downstream_client.clone() {
+        if let Some((client, downstream_project_id)) = self.downstream_client.clone() {
             if let Some(summaries) = self.diagnostic_summaries.get(&worktree.id()) {
                 for (path, summaries) in summaries {
                     for (&server_id, summary) in summaries {
                         client
                             .send(proto::UpdateDiagnosticSummary {
-                                project_id: self.project_id,
+                                project_id: downstream_project_id,
                                 worktree_id: worktree.id().to_proto(),
                                 summary: Some(summary.to_proto(server_id, path)),
                             })
@@ -798,8 +800,14 @@ impl LspStore {
     {
         let buffer = buffer_handle.read(cx);
 
-        if let Some(upstream_client) = self.upstream_client() {
-            return self.send_lsp_proto_request(buffer_handle, upstream_client, request, cx);
+        if let Some((upstream_client, upstream_project_id)) = self.upstream_client() {
+            return self.send_lsp_proto_request(
+                buffer_handle,
+                upstream_client,
+                upstream_project_id,
+                request,
+                cx,
+            );
         }
 
         let language_server = match server {
@@ -1077,9 +1085,9 @@ impl LspStore {
         push_to_history: bool,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<ProjectTransaction>> {
-        if let Some(upstream_client) = self.upstream_client() {
+        if let Some((upstream_client, project_id)) = self.upstream_client() {
             let request = proto::ApplyCodeAction {
-                project_id: self.project_id,
+                project_id,
                 buffer_id: buffer_handle.read(cx).remote_id().into(),
                 action: Some(Self::serialize_code_action(&action)),
             };
@@ -1163,9 +1171,9 @@ impl LspStore {
         server_id: LanguageServerId,
         cx: &mut ModelContext<Self>,
     ) -> Task<anyhow::Result<InlayHint>> {
-        if let Some(upstream_client) = self.upstream_client() {
+        if let Some((upstream_client, project_id)) = self.upstream_client() {
             let request = proto::ResolveInlayHint {
-                project_id: self.project_id,
+                project_id,
                 buffer_id: buffer_handle.read(cx).remote_id().into(),
                 language_server_id: server_id.0 as u64,
                 hint: Some(InlayHints::project_to_proto_hint(hint.clone())),
@@ -1274,9 +1282,9 @@ impl LspStore {
         trigger: String,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Option<Transaction>>> {
-        if let Some(client) = self.upstream_client() {
+        if let Some((client, project_id)) = self.upstream_client() {
             let request = proto::OnTypeFormatting {
-                project_id: self.project_id,
+                project_id,
                 buffer_id: buffer.read(cx).remote_id().into(),
                 position: Some(serialize_anchor(&position)),
                 trigger,
@@ -1424,11 +1432,11 @@ impl LspStore {
         range: Range<Anchor>,
         cx: &mut ModelContext<Self>,
     ) -> Task<Vec<CodeAction>> {
-        if let Some(upstream_client) = self.upstream_client() {
+        if let Some((upstream_client, project_id)) = self.upstream_client() {
             let request_task = upstream_client.request(proto::MultiLspQuery {
                 buffer_id: buffer_handle.read(cx).remote_id().into(),
                 version: serialize_version(&buffer_handle.read(cx).version()),
-                project_id: self.project_id,
+                project_id,
                 strategy: Some(proto::multi_lsp_query::Strategy::All(
                     proto::AllLanguageServers {},
                 )),
@@ -1437,7 +1445,7 @@ impl LspStore {
                         range: range.clone(),
                         kinds: None,
                     }
-                    .to_proto(self.project_id, buffer_handle.read(cx)),
+                    .to_proto(project_id, buffer_handle.read(cx)),
                 )),
             });
             let buffer = buffer_handle.clone();
@@ -1504,10 +1512,11 @@ impl LspStore {
     ) -> Task<Result<Vec<Completion>>> {
         let language_registry = self.languages.clone();
 
-        if let Some(upstream_client) = self.upstream_client() {
+        if let Some((upstream_client, project_id)) = self.upstream_client() {
             let task = self.send_lsp_proto_request(
                 buffer.clone(),
                 upstream_client,
+                project_id,
                 GetCompletions { position, context },
                 cx,
             );
@@ -1603,14 +1612,13 @@ impl LspStore {
     ) -> Task<Result<bool>> {
         let client = self.upstream_client();
         let language_registry = self.languages.clone();
-        let project_id = self.project_id;
 
         let buffer_id = buffer.read(cx).remote_id();
         let buffer_snapshot = buffer.read(cx).snapshot();
 
         cx.spawn(move |this, cx| async move {
             let mut did_resolve = false;
-            if let Some(client) = client {
+            if let Some((client, project_id)) = client {
                 for completion_index in completion_indices {
                     let (server_id, completion) = {
                         let completions_guard = completions.read();
@@ -1811,8 +1819,7 @@ impl LspStore {
         let buffer = buffer_handle.read(cx);
         let buffer_id = buffer.remote_id();
 
-        if let Some(client) = self.upstream_client() {
-            let project_id = self.project_id;
+        if let Some((client, project_id)) = self.upstream_client() {
             cx.spawn(move |_, mut cx| async move {
                 let response = client
                     .request(proto::ApplyCompletionAdditionalEdits {
@@ -1927,9 +1934,9 @@ impl LspStore {
         let buffer_id = buffer.remote_id().into();
         let lsp_request = InlayHints { range };
 
-        if let Some(client) = self.upstream_client() {
+        if let Some((client, project_id)) = self.upstream_client() {
             let request = proto::InlayHints {
-                project_id: self.project_id,
+                project_id,
                 buffer_id,
                 start: Some(serialize_anchor(&range_start)),
                 end: Some(serialize_anchor(&range_end)),
@@ -1977,16 +1984,16 @@ impl LspStore {
     ) -> Task<Vec<SignatureHelp>> {
         let position = position.to_point_utf16(buffer.read(cx));
 
-        if let Some(client) = self.upstream_client() {
+        if let Some((client, upstream_project_id)) = self.upstream_client() {
             let request_task = client.request(proto::MultiLspQuery {
                 buffer_id: buffer.read(cx).remote_id().into(),
                 version: serialize_version(&buffer.read(cx).version()),
-                project_id: self.project_id,
+                project_id: upstream_project_id,
                 strategy: Some(proto::multi_lsp_query::Strategy::All(
                     proto::AllLanguageServers {},
                 )),
                 request: Some(proto::multi_lsp_query::Request::GetSignatureHelp(
-                    GetSignatureHelp { position }.to_proto(self.project_id, buffer.read(cx)),
+                    GetSignatureHelp { position }.to_proto(upstream_project_id, buffer.read(cx)),
                 )),
             });
             let buffer = buffer.clone();
@@ -2049,16 +2056,16 @@ impl LspStore {
         position: PointUtf16,
         cx: &mut ModelContext<Self>,
     ) -> Task<Vec<Hover>> {
-        if let Some(client) = self.upstream_client() {
+        if let Some((client, upstream_project_id)) = self.upstream_client() {
             let request_task = client.request(proto::MultiLspQuery {
                 buffer_id: buffer.read(cx).remote_id().into(),
                 version: serialize_version(&buffer.read(cx).version()),
-                project_id: self.project_id,
+                project_id: upstream_project_id,
                 strategy: Some(proto::multi_lsp_query::Strategy::All(
                     proto::AllLanguageServers {},
                 )),
                 request: Some(proto::multi_lsp_query::Request::GetHover(
-                    GetHover { position }.to_proto(self.project_id, buffer.read(cx)),
+                    GetHover { position }.to_proto(upstream_project_id, buffer.read(cx)),
                 )),
             });
             let buffer = buffer.clone();
@@ -2123,9 +2130,9 @@ impl LspStore {
     pub fn symbols(&self, query: &str, cx: &mut ModelContext<Self>) -> Task<Result<Vec<Symbol>>> {
         let language_registry = self.languages.clone();
 
-        if let Some(upstream_client) = self.upstream_client().as_ref() {
+        if let Some((upstream_client, project_id)) = self.upstream_client().as_ref() {
             let request = upstream_client.request(proto::GetProjectSymbols {
-                project_id: self.project_id,
+                project_id: *project_id,
                 query: query.to_string(),
             });
             cx.foreground_executor().spawn(async move {
@@ -2598,8 +2605,7 @@ impl LspStore {
         downstream_client: AnyProtoClient,
         _: &mut ModelContext<Self>,
     ) {
-        self.project_id = project_id;
-        self.downstream_client = Some(downstream_client.clone());
+        self.downstream_client = Some((downstream_client.clone(), project_id));
 
         for (server_id, status) in &self.language_server_statuses {
             downstream_client
@@ -2857,10 +2863,10 @@ impl LspStore {
         }
 
         if !old_summary.is_empty() || !new_summary.is_empty() {
-            if let Some(downstream_client) = &self.downstream_client {
+            if let Some((downstream_client, project_id)) = &self.downstream_client {
                 downstream_client
                     .send(proto::UpdateDiagnosticSummary {
-                        project_id: self.project_id,
+                        project_id: *project_id,
                         worktree_id: worktree_id.to_proto(),
                         summary: Some(proto::DiagnosticSummary {
                             path: worktree_path.to_string_lossy().to_string(),
@@ -2881,9 +2887,9 @@ impl LspStore {
         symbol: &Symbol,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Model<Buffer>>> {
-        if let Some(client) = self.upstream_client() {
+        if let Some((client, project_id)) = self.upstream_client() {
             let request = client.request(proto::OpenBufferForSymbol {
-                project_id: self.project_id,
+                project_id,
                 symbol: Some(Self::serialize_symbol(symbol)),
             });
             cx.spawn(move |this, mut cx| async move {
@@ -3184,6 +3190,17 @@ impl LspStore {
         envelope: TypedEnvelope<proto::MultiLspQuery>,
         mut cx: AsyncAppContext,
     ) -> Result<proto::MultiLspQueryResponse> {
+        let response_from_ssh = this.update(&mut cx, |this, _| {
+            let ssh = this.as_ssh()?;
+            let mut payload = envelope.payload.clone();
+            payload.project_id = SSH_PROJECT_ID;
+
+            Some(ssh.upstream_client.request(payload))
+        })?;
+        if let Some(response_from_ssh) = response_from_ssh {
+            return response_from_ssh.await;
+        }
+
         let sender_id = envelope.original_sender_id().unwrap_or_default();
         let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
         let version = deserialize_version(&envelope.payload.version);
@@ -4779,10 +4796,11 @@ impl LspStore {
         // TODO: We should use `adapter` here instead of reaching through the `CachedLspAdapter`.
         let lsp_adapter = adapter.adapter.clone();
 
-        let project_id = self.project_id;
+        let Some((upstream_client, project_id)) = self.upstream_client() else {
+            return;
+        };
         let worktree_id = worktree.read(cx).id().to_proto();
-        let upstream_client = ssh.upstream_client.clone();
-        let name = adapter.name();
+        let name = adapter.name().to_string();
 
         let Some(available_language) = self.languages.available_language_for_name(&language) else {
             log::error!("failed to find available language {language}");
@@ -5165,12 +5183,11 @@ impl LspStore {
                     }
                 });
 
-                let project_id = self.project_id;
                 for (worktree_id, summaries) in self.diagnostic_summaries.iter_mut() {
                     summaries.retain(|path, summaries_by_server_id| {
                         if summaries_by_server_id.remove(&server_id).is_some() {
-                            if let Some(downstream_client) = self.downstream_client.clone() {
-                                downstream_client
+                            if let Some((client, project_id)) = self.downstream_client.clone() {
+                                client
                                     .send(proto::UpdateDiagnosticSummary {
                                         project_id,
                                         worktree_id: worktree_id.to_proto(),
@@ -5236,9 +5253,9 @@ impl LspStore {
         buffers: impl IntoIterator<Item = Model<Buffer>>,
         cx: &mut ModelContext<Self>,
     ) {
-        if let Some(client) = self.upstream_client() {
+        if let Some((client, project_id)) = self.upstream_client() {
             let request = client.request(proto::RestartLanguageServers {
-                project_id: self.project_id,
+                project_id,
                 buffer_ids: buffers
                     .into_iter()
                     .map(|b| b.read(cx).remote_id().to_proto())
@@ -5694,9 +5711,9 @@ impl LspStore {
                     async move {
                         this.update(&mut cx, |this, cx| {
                             cx.emit(LspStoreEvent::RefreshInlayHints);
-                            this.downstream_client.as_ref().map(|client| {
+                            this.downstream_client.as_ref().map(|(client, project_id)| {
                                 client.send(proto::RefreshInlayHints {
-                                    project_id: this.project_id,
+                                    project_id: *project_id,
                                 })
                             })
                         })?
@@ -6073,9 +6090,9 @@ impl LspStore {
 
         cx.emit(LspStoreEvent::LanguageServerAdded(server_id));
 
-        if let Some(downstream_client) = self.downstream_client.as_ref() {
+        if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {
             downstream_client.send(proto::StartLanguageServer {
-                project_id: self.project_id,
+                project_id: *project_id,
                 server: Some(proto::LanguageServer {
                     id: server_id.0 as u64,
                     name: language_server.name().to_string(),
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 78584cbae0c65f..0c54a16187a4a6 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -625,7 +625,7 @@ impl Project {
             let snippets =
                 SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
 
-            let worktree_store = cx.new_model(|_| WorktreeStore::new(None, false, fs.clone()));
+            let worktree_store = cx.new_model(|_| WorktreeStore::local(false, fs.clone()));
             cx.subscribe(&worktree_store, Self::on_worktree_store_event)
                 .detach();
 
@@ -722,7 +722,7 @@ impl Project {
                 SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
 
             let worktree_store =
-                cx.new_model(|_| WorktreeStore::new(Some(ssh.clone().into()), false, fs.clone()));
+                cx.new_model(|_| WorktreeStore::remote(false, ssh.clone().into(), 0, None));
             cx.subscribe(&worktree_store, Self::on_worktree_store_event)
                 .detach();
 
@@ -744,7 +744,6 @@ impl Project {
                     worktree_store.clone(),
                     languages.clone(),
                     ssh.clone().into(),
-                    0,
                     cx,
                 )
             });
@@ -874,11 +873,15 @@ impl Project {
         let role = response.payload.role();
 
         let worktree_store = cx.new_model(|_| {
-            let mut store = WorktreeStore::new(Some(client.clone().into()), true, fs.clone());
-            if let Some(dev_server_project_id) = response.payload.dev_server_project_id {
-                store.set_dev_server_project_id(DevServerProjectId(dev_server_project_id));
-            }
-            store
+            WorktreeStore::remote(
+                true,
+                client.clone().into(),
+                response.payload.project_id,
+                response
+                    .payload
+                    .dev_server_project_id
+                    .map(DevServerProjectId),
+            )
         })?;
         let buffer_store =
             cx.new_model(|cx| BufferStore::new(worktree_store.clone(), Some(remote_id), cx))?;
diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 5c3b2a00a98665..9f25572fc7ec08 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -36,19 +36,27 @@ struct MatchingEntry {
     respond: oneshot::Sender<ProjectPath>,
 }
 
+enum WorktreeStoreState {
+    Local {
+        fs: Arc<dyn Fs>,
+    },
+    Remote {
+        dev_server_project_id: Option<DevServerProjectId>,
+        upstream_client: AnyProtoClient,
+        upstream_project_id: u64,
+    },
+}
+
 pub struct WorktreeStore {
     next_entry_id: Arc<AtomicUsize>,
-    upstream_client: Option<AnyProtoClient>,
-    downstream_client: Option<AnyProtoClient>,
-    remote_id: u64,
-    dev_server_project_id: Option<DevServerProjectId>,
+    downstream_client: Option<(AnyProtoClient, u64)>,
     retain_worktrees: bool,
     worktrees: Vec<WorktreeHandle>,
     worktrees_reordered: bool,
     #[allow(clippy::type_complexity)]
     loading_worktrees:
         HashMap<Arc<Path>, Shared<Task<Result<Model<Worktree>, Arc<anyhow::Error>>>>>,
-    fs: Arc<dyn Fs>,
+    state: WorktreeStoreState,
 }
 
 pub enum WorktreeStoreEvent {
@@ -69,27 +77,37 @@ impl WorktreeStore {
         client.add_model_request_handler(Self::handle_expand_project_entry);
     }
 
-    pub fn new(
-        upstream_client: Option<AnyProtoClient>,
-        retain_worktrees: bool,
-        fs: Arc<dyn Fs>,
-    ) -> Self {
+    pub fn local(retain_worktrees: bool, fs: Arc<dyn Fs>) -> Self {
         Self {
             next_entry_id: Default::default(),
             loading_worktrees: Default::default(),
-            dev_server_project_id: None,
             downstream_client: None,
             worktrees: Vec::new(),
             worktrees_reordered: false,
             retain_worktrees,
-            remote_id: 0,
-            upstream_client,
-            fs,
+            state: WorktreeStoreState::Local { fs },
         }
     }
 
-    pub fn set_dev_server_project_id(&mut self, id: DevServerProjectId) {
-        self.dev_server_project_id = Some(id);
+    pub fn remote(
+        retain_worktrees: bool,
+        upstream_client: AnyProtoClient,
+        upstream_project_id: u64,
+        dev_server_project_id: Option<DevServerProjectId>,
+    ) -> Self {
+        Self {
+            next_entry_id: Default::default(),
+            loading_worktrees: Default::default(),
+            downstream_client: None,
+            worktrees: Vec::new(),
+            worktrees_reordered: false,
+            retain_worktrees,
+            state: WorktreeStoreState::Remote {
+                upstream_client,
+                upstream_project_id,
+                dev_server_project_id,
+            },
+        }
     }
 
     /// Iterates through all worktrees, including ones that don't appear in the project panel
@@ -159,14 +177,28 @@ impl WorktreeStore {
     ) -> Task<Result<Model<Worktree>>> {
         let path: Arc<Path> = abs_path.as_ref().into();
         if !self.loading_worktrees.contains_key(&path) {
-            let task = if let Some(client) = self.upstream_client.clone() {
-                if let Some(dev_server_project_id) = self.dev_server_project_id {
-                    self.create_dev_server_worktree(client, dev_server_project_id, abs_path, cx)
-                } else {
-                    self.create_ssh_worktree(client, abs_path, visible, cx)
+            let task = match &self.state {
+                WorktreeStoreState::Remote {
+                    upstream_client,
+                    dev_server_project_id,
+                    ..
+                } => {
+                    if let Some(dev_server_project_id) = dev_server_project_id {
+                        self.create_dev_server_worktree(
+                            upstream_client.clone(),
+                            *dev_server_project_id,
+                            abs_path,
+                            cx,
+                        )
+                    } else if upstream_client.is_via_collab() {
+                        Task::ready(Err(Arc::new(anyhow!("cannot create worktrees via collab"))))
+                    } else {
+                        self.create_ssh_worktree(upstream_client.clone(), abs_path, visible, cx)
+                    }
+                }
+                WorktreeStoreState::Local { fs } => {
+                    self.create_local_worktree(fs.clone(), abs_path, visible, cx)
                 }
-            } else {
-                self.create_local_worktree(abs_path, visible, cx)
             };
 
             self.loading_worktrees.insert(path.clone(), task.shared());
@@ -236,11 +268,11 @@ impl WorktreeStore {
 
     fn create_local_worktree(
         &mut self,
+        fs: Arc<dyn Fs>,
         abs_path: impl AsRef<Path>,
         visible: bool,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Model<Worktree>, Arc<anyhow::Error>>> {
-        let fs = self.fs.clone();
         let next_entry_id = self.next_entry_id.clone();
         let path: Arc<Path> = abs_path.as_ref().into();
 
@@ -374,6 +406,17 @@ impl WorktreeStore {
         self.worktrees_reordered = worktrees_reordered;
     }
 
+    fn upstream_client(&self) -> Option<(AnyProtoClient, u64)> {
+        match &self.state {
+            WorktreeStoreState::Remote {
+                upstream_client,
+                upstream_project_id,
+                ..
+            } => Some((upstream_client.clone(), *upstream_project_id)),
+            WorktreeStoreState::Local { .. } => None,
+        }
+    }
+
     pub fn set_worktrees_from_proto(
         &mut self,
         worktrees: Vec<proto::WorktreeMetadata>,
@@ -389,8 +432,8 @@ impl WorktreeStore {
             })
             .collect::<HashMap<_, _>>();
 
-        let client = self
-            .upstream_client
+        let (client, project_id) = self
+            .upstream_client()
             .clone()
             .ok_or_else(|| anyhow!("invalid project"))?;
 
@@ -408,7 +451,7 @@ impl WorktreeStore {
                 self.worktrees.push(handle);
             } else {
                 self.add(
-                    &Worktree::remote(self.remote_id, replica_id, worktree, client.clone(), cx),
+                    &Worktree::remote(project_id, replica_id, worktree, client.clone(), cx),
                     cx,
                 );
             }
@@ -477,10 +520,9 @@ impl WorktreeStore {
     }
 
     pub fn send_project_updates(&mut self, cx: &mut ModelContext<Self>) {
-        let Some(downstream_client) = self.downstream_client.clone() else {
+        let Some((downstream_client, project_id)) = self.downstream_client.clone() else {
             return;
         };
-        let project_id = self.remote_id;
 
         let update = proto::UpdateProject {
             project_id,
@@ -549,8 +591,7 @@ impl WorktreeStore {
         cx: &mut ModelContext<Self>,
     ) {
         self.retain_worktrees = true;
-        self.remote_id = remote_id;
-        self.downstream_client = Some(downsteam_client);
+        self.downstream_client = Some((downsteam_client, remote_id));
 
         // When shared, retain all worktrees
         for worktree_handle in self.worktrees.iter_mut() {
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 9d5c26d6c7ce1a..0d644a64a6aa7a 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -45,7 +45,7 @@ impl HeadlessProject {
         let languages = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
 
         let worktree_store = cx.new_model(|cx| {
-            let mut store = WorktreeStore::new(None, true, fs.clone());
+            let mut store = WorktreeStore::local(true, fs.clone());
             store.shared(SSH_PROJECT_ID, session.clone().into(), cx);
             store
         });

From bc751d6c1994634cea98bb855ec2981d3a976d8c Mon Sep 17 00:00:00 2001
From: Boris Verkhovskiy <boris.verk@gmail.com>
Date: Mon, 23 Sep 2024 10:03:55 -0600
Subject: [PATCH 272/762] Don't highlight Python import names as type (#17984)

Works on #14892

Follow up to #17473
---
 crates/languages/src/python/highlights.scm | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/crates/languages/src/python/highlights.scm b/crates/languages/src/python/highlights.scm
index df6b60466cd2a6..3255677bedc428 100644
--- a/crates/languages/src/python/highlights.scm
+++ b/crates/languages/src/python/highlights.scm
@@ -2,24 +2,6 @@
 (attribute attribute: (identifier) @property)
 (type (identifier) @type)
 
-; Module imports
-
-(import_statement
-  (dotted_name (identifier) @type))
-
-(import_statement
-  (aliased_import
-    name: (dotted_name (identifier) @type)
-    alias: (identifier) @type))
-
-(import_from_statement
-  (dotted_name (identifier) @type))
-
-(import_from_statement
-  (aliased_import
-    name: (dotted_name (identifier) @type)
-    alias: (identifier) @type))
-
 ; Function calls
 
 (decorator) @function

From 3c95a64a23c96303b864335ec55c3ec93ca0e414 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Mon, 23 Sep 2024 12:11:26 -0400
Subject: [PATCH 273/762] Add a rather-conservative stale issue action in
 dry-run mode (#18233)

Zed is becoming more popular and our issue tracker is only growing
larger and larger. I realize that a stale issue action can be
controversial, but the way we currently manage issues hasn't scaled well
and it will only get worse. We need some crowd-sourced system. Let's ask
those who have opened issues if their issues are still valid. This is
rather conservative and only targets bugs and crashes. I'll run it in
debug mode, report the results, and enable it if it feels right. We can
always turn this off if users end up really not liking it.

My original rules were:

```txt
If an issue is old enough (12 months or older)
AND if there are no recent comments from the team (last dev comment is older than 6 months)
AND it has less than X upvotes (5)
AND it does not have an open PR linked to it
AND is a "defect" or "panic / crash"
AND does not have a "ignore top-ranking issues" label
AND was not opened by a org member
AND is open
AND is issue (not a pull request)

THEN close the issue with a kind message.
```

But only some of these were actually supported in the configuration.

Release Notes:

- N/A
---
 .github/workflows/close_stale_issues.yml | 28 ++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 .github/workflows/close_stale_issues.yml

diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/close_stale_issues.yml
new file mode 100644
index 00000000000000..240403169c471e
--- /dev/null
+++ b/.github/workflows/close_stale_issues.yml
@@ -0,0 +1,28 @@
+name: "Close Stale Issues"
+on:
+  schedule:
+    - cron: "0 1 * * *"
+  workflow_dispatch:
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v9
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          stale-issue-message: >
+            Hi there! 👋
+
+            We're working to clean up our issue tracker by closing older issues that might not be relevant anymore. Are you able to reproduce this issue in the latest version of Zed? If so, please let us know by commenting on this issue and we will keep it open; otherwise, we'll close it in a week. Feel free to open a new issue if you're seeing this message after the issue has been closed.
+
+            Thanks for your help!
+          close-issue-message: "This issue was closed due to inactivity; feel free to open a new issue if you're still experiencing this problem!"
+          days-before-stale: 365
+          days-before-close: 7
+          only-issue-labels: "defect,panic / crash"
+          operations-per-run: 100
+          ascending: true
+          enable-statistics: true
+          debug-only: true
+          stale-issue-label: "stale"

From 20826336d9c2815da327ead99006b28dc8800082 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Mon, 23 Sep 2024 12:15:33 -0400
Subject: [PATCH 274/762] update stale issue configuration to use
 `any-of-issue-labels` (#18236)

Release Notes:

- N/A
---
 .github/workflows/close_stale_issues.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/close_stale_issues.yml
index 240403169c471e..1cac6450e86052 100644
--- a/.github/workflows/close_stale_issues.yml
+++ b/.github/workflows/close_stale_issues.yml
@@ -20,7 +20,7 @@ jobs:
           close-issue-message: "This issue was closed due to inactivity; feel free to open a new issue if you're still experiencing this problem!"
           days-before-stale: 365
           days-before-close: 7
-          only-issue-labels: "defect,panic / crash"
+          any-of-issue-labels: "defect,panic / crash"
           operations-per-run: 100
           ascending: true
           enable-statistics: true

From 65bb989c61e90271e544566b7999feaa9e8ff105 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 23 Sep 2024 12:16:51 -0400
Subject: [PATCH 275/762] gpui: Update doc comment for
 `SharedString::new_static` (#18234)

This PR updates the doc comment for `SharedString::new_static`.

Release Notes:

- N/A
---
 crates/gpui/src/shared_string.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/gpui/src/shared_string.rs b/crates/gpui/src/shared_string.rs
index f5aef6adf80be6..e1fd4f1a5caa9c 100644
--- a/crates/gpui/src/shared_string.rs
+++ b/crates/gpui/src/shared_string.rs
@@ -10,9 +10,9 @@ use util::arc_cow::ArcCow;
 pub struct SharedString(ArcCow<'static, str>);
 
 impl SharedString {
-    /// creates a static SharedString
-    pub const fn new_static(s: &'static str) -> Self {
-        Self(ArcCow::Borrowed(s))
+    /// Creates a static [`SharedString`] from a `&'static str`.
+    pub const fn new_static(str: &'static str) -> Self {
+        Self(ArcCow::Borrowed(str))
     }
 }
 

From 11953bbc16c12c61363f6e15d023c6ff9488114a Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Mon, 23 Sep 2024 12:24:49 -0400
Subject: [PATCH 276/762] Disable debug mode for stale issue action (#18237)

Release Notes:

- N/A
---
 .github/workflows/close_stale_issues.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/close_stale_issues.yml
index 1cac6450e86052..be4f6f4af04bae 100644
--- a/.github/workflows/close_stale_issues.yml
+++ b/.github/workflows/close_stale_issues.yml
@@ -24,5 +24,4 @@ jobs:
           operations-per-run: 100
           ascending: true
           enable-statistics: true
-          debug-only: true
           stale-issue-label: "stale"

From 1efe87029bffc2b23784247db3a851dc11ba9ae8 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Mon, 23 Sep 2024 12:32:31 -0400
Subject: [PATCH 277/762] Update stale issues configuration to use 180 days
 (#18238)

Release Notes:

- N/A
---
 .github/workflows/close_stale_issues.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/close_stale_issues.yml
index be4f6f4af04bae..afc28ec180b15e 100644
--- a/.github/workflows/close_stale_issues.yml
+++ b/.github/workflows/close_stale_issues.yml
@@ -18,7 +18,7 @@ jobs:
 
             Thanks for your help!
           close-issue-message: "This issue was closed due to inactivity; feel free to open a new issue if you're still experiencing this problem!"
-          days-before-stale: 365
+          days-before-stale: 180
           days-before-close: 7
           any-of-issue-labels: "defect,panic / crash"
           operations-per-run: 100

From 7051bc00c2fe8d7407480a805e950cb73343bb45 Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Mon, 23 Sep 2024 11:40:34 -0600
Subject: [PATCH 278/762] Add "Fix with Assistant" code action on lines with
 diagnostics (#18163)

Release Notes:

- Added a new "Fix with Assistant" action on code with errors or
warnings.

---------

Co-authored-by: Nathan <nathan@zed.dev>
---
 Cargo.lock                                    |   1 +
 crates/assistant/Cargo.toml                   |   1 +
 crates/assistant/src/inline_assistant.rs      | 195 ++++++++++++++++--
 crates/assistant/src/workflow.rs              |   1 +
 .../remote_editing_collaboration_tests.rs     |   1 +
 crates/editor/src/editor.rs                   | 169 +++++++++++----
 crates/gpui/src/executor.rs                   |   6 +-
 crates/multi_buffer/src/multi_buffer.rs       |  67 ++++++
 crates/project/src/lsp_store.rs               |  34 +--
 crates/project/src/project.rs                 |   2 +-
 crates/project/src/project_tests.rs           |   3 +-
 crates/search/src/project_search.rs           |   2 +-
 crates/workspace/src/workspace.rs             |   8 +-
 13 files changed, 418 insertions(+), 72 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c0f6751b895e28..e345736295613b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -404,6 +404,7 @@ dependencies = [
  "language_model",
  "languages",
  "log",
+ "lsp",
  "markdown",
  "menu",
  "multi_buffer",
diff --git a/crates/assistant/Cargo.toml b/crates/assistant/Cargo.toml
index 9f715d822474d2..9e61eee18aaf8a 100644
--- a/crates/assistant/Cargo.toml
+++ b/crates/assistant/Cargo.toml
@@ -51,6 +51,7 @@ indoc.workspace = true
 language.workspace = true
 language_model.workspace = true
 log.workspace = true
+lsp.workspace = true
 markdown.workspace = true
 menu.workspace = true
 multi_buffer.workspace = true
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index f2428c3a2e94cf..9c117e66653e93 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -12,8 +12,9 @@ use editor::{
         BlockContext, BlockDisposition, BlockProperties, BlockStyle, CustomBlockId, RenderBlock,
         ToDisplayPoint,
     },
-    Anchor, AnchorRangeExt, Editor, EditorElement, EditorEvent, EditorMode, EditorStyle,
-    ExcerptRange, GutterDimensions, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint,
+    Anchor, AnchorRangeExt, CodeActionProvider, Editor, EditorElement, EditorEvent, EditorMode,
+    EditorStyle, ExcerptId, ExcerptRange, GutterDimensions, MultiBuffer, MultiBufferSnapshot,
+    ToOffset as _, ToPoint,
 };
 use feature_flags::{FeatureFlagAppExt as _, ZedPro};
 use fs::Fs;
@@ -35,6 +36,7 @@ use language_model::{
 };
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
+use project::{CodeAction, ProjectTransaction};
 use rope::Rope;
 use settings::{Settings, SettingsStore};
 use smol::future::FutureExt;
@@ -49,10 +51,11 @@ use std::{
     time::{Duration, Instant},
 };
 use terminal_view::terminal_panel::TerminalPanel;
+use text::{OffsetRangeExt, ToPoint as _};
 use theme::ThemeSettings;
 use ui::{prelude::*, CheckboxWithLabel, IconButtonShape, Popover, Tooltip};
 use util::{RangeExt, ResultExt};
-use workspace::{notifications::NotificationId, Toast, Workspace};
+use workspace::{notifications::NotificationId, ItemHandle, Toast, Workspace};
 
 pub fn init(
     fs: Arc<dyn Fs>,
@@ -129,8 +132,10 @@ impl InlineAssistant {
     }
 
     pub fn register_workspace(&mut self, workspace: &View<Workspace>, cx: &mut WindowContext) {
-        cx.subscribe(workspace, |_, event, cx| {
-            Self::update_global(cx, |this, cx| this.handle_workspace_event(event, cx));
+        cx.subscribe(workspace, |workspace, event, cx| {
+            Self::update_global(cx, |this, cx| {
+                this.handle_workspace_event(workspace, event, cx)
+            });
         })
         .detach();
 
@@ -150,19 +155,49 @@ impl InlineAssistant {
         .detach();
     }
 
-    fn handle_workspace_event(&mut self, event: &workspace::Event, cx: &mut WindowContext) {
-        // When the user manually saves an editor, automatically accepts all finished transformations.
-        if let workspace::Event::UserSavedItem { item, .. } = event {
-            if let Some(editor) = item.upgrade().and_then(|item| item.act_as::<Editor>(cx)) {
-                if let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade()) {
-                    for assist_id in editor_assists.assist_ids.clone() {
-                        let assist = &self.assists[&assist_id];
-                        if let CodegenStatus::Done = assist.codegen.read(cx).status(cx) {
-                            self.finish_assist(assist_id, false, cx)
+    fn handle_workspace_event(
+        &mut self,
+        workspace: View<Workspace>,
+        event: &workspace::Event,
+        cx: &mut WindowContext,
+    ) {
+        match event {
+            workspace::Event::UserSavedItem { item, .. } => {
+                // When the user manually saves an editor, automatically accepts all finished transformations.
+                if let Some(editor) = item.upgrade().and_then(|item| item.act_as::<Editor>(cx)) {
+                    if let Some(editor_assists) = self.assists_by_editor.get(&editor.downgrade()) {
+                        for assist_id in editor_assists.assist_ids.clone() {
+                            let assist = &self.assists[&assist_id];
+                            if let CodegenStatus::Done = assist.codegen.read(cx).status(cx) {
+                                self.finish_assist(assist_id, false, cx)
+                            }
                         }
                     }
                 }
             }
+            workspace::Event::ItemAdded { item } => {
+                self.register_workspace_item(&workspace, item.as_ref(), cx);
+            }
+            _ => (),
+        }
+    }
+
+    fn register_workspace_item(
+        &mut self,
+        workspace: &View<Workspace>,
+        item: &dyn ItemHandle,
+        cx: &mut WindowContext,
+    ) {
+        if let Some(editor) = item.act_as::<Editor>(cx) {
+            editor.update(cx, |editor, cx| {
+                editor.push_code_action_provider(
+                    Arc::new(AssistantCodeActionProvider {
+                        editor: cx.view().downgrade(),
+                        workspace: workspace.downgrade(),
+                    }),
+                    cx,
+                );
+            });
         }
     }
 
@@ -332,6 +367,7 @@ impl InlineAssistant {
         mut range: Range<Anchor>,
         initial_prompt: String,
         initial_transaction_id: Option<TransactionId>,
+        focus: bool,
         workspace: Option<WeakView<Workspace>>,
         assistant_panel: Option<&View<AssistantPanel>>,
         cx: &mut WindowContext,
@@ -404,6 +440,11 @@ impl InlineAssistant {
         assist_group.assist_ids.push(assist_id);
         editor_assists.assist_ids.push(assist_id);
         self.assist_groups.insert(assist_group_id, assist_group);
+
+        if focus {
+            self.focus_assist(assist_id, cx);
+        }
+
         assist_id
     }
 
@@ -3289,6 +3330,132 @@ where
     }
 }
 
+struct AssistantCodeActionProvider {
+    editor: WeakView<Editor>,
+    workspace: WeakView<Workspace>,
+}
+
+impl CodeActionProvider for AssistantCodeActionProvider {
+    fn code_actions(
+        &self,
+        buffer: &Model<Buffer>,
+        range: Range<text::Anchor>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<Vec<CodeAction>>> {
+        let snapshot = buffer.read(cx).snapshot();
+        let mut range = range.to_point(&snapshot);
+
+        // Expand the range to line boundaries.
+        range.start.column = 0;
+        range.end.column = snapshot.line_len(range.end.row);
+
+        let mut has_diagnostics = false;
+        for diagnostic in snapshot.diagnostics_in_range::<_, Point>(range.clone(), false) {
+            range.start = cmp::min(range.start, diagnostic.range.start);
+            range.end = cmp::max(range.end, diagnostic.range.end);
+            has_diagnostics = true;
+        }
+        if has_diagnostics {
+            if let Some(symbols_containing_start) = snapshot.symbols_containing(range.start, None) {
+                if let Some(symbol) = symbols_containing_start.last() {
+                    range.start = cmp::min(range.start, symbol.range.start.to_point(&snapshot));
+                    range.end = cmp::max(range.end, symbol.range.end.to_point(&snapshot));
+                }
+            }
+
+            if let Some(symbols_containing_end) = snapshot.symbols_containing(range.end, None) {
+                if let Some(symbol) = symbols_containing_end.last() {
+                    range.start = cmp::min(range.start, symbol.range.start.to_point(&snapshot));
+                    range.end = cmp::max(range.end, symbol.range.end.to_point(&snapshot));
+                }
+            }
+
+            Task::ready(Ok(vec![CodeAction {
+                server_id: language::LanguageServerId(0),
+                range: snapshot.anchor_before(range.start)..snapshot.anchor_after(range.end),
+                lsp_action: lsp::CodeAction {
+                    title: "Fix with Assistant".into(),
+                    ..Default::default()
+                },
+            }]))
+        } else {
+            Task::ready(Ok(Vec::new()))
+        }
+    }
+
+    fn apply_code_action(
+        &self,
+        buffer: Model<Buffer>,
+        action: CodeAction,
+        excerpt_id: ExcerptId,
+        _push_to_history: bool,
+        cx: &mut WindowContext,
+    ) -> Task<Result<ProjectTransaction>> {
+        let editor = self.editor.clone();
+        let workspace = self.workspace.clone();
+        cx.spawn(|mut cx| async move {
+            let editor = editor.upgrade().context("editor was released")?;
+            let range = editor
+                .update(&mut cx, |editor, cx| {
+                    editor.buffer().update(cx, |multibuffer, cx| {
+                        let buffer = buffer.read(cx);
+                        let multibuffer_snapshot = multibuffer.read(cx);
+
+                        let old_context_range =
+                            multibuffer_snapshot.context_range_for_excerpt(excerpt_id)?;
+                        let mut new_context_range = old_context_range.clone();
+                        if action
+                            .range
+                            .start
+                            .cmp(&old_context_range.start, buffer)
+                            .is_lt()
+                        {
+                            new_context_range.start = action.range.start;
+                        }
+                        if action.range.end.cmp(&old_context_range.end, buffer).is_gt() {
+                            new_context_range.end = action.range.end;
+                        }
+                        drop(multibuffer_snapshot);
+
+                        if new_context_range != old_context_range {
+                            multibuffer.resize_excerpt(excerpt_id, new_context_range, cx);
+                        }
+
+                        let multibuffer_snapshot = multibuffer.read(cx);
+                        Some(
+                            multibuffer_snapshot
+                                .anchor_in_excerpt(excerpt_id, action.range.start)?
+                                ..multibuffer_snapshot
+                                    .anchor_in_excerpt(excerpt_id, action.range.end)?,
+                        )
+                    })
+                })?
+                .context("invalid range")?;
+            let assistant_panel = workspace.update(&mut cx, |workspace, cx| {
+                workspace
+                    .panel::<AssistantPanel>(cx)
+                    .context("assistant panel was released")
+            })??;
+
+            cx.update_global(|assistant: &mut InlineAssistant, cx| {
+                let assist_id = assistant.suggest_assist(
+                    &editor,
+                    range,
+                    "Fix Diagnostics".into(),
+                    None,
+                    true,
+                    Some(workspace),
+                    Some(&assistant_panel),
+                    cx,
+                );
+                assistant.start_assist(assist_id, cx);
+            })?;
+
+            Ok(ProjectTransaction::default())
+        })
+    }
+}
+
 fn prefixes(text: &str) -> impl Iterator<Item = &str> {
     (0..text.len() - 1).map(|ix| &text[..ix + 1])
 }
diff --git a/crates/assistant/src/workflow.rs b/crates/assistant/src/workflow.rs
index 75c65ed0a78e42..8a770e21aa7caa 100644
--- a/crates/assistant/src/workflow.rs
+++ b/crates/assistant/src/workflow.rs
@@ -187,6 +187,7 @@ impl WorkflowSuggestion {
                 suggestion_range,
                 initial_prompt,
                 initial_transaction_id,
+                false,
                 Some(workspace.clone()),
                 Some(assistant_panel),
                 cx,
diff --git a/crates/collab/src/tests/remote_editing_collaboration_tests.rs b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
index cdcf69cf7e9ace..a81166bb00ceec 100644
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -53,6 +53,7 @@ async fn test_sharing_an_ssh_remote_project(
     let (project_a, worktree_id) = client_a
         .build_ssh_project("/code/project1", client_ssh, cx_a)
         .await;
+    executor.run_until_parked();
 
     // User A shares the remote project.
     let active_call_a = cx_a.read(ActiveCall::global);
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index b1a3d95a0da780..cbc272d995213c 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -68,7 +68,7 @@ use element::LineWithInvisibles;
 pub use element::{
     CursorLayout, EditorElement, HighlightedRange, HighlightedRangeLine, PointForPosition,
 };
-use futures::FutureExt;
+use futures::{future, FutureExt};
 use fuzzy::{StringMatch, StringMatchCandidate};
 use git::blame::GitBlame;
 use git::diff_hunk_to_display;
@@ -569,8 +569,8 @@ pub struct Editor {
     find_all_references_task_sources: Vec<Anchor>,
     next_completion_id: CompletionId,
     completion_documentation_pre_resolve_debounce: DebouncedDelay,
-    available_code_actions: Option<(Location, Arc<[CodeAction]>)>,
-    code_actions_task: Option<Task<()>>,
+    available_code_actions: Option<(Location, Arc<[AvailableCodeAction]>)>,
+    code_actions_task: Option<Task<Result<()>>>,
     document_highlights_task: Option<Task<()>>,
     linked_editing_range_task: Option<Task<Option<()>>>,
     linked_edit_ranges: linked_editing_ranges::LinkedEditingRanges,
@@ -590,6 +590,7 @@ pub struct Editor {
     gutter_hovered: bool,
     hovered_link_state: Option<HoveredLinkState>,
     inline_completion_provider: Option<RegisteredInlineCompletionProvider>,
+    code_action_providers: Vec<Arc<dyn CodeActionProvider>>,
     active_inline_completion: Option<CompletionState>,
     // enable_inline_completions is a switch that Vim can use to disable
     // inline completions based on its mode.
@@ -1360,10 +1361,16 @@ impl CompletionsMenu {
     }
 }
 
+struct AvailableCodeAction {
+    excerpt_id: ExcerptId,
+    action: CodeAction,
+    provider: Arc<dyn CodeActionProvider>,
+}
+
 #[derive(Clone)]
 struct CodeActionContents {
     tasks: Option<Arc<ResolvedTasks>>,
-    actions: Option<Arc<[CodeAction]>>,
+    actions: Option<Arc<[AvailableCodeAction]>>,
 }
 
 impl CodeActionContents {
@@ -1395,9 +1402,11 @@ impl CodeActionContents {
                     .map(|(kind, task)| CodeActionsItem::Task(kind.clone(), task.clone()))
             })
             .chain(self.actions.iter().flat_map(|actions| {
-                actions
-                    .iter()
-                    .map(|action| CodeActionsItem::CodeAction(action.clone()))
+                actions.iter().map(|available| CodeActionsItem::CodeAction {
+                    excerpt_id: available.excerpt_id,
+                    action: available.action.clone(),
+                    provider: available.provider.clone(),
+                })
             }))
     }
     fn get(&self, index: usize) -> Option<CodeActionsItem> {
@@ -1410,10 +1419,13 @@ impl CodeActionContents {
                         .cloned()
                         .map(|(kind, task)| CodeActionsItem::Task(kind, task))
                 } else {
-                    actions
-                        .get(index - tasks.templates.len())
-                        .cloned()
-                        .map(CodeActionsItem::CodeAction)
+                    actions.get(index - tasks.templates.len()).map(|available| {
+                        CodeActionsItem::CodeAction {
+                            excerpt_id: available.excerpt_id,
+                            action: available.action.clone(),
+                            provider: available.provider.clone(),
+                        }
+                    })
                 }
             }
             (Some(tasks), None) => tasks
@@ -1421,7 +1433,15 @@ impl CodeActionContents {
                 .get(index)
                 .cloned()
                 .map(|(kind, task)| CodeActionsItem::Task(kind, task)),
-            (None, Some(actions)) => actions.get(index).cloned().map(CodeActionsItem::CodeAction),
+            (None, Some(actions)) => {
+                actions
+                    .get(index)
+                    .map(|available| CodeActionsItem::CodeAction {
+                        excerpt_id: available.excerpt_id,
+                        action: available.action.clone(),
+                        provider: available.provider.clone(),
+                    })
+            }
             (None, None) => None,
         }
     }
@@ -1431,7 +1451,11 @@ impl CodeActionContents {
 #[derive(Clone)]
 enum CodeActionsItem {
     Task(TaskSourceKind, ResolvedTask),
-    CodeAction(CodeAction),
+    CodeAction {
+        excerpt_id: ExcerptId,
+        action: CodeAction,
+        provider: Arc<dyn CodeActionProvider>,
+    },
 }
 
 impl CodeActionsItem {
@@ -1442,14 +1466,14 @@ impl CodeActionsItem {
         Some(task)
     }
     fn as_code_action(&self) -> Option<&CodeAction> {
-        let Self::CodeAction(action) = self else {
+        let Self::CodeAction { action, .. } = self else {
             return None;
         };
         Some(action)
     }
     fn label(&self) -> String {
         match self {
-            Self::CodeAction(action) => action.lsp_action.title.clone(),
+            Self::CodeAction { action, .. } => action.lsp_action.title.clone(),
             Self::Task(_, task) => task.resolved_label.clone(),
         }
     }
@@ -1588,7 +1612,9 @@ impl CodeActionsMenu {
                 .enumerate()
                 .max_by_key(|(_, action)| match action {
                     CodeActionsItem::Task(_, task) => task.resolved_label.chars().count(),
-                    CodeActionsItem::CodeAction(action) => action.lsp_action.title.chars().count(),
+                    CodeActionsItem::CodeAction { action, .. } => {
+                        action.lsp_action.title.chars().count()
+                    }
                 })
                 .map(|(ix, _)| ix),
         )
@@ -1864,6 +1890,11 @@ impl Editor {
             None
         };
 
+        let mut code_action_providers = Vec::new();
+        if let Some(project) = project.clone() {
+            code_action_providers.push(Arc::new(project) as Arc<_>);
+        }
+
         let mut this = Self {
             focus_handle,
             show_cursor_when_unfocused: false,
@@ -1915,6 +1946,7 @@ impl Editor {
             next_completion_id: 0,
             completion_documentation_pre_resolve_debounce: DebouncedDelay::new(),
             next_inlay_id: 0,
+            code_action_providers,
             available_code_actions: Default::default(),
             code_actions_task: Default::default(),
             document_highlights_task: Default::default(),
@@ -4553,7 +4585,7 @@ impl Editor {
         let action = action.clone();
         cx.spawn(|editor, mut cx| async move {
             while let Some(prev_task) = task {
-                prev_task.await;
+                prev_task.await.log_err();
                 task = editor.update(&mut cx, |this, _| this.code_actions_task.take())?;
             }
 
@@ -4727,17 +4759,16 @@ impl Editor {
                     Some(Task::ready(Ok(())))
                 })
             }
-            CodeActionsItem::CodeAction(action) => {
-                let apply_code_actions = workspace
-                    .read(cx)
-                    .project()
-                    .clone()
-                    .update(cx, |project, cx| {
-                        project.apply_code_action(buffer, action, true, cx)
-                    });
+            CodeActionsItem::CodeAction {
+                excerpt_id,
+                action,
+                provider,
+            } => {
+                let apply_code_action =
+                    provider.apply_code_action(buffer, action, excerpt_id, true, cx);
                 let workspace = workspace.downgrade();
                 Some(cx.spawn(|editor, cx| async move {
-                    let project_transaction = apply_code_actions.await?;
+                    let project_transaction = apply_code_action.await?;
                     Self::open_project_transaction(
                         &editor,
                         workspace,
@@ -4835,8 +4866,16 @@ impl Editor {
         Ok(())
     }
 
+    pub fn push_code_action_provider(
+        &mut self,
+        provider: Arc<dyn CodeActionProvider>,
+        cx: &mut ViewContext<Self>,
+    ) {
+        self.code_action_providers.push(provider);
+        self.refresh_code_actions(cx);
+    }
+
     fn refresh_code_actions(&mut self, cx: &mut ViewContext<Self>) -> Option<()> {
-        let project = self.project.clone()?;
         let buffer = self.buffer.read(cx);
         let newest_selection = self.selections.newest_anchor().clone();
         let (start_buffer, start) = buffer.text_anchor_for_position(newest_selection.start, cx)?;
@@ -4850,13 +4889,30 @@ impl Editor {
                 .timer(CODE_ACTIONS_DEBOUNCE_TIMEOUT)
                 .await;
 
-            let actions = if let Ok(code_actions) = project.update(&mut cx, |project, cx| {
-                project.code_actions(&start_buffer, start..end, cx)
-            }) {
-                code_actions.await
-            } else {
-                Vec::new()
-            };
+            let (providers, tasks) = this.update(&mut cx, |this, cx| {
+                let providers = this.code_action_providers.clone();
+                let tasks = this
+                    .code_action_providers
+                    .iter()
+                    .map(|provider| provider.code_actions(&start_buffer, start..end, cx))
+                    .collect::<Vec<_>>();
+                (providers, tasks)
+            })?;
+
+            let mut actions = Vec::new();
+            for (provider, provider_actions) in
+                providers.into_iter().zip(future::join_all(tasks).await)
+            {
+                if let Some(provider_actions) = provider_actions.log_err() {
+                    actions.extend(provider_actions.into_iter().map(|action| {
+                        AvailableCodeAction {
+                            excerpt_id: newest_selection.start.excerpt_id,
+                            action,
+                            provider: provider.clone(),
+                        }
+                    }));
+                }
+            }
 
             this.update(&mut cx, |this, cx| {
                 this.available_code_actions = if actions.is_empty() {
@@ -4872,7 +4928,6 @@ impl Editor {
                 };
                 cx.notify();
             })
-            .log_err();
         }));
         None
     }
@@ -9685,7 +9740,7 @@ impl Editor {
                     })
                     .context("location tasks preparation")?;
 
-                let locations = futures::future::join_all(location_tasks)
+                let locations = future::join_all(location_tasks)
                     .await
                     .into_iter()
                     .filter_map(|location| location.transpose())
@@ -12574,6 +12629,48 @@ pub trait CompletionProvider {
     }
 }
 
+pub trait CodeActionProvider {
+    fn code_actions(
+        &self,
+        buffer: &Model<Buffer>,
+        range: Range<text::Anchor>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<Vec<CodeAction>>>;
+
+    fn apply_code_action(
+        &self,
+        buffer_handle: Model<Buffer>,
+        action: CodeAction,
+        excerpt_id: ExcerptId,
+        push_to_history: bool,
+        cx: &mut WindowContext,
+    ) -> Task<Result<ProjectTransaction>>;
+}
+
+impl CodeActionProvider for Model<Project> {
+    fn code_actions(
+        &self,
+        buffer: &Model<Buffer>,
+        range: Range<text::Anchor>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<Vec<CodeAction>>> {
+        self.update(cx, |project, cx| project.code_actions(buffer, range, cx))
+    }
+
+    fn apply_code_action(
+        &self,
+        buffer_handle: Model<Buffer>,
+        action: CodeAction,
+        _excerpt_id: ExcerptId,
+        push_to_history: bool,
+        cx: &mut WindowContext,
+    ) -> Task<Result<ProjectTransaction>> {
+        self.update(cx, |project, cx| {
+            project.apply_code_action(buffer_handle, action, push_to_history, cx)
+        })
+    }
+}
+
 fn snippet_completions(
     project: &Project,
     buffer: &Model<Buffer>,
diff --git a/crates/gpui/src/executor.rs b/crates/gpui/src/executor.rs
index b909e63271c069..3035892d7a17f2 100644
--- a/crates/gpui/src/executor.rs
+++ b/crates/gpui/src/executor.rs
@@ -407,7 +407,11 @@ impl BackgroundExecutor {
 
     /// How many CPUs are available to the dispatcher.
     pub fn num_cpus(&self) -> usize {
-        num_cpus::get()
+        #[cfg(any(test, feature = "test-support"))]
+        return 4;
+
+        #[cfg(not(any(test, feature = "test-support")))]
+        return num_cpus::get();
     }
 
     /// Whether we're on the main thread.
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index d406f9bfaf6ac2..0df196bb9829dc 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -1810,6 +1810,69 @@ impl MultiBuffer {
         self.as_singleton().unwrap().read(cx).is_parsing()
     }
 
+    pub fn resize_excerpt(
+        &mut self,
+        id: ExcerptId,
+        range: Range<text::Anchor>,
+        cx: &mut ModelContext<Self>,
+    ) {
+        self.sync(cx);
+
+        let snapshot = self.snapshot(cx);
+        let locator = snapshot.excerpt_locator_for_id(id);
+        let mut new_excerpts = SumTree::default();
+        let mut cursor = snapshot.excerpts.cursor::<(Option<&Locator>, usize)>(&());
+        let mut edits = Vec::<Edit<usize>>::new();
+
+        let prefix = cursor.slice(&Some(locator), Bias::Left, &());
+        new_excerpts.append(prefix, &());
+
+        let mut excerpt = cursor.item().unwrap().clone();
+        let old_text_len = excerpt.text_summary.len;
+
+        excerpt.range.context.start = range.start;
+        excerpt.range.context.end = range.end;
+        excerpt.max_buffer_row = range.end.to_point(&excerpt.buffer).row;
+
+        excerpt.text_summary = excerpt
+            .buffer
+            .text_summary_for_range(excerpt.range.context.clone());
+
+        let new_start_offset = new_excerpts.summary().text.len;
+        let old_start_offset = cursor.start().1;
+        let edit = Edit {
+            old: old_start_offset..old_start_offset + old_text_len,
+            new: new_start_offset..new_start_offset + excerpt.text_summary.len,
+        };
+
+        if let Some(last_edit) = edits.last_mut() {
+            if last_edit.old.end == edit.old.start {
+                last_edit.old.end = edit.old.end;
+                last_edit.new.end = edit.new.end;
+            } else {
+                edits.push(edit);
+            }
+        } else {
+            edits.push(edit);
+        }
+
+        new_excerpts.push(excerpt, &());
+
+        cursor.next(&());
+
+        new_excerpts.append(cursor.suffix(&()), &());
+
+        drop(cursor);
+        self.snapshot.borrow_mut().excerpts = new_excerpts;
+
+        self.subscriptions.publish_mut(edits);
+        cx.emit(Event::Edited {
+            singleton_buffer_edited: false,
+        });
+        cx.emit(Event::ExcerptsExpanded { ids: vec![id] });
+        cx.notify();
+    }
+
     pub fn expand_excerpts(
         &mut self,
         ids: impl IntoIterator<Item = ExcerptId>,
@@ -3139,6 +3202,10 @@ impl MultiBufferSnapshot {
         None
     }
 
+    pub fn context_range_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<Range<text::Anchor>> {
+        Some(self.excerpt(excerpt_id)?.range.context.clone())
+    }
+
     pub fn can_resolve(&self, anchor: &Anchor) -> bool {
         if anchor.excerpt_id == ExcerptId::min() || anchor.excerpt_id == ExcerptId::max() {
             true
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 4506fcc6feb430..b2920bc791c47d 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -1431,7 +1431,7 @@ impl LspStore {
         buffer_handle: &Model<Buffer>,
         range: Range<Anchor>,
         cx: &mut ModelContext<Self>,
-    ) -> Task<Vec<CodeAction>> {
+    ) -> Task<Result<Vec<CodeAction>>> {
         if let Some((upstream_client, project_id)) = self.upstream_client() {
             let request_task = upstream_client.request(proto::MultiLspQuery {
                 buffer_id: buffer_handle.read(cx).remote_id().into(),
@@ -1451,14 +1451,11 @@ impl LspStore {
             let buffer = buffer_handle.clone();
             cx.spawn(|weak_project, cx| async move {
                 let Some(project) = weak_project.upgrade() else {
-                    return Vec::new();
+                    return Ok(Vec::new());
                 };
-                join_all(
-                    request_task
-                        .await
-                        .log_err()
-                        .map(|response| response.responses)
-                        .unwrap_or_default()
+                let responses = request_task.await?.responses;
+                let actions = join_all(
+                    responses
                         .into_iter()
                         .filter_map(|lsp_response| match lsp_response.response? {
                             proto::lsp_response::Response::GetCodeActionsResponse(response) => {
@@ -1470,7 +1467,7 @@ impl LspStore {
                             }
                         })
                         .map(|code_actions_response| {
-                            let response = GetCodeActions {
+                            GetCodeActions {
                                 range: range.clone(),
                                 kinds: None,
                             }
@@ -1479,14 +1476,17 @@ impl LspStore {
                                 project.clone(),
                                 buffer.clone(),
                                 cx.clone(),
-                            );
-                            async move { response.await.log_err().unwrap_or_default() }
+                            )
                         }),
                 )
-                .await
-                .into_iter()
-                .flatten()
-                .collect()
+                .await;
+
+                Ok(actions
+                    .into_iter()
+                    .collect::<Result<Vec<Vec<_>>>>()?
+                    .into_iter()
+                    .flatten()
+                    .collect())
             })
         } else {
             let all_actions_task = self.request_multiple_lsp_locally(
@@ -1498,7 +1498,9 @@ impl LspStore {
                 },
                 cx,
             );
-            cx.spawn(|_, _| async move { all_actions_task.await.into_iter().flatten().collect() })
+            cx.spawn(
+                |_, _| async move { Ok(all_actions_task.await.into_iter().flatten().collect()) },
+            )
         }
     }
 
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 0c54a16187a4a6..b1347c6d063f25 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -3247,7 +3247,7 @@ impl Project {
         buffer_handle: &Model<Buffer>,
         range: Range<T>,
         cx: &mut ModelContext<Self>,
-    ) -> Task<Vec<CodeAction>> {
+    ) -> Task<Result<Vec<CodeAction>>> {
         let buffer = buffer_handle.read(cx);
         let range = buffer.anchor_before(range.start)..buffer.anchor_before(range.end);
         self.lsp_store.update(cx, |lsp_store, cx| {
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index d0d67f0cda4a40..a7d2e6766c2330 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -2708,7 +2708,7 @@ async fn test_apply_code_actions_with_commands(cx: &mut gpui::TestAppContext) {
         .next()
         .await;
 
-    let action = actions.await[0].clone();
+    let action = actions.await.unwrap()[0].clone();
     let apply = project.update(cx, |project, cx| {
         project.apply_code_action(buffer.clone(), action, true, cx)
     });
@@ -5046,6 +5046,7 @@ async fn test_multiple_language_server_actions(cx: &mut gpui::TestAppContext) {
         vec!["TailwindServer code action", "TypeScriptServer code action"],
         code_actions_task
             .await
+            .unwrap()
             .into_iter()
             .map(|code_action| code_action.lsp_action.title)
             .sorted()
diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs
index fac3c55bf45506..d5b719a657628e 100644
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -2745,7 +2745,7 @@ pub mod tests {
                 search_view
                     .results_editor
                     .update(cx, |editor, cx| editor.display_text(cx)),
-                "\n\n\nconst ONE: usize = 1;\n\n\n\n\nconst TWO: usize = one::ONE + one::ONE;\n",
+                "\n\n\nconst TWO: usize = one::ONE + one::ONE;\n\n\n\n\nconst ONE: usize = 1;\n",
                 "New search in directory should have a filter that matches a certain directory"
             );
                 })
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 1fbeab38a2e8b4..92bfc8c5c56d4d 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -675,7 +675,9 @@ impl DelayedDebouncedEditAction {
 pub enum Event {
     PaneAdded(View<Pane>),
     PaneRemoved,
-    ItemAdded,
+    ItemAdded {
+        item: Box<dyn ItemHandle>,
+    },
     ItemRemoved,
     ActiveItemChanged,
     UserSavedItem {
@@ -2984,7 +2986,9 @@ impl Workspace {
         match event {
             pane::Event::AddItem { item } => {
                 item.added_to_pane(self, pane, cx);
-                cx.emit(Event::ItemAdded);
+                cx.emit(Event::ItemAdded {
+                    item: item.boxed_clone(),
+                });
             }
             pane::Event::Split(direction) => {
                 self.split_and_clone(pane, *direction, cx);

From 1ff10b71c8ea9cae6263225445e35c68ab0808be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8B=90=E7=8B=B8?=
 <134658521+Huliiiiii@users.noreply.github.com>
Date: Tue, 24 Sep 2024 03:39:01 +0800
Subject: [PATCH 279/762] lua: Add auto-close for single quote strings and
 highlight escape sequences (#18199)

- Add auto close to single quote string
- Add syntax highlights to escape sequence
---
 extensions/lua/languages/lua/config.toml    | 2 +-
 extensions/lua/languages/lua/highlights.scm | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/extensions/lua/languages/lua/config.toml b/extensions/lua/languages/lua/config.toml
index 6c3aee09ea71b2..7ec8ef2f03f549 100644
--- a/extensions/lua/languages/lua/config.toml
+++ b/extensions/lua/languages/lua/config.toml
@@ -8,6 +8,6 @@ brackets = [
     { start = "[", end = "]", close = true, newline = true },
     { start = "(", end = ")", close = true, newline = true },
     { start = "\"", end = "\"", close = true, newline = false, not_in = ["string"] },
-    { start = "'", end = "'", close = false, newline = false, not_in = ["string"] },
+    { start = "'", end = "'", close = true, newline = false, not_in = ["string"] },
 ]
 collapsed_placeholder = "--[ ... ]--"
diff --git a/extensions/lua/languages/lua/highlights.scm b/extensions/lua/languages/lua/highlights.scm
index 98e2c2eaff6380..7b0b8364ea2d38 100644
--- a/extensions/lua/languages/lua/highlights.scm
+++ b/extensions/lua/languages/lua/highlights.scm
@@ -196,3 +196,4 @@
 (number) @number
 
 (string) @string
+(escape_sequence) @string.escape

From e95e1c9ae5bd94ffaa595b8e56a727802441457d Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 23 Sep 2024 19:45:00 +0000
Subject: [PATCH 280/762] Add '?plain=1' to Permalinks on GitLab/GitHub for md
 files (#18241)

Improve our Permalinks to markdown files.
GitHub/GitLab supports the same URL syntax.
---
 crates/git_hosting_providers/src/providers/github.rs | 3 +++
 crates/git_hosting_providers/src/providers/gitlab.rs | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/crates/git_hosting_providers/src/providers/github.rs b/crates/git_hosting_providers/src/providers/github.rs
index be46b51ddf7bdf..77eaa80961e61c 100644
--- a/crates/git_hosting_providers/src/providers/github.rs
+++ b/crates/git_hosting_providers/src/providers/github.rs
@@ -145,6 +145,9 @@ impl GitHostingProvider for Github {
             .base_url()
             .join(&format!("{owner}/{repo}/blob/{sha}/{path}"))
             .unwrap();
+        if path.ends_with(".md") {
+            permalink.set_query(Some("plain=1"));
+        }
         permalink.set_fragment(
             selection
                 .map(|selection| self.line_fragment(&selection))
diff --git a/crates/git_hosting_providers/src/providers/gitlab.rs b/crates/git_hosting_providers/src/providers/gitlab.rs
index ccb8a7280a2c64..36ee214cf9d47c 100644
--- a/crates/git_hosting_providers/src/providers/gitlab.rs
+++ b/crates/git_hosting_providers/src/providers/gitlab.rs
@@ -65,6 +65,9 @@ impl GitHostingProvider for Gitlab {
             .base_url()
             .join(&format!("{owner}/{repo}/-/blob/{sha}/{path}"))
             .unwrap();
+        if path.ends_with(".md") {
+            permalink.set_query(Some("plain=1"));
+        }
         permalink.set_fragment(
             selection
                 .map(|selection| self.line_fragment(&selection))

From e4080ef565f71c15a4cd89f6b0d565b82ec53f7d Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Mon, 23 Sep 2024 14:33:28 -0600
Subject: [PATCH 281/762] Move formatting to LSP store (#18242)

Release Notes:

- ssh-remoting: Fixed format on save

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 .../src/activity_indicator.rs                 |   2 +-
 crates/collab/src/tests/integration_tests.rs  |   4 +-
 crates/editor/src/editor.rs                   |   4 +-
 crates/editor/src/items.rs                    |   4 +-
 crates/project/src/lsp_store.rs               | 649 +++++++++++++++++-
 crates/project/src/prettier_store.rs          |   8 +-
 crates/project/src/project.rs                 | 639 +----------------
 crates/project/src/project_tests.rs           |   2 +-
 8 files changed, 655 insertions(+), 657 deletions(-)

diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs
index a9ae7d075d10c2..fee0ef73f7bee1 100644
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -280,7 +280,7 @@ impl ActivityIndicator {
         }
 
         // Show any formatting failure
-        if let Some(failure) = self.project.read(cx).last_formatting_failure() {
+        if let Some(failure) = self.project.read(cx).last_formatting_failure(cx) {
             return Some(Content {
                 icon: Some(
                     Icon::new(IconName::Warning)
diff --git a/crates/collab/src/tests/integration_tests.rs b/crates/collab/src/tests/integration_tests.rs
index 51593e081e46c1..d5cef3589cce33 100644
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -28,8 +28,8 @@ use live_kit_client::MacOSDisplay;
 use lsp::LanguageServerId;
 use parking_lot::Mutex;
 use project::{
-    search::SearchQuery, search::SearchResult, DiagnosticSummary, FormatTrigger, HoverBlockKind,
-    Project, ProjectPath,
+    lsp_store::FormatTrigger, search::SearchQuery, search::SearchResult, DiagnosticSummary,
+    HoverBlockKind, Project, ProjectPath,
 };
 use rand::prelude::*;
 use serde_json::json;
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index cbc272d995213c..dc536471023f08 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -122,8 +122,8 @@ use ordered_float::OrderedFloat;
 use parking_lot::{Mutex, RwLock};
 use project::project_settings::{GitGutterSetting, ProjectSettings};
 use project::{
-    CodeAction, Completion, CompletionIntent, FormatTrigger, Item, Location, Project, ProjectPath,
-    ProjectTransaction, TaskSourceKind,
+    lsp_store::FormatTrigger, CodeAction, Completion, CompletionIntent, Item, Location, Project,
+    ProjectPath, ProjectTransaction, TaskSourceKind,
 };
 use rand::prelude::*;
 use rpc::{proto::*, ErrorExt};
diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index 1d301f2ee68cd6..b3f4cc813fe8ad 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -20,8 +20,8 @@ use language::{
 };
 use multi_buffer::AnchorRangeExt;
 use project::{
-    project_settings::ProjectSettings, search::SearchQuery, FormatTrigger, Item as _, Project,
-    ProjectPath,
+    lsp_store::FormatTrigger, project_settings::ProjectSettings, search::SearchQuery, Item as _,
+    Project, ProjectPath,
 };
 use rpc::proto::{self, update_view, PeerId};
 use settings::Settings;
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index b2920bc791c47d..6673f9da1ddd71 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -1,5 +1,6 @@
 use crate::{
     buffer_store::{BufferStore, BufferStoreEvent},
+    deserialize_code_actions,
     environment::ProjectEnvironment,
     lsp_command::{self, *},
     lsp_ext_command,
@@ -19,7 +20,7 @@ use futures::{
     future::{join_all, BoxFuture, Shared},
     select,
     stream::FuturesUnordered,
-    Future, FutureExt, StreamExt,
+    AsyncWriteExt, Future, FutureExt, StreamExt,
 };
 use globset::{Glob, GlobSet, GlobSetBuilder};
 use gpui::{
@@ -29,12 +30,13 @@ use gpui::{
 use http_client::{AsyncBody, HttpClient, Request, Response, Uri};
 use language::{
     language_settings::{
-        all_language_settings, language_settings, AllLanguageSettings, LanguageSettings,
+        all_language_settings, language_settings, AllLanguageSettings, FormatOnSave, Formatter,
+        LanguageSettings, SelectedFormatter,
     },
     markdown, point_to_lsp, prepare_completion_documentation,
     proto::{deserialize_anchor, deserialize_version, serialize_anchor, serialize_version},
     range_from_lsp, Bias, Buffer, BufferSnapshot, CachedLspAdapter, CodeLabel, Diagnostic,
-    DiagnosticEntry, DiagnosticSet, Documentation, File as _, Language, LanguageConfig,
+    DiagnosticEntry, DiagnosticSet, Diff, Documentation, File as _, Language, LanguageConfig,
     LanguageMatcher, LanguageName, LanguageRegistry, LanguageServerName, LocalFile, LspAdapter,
     LspAdapterDelegate, Patch, PendingLanguageServer, PointUtf16, TextBufferSnapshot, ToOffset,
     ToPointUtf16, Transaction, Unclipped,
@@ -90,12 +92,38 @@ const SERVER_REINSTALL_DEBOUNCE_TIMEOUT: Duration = Duration::from_secs(1);
 const SERVER_LAUNCHING_BEFORE_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(5);
 pub const SERVER_PROGRESS_THROTTLE_TIMEOUT: Duration = Duration::from_millis(100);
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum FormatTrigger {
+    Save,
+    Manual,
+}
+
+// Currently, formatting operations are represented differently depending on
+// whether they come from a language server or an external command.
+#[derive(Debug)]
+pub enum FormatOperation {
+    Lsp(Vec<(Range<Anchor>, String)>),
+    External(Diff),
+    Prettier(Diff),
+}
+
+impl FormatTrigger {
+    fn from_proto(value: i32) -> FormatTrigger {
+        match value {
+            0 => FormatTrigger::Save,
+            1 => FormatTrigger::Manual,
+            _ => FormatTrigger::Save,
+        }
+    }
+}
+
 pub struct LocalLspStore {
     http_client: Option<Arc<dyn HttpClient>>,
     environment: Model<ProjectEnvironment>,
     fs: Arc<dyn Fs>,
     yarn: Model<YarnPathStore>,
     pub language_servers: HashMap<LanguageServerId, LanguageServerState>,
+    buffers_being_formatted: HashSet<BufferId>,
     last_workspace_edits_by_language_server: HashMap<LanguageServerId, ProjectTransaction>,
     language_server_watched_paths: HashMap<LanguageServerId, Model<LanguageServerWatchedPaths>>,
     language_server_watcher_registrations:
@@ -104,6 +132,7 @@ pub struct LocalLspStore {
         HashMap<LanguageServerId, (LanguageServerName, Arc<LanguageServer>)>,
     prettier_store: Model<PrettierStore>,
     current_lsp_settings: HashMap<LanguageServerName, LspSettings>,
+    last_formatting_failure: Option<String>,
     _subscription: gpui::Subscription,
 }
 
@@ -128,6 +157,485 @@ impl LocalLspStore {
             futures::future::join_all(shutdown_futures).await;
         }
     }
+    async fn format_locally(
+        lsp_store: WeakModel<LspStore>,
+        mut buffers_with_paths: Vec<(Model<Buffer>, Option<PathBuf>)>,
+        push_to_history: bool,
+        trigger: FormatTrigger,
+        mut cx: AsyncAppContext,
+    ) -> anyhow::Result<ProjectTransaction> {
+        // Do not allow multiple concurrent formatting requests for the
+        // same buffer.
+        lsp_store.update(&mut cx, |this, cx| {
+            let this = this.as_local_mut().unwrap();
+            buffers_with_paths.retain(|(buffer, _)| {
+                this.buffers_being_formatted
+                    .insert(buffer.read(cx).remote_id())
+            });
+        })?;
+
+        let _cleanup = defer({
+            let this = lsp_store.clone();
+            let mut cx = cx.clone();
+            let buffers = &buffers_with_paths;
+            move || {
+                this.update(&mut cx, |this, cx| {
+                    let this = this.as_local_mut().unwrap();
+                    for (buffer, _) in buffers {
+                        this.buffers_being_formatted
+                            .remove(&buffer.read(cx).remote_id());
+                    }
+                })
+                .ok();
+            }
+        });
+
+        let mut project_transaction = ProjectTransaction::default();
+        for (buffer, buffer_abs_path) in &buffers_with_paths {
+            let (primary_adapter_and_server, adapters_and_servers) =
+                lsp_store.update(&mut cx, |lsp_store, cx| {
+                    let buffer = buffer.read(cx);
+
+                    let adapters_and_servers = lsp_store
+                        .language_servers_for_buffer(buffer, cx)
+                        .map(|(adapter, lsp)| (adapter.clone(), lsp.clone()))
+                        .collect::<Vec<_>>();
+
+                    let primary_adapter = lsp_store
+                        .primary_language_server_for_buffer(buffer, cx)
+                        .map(|(adapter, lsp)| (adapter.clone(), lsp.clone()));
+
+                    (primary_adapter, adapters_and_servers)
+                })?;
+
+            let settings = buffer.update(&mut cx, |buffer, cx| {
+                language_settings(buffer.language(), buffer.file(), cx).clone()
+            })?;
+
+            let remove_trailing_whitespace = settings.remove_trailing_whitespace_on_save;
+            let ensure_final_newline = settings.ensure_final_newline_on_save;
+
+            // First, format buffer's whitespace according to the settings.
+            let trailing_whitespace_diff = if remove_trailing_whitespace {
+                Some(
+                    buffer
+                        .update(&mut cx, |b, cx| b.remove_trailing_whitespace(cx))?
+                        .await,
+                )
+            } else {
+                None
+            };
+            let whitespace_transaction_id = buffer.update(&mut cx, |buffer, cx| {
+                buffer.finalize_last_transaction();
+                buffer.start_transaction();
+                if let Some(diff) = trailing_whitespace_diff {
+                    buffer.apply_diff(diff, cx);
+                }
+                if ensure_final_newline {
+                    buffer.ensure_final_newline(cx);
+                }
+                buffer.end_transaction(cx)
+            })?;
+
+            // Apply the `code_actions_on_format` before we run the formatter.
+            let code_actions = deserialize_code_actions(&settings.code_actions_on_format);
+            #[allow(clippy::nonminimal_bool)]
+            if !code_actions.is_empty()
+                && !(trigger == FormatTrigger::Save && settings.format_on_save == FormatOnSave::Off)
+            {
+                LspStore::execute_code_actions_on_servers(
+                    &lsp_store,
+                    &adapters_and_servers,
+                    code_actions,
+                    buffer,
+                    push_to_history,
+                    &mut project_transaction,
+                    &mut cx,
+                )
+                .await?;
+            }
+
+            // Apply language-specific formatting using either the primary language server
+            // or external command.
+            // Except for code actions, which are applied with all connected language servers.
+            let primary_language_server =
+                primary_adapter_and_server.map(|(_adapter, server)| server.clone());
+            let server_and_buffer = primary_language_server
+                .as_ref()
+                .zip(buffer_abs_path.as_ref());
+
+            let prettier_settings = buffer.read_with(&cx, |buffer, cx| {
+                language_settings(buffer.language(), buffer.file(), cx)
+                    .prettier
+                    .clone()
+            })?;
+
+            let mut format_operations: Vec<FormatOperation> = vec![];
+            {
+                match trigger {
+                    FormatTrigger::Save => {
+                        match &settings.format_on_save {
+                            FormatOnSave::Off => {
+                                // nothing
+                            }
+                            FormatOnSave::On => {
+                                match &settings.formatter {
+                                    SelectedFormatter::Auto => {
+                                        // do the auto-format: prefer prettier, fallback to primary language server
+                                        let diff = {
+                                            if prettier_settings.allowed {
+                                                Self::perform_format(
+                                                    &Formatter::Prettier,
+                                                    server_and_buffer,
+                                                    lsp_store.clone(),
+                                                    buffer,
+                                                    buffer_abs_path,
+                                                    &settings,
+                                                    &adapters_and_servers,
+                                                    push_to_history,
+                                                    &mut project_transaction,
+                                                    &mut cx,
+                                                )
+                                                .await
+                                            } else {
+                                                Self::perform_format(
+                                                    &Formatter::LanguageServer { name: None },
+                                                    server_and_buffer,
+                                                    lsp_store.clone(),
+                                                    buffer,
+                                                    buffer_abs_path,
+                                                    &settings,
+                                                    &adapters_and_servers,
+                                                    push_to_history,
+                                                    &mut project_transaction,
+                                                    &mut cx,
+                                                )
+                                                .await
+                                            }
+                                        }
+                                        .log_err()
+                                        .flatten();
+                                        if let Some(op) = diff {
+                                            format_operations.push(op);
+                                        }
+                                    }
+                                    SelectedFormatter::List(formatters) => {
+                                        for formatter in formatters.as_ref() {
+                                            let diff = Self::perform_format(
+                                                formatter,
+                                                server_and_buffer,
+                                                lsp_store.clone(),
+                                                buffer,
+                                                buffer_abs_path,
+                                                &settings,
+                                                &adapters_and_servers,
+                                                push_to_history,
+                                                &mut project_transaction,
+                                                &mut cx,
+                                            )
+                                            .await
+                                            .log_err()
+                                            .flatten();
+                                            if let Some(op) = diff {
+                                                format_operations.push(op);
+                                            }
+
+                                            // format with formatter
+                                        }
+                                    }
+                                }
+                            }
+                            FormatOnSave::List(formatters) => {
+                                for formatter in formatters.as_ref() {
+                                    let diff = Self::perform_format(
+                                        formatter,
+                                        server_and_buffer,
+                                        lsp_store.clone(),
+                                        buffer,
+                                        buffer_abs_path,
+                                        &settings,
+                                        &adapters_and_servers,
+                                        push_to_history,
+                                        &mut project_transaction,
+                                        &mut cx,
+                                    )
+                                    .await
+                                    .log_err()
+                                    .flatten();
+                                    if let Some(op) = diff {
+                                        format_operations.push(op);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    FormatTrigger::Manual => {
+                        match &settings.formatter {
+                            SelectedFormatter::Auto => {
+                                // do the auto-format: prefer prettier, fallback to primary language server
+                                let diff = {
+                                    if prettier_settings.allowed {
+                                        Self::perform_format(
+                                            &Formatter::Prettier,
+                                            server_and_buffer,
+                                            lsp_store.clone(),
+                                            buffer,
+                                            buffer_abs_path,
+                                            &settings,
+                                            &adapters_and_servers,
+                                            push_to_history,
+                                            &mut project_transaction,
+                                            &mut cx,
+                                        )
+                                        .await
+                                    } else {
+                                        Self::perform_format(
+                                            &Formatter::LanguageServer { name: None },
+                                            server_and_buffer,
+                                            lsp_store.clone(),
+                                            buffer,
+                                            buffer_abs_path,
+                                            &settings,
+                                            &adapters_and_servers,
+                                            push_to_history,
+                                            &mut project_transaction,
+                                            &mut cx,
+                                        )
+                                        .await
+                                    }
+                                }
+                                .log_err()
+                                .flatten();
+
+                                if let Some(op) = diff {
+                                    format_operations.push(op)
+                                }
+                            }
+                            SelectedFormatter::List(formatters) => {
+                                for formatter in formatters.as_ref() {
+                                    // format with formatter
+                                    let diff = Self::perform_format(
+                                        formatter,
+                                        server_and_buffer,
+                                        lsp_store.clone(),
+                                        buffer,
+                                        buffer_abs_path,
+                                        &settings,
+                                        &adapters_and_servers,
+                                        push_to_history,
+                                        &mut project_transaction,
+                                        &mut cx,
+                                    )
+                                    .await
+                                    .log_err()
+                                    .flatten();
+                                    if let Some(op) = diff {
+                                        format_operations.push(op);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            buffer.update(&mut cx, |b, cx| {
+                // If the buffer had its whitespace formatted and was edited while the language-specific
+                // formatting was being computed, avoid applying the language-specific formatting, because
+                // it can't be grouped with the whitespace formatting in the undo history.
+                if let Some(transaction_id) = whitespace_transaction_id {
+                    if b.peek_undo_stack()
+                        .map_or(true, |e| e.transaction_id() != transaction_id)
+                    {
+                        format_operations.clear();
+                    }
+                }
+
+                // Apply any language-specific formatting, and group the two formatting operations
+                // in the buffer's undo history.
+                for operation in format_operations {
+                    match operation {
+                        FormatOperation::Lsp(edits) => {
+                            b.edit(edits, None, cx);
+                        }
+                        FormatOperation::External(diff) => {
+                            b.apply_diff(diff, cx);
+                        }
+                        FormatOperation::Prettier(diff) => {
+                            b.apply_diff(diff, cx);
+                        }
+                    }
+
+                    if let Some(transaction_id) = whitespace_transaction_id {
+                        b.group_until_transaction(transaction_id);
+                    } else if let Some(transaction) = project_transaction.0.get(buffer) {
+                        b.group_until_transaction(transaction.id)
+                    }
+                }
+
+                if let Some(transaction) = b.finalize_last_transaction().cloned() {
+                    if !push_to_history {
+                        b.forget_transaction(transaction.id);
+                    }
+                    project_transaction.0.insert(buffer.clone(), transaction);
+                }
+            })?;
+        }
+
+        Ok(project_transaction)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    async fn perform_format(
+        formatter: &Formatter,
+        primary_server_and_buffer: Option<(&Arc<LanguageServer>, &PathBuf)>,
+        lsp_store: WeakModel<LspStore>,
+        buffer: &Model<Buffer>,
+        buffer_abs_path: &Option<PathBuf>,
+        settings: &LanguageSettings,
+        adapters_and_servers: &[(Arc<CachedLspAdapter>, Arc<LanguageServer>)],
+        push_to_history: bool,
+        transaction: &mut ProjectTransaction,
+        cx: &mut AsyncAppContext,
+    ) -> Result<Option<FormatOperation>, anyhow::Error> {
+        let result = match formatter {
+            Formatter::LanguageServer { name } => {
+                if let Some((language_server, buffer_abs_path)) = primary_server_and_buffer {
+                    let language_server = if let Some(name) = name {
+                        adapters_and_servers
+                            .iter()
+                            .find_map(|(adapter, server)| {
+                                adapter.name.0.as_ref().eq(name.as_str()).then_some(server)
+                            })
+                            .unwrap_or(language_server)
+                    } else {
+                        language_server
+                    };
+
+                    Some(FormatOperation::Lsp(
+                        LspStore::format_via_lsp(
+                            &lsp_store,
+                            buffer,
+                            buffer_abs_path,
+                            language_server,
+                            settings,
+                            cx,
+                        )
+                        .await
+                        .context("failed to format via language server")?,
+                    ))
+                } else {
+                    None
+                }
+            }
+            Formatter::Prettier => {
+                let prettier = lsp_store.update(cx, |lsp_store, _cx| {
+                    lsp_store.prettier_store().unwrap().downgrade()
+                })?;
+                prettier_store::format_with_prettier(&prettier, buffer, cx)
+                    .await
+                    .transpose()
+                    .ok()
+                    .flatten()
+            }
+            Formatter::External { command, arguments } => {
+                let buffer_abs_path = buffer_abs_path.as_ref().map(|path| path.as_path());
+                Self::format_via_external_command(buffer, buffer_abs_path, command, arguments, cx)
+                    .await
+                    .context(format!(
+                        "failed to format via external command {:?}",
+                        command
+                    ))?
+                    .map(FormatOperation::External)
+            }
+            Formatter::CodeActions(code_actions) => {
+                let code_actions = deserialize_code_actions(code_actions);
+                if !code_actions.is_empty() {
+                    LspStore::execute_code_actions_on_servers(
+                        &lsp_store,
+                        adapters_and_servers,
+                        code_actions,
+                        buffer,
+                        push_to_history,
+                        transaction,
+                        cx,
+                    )
+                    .await?;
+                }
+                None
+            }
+        };
+        anyhow::Ok(result)
+    }
+
+    async fn format_via_external_command(
+        buffer: &Model<Buffer>,
+        buffer_abs_path: Option<&Path>,
+        command: &str,
+        arguments: &[String],
+        cx: &mut AsyncAppContext,
+    ) -> Result<Option<Diff>> {
+        let working_dir_path = buffer.update(cx, |buffer, cx| {
+            let file = File::from_dyn(buffer.file())?;
+            let worktree = file.worktree.read(cx);
+            let mut worktree_path = worktree.abs_path().to_path_buf();
+            if worktree.root_entry()?.is_file() {
+                worktree_path.pop();
+            }
+            Some(worktree_path)
+        })?;
+
+        let mut child = smol::process::Command::new(command);
+        #[cfg(target_os = "windows")]
+        {
+            use smol::process::windows::CommandExt;
+            child.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
+        }
+
+        if let Some(working_dir_path) = working_dir_path {
+            child.current_dir(working_dir_path);
+        }
+
+        let mut child = child
+            .args(arguments.iter().map(|arg| {
+                if let Some(buffer_abs_path) = buffer_abs_path {
+                    arg.replace("{buffer_path}", &buffer_abs_path.to_string_lossy())
+                } else {
+                    arg.replace("{buffer_path}", "Untitled")
+                }
+            }))
+            .stdin(smol::process::Stdio::piped())
+            .stdout(smol::process::Stdio::piped())
+            .stderr(smol::process::Stdio::piped())
+            .spawn()?;
+
+        let stdin = child
+            .stdin
+            .as_mut()
+            .ok_or_else(|| anyhow!("failed to acquire stdin"))?;
+        let text = buffer.update(cx, |buffer, _| buffer.as_rope().clone())?;
+        for chunk in text.chunks() {
+            stdin.write_all(chunk.as_bytes()).await?;
+        }
+        stdin.flush().await?;
+
+        let output = child.output().await?;
+        if !output.status.success() {
+            return Err(anyhow!(
+                "command failed with exit code {:?}:\nstdout: {}\nstderr: {}",
+                output.status.code(),
+                String::from_utf8_lossy(&output.stdout),
+                String::from_utf8_lossy(&output.stderr),
+            ));
+        }
+
+        let stdout = String::from_utf8(output.stdout)?;
+        Ok(Some(
+            buffer
+                .update(cx, |buffer, cx| buffer.diff(stdout, cx))?
+                .await,
+        ))
+    }
 }
 
 pub struct RemoteLspStore {
@@ -221,8 +729,6 @@ pub enum LspStoreEvent {
         edits: Vec<(lsp::Range, Snippet)>,
         most_recent_edit: clock::Lamport,
     },
-    StartFormattingLocalBuffer(BufferId),
-    FinishFormattingLocalBuffer(BufferId),
 }
 
 #[derive(Clone, Debug, Serialize)]
@@ -251,6 +757,7 @@ impl LspStore {
         client.add_model_message_handler(Self::handle_start_language_server);
         client.add_model_message_handler(Self::handle_update_language_server);
         client.add_model_message_handler(Self::handle_update_diagnostic_summary);
+        client.add_model_request_handler(Self::handle_format_buffers);
         client.add_model_request_handler(Self::handle_resolve_completion_documentation);
         client.add_model_request_handler(Self::handle_apply_code_action);
         client.add_model_request_handler(Self::handle_inlay_hints);
@@ -366,6 +873,8 @@ impl LspStore {
                 language_server_watched_paths: Default::default(),
                 language_server_watcher_registrations: Default::default(),
                 current_lsp_settings: ProjectSettings::get_global(cx).lsp.clone(),
+                buffers_being_formatted: Default::default(),
+                last_formatting_failure: None,
                 prettier_store,
                 environment,
                 http_client,
@@ -387,6 +896,7 @@ impl LspStore {
             diagnostic_summaries: Default::default(),
             diagnostics: Default::default(),
             active_entry: None,
+
             _maintain_workspace_config: Self::maintain_workspace_config(cx),
             _maintain_buffer_languages: Self::maintain_buffer_languages(languages.clone(), cx),
         }
@@ -1276,7 +1786,7 @@ impl LspStore {
     }
 
     fn apply_on_type_formatting(
-        &self,
+        &mut self,
         buffer: Model<Buffer>,
         position: Anchor,
         trigger: String,
@@ -1298,25 +1808,18 @@ impl LspStore {
                     .map(language::proto::deserialize_transaction)
                     .transpose()
             })
-        } else {
+        } else if let Some(local) = self.as_local_mut() {
+            let buffer_id = buffer.read(cx).remote_id();
+            local.buffers_being_formatted.insert(buffer_id);
             cx.spawn(move |this, mut cx| async move {
-                // Do not allow multiple concurrent formatting requests for the
-                // same buffer.
-                this.update(&mut cx, |_, cx| {
-                    cx.emit(LspStoreEvent::StartFormattingLocalBuffer(
-                        buffer.read(cx).remote_id(),
-                    ));
-                })?;
-
                 let _cleanup = defer({
                     let this = this.clone();
                     let mut cx = cx.clone();
-                    let closure_buffer = buffer.clone();
                     move || {
-                        this.update(&mut cx, |_, cx| {
-                            cx.emit(LspStoreEvent::FinishFormattingLocalBuffer(
-                                closure_buffer.read(cx).remote_id(),
-                            ))
+                        this.update(&mut cx, |this, _| {
+                            if let Some(local) = this.as_local_mut() {
+                                local.buffers_being_formatted.remove(&buffer_id);
+                            }
                         })
                         .ok();
                     }
@@ -1333,6 +1836,8 @@ impl LspStore {
                 })?
                 .await
             })
+        } else {
+            Task::ready(Err(anyhow!("No upstream client or local language server")))
         }
     }
 
@@ -4708,6 +5213,110 @@ impl LspStore {
                 .map(language::proto::serialize_transaction),
         })
     }
+    pub fn last_formatting_failure(&self) -> Option<&str> {
+        self.as_local()
+            .and_then(|local| local.last_formatting_failure.as_deref())
+    }
+
+    pub fn format(
+        &mut self,
+        buffers: HashSet<Model<Buffer>>,
+        push_to_history: bool,
+        trigger: FormatTrigger,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<anyhow::Result<ProjectTransaction>> {
+        if let Some(_) = self.as_local() {
+            let buffers_with_paths = buffers
+                .into_iter()
+                .map(|buffer_handle| {
+                    let buffer = buffer_handle.read(cx);
+                    let buffer_abs_path = File::from_dyn(buffer.file())
+                        .and_then(|file| file.as_local().map(|f| f.abs_path(cx)));
+                    (buffer_handle, buffer_abs_path)
+                })
+                .collect::<Vec<_>>();
+
+            cx.spawn(move |lsp_store, mut cx| async move {
+                let result = LocalLspStore::format_locally(
+                    lsp_store.clone(),
+                    buffers_with_paths,
+                    push_to_history,
+                    trigger,
+                    cx.clone(),
+                )
+                .await;
+
+                lsp_store.update(&mut cx, |lsp_store, _| {
+                    let local = lsp_store.as_local_mut().unwrap();
+                    match &result {
+                        Ok(_) => local.last_formatting_failure = None,
+                        Err(error) => {
+                            local.last_formatting_failure.replace(error.to_string());
+                        }
+                    }
+                })?;
+
+                result
+            })
+        } else if let Some((client, project_id)) = self.upstream_client() {
+            cx.spawn(move |this, mut cx| async move {
+                let response = client
+                    .request(proto::FormatBuffers {
+                        project_id,
+                        trigger: trigger as i32,
+                        buffer_ids: buffers
+                            .iter()
+                            .map(|buffer| {
+                                buffer.update(&mut cx, |buffer, _| buffer.remote_id().into())
+                            })
+                            .collect::<Result<_>>()?,
+                    })
+                    .await?
+                    .transaction
+                    .ok_or_else(|| anyhow!("missing transaction"))?;
+                BufferStore::deserialize_project_transaction(
+                    this.read_with(&cx, |this, _| this.buffer_store.downgrade())?,
+                    response,
+                    push_to_history,
+                    cx,
+                )
+                .await
+            })
+        } else {
+            Task::ready(Ok(ProjectTransaction::default()))
+        }
+    }
+
+    async fn handle_format_buffers(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::FormatBuffers>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::FormatBuffersResponse> {
+        let sender_id = envelope.original_sender_id().unwrap_or_default();
+        let format = this.update(&mut cx, |this, cx| {
+            let mut buffers = HashSet::default();
+            for buffer_id in &envelope.payload.buffer_ids {
+                let buffer_id = BufferId::new(*buffer_id)?;
+                buffers.insert(this.buffer_store.read(cx).get_existing(buffer_id)?);
+            }
+            let trigger = FormatTrigger::from_proto(envelope.payload.trigger);
+            Ok::<_, anyhow::Error>(this.format(buffers, false, trigger, cx))
+        })??;
+
+        let project_transaction = format.await?;
+        let project_transaction = this.update(&mut cx, |this, cx| {
+            this.buffer_store.update(cx, |buffer_store, cx| {
+                buffer_store.serialize_project_transaction_for_peer(
+                    project_transaction,
+                    sender_id,
+                    cx,
+                )
+            })
+        })?;
+        Ok(proto::FormatBuffersResponse {
+            transaction: Some(project_transaction),
+        })
+    }
 
     fn language_settings<'a>(
         &'a self,
diff --git a/crates/project/src/prettier_store.rs b/crates/project/src/prettier_store.rs
index 75d70c1d3f72f1..82bd8464b2e535 100644
--- a/crates/project/src/prettier_store.rs
+++ b/crates/project/src/prettier_store.rs
@@ -25,8 +25,8 @@ use smol::stream::StreamExt;
 use util::{ResultExt, TryFutureExt};
 
 use crate::{
-    worktree_store::WorktreeStore, File, FormatOperation, PathChange, ProjectEntryId, Worktree,
-    WorktreeId,
+    lsp_store::WorktreeId, worktree_store::WorktreeStore, File, PathChange, ProjectEntryId,
+    Worktree,
 };
 
 pub struct PrettierStore {
@@ -644,7 +644,7 @@ pub(super) async fn format_with_prettier(
     prettier_store: &WeakModel<PrettierStore>,
     buffer: &Model<Buffer>,
     cx: &mut AsyncAppContext,
-) -> Option<Result<FormatOperation>> {
+) -> Option<Result<crate::lsp_store::FormatOperation>> {
     let prettier_instance = prettier_store
         .update(cx, |prettier_store, cx| {
             prettier_store.prettier_instance_for_buffer(buffer, cx)
@@ -671,7 +671,7 @@ pub(super) async fn format_with_prettier(
             let format_result = prettier
                 .format(buffer, buffer_path, cx)
                 .await
-                .map(FormatOperation::Prettier)
+                .map(crate::lsp_store::FormatOperation::Prettier)
                 .with_context(|| format!("{} failed to format buffer", prettier_description));
 
             Some(format_result)
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index b1347c6d063f25..dc9337674b7eb7 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -31,7 +31,7 @@ pub use environment::ProjectEnvironment;
 use futures::{
     channel::mpsc::{self, UnboundedReceiver},
     future::try_join_all,
-    AsyncWriteExt, StreamExt,
+    StreamExt,
 };
 
 use git::{blame::Blame, repository::GitRepository};
@@ -41,17 +41,14 @@ use gpui::{
 };
 use itertools::Itertools;
 use language::{
-    language_settings::{
-        language_settings, FormatOnSave, Formatter, InlayHintKind, LanguageSettings,
-        SelectedFormatter,
-    },
+    language_settings::InlayHintKind,
     proto::{
         deserialize_anchor, serialize_anchor, serialize_line_ending, serialize_version,
         split_operations,
     },
     Buffer, BufferEvent, CachedLspAdapter, Capability, CodeLabel, ContextProvider, DiagnosticEntry,
-    Diff, Documentation, File as _, Language, LanguageRegistry, LanguageServerName, PointUtf16,
-    ToOffset, ToPointUtf16, Transaction, Unclipped,
+    Documentation, File as _, Language, LanguageRegistry, LanguageServerName, PointUtf16, ToOffset,
+    ToPointUtf16, Transaction, Unclipped,
 };
 use lsp::{CompletionContext, DocumentHighlightKind, LanguageServer, LanguageServerId};
 use lsp_command::*;
@@ -84,7 +81,7 @@ use task::{
 };
 use terminals::Terminals;
 use text::{Anchor, BufferId};
-use util::{defer, paths::compare_paths, ResultExt as _};
+use util::{paths::compare_paths, ResultExt as _};
 use worktree::{CreatedEntry, Snapshot, Traversal};
 use worktree_store::{WorktreeStore, WorktreeStoreEvent};
 
@@ -164,8 +161,6 @@ pub struct Project {
     search_included_history: SearchHistory,
     search_excluded_history: SearchHistory,
     snippets: Model<SnippetProvider>,
-    last_formatting_failure: Option<String>,
-    buffers_being_formatted: HashSet<BufferId>,
     environment: Model<ProjectEnvironment>,
     settings_observer: Model<SettingsObserver>,
 }
@@ -477,31 +472,6 @@ impl Hover {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum FormatTrigger {
-    Save,
-    Manual,
-}
-
-// Currently, formatting operations are represented differently depending on
-// whether they come from a language server or an external command.
-#[derive(Debug)]
-enum FormatOperation {
-    Lsp(Vec<(Range<Anchor>, String)>),
-    External(Diff),
-    Prettier(Diff),
-}
-
-impl FormatTrigger {
-    fn from_proto(value: i32) -> FormatTrigger {
-        match value {
-            0 => FormatTrigger::Save,
-            1 => FormatTrigger::Manual,
-            _ => FormatTrigger::Save,
-        }
-    }
-}
-
 enum EntitySubscription {
     Project(PendingEntitySubscription<Project>),
     BufferStore(PendingEntitySubscription<BufferStore>),
@@ -591,7 +561,7 @@ impl Project {
         client.add_model_message_handler(Self::handle_update_worktree);
         client.add_model_request_handler(Self::handle_reload_buffers);
         client.add_model_request_handler(Self::handle_synchronize_buffers);
-        client.add_model_request_handler(Self::handle_format_buffers);
+
         client.add_model_request_handler(Self::handle_search_project);
         client.add_model_request_handler(Self::handle_search_candidate_buffers);
         client.add_model_request_handler(Self::handle_open_buffer_by_id);
@@ -695,8 +665,7 @@ impl Project {
                 search_history: Self::new_search_history(),
                 environment,
                 remotely_created_models: Default::default(),
-                last_formatting_failure: None,
-                buffers_being_formatted: Default::default(),
+
                 search_included_history: Self::new_search_history(),
                 search_excluded_history: Self::new_search_history(),
             }
@@ -779,8 +748,7 @@ impl Project {
                 search_history: Self::new_search_history(),
                 environment,
                 remotely_created_models: Default::default(),
-                last_formatting_failure: None,
-                buffers_being_formatted: Default::default(),
+
                 search_included_history: Self::new_search_history(),
                 search_excluded_history: Self::new_search_history(),
             };
@@ -967,8 +935,6 @@ impl Project {
                 search_excluded_history: Self::new_search_history(),
                 environment: ProjectEnvironment::new(&worktree_store, None, cx),
                 remotely_created_models: Arc::new(Mutex::new(RemotelyCreatedModels::default())),
-                last_formatting_failure: None,
-                buffers_being_formatted: Default::default(),
             };
             this.set_role(role, cx);
             for worktree in worktrees {
@@ -2061,12 +2027,6 @@ impl Project {
                     cx.emit(Event::SnippetEdit(*buffer_id, edits.clone()))
                 }
             }
-            LspStoreEvent::StartFormattingLocalBuffer(buffer_id) => {
-                self.buffers_being_formatted.insert(*buffer_id);
-            }
-            LspStoreEvent::FinishFormattingLocalBuffer(buffer_id) => {
-                self.buffers_being_formatted.remove(buffer_id);
-            }
         }
     }
 
@@ -2352,8 +2312,8 @@ impl Project {
         self.lsp_store.read(cx).language_server_statuses()
     }
 
-    pub fn last_formatting_failure(&self) -> Option<&str> {
-        self.last_formatting_failure.as_deref()
+    pub fn last_formatting_failure<'a>(&self, cx: &'a AppContext) -> Option<&'a str> {
+        self.lsp_store.read(cx).last_formatting_failure()
     }
 
     pub fn update_diagnostics(
@@ -2455,558 +2415,12 @@ impl Project {
         &mut self,
         buffers: HashSet<Model<Buffer>>,
         push_to_history: bool,
-        trigger: FormatTrigger,
+        trigger: lsp_store::FormatTrigger,
         cx: &mut ModelContext<Project>,
     ) -> Task<anyhow::Result<ProjectTransaction>> {
-        if self.is_local_or_ssh() {
-            let buffers_with_paths = buffers
-                .into_iter()
-                .map(|buffer_handle| {
-                    let buffer = buffer_handle.read(cx);
-                    let buffer_abs_path = File::from_dyn(buffer.file())
-                        .and_then(|file| file.as_local().map(|f| f.abs_path(cx)));
-                    (buffer_handle, buffer_abs_path)
-                })
-                .collect::<Vec<_>>();
-
-            cx.spawn(move |project, mut cx| async move {
-                let result = Self::format_locally(
-                    project.clone(),
-                    buffers_with_paths,
-                    push_to_history,
-                    trigger,
-                    cx.clone(),
-                )
-                .await;
-
-                project.update(&mut cx, |project, _| match &result {
-                    Ok(_) => project.last_formatting_failure = None,
-                    Err(error) => {
-                        project.last_formatting_failure.replace(error.to_string());
-                    }
-                })?;
-
-                result
-            })
-        } else {
-            let remote_id = self.remote_id();
-            let client = self.client.clone();
-            cx.spawn(move |this, mut cx| async move {
-                if let Some(project_id) = remote_id {
-                    let response = client
-                        .request(proto::FormatBuffers {
-                            project_id,
-                            trigger: trigger as i32,
-                            buffer_ids: buffers
-                                .iter()
-                                .map(|buffer| {
-                                    buffer.update(&mut cx, |buffer, _| buffer.remote_id().into())
-                                })
-                                .collect::<Result<_>>()?,
-                        })
-                        .await?
-                        .transaction
-                        .ok_or_else(|| anyhow!("missing transaction"))?;
-                    BufferStore::deserialize_project_transaction(
-                        this.read_with(&cx, |this, _| this.buffer_store.downgrade())?,
-                        response,
-                        push_to_history,
-                        cx,
-                    )
-                    .await
-                } else {
-                    Ok(ProjectTransaction::default())
-                }
-            })
-        }
-    }
-
-    async fn format_locally(
-        project: WeakModel<Project>,
-        mut buffers_with_paths: Vec<(Model<Buffer>, Option<PathBuf>)>,
-        push_to_history: bool,
-        trigger: FormatTrigger,
-        mut cx: AsyncAppContext,
-    ) -> anyhow::Result<ProjectTransaction> {
-        // Do not allow multiple concurrent formatting requests for the
-        // same buffer.
-        let lsp_store = project.update(&mut cx, |this, cx| {
-            buffers_with_paths.retain(|(buffer, _)| {
-                this.buffers_being_formatted
-                    .insert(buffer.read(cx).remote_id())
-            });
-            this.lsp_store.downgrade()
-        })?;
-
-        let _cleanup = defer({
-            let this = project.clone();
-            let mut cx = cx.clone();
-            let buffers = &buffers_with_paths;
-            move || {
-                this.update(&mut cx, |this, cx| {
-                    for (buffer, _) in buffers {
-                        this.buffers_being_formatted
-                            .remove(&buffer.read(cx).remote_id());
-                    }
-                })
-                .ok();
-            }
-        });
-
-        let mut project_transaction = ProjectTransaction::default();
-        for (buffer, buffer_abs_path) in &buffers_with_paths {
-            let (primary_adapter_and_server, adapters_and_servers) =
-                project.update(&mut cx, |project, cx| {
-                    let buffer = buffer.read(cx);
-
-                    let adapters_and_servers = project
-                        .language_servers_for_buffer(buffer, cx)
-                        .map(|(adapter, lsp)| (adapter.clone(), lsp.clone()))
-                        .collect::<Vec<_>>();
-
-                    let primary_adapter = project
-                        .lsp_store
-                        .read(cx)
-                        .primary_language_server_for_buffer(buffer, cx)
-                        .map(|(adapter, lsp)| (adapter.clone(), lsp.clone()));
-
-                    (primary_adapter, adapters_and_servers)
-                })?;
-
-            let settings = buffer.update(&mut cx, |buffer, cx| {
-                language_settings(buffer.language(), buffer.file(), cx).clone()
-            })?;
-
-            let remove_trailing_whitespace = settings.remove_trailing_whitespace_on_save;
-            let ensure_final_newline = settings.ensure_final_newline_on_save;
-
-            // First, format buffer's whitespace according to the settings.
-            let trailing_whitespace_diff = if remove_trailing_whitespace {
-                Some(
-                    buffer
-                        .update(&mut cx, |b, cx| b.remove_trailing_whitespace(cx))?
-                        .await,
-                )
-            } else {
-                None
-            };
-            let whitespace_transaction_id = buffer.update(&mut cx, |buffer, cx| {
-                buffer.finalize_last_transaction();
-                buffer.start_transaction();
-                if let Some(diff) = trailing_whitespace_diff {
-                    buffer.apply_diff(diff, cx);
-                }
-                if ensure_final_newline {
-                    buffer.ensure_final_newline(cx);
-                }
-                buffer.end_transaction(cx)
-            })?;
-
-            // Apply the `code_actions_on_format` before we run the formatter.
-            let code_actions = deserialize_code_actions(&settings.code_actions_on_format);
-            #[allow(clippy::nonminimal_bool)]
-            if !code_actions.is_empty()
-                && !(trigger == FormatTrigger::Save && settings.format_on_save == FormatOnSave::Off)
-            {
-                LspStore::execute_code_actions_on_servers(
-                    &lsp_store,
-                    &adapters_and_servers,
-                    code_actions,
-                    buffer,
-                    push_to_history,
-                    &mut project_transaction,
-                    &mut cx,
-                )
-                .await?;
-            }
-
-            // Apply language-specific formatting using either the primary language server
-            // or external command.
-            // Except for code actions, which are applied with all connected language servers.
-            let primary_language_server =
-                primary_adapter_and_server.map(|(_adapter, server)| server.clone());
-            let server_and_buffer = primary_language_server
-                .as_ref()
-                .zip(buffer_abs_path.as_ref());
-
-            let prettier_settings = buffer.read_with(&cx, |buffer, cx| {
-                language_settings(buffer.language(), buffer.file(), cx)
-                    .prettier
-                    .clone()
-            })?;
-
-            let mut format_operations: Vec<FormatOperation> = vec![];
-            {
-                match trigger {
-                    FormatTrigger::Save => {
-                        match &settings.format_on_save {
-                            FormatOnSave::Off => {
-                                // nothing
-                            }
-                            FormatOnSave::On => {
-                                match &settings.formatter {
-                                    SelectedFormatter::Auto => {
-                                        // do the auto-format: prefer prettier, fallback to primary language server
-                                        let diff = {
-                                            if prettier_settings.allowed {
-                                                Self::perform_format(
-                                                    &Formatter::Prettier,
-                                                    server_and_buffer,
-                                                    project.clone(),
-                                                    buffer,
-                                                    buffer_abs_path,
-                                                    &settings,
-                                                    &adapters_and_servers,
-                                                    push_to_history,
-                                                    &mut project_transaction,
-                                                    &mut cx,
-                                                )
-                                                .await
-                                            } else {
-                                                Self::perform_format(
-                                                    &Formatter::LanguageServer { name: None },
-                                                    server_and_buffer,
-                                                    project.clone(),
-                                                    buffer,
-                                                    buffer_abs_path,
-                                                    &settings,
-                                                    &adapters_and_servers,
-                                                    push_to_history,
-                                                    &mut project_transaction,
-                                                    &mut cx,
-                                                )
-                                                .await
-                                            }
-                                        }
-                                        .log_err()
-                                        .flatten();
-                                        if let Some(op) = diff {
-                                            format_operations.push(op);
-                                        }
-                                    }
-                                    SelectedFormatter::List(formatters) => {
-                                        for formatter in formatters.as_ref() {
-                                            let diff = Self::perform_format(
-                                                formatter,
-                                                server_and_buffer,
-                                                project.clone(),
-                                                buffer,
-                                                buffer_abs_path,
-                                                &settings,
-                                                &adapters_and_servers,
-                                                push_to_history,
-                                                &mut project_transaction,
-                                                &mut cx,
-                                            )
-                                            .await
-                                            .log_err()
-                                            .flatten();
-                                            if let Some(op) = diff {
-                                                format_operations.push(op);
-                                            }
-
-                                            // format with formatter
-                                        }
-                                    }
-                                }
-                            }
-                            FormatOnSave::List(formatters) => {
-                                for formatter in formatters.as_ref() {
-                                    let diff = Self::perform_format(
-                                        formatter,
-                                        server_and_buffer,
-                                        project.clone(),
-                                        buffer,
-                                        buffer_abs_path,
-                                        &settings,
-                                        &adapters_and_servers,
-                                        push_to_history,
-                                        &mut project_transaction,
-                                        &mut cx,
-                                    )
-                                    .await
-                                    .log_err()
-                                    .flatten();
-                                    if let Some(op) = diff {
-                                        format_operations.push(op);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    FormatTrigger::Manual => {
-                        match &settings.formatter {
-                            SelectedFormatter::Auto => {
-                                // do the auto-format: prefer prettier, fallback to primary language server
-                                let diff = {
-                                    if prettier_settings.allowed {
-                                        Self::perform_format(
-                                            &Formatter::Prettier,
-                                            server_and_buffer,
-                                            project.clone(),
-                                            buffer,
-                                            buffer_abs_path,
-                                            &settings,
-                                            &adapters_and_servers,
-                                            push_to_history,
-                                            &mut project_transaction,
-                                            &mut cx,
-                                        )
-                                        .await
-                                    } else {
-                                        Self::perform_format(
-                                            &Formatter::LanguageServer { name: None },
-                                            server_and_buffer,
-                                            project.clone(),
-                                            buffer,
-                                            buffer_abs_path,
-                                            &settings,
-                                            &adapters_and_servers,
-                                            push_to_history,
-                                            &mut project_transaction,
-                                            &mut cx,
-                                        )
-                                        .await
-                                    }
-                                }
-                                .log_err()
-                                .flatten();
-
-                                if let Some(op) = diff {
-                                    format_operations.push(op)
-                                }
-                            }
-                            SelectedFormatter::List(formatters) => {
-                                for formatter in formatters.as_ref() {
-                                    // format with formatter
-                                    let diff = Self::perform_format(
-                                        formatter,
-                                        server_and_buffer,
-                                        project.clone(),
-                                        buffer,
-                                        buffer_abs_path,
-                                        &settings,
-                                        &adapters_and_servers,
-                                        push_to_history,
-                                        &mut project_transaction,
-                                        &mut cx,
-                                    )
-                                    .await
-                                    .log_err()
-                                    .flatten();
-                                    if let Some(op) = diff {
-                                        format_operations.push(op);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            buffer.update(&mut cx, |b, cx| {
-                // If the buffer had its whitespace formatted and was edited while the language-specific
-                // formatting was being computed, avoid applying the language-specific formatting, because
-                // it can't be grouped with the whitespace formatting in the undo history.
-                if let Some(transaction_id) = whitespace_transaction_id {
-                    if b.peek_undo_stack()
-                        .map_or(true, |e| e.transaction_id() != transaction_id)
-                    {
-                        format_operations.clear();
-                    }
-                }
-
-                // Apply any language-specific formatting, and group the two formatting operations
-                // in the buffer's undo history.
-                for operation in format_operations {
-                    match operation {
-                        FormatOperation::Lsp(edits) => {
-                            b.edit(edits, None, cx);
-                        }
-                        FormatOperation::External(diff) => {
-                            b.apply_diff(diff, cx);
-                        }
-                        FormatOperation::Prettier(diff) => {
-                            b.apply_diff(diff, cx);
-                        }
-                    }
-
-                    if let Some(transaction_id) = whitespace_transaction_id {
-                        b.group_until_transaction(transaction_id);
-                    } else if let Some(transaction) = project_transaction.0.get(buffer) {
-                        b.group_until_transaction(transaction.id)
-                    }
-                }
-
-                if let Some(transaction) = b.finalize_last_transaction().cloned() {
-                    if !push_to_history {
-                        b.forget_transaction(transaction.id);
-                    }
-                    project_transaction.0.insert(buffer.clone(), transaction);
-                }
-            })?;
-        }
-
-        Ok(project_transaction)
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    async fn perform_format(
-        formatter: &Formatter,
-        primary_server_and_buffer: Option<(&Arc<LanguageServer>, &PathBuf)>,
-        project: WeakModel<Project>,
-        buffer: &Model<Buffer>,
-        buffer_abs_path: &Option<PathBuf>,
-        settings: &LanguageSettings,
-        adapters_and_servers: &[(Arc<CachedLspAdapter>, Arc<LanguageServer>)],
-        push_to_history: bool,
-        transaction: &mut ProjectTransaction,
-        cx: &mut AsyncAppContext,
-    ) -> Result<Option<FormatOperation>, anyhow::Error> {
-        let result = match formatter {
-            Formatter::LanguageServer { name } => {
-                if let Some((language_server, buffer_abs_path)) = primary_server_and_buffer {
-                    let language_server = if let Some(name) = name {
-                        adapters_and_servers
-                            .iter()
-                            .find_map(|(adapter, server)| {
-                                adapter.name.0.as_ref().eq(name.as_str()).then_some(server)
-                            })
-                            .unwrap_or(language_server)
-                    } else {
-                        language_server
-                    };
-
-                    let lsp_store = project.update(cx, |p, _| p.lsp_store.downgrade())?;
-                    Some(FormatOperation::Lsp(
-                        LspStore::format_via_lsp(
-                            &lsp_store,
-                            buffer,
-                            buffer_abs_path,
-                            language_server,
-                            settings,
-                            cx,
-                        )
-                        .await
-                        .context("failed to format via language server")?,
-                    ))
-                } else {
-                    None
-                }
-            }
-            Formatter::Prettier => {
-                let prettier = project.update(cx, |project, cx| {
-                    project
-                        .lsp_store
-                        .read(cx)
-                        .prettier_store()
-                        .unwrap()
-                        .downgrade()
-                })?;
-                prettier_store::format_with_prettier(&prettier, buffer, cx)
-                    .await
-                    .transpose()
-                    .ok()
-                    .flatten()
-            }
-            Formatter::External { command, arguments } => {
-                let buffer_abs_path = buffer_abs_path.as_ref().map(|path| path.as_path());
-                Self::format_via_external_command(buffer, buffer_abs_path, command, arguments, cx)
-                    .await
-                    .context(format!(
-                        "failed to format via external command {:?}",
-                        command
-                    ))?
-                    .map(FormatOperation::External)
-            }
-            Formatter::CodeActions(code_actions) => {
-                let code_actions = deserialize_code_actions(code_actions);
-                let lsp_store = project.update(cx, |p, _| p.lsp_store.downgrade())?;
-                if !code_actions.is_empty() {
-                    LspStore::execute_code_actions_on_servers(
-                        &lsp_store,
-                        adapters_and_servers,
-                        code_actions,
-                        buffer,
-                        push_to_history,
-                        transaction,
-                        cx,
-                    )
-                    .await?;
-                }
-                None
-            }
-        };
-        anyhow::Ok(result)
-    }
-
-    async fn format_via_external_command(
-        buffer: &Model<Buffer>,
-        buffer_abs_path: Option<&Path>,
-        command: &str,
-        arguments: &[String],
-        cx: &mut AsyncAppContext,
-    ) -> Result<Option<Diff>> {
-        let working_dir_path = buffer.update(cx, |buffer, cx| {
-            let file = File::from_dyn(buffer.file())?;
-            let worktree = file.worktree.read(cx);
-            let mut worktree_path = worktree.abs_path().to_path_buf();
-            if worktree.root_entry()?.is_file() {
-                worktree_path.pop();
-            }
-            Some(worktree_path)
-        })?;
-
-        let mut child = smol::process::Command::new(command);
-        #[cfg(target_os = "windows")]
-        {
-            use smol::process::windows::CommandExt;
-            child.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
-        }
-
-        if let Some(working_dir_path) = working_dir_path {
-            child.current_dir(working_dir_path);
-        }
-
-        let mut child = child
-            .args(arguments.iter().map(|arg| {
-                if let Some(buffer_abs_path) = buffer_abs_path {
-                    arg.replace("{buffer_path}", &buffer_abs_path.to_string_lossy())
-                } else {
-                    arg.replace("{buffer_path}", "Untitled")
-                }
-            }))
-            .stdin(smol::process::Stdio::piped())
-            .stdout(smol::process::Stdio::piped())
-            .stderr(smol::process::Stdio::piped())
-            .spawn()?;
-
-        let stdin = child
-            .stdin
-            .as_mut()
-            .ok_or_else(|| anyhow!("failed to acquire stdin"))?;
-        let text = buffer.update(cx, |buffer, _| buffer.as_rope().clone())?;
-        for chunk in text.chunks() {
-            stdin.write_all(chunk.as_bytes()).await?;
-        }
-        stdin.flush().await?;
-
-        let output = child.output().await?;
-        if !output.status.success() {
-            return Err(anyhow!(
-                "command failed with exit code {:?}:\nstdout: {}\nstderr: {}",
-                output.status.code(),
-                String::from_utf8_lossy(&output.stdout),
-                String::from_utf8_lossy(&output.stderr),
-            ));
-        }
-
-        let stdout = String::from_utf8(output.stdout)?;
-        Ok(Some(
-            buffer
-                .update(cx, |buffer, cx| buffer.diff(stdout, cx))?
-                .await,
-        ))
+        self.lsp_store.update(cx, |lsp_store, cx| {
+            lsp_store.format(buffers, push_to_history, trigger, cx)
+        })
     }
 
     #[inline(never)]
@@ -4210,31 +3624,6 @@ impl Project {
         Ok(response)
     }
 
-    async fn handle_format_buffers(
-        this: Model<Self>,
-        envelope: TypedEnvelope<proto::FormatBuffers>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::FormatBuffersResponse> {
-        let sender_id = envelope.original_sender_id()?;
-        let format = this.update(&mut cx, |this, cx| {
-            let mut buffers = HashSet::default();
-            for buffer_id in &envelope.payload.buffer_ids {
-                let buffer_id = BufferId::new(*buffer_id)?;
-                buffers.insert(this.buffer_store.read(cx).get_existing(buffer_id)?);
-            }
-            let trigger = FormatTrigger::from_proto(envelope.payload.trigger);
-            Ok::<_, anyhow::Error>(this.format(buffers, false, trigger, cx))
-        })??;
-
-        let project_transaction = format.await?;
-        let project_transaction = this.update(&mut cx, |this, cx| {
-            this.serialize_project_transaction_for_peer(project_transaction, sender_id, cx)
-        })?;
-        Ok(proto::FormatBuffersResponse {
-            transaction: Some(project_transaction),
-        })
-    }
-
     async fn handle_task_context_for_location(
         project: Model<Self>,
         envelope: TypedEnvelope<proto::TaskContextForLocation>,
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index a7d2e6766c2330..9e58caa2442439 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -4,7 +4,7 @@ use futures::{future, StreamExt};
 use gpui::{AppContext, SemanticVersion, UpdateGlobal};
 use http_client::Url;
 use language::{
-    language_settings::{AllLanguageSettings, LanguageSettingsContent},
+    language_settings::{language_settings, AllLanguageSettings, LanguageSettingsContent},
     tree_sitter_rust, tree_sitter_typescript, Diagnostic, DiagnosticSet, FakeLspAdapter,
     LanguageConfig, LanguageMatcher, LanguageName, LineEnding, OffsetRangeExt, Point, ToPoint,
 };

From 3ba071b993099cdd9365f2223dd41fabf26df266 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Mon, 23 Sep 2024 15:28:04 -0600
Subject: [PATCH 282/762] Allow using system node (#18172)

Release Notes:

- (Potentially breaking change) Zed will now use the node installed on
your $PATH (if it is more recent than v18) instead of downloading its
own. You can disable the new behavior with `{"node":
{"disable_path_lookup": true}}` in your settings. We do not yet use
system/project-local node_modules.

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 Cargo.lock                                    |   4 +
 assets/settings/default.json                  |  15 +
 crates/collab/src/tests/test_server.rs        |   6 +-
 crates/copilot/src/copilot.rs                 |  12 +-
 crates/evals/src/eval.rs                      |   4 +-
 crates/extension/src/extension_store.rs       |   4 +-
 crates/extension/src/extension_store_test.rs  |   6 +-
 crates/extension/src/wasm_host.rs             |   4 +-
 crates/headless/src/headless.rs               |   2 +-
 crates/http_client/src/http_client.rs         |  29 +
 crates/language/src/language.rs               |   1 +
 crates/languages/src/css.rs                   |  10 +-
 crates/languages/src/json.rs                  |  10 +-
 crates/languages/src/lib.rs                   |   6 +-
 crates/languages/src/python.rs                |  10 +-
 crates/languages/src/tailwind.rs              |  10 +-
 crates/languages/src/typescript.rs            |  24 +-
 crates/languages/src/vtsls.rs                 |  10 +-
 crates/languages/src/yaml.rs                  |  10 +-
 crates/markdown/examples/markdown.rs          |   4 +-
 crates/markdown/examples/markdown_as_child.rs |   4 +-
 crates/node_runtime/Cargo.toml                |   2 +
 crates/node_runtime/src/node_runtime.rs       | 646 +++++++++++-------
 crates/prettier/src/prettier.rs               |   4 +-
 crates/project/src/lsp_store.rs               |  33 +-
 crates/project/src/prettier_store.rs          |  18 +-
 crates/project/src/project.rs                 |  12 +-
 crates/project/src/project_settings.rs        |  15 +
 crates/remote_server/src/headless_project.rs  |   4 +-
 .../remote_server/src/remote_editing_tests.rs |   4 +-
 crates/workspace/src/workspace.rs             |  10 +-
 crates/zed/Cargo.toml                         |   2 +
 crates/zed/src/main.rs                        |  32 +-
 crates/zed/src/zed.rs                         |   2 +-
 34 files changed, 596 insertions(+), 373 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e345736295613b..894dd00f6d7f79 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7190,6 +7190,7 @@ dependencies = [
  "async-std",
  "async-tar",
  "async-trait",
+ "async-watch",
  "async_zip",
  "futures 0.3.30",
  "http_client",
@@ -7202,6 +7203,7 @@ dependencies = [
  "tempfile",
  "util",
  "walkdir",
+ "which 6.0.3",
  "windows 0.58.0",
 ]
 
@@ -14393,6 +14395,7 @@ dependencies = [
  "ashpd",
  "assets",
  "assistant",
+ "async-watch",
  "audio",
  "auto_update",
  "backtrace",
@@ -14466,6 +14469,7 @@ dependencies = [
  "session",
  "settings",
  "settings_ui",
+ "shellexpand 2.1.2",
  "simplelog",
  "smol",
  "snippet_provider",
diff --git a/assets/settings/default.json b/assets/settings/default.json
index e04ab90f217cdf..3e8d3c8c70dd7d 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -771,6 +771,21 @@
       "pyrightconfig.json"
     ]
   },
+  /// By default use a recent system version of node, or install our own.
+  /// You can override this to use a version of node that is not in $PATH with:
+  /// {
+  ///   "node": {
+  ///     "node_path": "/path/to/node"
+  ///     "npm_path": "/path/to/npm" (defaults to node_path/../npm)
+  ///   }
+  /// }
+  /// or to ensure Zed always downloads and installs an isolated version of node:
+  /// {
+  ///   "node": {
+  ///     "disable_path_lookup": true
+  ///   }
+  /// NOTE: changing this setting currently requires restarting Zed.
+  "node": {},
   // The extensions that Zed should automatically install on startup.
   //
   // If you don't want any of these extensions, add this field to your settings
diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs
index 1421e4c7f7aed7..6f07d76b0b26b0 100644
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -21,7 +21,7 @@ use git::GitHostingProviderRegistry;
 use gpui::{BackgroundExecutor, Context, Model, Task, TestAppContext, View, VisualTestContext};
 use http_client::FakeHttpClient;
 use language::LanguageRegistry;
-use node_runtime::FakeNodeRuntime;
+use node_runtime::NodeRuntime;
 use notifications::NotificationStore;
 use parking_lot::Mutex;
 use project::{Project, WorktreeId};
@@ -278,7 +278,7 @@ impl TestServer {
             languages: language_registry,
             fs: fs.clone(),
             build_window_options: |_, _| Default::default(),
-            node_runtime: FakeNodeRuntime::new(),
+            node_runtime: NodeRuntime::unavailable(),
             session,
         });
 
@@ -408,7 +408,7 @@ impl TestServer {
             languages: language_registry,
             fs: fs.clone(),
             build_window_options: |_, _| Default::default(),
-            node_runtime: FakeNodeRuntime::new(),
+            node_runtime: NodeRuntime::unavailable(),
             session,
         });
 
diff --git a/crates/copilot/src/copilot.rs b/crates/copilot/src/copilot.rs
index cdbe65ba1dcca1..a1fd7a9bb96683 100644
--- a/crates/copilot/src/copilot.rs
+++ b/crates/copilot/src/copilot.rs
@@ -57,7 +57,7 @@ pub fn init(
     new_server_id: LanguageServerId,
     fs: Arc<dyn Fs>,
     http: Arc<dyn HttpClient>,
-    node_runtime: Arc<dyn NodeRuntime>,
+    node_runtime: NodeRuntime,
     cx: &mut AppContext,
 ) {
     copilot_chat::init(fs, http.clone(), cx);
@@ -302,7 +302,7 @@ pub struct Completion {
 
 pub struct Copilot {
     http: Arc<dyn HttpClient>,
-    node_runtime: Arc<dyn NodeRuntime>,
+    node_runtime: NodeRuntime,
     server: CopilotServer,
     buffers: HashSet<WeakModel<Buffer>>,
     server_id: LanguageServerId,
@@ -334,7 +334,7 @@ impl Copilot {
     fn start(
         new_server_id: LanguageServerId,
         http: Arc<dyn HttpClient>,
-        node_runtime: Arc<dyn NodeRuntime>,
+        node_runtime: NodeRuntime,
         cx: &mut ModelContext<Self>,
     ) -> Self {
         let mut this = Self {
@@ -392,7 +392,7 @@ impl Copilot {
     #[cfg(any(test, feature = "test-support"))]
     pub fn fake(cx: &mut gpui::TestAppContext) -> (Model<Self>, lsp::FakeLanguageServer) {
         use lsp::FakeLanguageServer;
-        use node_runtime::FakeNodeRuntime;
+        use node_runtime::NodeRuntime;
 
         let (server, fake_server) = FakeLanguageServer::new(
             LanguageServerId(0),
@@ -406,7 +406,7 @@ impl Copilot {
             cx.to_async(),
         );
         let http = http_client::FakeHttpClient::create(|_| async { unreachable!() });
-        let node_runtime = FakeNodeRuntime::new();
+        let node_runtime = NodeRuntime::unavailable();
         let this = cx.new_model(|cx| Self {
             server_id: LanguageServerId(0),
             http: http.clone(),
@@ -425,7 +425,7 @@ impl Copilot {
     async fn start_language_server(
         new_server_id: LanguageServerId,
         http: Arc<dyn HttpClient>,
-        node_runtime: Arc<dyn NodeRuntime>,
+        node_runtime: NodeRuntime,
         this: WeakModel<Self>,
         mut cx: AsyncAppContext,
     ) {
diff --git a/crates/evals/src/eval.rs b/crates/evals/src/eval.rs
index e2c8b42644a31d..899d8210537111 100644
--- a/crates/evals/src/eval.rs
+++ b/crates/evals/src/eval.rs
@@ -9,7 +9,7 @@ use git::GitHostingProviderRegistry;
 use gpui::{AsyncAppContext, BackgroundExecutor, Context, Model};
 use http_client::{HttpClient, Method};
 use language::LanguageRegistry;
-use node_runtime::FakeNodeRuntime;
+use node_runtime::NodeRuntime;
 use open_ai::OpenAiEmbeddingModel;
 use project::Project;
 use semantic_index::{
@@ -292,7 +292,7 @@ async fn run_evaluation(
     let user_store = cx
         .new_model(|cx| UserStore::new(client.clone(), cx))
         .unwrap();
-    let node_runtime = Arc::new(FakeNodeRuntime {});
+    let node_runtime = NodeRuntime::unavailable();
 
     let evaluations = fs::read(&evaluations_path).expect("failed to read evaluations.json");
     let evaluations: Vec<EvaluationProject> = serde_json::from_slice(&evaluations).unwrap();
diff --git a/crates/extension/src/extension_store.rs b/crates/extension/src/extension_store.rs
index 8dbd618a25784b..5f9fbffb11b2ec 100644
--- a/crates/extension/src/extension_store.rs
+++ b/crates/extension/src/extension_store.rs
@@ -177,7 +177,7 @@ actions!(zed, [ReloadExtensions]);
 pub fn init(
     fs: Arc<dyn Fs>,
     client: Arc<Client>,
-    node_runtime: Arc<dyn NodeRuntime>,
+    node_runtime: NodeRuntime,
     language_registry: Arc<LanguageRegistry>,
     theme_registry: Arc<ThemeRegistry>,
     cx: &mut AppContext,
@@ -228,7 +228,7 @@ impl ExtensionStore {
         http_client: Arc<HttpClientWithUrl>,
         builder_client: Arc<dyn HttpClient>,
         telemetry: Option<Arc<Telemetry>>,
-        node_runtime: Arc<dyn NodeRuntime>,
+        node_runtime: NodeRuntime,
         language_registry: Arc<LanguageRegistry>,
         theme_registry: Arc<ThemeRegistry>,
         slash_command_registry: Arc<SlashCommandRegistry>,
diff --git a/crates/extension/src/extension_store_test.rs b/crates/extension/src/extension_store_test.rs
index 4bdafaa32c2aff..126e6b2cfbdad0 100644
--- a/crates/extension/src/extension_store_test.rs
+++ b/crates/extension/src/extension_store_test.rs
@@ -15,7 +15,7 @@ use http_client::{FakeHttpClient, Response};
 use indexed_docs::IndexedDocsRegistry;
 use isahc_http_client::IsahcHttpClient;
 use language::{LanguageMatcher, LanguageRegistry, LanguageServerBinaryStatus, LanguageServerName};
-use node_runtime::FakeNodeRuntime;
+use node_runtime::NodeRuntime;
 use parking_lot::Mutex;
 use project::{Project, DEFAULT_COMPLETION_CONTEXT};
 use release_channel::AppVersion;
@@ -264,7 +264,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
     let slash_command_registry = SlashCommandRegistry::new();
     let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
     let snippet_registry = Arc::new(SnippetRegistry::new());
-    let node_runtime = FakeNodeRuntime::new();
+    let node_runtime = NodeRuntime::unavailable();
 
     let store = cx.new_model(|cx| {
         ExtensionStore::new(
@@ -490,7 +490,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
     let slash_command_registry = SlashCommandRegistry::new();
     let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
     let snippet_registry = Arc::new(SnippetRegistry::new());
-    let node_runtime = FakeNodeRuntime::new();
+    let node_runtime = NodeRuntime::unavailable();
 
     let mut status_updates = language_registry.language_server_binary_statuses();
 
diff --git a/crates/extension/src/wasm_host.rs b/crates/extension/src/wasm_host.rs
index 039f2d923b0d2f..b3fd13a5bada34 100644
--- a/crates/extension/src/wasm_host.rs
+++ b/crates/extension/src/wasm_host.rs
@@ -33,7 +33,7 @@ pub(crate) struct WasmHost {
     engine: Engine,
     release_channel: ReleaseChannel,
     http_client: Arc<dyn HttpClient>,
-    node_runtime: Arc<dyn NodeRuntime>,
+    node_runtime: NodeRuntime,
     pub(crate) language_registry: Arc<LanguageRegistry>,
     fs: Arc<dyn Fs>,
     pub(crate) work_dir: PathBuf,
@@ -80,7 +80,7 @@ impl WasmHost {
     pub fn new(
         fs: Arc<dyn Fs>,
         http_client: Arc<dyn HttpClient>,
-        node_runtime: Arc<dyn NodeRuntime>,
+        node_runtime: NodeRuntime,
         language_registry: Arc<LanguageRegistry>,
         work_dir: PathBuf,
         cx: &mut AppContext,
diff --git a/crates/headless/src/headless.rs b/crates/headless/src/headless.rs
index a5504500da0177..1405577643606a 100644
--- a/crates/headless/src/headless.rs
+++ b/crates/headless/src/headless.rs
@@ -25,7 +25,7 @@ pub struct DevServer {
 }
 
 pub struct AppState {
-    pub node_runtime: Arc<dyn NodeRuntime>,
+    pub node_runtime: NodeRuntime,
     pub user_store: Model<UserStore>,
     pub languages: Arc<LanguageRegistry>,
     pub fs: Arc<dyn Fs>,
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index d78b2dd23c7f7f..c0630151519c5a 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -264,6 +264,35 @@ pub fn read_proxy_from_env() -> Option<Uri> {
     None
 }
 
+pub struct BlockedHttpClient;
+
+impl HttpClient for BlockedHttpClient {
+    fn send(
+        &self,
+        _req: Request<AsyncBody>,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
+        Box::pin(async {
+            Err(std::io::Error::new(
+                std::io::ErrorKind::PermissionDenied,
+                "BlockedHttpClient disallowed request",
+            )
+            .into())
+        })
+    }
+
+    fn proxy(&self) -> Option<&Uri> {
+        None
+    }
+
+    fn send_with_redirect_policy(
+        &self,
+        req: Request<AsyncBody>,
+        _: bool,
+    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
+        self.send(req)
+    }
+}
+
 #[cfg(feature = "test-support")]
 type FakeHttpHandler = Box<
     dyn Fn(Request<AsyncBody>) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>>
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index 29a7ac1860b0c5..166d846f86e8bc 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -564,6 +564,7 @@ async fn try_fetch_server_binary<L: LspAdapter + 'static + Send + Sync + ?Sized>
     let name = adapter.name();
     log::info!("fetching latest version of language server {:?}", name.0);
     delegate.update_status(name.clone(), LanguageServerBinaryStatus::CheckingForUpdate);
+
     let latest_version = adapter
         .fetch_latest_server_version(delegate.as_ref())
         .await?;
diff --git a/crates/languages/src/css.rs b/crates/languages/src/css.rs
index cf259d69d321a8..7b7e9ae77f06fc 100644
--- a/crates/languages/src/css.rs
+++ b/crates/languages/src/css.rs
@@ -22,11 +22,11 @@ fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
 }
 
 pub struct CssLspAdapter {
-    node: Arc<dyn NodeRuntime>,
+    node: NodeRuntime,
 }
 
 impl CssLspAdapter {
-    pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
+    pub fn new(node: NodeRuntime) -> Self {
         CssLspAdapter { node }
     }
 }
@@ -81,14 +81,14 @@ impl LspAdapter for CssLspAdapter {
         container_dir: PathBuf,
         _: &dyn LspAdapterDelegate,
     ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &*self.node).await
+        get_cached_server_binary(container_dir, &self.node).await
     }
 
     async fn installation_test_binary(
         &self,
         container_dir: PathBuf,
     ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &*self.node).await
+        get_cached_server_binary(container_dir, &self.node).await
     }
 
     async fn initialization_options(
@@ -103,7 +103,7 @@ impl LspAdapter for CssLspAdapter {
 
 async fn get_cached_server_binary(
     container_dir: PathBuf,
-    node: &dyn NodeRuntime,
+    node: &NodeRuntime,
 ) -> Option<LanguageServerBinary> {
     maybe!(async {
         let mut last_version_dir = None;
diff --git a/crates/languages/src/json.rs b/crates/languages/src/json.rs
index 6b5f74c2634b45..44cc68387676ee 100644
--- a/crates/languages/src/json.rs
+++ b/crates/languages/src/json.rs
@@ -59,13 +59,13 @@ fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
 }
 
 pub struct JsonLspAdapter {
-    node: Arc<dyn NodeRuntime>,
+    node: NodeRuntime,
     languages: Arc<LanguageRegistry>,
     workspace_config: OnceLock<Value>,
 }
 
 impl JsonLspAdapter {
-    pub fn new(node: Arc<dyn NodeRuntime>, languages: Arc<LanguageRegistry>) -> Self {
+    pub fn new(node: NodeRuntime, languages: Arc<LanguageRegistry>) -> Self {
         Self {
             node,
             languages,
@@ -183,14 +183,14 @@ impl LspAdapter for JsonLspAdapter {
         container_dir: PathBuf,
         _: &dyn LspAdapterDelegate,
     ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &*self.node).await
+        get_cached_server_binary(container_dir, &self.node).await
     }
 
     async fn installation_test_binary(
         &self,
         container_dir: PathBuf,
     ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &*self.node).await
+        get_cached_server_binary(container_dir, &self.node).await
     }
 
     async fn initialization_options(
@@ -226,7 +226,7 @@ impl LspAdapter for JsonLspAdapter {
 
 async fn get_cached_server_binary(
     container_dir: PathBuf,
-    node: &dyn NodeRuntime,
+    node: &NodeRuntime,
 ) -> Option<LanguageServerBinary> {
     maybe!(async {
         let mut last_version_dir = None;
diff --git a/crates/languages/src/lib.rs b/crates/languages/src/lib.rs
index 0a3fc71d08961d..7435ddb13196dd 100644
--- a/crates/languages/src/lib.rs
+++ b/crates/languages/src/lib.rs
@@ -30,11 +30,7 @@ mod yaml;
 #[exclude = "*.rs"]
 struct LanguageDir;
 
-pub fn init(
-    languages: Arc<LanguageRegistry>,
-    node_runtime: Arc<dyn NodeRuntime>,
-    cx: &mut AppContext,
-) {
+pub fn init(languages: Arc<LanguageRegistry>, node_runtime: NodeRuntime, cx: &mut AppContext) {
     languages.register_native_grammars([
         ("bash", tree_sitter_bash::LANGUAGE),
         ("c", tree_sitter_c::LANGUAGE),
diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs
index 0dce8fb6617616..75f124489c3820 100644
--- a/crates/languages/src/python.rs
+++ b/crates/languages/src/python.rs
@@ -26,13 +26,13 @@ fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
 }
 
 pub struct PythonLspAdapter {
-    node: Arc<dyn NodeRuntime>,
+    node: NodeRuntime,
 }
 
 impl PythonLspAdapter {
     const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("pyright");
 
-    pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
+    pub fn new(node: NodeRuntime) -> Self {
         PythonLspAdapter { node }
     }
 }
@@ -94,14 +94,14 @@ impl LspAdapter for PythonLspAdapter {
         container_dir: PathBuf,
         _: &dyn LspAdapterDelegate,
     ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &*self.node).await
+        get_cached_server_binary(container_dir, &self.node).await
     }
 
     async fn installation_test_binary(
         &self,
         container_dir: PathBuf,
     ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &*self.node).await
+        get_cached_server_binary(container_dir, &self.node).await
     }
 
     async fn process_completions(&self, items: &mut [lsp::CompletionItem]) {
@@ -198,7 +198,7 @@ impl LspAdapter for PythonLspAdapter {
 
 async fn get_cached_server_binary(
     container_dir: PathBuf,
-    node: &dyn NodeRuntime,
+    node: &NodeRuntime,
 ) -> Option<LanguageServerBinary> {
     let server_path = container_dir.join(SERVER_PATH);
     if server_path.exists() {
diff --git a/crates/languages/src/tailwind.rs b/crates/languages/src/tailwind.rs
index e3e17a8fa72eb4..62d967d6a4a267 100644
--- a/crates/languages/src/tailwind.rs
+++ b/crates/languages/src/tailwind.rs
@@ -28,14 +28,14 @@ fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
 }
 
 pub struct TailwindLspAdapter {
-    node: Arc<dyn NodeRuntime>,
+    node: NodeRuntime,
 }
 
 impl TailwindLspAdapter {
     const SERVER_NAME: LanguageServerName =
         LanguageServerName::new_static("tailwindcss-language-server");
 
-    pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
+    pub fn new(node: NodeRuntime) -> Self {
         TailwindLspAdapter { node }
     }
 }
@@ -122,14 +122,14 @@ impl LspAdapter for TailwindLspAdapter {
         container_dir: PathBuf,
         _: &dyn LspAdapterDelegate,
     ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &*self.node).await
+        get_cached_server_binary(container_dir, &self.node).await
     }
 
     async fn installation_test_binary(
         &self,
         container_dir: PathBuf,
     ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &*self.node).await
+        get_cached_server_binary(container_dir, &self.node).await
     }
 
     async fn initialization_options(
@@ -198,7 +198,7 @@ impl LspAdapter for TailwindLspAdapter {
 
 async fn get_cached_server_binary(
     container_dir: PathBuf,
-    node: &dyn NodeRuntime,
+    node: &NodeRuntime,
 ) -> Option<LanguageServerBinary> {
     maybe!(async {
         let mut last_version_dir = None;
diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs
index b09216c9703698..25a97c8014d0a1 100644
--- a/crates/languages/src/typescript.rs
+++ b/crates/languages/src/typescript.rs
@@ -65,7 +65,7 @@ fn eslint_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
 }
 
 pub struct TypeScriptLspAdapter {
-    node: Arc<dyn NodeRuntime>,
+    node: NodeRuntime,
 }
 
 impl TypeScriptLspAdapter {
@@ -73,7 +73,7 @@ impl TypeScriptLspAdapter {
     const NEW_SERVER_PATH: &'static str = "node_modules/typescript-language-server/lib/cli.mjs";
     const SERVER_NAME: LanguageServerName =
         LanguageServerName::new_static("typescript-language-server");
-    pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
+    pub fn new(node: NodeRuntime) -> Self {
         TypeScriptLspAdapter { node }
     }
     async fn tsdk_path(adapter: &Arc<dyn LspAdapterDelegate>) -> &'static str {
@@ -161,14 +161,14 @@ impl LspAdapter for TypeScriptLspAdapter {
         container_dir: PathBuf,
         _: &dyn LspAdapterDelegate,
     ) -> Option<LanguageServerBinary> {
-        get_cached_ts_server_binary(container_dir, &*self.node).await
+        get_cached_ts_server_binary(container_dir, &self.node).await
     }
 
     async fn installation_test_binary(
         &self,
         container_dir: PathBuf,
     ) -> Option<LanguageServerBinary> {
-        get_cached_ts_server_binary(container_dir, &*self.node).await
+        get_cached_ts_server_binary(container_dir, &self.node).await
     }
 
     fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
@@ -264,7 +264,7 @@ impl LspAdapter for TypeScriptLspAdapter {
 
 async fn get_cached_ts_server_binary(
     container_dir: PathBuf,
-    node: &dyn NodeRuntime,
+    node: &NodeRuntime,
 ) -> Option<LanguageServerBinary> {
     maybe!(async {
         let old_server_path = container_dir.join(TypeScriptLspAdapter::OLD_SERVER_PATH);
@@ -293,7 +293,7 @@ async fn get_cached_ts_server_binary(
 }
 
 pub struct EsLintLspAdapter {
-    node: Arc<dyn NodeRuntime>,
+    node: NodeRuntime,
 }
 
 impl EsLintLspAdapter {
@@ -310,7 +310,7 @@ impl EsLintLspAdapter {
     const FLAT_CONFIG_FILE_NAMES: &'static [&'static str] =
         &["eslint.config.js", "eslint.config.mjs", "eslint.config.cjs"];
 
-    pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
+    pub fn new(node: NodeRuntime) -> Self {
         EsLintLspAdapter { node }
     }
 }
@@ -476,11 +476,11 @@ impl LspAdapter for EsLintLspAdapter {
             }
 
             self.node
-                .run_npm_subcommand(Some(&repo_root), "install", &[])
+                .run_npm_subcommand(&repo_root, "install", &[])
                 .await?;
 
             self.node
-                .run_npm_subcommand(Some(&repo_root), "run-script", &["compile"])
+                .run_npm_subcommand(&repo_root, "run-script", &["compile"])
                 .await?;
         }
 
@@ -496,20 +496,20 @@ impl LspAdapter for EsLintLspAdapter {
         container_dir: PathBuf,
         _: &dyn LspAdapterDelegate,
     ) -> Option<LanguageServerBinary> {
-        get_cached_eslint_server_binary(container_dir, &*self.node).await
+        get_cached_eslint_server_binary(container_dir, &self.node).await
     }
 
     async fn installation_test_binary(
         &self,
         container_dir: PathBuf,
     ) -> Option<LanguageServerBinary> {
-        get_cached_eslint_server_binary(container_dir, &*self.node).await
+        get_cached_eslint_server_binary(container_dir, &self.node).await
     }
 }
 
 async fn get_cached_eslint_server_binary(
     container_dir: PathBuf,
-    node: &dyn NodeRuntime,
+    node: &NodeRuntime,
 ) -> Option<LanguageServerBinary> {
     maybe!(async {
         // This is unfortunate but we don't know what the version is to build a path directly
diff --git a/crates/languages/src/vtsls.rs b/crates/languages/src/vtsls.rs
index 5ec31213840bb1..3c1cf0fcbe151b 100644
--- a/crates/languages/src/vtsls.rs
+++ b/crates/languages/src/vtsls.rs
@@ -20,13 +20,13 @@ fn typescript_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
 }
 
 pub struct VtslsLspAdapter {
-    node: Arc<dyn NodeRuntime>,
+    node: NodeRuntime,
 }
 
 impl VtslsLspAdapter {
     const SERVER_PATH: &'static str = "node_modules/@vtsls/language-server/bin/vtsls.js";
 
-    pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
+    pub fn new(node: NodeRuntime) -> Self {
         VtslsLspAdapter { node }
     }
     async fn tsdk_path(adapter: &Arc<dyn LspAdapterDelegate>) -> &'static str {
@@ -154,14 +154,14 @@ impl LspAdapter for VtslsLspAdapter {
         container_dir: PathBuf,
         _: &dyn LspAdapterDelegate,
     ) -> Option<LanguageServerBinary> {
-        get_cached_ts_server_binary(container_dir, &*self.node).await
+        get_cached_ts_server_binary(container_dir, &self.node).await
     }
 
     async fn installation_test_binary(
         &self,
         container_dir: PathBuf,
     ) -> Option<LanguageServerBinary> {
-        get_cached_ts_server_binary(container_dir, &*self.node).await
+        get_cached_ts_server_binary(container_dir, &self.node).await
     }
 
     fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
@@ -298,7 +298,7 @@ impl LspAdapter for VtslsLspAdapter {
 
 async fn get_cached_ts_server_binary(
     container_dir: PathBuf,
-    node: &dyn NodeRuntime,
+    node: &NodeRuntime,
 ) -> Option<LanguageServerBinary> {
     maybe!(async {
         let server_path = container_dir.join(VtslsLspAdapter::SERVER_PATH);
diff --git a/crates/languages/src/yaml.rs b/crates/languages/src/yaml.rs
index 583961f4b1c0e9..32ca73168ab2d2 100644
--- a/crates/languages/src/yaml.rs
+++ b/crates/languages/src/yaml.rs
@@ -26,12 +26,12 @@ fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
 }
 
 pub struct YamlLspAdapter {
-    node: Arc<dyn NodeRuntime>,
+    node: NodeRuntime,
 }
 
 impl YamlLspAdapter {
     const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("yaml-language-server");
-    pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
+    pub fn new(node: NodeRuntime) -> Self {
         YamlLspAdapter { node }
     }
 }
@@ -117,14 +117,14 @@ impl LspAdapter for YamlLspAdapter {
         container_dir: PathBuf,
         _: &dyn LspAdapterDelegate,
     ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &*self.node).await
+        get_cached_server_binary(container_dir, &self.node).await
     }
 
     async fn installation_test_binary(
         &self,
         container_dir: PathBuf,
     ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &*self.node).await
+        get_cached_server_binary(container_dir, &self.node).await
     }
 
     async fn workspace_configuration(
@@ -157,7 +157,7 @@ impl LspAdapter for YamlLspAdapter {
 
 async fn get_cached_server_binary(
     container_dir: PathBuf,
-    node: &dyn NodeRuntime,
+    node: &NodeRuntime,
 ) -> Option<LanguageServerBinary> {
     maybe!(async {
         let mut last_version_dir = None;
diff --git a/crates/markdown/examples/markdown.rs b/crates/markdown/examples/markdown.rs
index c2f3ab8158609a..0514ebcf4e1e57 100644
--- a/crates/markdown/examples/markdown.rs
+++ b/crates/markdown/examples/markdown.rs
@@ -2,7 +2,7 @@ use assets::Assets;
 use gpui::{prelude::*, rgb, App, KeyBinding, StyleRefinement, View, WindowOptions};
 use language::{language_settings::AllLanguageSettings, LanguageRegistry};
 use markdown::{Markdown, MarkdownStyle};
-use node_runtime::FakeNodeRuntime;
+use node_runtime::NodeRuntime;
 use settings::SettingsStore;
 use std::sync::Arc;
 use theme::LoadThemes;
@@ -102,7 +102,7 @@ pub fn main() {
         });
         cx.bind_keys([KeyBinding::new("cmd-c", markdown::Copy, None)]);
 
-        let node_runtime = FakeNodeRuntime::new();
+        let node_runtime = NodeRuntime::unavailable();
         theme::init(LoadThemes::JustBase, cx);
 
         let language_registry = LanguageRegistry::new(cx.background_executor().clone());
diff --git a/crates/markdown/examples/markdown_as_child.rs b/crates/markdown/examples/markdown_as_child.rs
index 829e69436a6bea..3700e64364dfd8 100644
--- a/crates/markdown/examples/markdown_as_child.rs
+++ b/crates/markdown/examples/markdown_as_child.rs
@@ -2,7 +2,7 @@ use assets::Assets;
 use gpui::*;
 use language::{language_settings::AllLanguageSettings, LanguageRegistry};
 use markdown::{Markdown, MarkdownStyle};
-use node_runtime::FakeNodeRuntime;
+use node_runtime::NodeRuntime;
 use settings::SettingsStore;
 use std::sync::Arc;
 use theme::LoadThemes;
@@ -28,7 +28,7 @@ pub fn main() {
         });
         cx.bind_keys([KeyBinding::new("cmd-c", markdown::Copy, None)]);
 
-        let node_runtime = FakeNodeRuntime::new();
+        let node_runtime = NodeRuntime::unavailable();
         let language_registry = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
         languages::init(language_registry.clone(), node_runtime, cx);
         theme::init(LoadThemes::JustBase, cx);
diff --git a/crates/node_runtime/Cargo.toml b/crates/node_runtime/Cargo.toml
index b7aee583360cba..d852b7ebdf9aac 100644
--- a/crates/node_runtime/Cargo.toml
+++ b/crates/node_runtime/Cargo.toml
@@ -18,6 +18,7 @@ test-support = ["tempfile"]
 [dependencies]
 anyhow.workspace = true
 async-compression.workspace = true
+async-watch.workspace = true
 async-tar.workspace = true
 async-trait.workspace = true
 async_zip.workspace = true
@@ -32,6 +33,7 @@ smol.workspace = true
 tempfile = { workspace = true, optional = true }
 util.workspace = true
 walkdir = "2.5.0"
+which.workspace = true
 
 [target.'cfg(windows)'.dependencies]
 async-std = { version = "1.12.0", features = ["unstable"] }
diff --git a/crates/node_runtime/src/node_runtime.rs b/crates/node_runtime/src/node_runtime.rs
index 4aa65ab6db8049..72c74ce7cf9830 100644
--- a/crates/node_runtime/src/node_runtime.rs
+++ b/crates/node_runtime/src/node_runtime.rs
@@ -5,7 +5,7 @@ pub use archive::extract_zip;
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
 use futures::AsyncReadExt;
-use http_client::HttpClient;
+use http_client::{HttpClient, Uri};
 use semver::Version;
 use serde::Deserialize;
 use smol::io::BufReader;
@@ -23,60 +23,166 @@ use util::ResultExt;
 #[cfg(windows)]
 use smol::process::windows::CommandExt;
 
-const VERSION: &str = "v22.5.1";
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct NodeBinaryOptions {
+    pub allow_path_lookup: bool,
+    pub allow_binary_download: bool,
+    pub use_paths: Option<(PathBuf, PathBuf)>,
+}
 
-#[cfg(not(windows))]
-const NODE_PATH: &str = "bin/node";
-#[cfg(windows)]
-const NODE_PATH: &str = "node.exe";
+#[derive(Clone)]
+pub struct NodeRuntime(Arc<Mutex<NodeRuntimeState>>);
 
-#[cfg(not(windows))]
-const NPM_PATH: &str = "bin/npm";
-#[cfg(windows)]
-const NPM_PATH: &str = "node_modules/npm/bin/npm-cli.js";
-
-enum ArchiveType {
-    TarGz,
-    Zip,
+struct NodeRuntimeState {
+    http: Arc<dyn HttpClient>,
+    instance: Option<Box<dyn NodeRuntimeTrait>>,
+    last_options: Option<NodeBinaryOptions>,
+    options: async_watch::Receiver<Option<NodeBinaryOptions>>,
 }
 
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "kebab-case")]
-pub struct NpmInfo {
-    #[serde(default)]
-    dist_tags: NpmInfoDistTags,
-    versions: Vec<String>,
-}
+impl NodeRuntime {
+    pub fn new(
+        http: Arc<dyn HttpClient>,
+        options: async_watch::Receiver<Option<NodeBinaryOptions>>,
+    ) -> Self {
+        NodeRuntime(Arc::new(Mutex::new(NodeRuntimeState {
+            http,
+            instance: None,
+            last_options: None,
+            options,
+        })))
+    }
 
-#[derive(Debug, Deserialize, Default)]
-pub struct NpmInfoDistTags {
-    latest: Option<String>,
-}
+    pub fn unavailable() -> Self {
+        NodeRuntime(Arc::new(Mutex::new(NodeRuntimeState {
+            http: Arc::new(http_client::BlockedHttpClient),
+            instance: None,
+            last_options: None,
+            options: async_watch::channel(Some(NodeBinaryOptions::default())).1,
+        })))
+    }
 
-#[async_trait::async_trait]
-pub trait NodeRuntime: Send + Sync {
-    async fn binary_path(&self) -> Result<PathBuf>;
-    async fn node_environment_path(&self) -> Result<OsString>;
+    async fn instance(&self) -> Result<Box<dyn NodeRuntimeTrait>> {
+        let mut state = self.0.lock().await;
 
-    async fn run_npm_subcommand(
+        while state.options.borrow().is_none() {
+            state.options.changed().await?;
+        }
+        let options = state.options.borrow().clone().unwrap();
+        if state.last_options.as_ref() != Some(&options) {
+            state.instance.take();
+        }
+        if let Some(instance) = state.instance.as_ref() {
+            return Ok(instance.boxed_clone());
+        }
+
+        if let Some((node, npm)) = options.use_paths.as_ref() {
+            let instance = SystemNodeRuntime::new(node.clone(), npm.clone()).await?;
+            state.instance = Some(instance.boxed_clone());
+            return Ok(instance);
+        }
+
+        if options.allow_path_lookup {
+            if let Some(instance) = SystemNodeRuntime::detect().await {
+                state.instance = Some(instance.boxed_clone());
+                return Ok(instance);
+            }
+        }
+
+        let instance = if options.allow_binary_download {
+            ManagedNodeRuntime::install_if_needed(&state.http).await?
+        } else {
+            Box::new(UnavailableNodeRuntime)
+        };
+
+        state.instance = Some(instance.boxed_clone());
+        return Ok(instance);
+    }
+
+    pub async fn binary_path(&self) -> Result<PathBuf> {
+        self.instance().await?.binary_path()
+    }
+
+    pub async fn run_npm_subcommand(
         &self,
-        directory: Option<&Path>,
+        directory: &Path,
         subcommand: &str,
         args: &[&str],
-    ) -> Result<Output>;
-
-    async fn npm_package_latest_version(&self, name: &str) -> Result<String>;
-
-    async fn npm_install_packages(&self, directory: &Path, packages: &[(&str, &str)])
-        -> Result<()>;
+    ) -> Result<Output> {
+        let http = self.0.lock().await.http.clone();
+        self.instance()
+            .await?
+            .run_npm_subcommand(Some(directory), http.proxy(), subcommand, args)
+            .await
+    }
 
-    async fn npm_package_installed_version(
+    pub async fn npm_package_installed_version(
         &self,
         local_package_directory: &Path,
         name: &str,
-    ) -> Result<Option<String>>;
+    ) -> Result<Option<String>> {
+        self.instance()
+            .await?
+            .npm_package_installed_version(local_package_directory, name)
+            .await
+    }
 
-    async fn should_install_npm_package(
+    pub async fn npm_package_latest_version(&self, name: &str) -> Result<String> {
+        let http = self.0.lock().await.http.clone();
+        let output = self
+            .instance()
+            .await?
+            .run_npm_subcommand(
+                None,
+                http.proxy(),
+                "info",
+                &[
+                    name,
+                    "--json",
+                    "--fetch-retry-mintimeout",
+                    "2000",
+                    "--fetch-retry-maxtimeout",
+                    "5000",
+                    "--fetch-timeout",
+                    "5000",
+                ],
+            )
+            .await?;
+
+        let mut info: NpmInfo = serde_json::from_slice(&output.stdout)?;
+        info.dist_tags
+            .latest
+            .or_else(|| info.versions.pop())
+            .ok_or_else(|| anyhow!("no version found for npm package {}", name))
+    }
+
+    pub async fn npm_install_packages(
+        &self,
+        directory: &Path,
+        packages: &[(&str, &str)],
+    ) -> Result<()> {
+        let packages: Vec<_> = packages
+            .iter()
+            .map(|(name, version)| format!("{name}@{version}"))
+            .collect();
+
+        let mut arguments: Vec<_> = packages.iter().map(|p| p.as_str()).collect();
+        arguments.extend_from_slice(&[
+            "--save-exact",
+            "--fetch-retry-mintimeout",
+            "2000",
+            "--fetch-retry-maxtimeout",
+            "5000",
+            "--fetch-timeout",
+            "5000",
+        ]);
+
+        self.run_npm_subcommand(directory, "install", &arguments)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn should_install_npm_package(
         &self,
         package_name: &str,
         local_executable_path: &Path,
@@ -110,21 +216,78 @@ pub trait NodeRuntime: Send + Sync {
     }
 }
 
-pub struct RealNodeRuntime {
-    http: Arc<dyn HttpClient>,
-    installation_lock: Mutex<()>,
+enum ArchiveType {
+    TarGz,
+    Zip,
 }
 
-impl RealNodeRuntime {
-    pub fn new(http: Arc<dyn HttpClient>) -> Arc<dyn NodeRuntime> {
-        Arc::new(RealNodeRuntime {
-            http,
-            installation_lock: Mutex::new(()),
-        })
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct NpmInfo {
+    #[serde(default)]
+    dist_tags: NpmInfoDistTags,
+    versions: Vec<String>,
+}
+
+#[derive(Debug, Deserialize, Default)]
+pub struct NpmInfoDistTags {
+    latest: Option<String>,
+}
+
+#[async_trait::async_trait]
+trait NodeRuntimeTrait: Send + Sync {
+    fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait>;
+    fn binary_path(&self) -> Result<PathBuf>;
+
+    async fn run_npm_subcommand(
+        &self,
+        directory: Option<&Path>,
+        proxy: Option<&Uri>,
+        subcommand: &str,
+        args: &[&str],
+    ) -> Result<Output>;
+
+    async fn npm_package_installed_version(
+        &self,
+        local_package_directory: &Path,
+        name: &str,
+    ) -> Result<Option<String>>;
+}
+
+#[derive(Clone)]
+struct ManagedNodeRuntime {
+    installation_path: PathBuf,
+}
+
+impl ManagedNodeRuntime {
+    const VERSION: &str = "v22.5.1";
+
+    #[cfg(not(windows))]
+    const NODE_PATH: &str = "bin/node";
+    #[cfg(windows)]
+    const NODE_PATH: &str = "node.exe";
+
+    #[cfg(not(windows))]
+    const NPM_PATH: &str = "bin/npm";
+    #[cfg(windows)]
+    const NPM_PATH: &str = "node_modules/npm/bin/npm-cli.js";
+
+    async fn node_environment_path(&self) -> Result<OsString> {
+        let node_binary = self.installation_path.join(Self::NODE_PATH);
+        let mut env_path = vec![node_binary
+            .parent()
+            .expect("invalid node binary path")
+            .to_path_buf()];
+
+        if let Some(existing_path) = std::env::var_os("PATH") {
+            let mut paths = std::env::split_paths(&existing_path).collect::<Vec<_>>();
+            env_path.append(&mut paths);
+        }
+
+        std::env::join_paths(env_path).context("failed to create PATH env variable")
     }
 
-    async fn install_if_needed(&self) -> Result<PathBuf> {
-        let _lock = self.installation_lock.lock().await;
+    async fn install_if_needed(http: &Arc<dyn HttpClient>) -> Result<Box<dyn NodeRuntimeTrait>> {
         log::info!("Node runtime install_if_needed");
 
         let os = match consts::OS {
@@ -140,11 +303,12 @@ impl RealNodeRuntime {
             other => bail!("Running on unsupported architecture: {other}"),
         };
 
-        let folder_name = format!("node-{VERSION}-{os}-{arch}");
+        let version = Self::VERSION;
+        let folder_name = format!("node-{version}-{os}-{arch}");
         let node_containing_dir = paths::support_dir().join("node");
         let node_dir = node_containing_dir.join(folder_name);
-        let node_binary = node_dir.join(NODE_PATH);
-        let npm_file = node_dir.join(NPM_PATH);
+        let node_binary = node_dir.join(Self::NODE_PATH);
+        let npm_file = node_dir.join(Self::NPM_PATH);
 
         let mut command = Command::new(&node_binary);
 
@@ -177,16 +341,16 @@ impl RealNodeRuntime {
                 other => bail!("Running on unsupported os: {other}"),
             };
 
+            let version = Self::VERSION;
             let file_name = format!(
-                "node-{VERSION}-{os}-{arch}.{extension}",
+                "node-{version}-{os}-{arch}.{extension}",
                 extension = match archive_type {
                     ArchiveType::TarGz => "tar.gz",
                     ArchiveType::Zip => "zip",
                 }
             );
-            let url = format!("https://nodejs.org/dist/{VERSION}/{file_name}");
-            let mut response = self
-                .http
+            let url = format!("https://nodejs.org/dist/{version}/{file_name}");
+            let mut response = http
                 .get(&url, Default::default(), true)
                 .await
                 .context("error downloading Node binary tarball")?;
@@ -207,43 +371,32 @@ impl RealNodeRuntime {
         _ = fs::write(node_dir.join("blank_user_npmrc"), []).await;
         _ = fs::write(node_dir.join("blank_global_npmrc"), []).await;
 
-        anyhow::Ok(node_dir)
+        anyhow::Ok(Box::new(ManagedNodeRuntime {
+            installation_path: node_dir,
+        }))
     }
 }
 
 #[async_trait::async_trait]
-impl NodeRuntime for RealNodeRuntime {
-    async fn binary_path(&self) -> Result<PathBuf> {
-        let installation_path = self.install_if_needed().await?;
-        Ok(installation_path.join(NODE_PATH))
+impl NodeRuntimeTrait for ManagedNodeRuntime {
+    fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
+        Box::new(self.clone())
     }
 
-    async fn node_environment_path(&self) -> Result<OsString> {
-        let installation_path = self.install_if_needed().await?;
-        let node_binary = installation_path.join(NODE_PATH);
-        let mut env_path = vec![node_binary
-            .parent()
-            .expect("invalid node binary path")
-            .to_path_buf()];
-
-        if let Some(existing_path) = std::env::var_os("PATH") {
-            let mut paths = std::env::split_paths(&existing_path).collect::<Vec<_>>();
-            env_path.append(&mut paths);
-        }
-
-        Ok(std::env::join_paths(env_path).context("failed to create PATH env variable")?)
+    fn binary_path(&self) -> Result<PathBuf> {
+        Ok(self.installation_path.join(Self::NODE_PATH))
     }
 
     async fn run_npm_subcommand(
         &self,
         directory: Option<&Path>,
+        proxy: Option<&Uri>,
         subcommand: &str,
         args: &[&str],
     ) -> Result<Output> {
         let attempt = || async move {
-            let installation_path = self.install_if_needed().await?;
-            let node_binary = installation_path.join(NODE_PATH);
-            let npm_file = installation_path.join(NPM_PATH);
+            let node_binary = self.installation_path.join(Self::NODE_PATH);
+            let npm_file = self.installation_path.join(Self::NPM_PATH);
             let env_path = self.node_environment_path().await?;
 
             if smol::fs::metadata(&node_binary).await.is_err() {
@@ -258,54 +411,17 @@ impl NodeRuntime for RealNodeRuntime {
             command.env_clear();
             command.env("PATH", env_path);
             command.arg(npm_file).arg(subcommand);
-            command.args(["--cache".into(), installation_path.join("cache")]);
+            command.args(["--cache".into(), self.installation_path.join("cache")]);
             command.args([
                 "--userconfig".into(),
-                installation_path.join("blank_user_npmrc"),
+                self.installation_path.join("blank_user_npmrc"),
             ]);
             command.args([
                 "--globalconfig".into(),
-                installation_path.join("blank_global_npmrc"),
+                self.installation_path.join("blank_global_npmrc"),
             ]);
             command.args(args);
-
-            if let Some(directory) = directory {
-                command.current_dir(directory);
-                command.args(["--prefix".into(), directory.to_path_buf()]);
-            }
-
-            if let Some(proxy) = self.http.proxy() {
-                // Map proxy settings from `http://localhost:10809` to `http://127.0.0.1:10809`
-                // NodeRuntime without environment information can not parse `localhost`
-                // correctly.
-                // TODO: map to `[::1]` if we are using ipv6
-                let proxy = proxy
-                    .to_string()
-                    .to_ascii_lowercase()
-                    .replace("localhost", "127.0.0.1");
-
-                command.args(["--proxy", &proxy]);
-            }
-
-            #[cfg(windows)]
-            {
-                // SYSTEMROOT is a critical environment variables for Windows.
-                if let Some(val) = std::env::var("SYSTEMROOT")
-                    .context("Missing environment variable: SYSTEMROOT!")
-                    .log_err()
-                {
-                    command.env("SYSTEMROOT", val);
-                }
-                // Without ComSpec, the post-install will always fail.
-                if let Some(val) = std::env::var("ComSpec")
-                    .context("Missing environment variable: ComSpec!")
-                    .log_err()
-                {
-                    command.env("ComSpec", val);
-                }
-                command.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
-            }
-
+            configure_npm_command(&mut command, directory, proxy);
             command.output().await.map_err(|e| anyhow!("{e}"))
         };
 
@@ -332,182 +448,228 @@ impl NodeRuntime for RealNodeRuntime {
 
         output.map_err(|e| anyhow!("{e}"))
     }
-
-    async fn npm_package_latest_version(&self, name: &str) -> Result<String> {
-        let output = self
-            .run_npm_subcommand(
-                None,
-                "info",
-                &[
-                    name,
-                    "--json",
-                    "--fetch-retry-mintimeout",
-                    "2000",
-                    "--fetch-retry-maxtimeout",
-                    "5000",
-                    "--fetch-timeout",
-                    "5000",
-                ],
-            )
-            .await?;
-
-        let mut info: NpmInfo = serde_json::from_slice(&output.stdout)?;
-        info.dist_tags
-            .latest
-            .or_else(|| info.versions.pop())
-            .ok_or_else(|| anyhow!("no version found for npm package {}", name))
-    }
-
     async fn npm_package_installed_version(
         &self,
         local_package_directory: &Path,
         name: &str,
     ) -> Result<Option<String>> {
-        let mut package_json_path = local_package_directory.to_owned();
-        package_json_path.extend(["node_modules", name, "package.json"]);
-
-        let mut file = match fs::File::open(package_json_path).await {
-            Ok(file) => file,
-            Err(err) => {
-                if err.kind() == io::ErrorKind::NotFound {
-                    return Ok(None);
-                }
+        read_package_installed_version(local_package_directory.join("node_modules"), name).await
+    }
+}
 
-                Err(err)?
-            }
-        };
+#[derive(Clone)]
+pub struct SystemNodeRuntime {
+    node: PathBuf,
+    npm: PathBuf,
+    global_node_modules: PathBuf,
+    scratch_dir: PathBuf,
+}
 
-        #[derive(Deserialize)]
-        struct PackageJson {
-            version: String,
+impl SystemNodeRuntime {
+    const MIN_VERSION: semver::Version = Version::new(18, 0, 0);
+    async fn new(node: PathBuf, npm: PathBuf) -> Result<Box<dyn NodeRuntimeTrait>> {
+        let output = Command::new(&node)
+            .arg("--version")
+            .output()
+            .await
+            .with_context(|| format!("running node from {:?}", node))?;
+        if !output.status.success() {
+            anyhow::bail!(
+                "failed to run node --version. stdout: {}, stderr: {}",
+                String::from_utf8_lossy(&output.stdout),
+                String::from_utf8_lossy(&output.stderr),
+            );
+        }
+        let version_str = String::from_utf8_lossy(&output.stdout);
+        let version = semver::Version::parse(version_str.trim().trim_start_matches('v'))?;
+        if version < Self::MIN_VERSION {
+            anyhow::bail!(
+                "node at {} is too old. want: {}, got: {}",
+                node.to_string_lossy(),
+                Self::MIN_VERSION,
+                version
+            )
         }
 
-        let mut contents = String::new();
-        file.read_to_string(&mut contents).await?;
-        let package_json: PackageJson = serde_json::from_str(&contents)?;
-        Ok(Some(package_json.version))
-    }
-
-    async fn npm_install_packages(
-        &self,
-        directory: &Path,
-        packages: &[(&str, &str)],
-    ) -> Result<()> {
-        let packages: Vec<_> = packages
-            .iter()
-            .map(|(name, version)| format!("{name}@{version}"))
-            .collect();
+        let scratch_dir = paths::support_dir().join("node");
+        fs::create_dir(&scratch_dir).await.ok();
+        fs::create_dir(scratch_dir.join("cache")).await.ok();
+        fs::write(scratch_dir.join("blank_user_npmrc"), [])
+            .await
+            .ok();
+        fs::write(scratch_dir.join("blank_global_npmrc"), [])
+            .await
+            .ok();
 
-        let mut arguments: Vec<_> = packages.iter().map(|p| p.as_str()).collect();
-        arguments.extend_from_slice(&[
-            "--save-exact",
-            "--fetch-retry-mintimeout",
-            "2000",
-            "--fetch-retry-maxtimeout",
-            "5000",
-            "--fetch-timeout",
-            "5000",
-        ]);
+        let mut this = Self {
+            node,
+            npm,
+            global_node_modules: PathBuf::default(),
+            scratch_dir,
+        };
+        let output = this.run_npm_subcommand(None, None, "root", &["-g"]).await?;
+        this.global_node_modules =
+            PathBuf::from(String::from_utf8_lossy(&output.stdout).to_string());
 
-        self.run_npm_subcommand(Some(directory), "install", &arguments)
-            .await?;
-        Ok(())
+        Ok(Box::new(this))
     }
-}
-
-pub struct FakeNodeRuntime;
 
-impl FakeNodeRuntime {
-    pub fn new() -> Arc<dyn NodeRuntime> {
-        Arc::new(Self)
+    async fn detect() -> Option<Box<dyn NodeRuntimeTrait>> {
+        let node = which::which("node").ok()?;
+        let npm = which::which("npm").ok()?;
+        Self::new(node, npm).await.log_err()
     }
 }
 
 #[async_trait::async_trait]
-impl NodeRuntime for FakeNodeRuntime {
-    async fn binary_path(&self) -> anyhow::Result<PathBuf> {
-        unreachable!()
+impl NodeRuntimeTrait for SystemNodeRuntime {
+    fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
+        Box::new(self.clone())
     }
 
-    async fn node_environment_path(&self) -> anyhow::Result<OsString> {
-        unreachable!()
+    fn binary_path(&self) -> Result<PathBuf> {
+        Ok(self.node.clone())
     }
 
     async fn run_npm_subcommand(
         &self,
-        _: Option<&Path>,
+        directory: Option<&Path>,
+        proxy: Option<&Uri>,
         subcommand: &str,
         args: &[&str],
     ) -> anyhow::Result<Output> {
-        unreachable!("Should not run npm subcommand '{subcommand}' with args {args:?}")
-    }
+        let mut command = Command::new(self.node.clone());
+        command
+            .env_clear()
+            .env("PATH", std::env::var_os("PATH").unwrap_or_default())
+            .arg(self.npm.clone())
+            .arg(subcommand)
+            .args(["--cache".into(), self.scratch_dir.join("cache")])
+            .args([
+                "--userconfig".into(),
+                self.scratch_dir.join("blank_user_npmrc"),
+            ])
+            .args([
+                "--globalconfig".into(),
+                self.scratch_dir.join("blank_global_npmrc"),
+            ])
+            .args(args);
+        configure_npm_command(&mut command, directory, proxy);
+        let output = command.output().await?;
+        if !output.status.success() {
+            return Err(anyhow!(
+                "failed to execute npm {subcommand} subcommand:\nstdout: {:?}\nstderr: {:?}",
+                String::from_utf8_lossy(&output.stdout),
+                String::from_utf8_lossy(&output.stderr)
+            ));
+        }
 
-    async fn npm_package_latest_version(&self, name: &str) -> anyhow::Result<String> {
-        unreachable!("Should not query npm package '{name}' for latest version")
+        Ok(output)
     }
 
     async fn npm_package_installed_version(
         &self,
-        _local_package_directory: &Path,
+        local_package_directory: &Path,
         name: &str,
     ) -> Result<Option<String>> {
-        unreachable!("Should not query npm package '{name}' for installed version")
-    }
-
-    async fn npm_install_packages(
-        &self,
-        _: &Path,
-        packages: &[(&str, &str)],
-    ) -> anyhow::Result<()> {
-        unreachable!("Should not install packages {packages:?}")
+        read_package_installed_version(local_package_directory.join("node_modules"), name).await
+        // todo: allow returning a globally installed version (requires callers not to hard-code the path)
     }
 }
 
-// TODO: Remove this when headless binary can  run node
-pub struct DummyNodeRuntime;
+async fn read_package_installed_version(
+    node_module_directory: PathBuf,
+    name: &str,
+) -> Result<Option<String>> {
+    let package_json_path = node_module_directory.join(name).join("package.json");
+
+    let mut file = match fs::File::open(package_json_path).await {
+        Ok(file) => file,
+        Err(err) => {
+            if err.kind() == io::ErrorKind::NotFound {
+                return Ok(None);
+            }
+
+            Err(err)?
+        }
+    };
 
-impl DummyNodeRuntime {
-    pub fn new() -> Arc<dyn NodeRuntime> {
-        Arc::new(Self)
+    #[derive(Deserialize)]
+    struct PackageJson {
+        version: String,
     }
+
+    let mut contents = String::new();
+    file.read_to_string(&mut contents).await?;
+    let package_json: PackageJson = serde_json::from_str(&contents)?;
+    Ok(Some(package_json.version))
 }
 
+pub struct UnavailableNodeRuntime;
+
 #[async_trait::async_trait]
-impl NodeRuntime for DummyNodeRuntime {
-    async fn binary_path(&self) -> anyhow::Result<PathBuf> {
-        anyhow::bail!("Dummy Node Runtime")
+impl NodeRuntimeTrait for UnavailableNodeRuntime {
+    fn boxed_clone(&self) -> Box<dyn NodeRuntimeTrait> {
+        Box::new(UnavailableNodeRuntime)
     }
-
-    async fn node_environment_path(&self) -> anyhow::Result<OsString> {
-        anyhow::bail!("Dummy node runtime")
+    fn binary_path(&self) -> Result<PathBuf> {
+        bail!("binary_path: no node runtime available")
     }
 
     async fn run_npm_subcommand(
         &self,
         _: Option<&Path>,
-        _subcommand: &str,
-        _args: &[&str],
+        _: Option<&Uri>,
+        _: &str,
+        _: &[&str],
     ) -> anyhow::Result<Output> {
-        anyhow::bail!("Dummy node runtime")
-    }
-
-    async fn npm_package_latest_version(&self, _name: &str) -> anyhow::Result<String> {
-        anyhow::bail!("Dummy node runtime")
+        bail!("run_npm_subcommand: no node runtime available")
     }
 
     async fn npm_package_installed_version(
         &self,
         _local_package_directory: &Path,
-        _name: &str,
+        _: &str,
     ) -> Result<Option<String>> {
-        anyhow::bail!("Dummy node runtime")
+        bail!("npm_package_installed_version: no node runtime available")
     }
+}
 
-    async fn npm_install_packages(
-        &self,
-        _: &Path,
-        _packages: &[(&str, &str)],
-    ) -> anyhow::Result<()> {
-        anyhow::bail!("Dummy node runtime")
+fn configure_npm_command(command: &mut Command, directory: Option<&Path>, proxy: Option<&Uri>) {
+    if let Some(directory) = directory {
+        command.current_dir(directory);
+        command.args(["--prefix".into(), directory.to_path_buf()]);
+    }
+
+    if let Some(proxy) = proxy {
+        // Map proxy settings from `http://localhost:10809` to `http://127.0.0.1:10809`
+        // NodeRuntime without environment information can not parse `localhost`
+        // correctly.
+        // TODO: map to `[::1]` if we are using ipv6
+        let proxy = proxy
+            .to_string()
+            .to_ascii_lowercase()
+            .replace("localhost", "127.0.0.1");
+
+        command.args(["--proxy", &proxy]);
+    }
+
+    #[cfg(windows)]
+    {
+        // SYSTEMROOT is a critical environment variables for Windows.
+        if let Some(val) = std::env::var("SYSTEMROOT")
+            .context("Missing environment variable: SYSTEMROOT!")
+            .log_err()
+        {
+            command.env("SYSTEMROOT", val);
+        }
+        // Without ComSpec, the post-install will always fail.
+        if let Some(val) = std::env::var("ComSpec")
+            .context("Missing environment variable: ComSpec!")
+            .log_err()
+        {
+            command.env("ComSpec", val);
+        }
+        command.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
     }
 }
diff --git a/crates/prettier/src/prettier.rs b/crates/prettier/src/prettier.rs
index 59ed915453996c..012beb3fd7ab28 100644
--- a/crates/prettier/src/prettier.rs
+++ b/crates/prettier/src/prettier.rs
@@ -138,7 +138,7 @@ impl Prettier {
     pub async fn start(
         _: LanguageServerId,
         prettier_dir: PathBuf,
-        _: Arc<dyn NodeRuntime>,
+        _: NodeRuntime,
         _: AsyncAppContext,
     ) -> anyhow::Result<Self> {
         Ok(Self::Test(TestPrettier {
@@ -151,7 +151,7 @@ impl Prettier {
     pub async fn start(
         server_id: LanguageServerId,
         prettier_dir: PathBuf,
-        node: Arc<dyn NodeRuntime>,
+        node: NodeRuntime,
         cx: AsyncAppContext,
     ) -> anyhow::Result<Self> {
         use lsp::LanguageServerBinary;
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 6673f9da1ddd71..6c71d4baebf563 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -17,7 +17,7 @@ use async_trait::async_trait;
 use client::{proto, TypedEnvelope};
 use collections::{btree_map, BTreeMap, HashMap, HashSet};
 use futures::{
-    future::{join_all, BoxFuture, Shared},
+    future::{join_all, Shared},
     select,
     stream::FuturesUnordered,
     AsyncWriteExt, Future, FutureExt, StreamExt,
@@ -27,7 +27,7 @@ use gpui::{
     AppContext, AsyncAppContext, Context, Entity, EventEmitter, Model, ModelContext, PromptLevel,
     Task, WeakModel,
 };
-use http_client::{AsyncBody, HttpClient, Request, Response, Uri};
+use http_client::{BlockedHttpClient, HttpClient};
 use language::{
     language_settings::{
         all_language_settings, language_settings, AllLanguageSettings, FormatOnSave, Formatter,
@@ -7979,35 +7979,6 @@ impl LspAdapterDelegate for LocalLspAdapterDelegate {
     }
 }
 
-struct BlockedHttpClient;
-
-impl HttpClient for BlockedHttpClient {
-    fn send(
-        &self,
-        _req: Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
-        Box::pin(async {
-            Err(std::io::Error::new(
-                std::io::ErrorKind::PermissionDenied,
-                "ssh host blocked http connection",
-            )
-            .into())
-        })
-    }
-
-    fn proxy(&self) -> Option<&Uri> {
-        None
-    }
-
-    fn send_with_redirect_policy(
-        &self,
-        req: Request<AsyncBody>,
-        _: bool,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
-        self.send(req)
-    }
-}
-
 struct SshLspAdapterDelegate {
     lsp_store: WeakModel<LspStore>,
     worktree: worktree::Snapshot,
diff --git a/crates/project/src/prettier_store.rs b/crates/project/src/prettier_store.rs
index 82bd8464b2e535..65e2aa2e7673e8 100644
--- a/crates/project/src/prettier_store.rs
+++ b/crates/project/src/prettier_store.rs
@@ -30,7 +30,7 @@ use crate::{
 };
 
 pub struct PrettierStore {
-    node: Arc<dyn NodeRuntime>,
+    node: NodeRuntime,
     fs: Arc<dyn Fs>,
     languages: Arc<LanguageRegistry>,
     worktree_store: Model<WorktreeStore>,
@@ -52,7 +52,7 @@ impl EventEmitter<PrettierStoreEvent> for PrettierStore {}
 
 impl PrettierStore {
     pub fn new(
-        node: Arc<dyn NodeRuntime>,
+        node: NodeRuntime,
         fs: Arc<dyn Fs>,
         languages: Arc<LanguageRegistry>,
         worktree_store: Model<WorktreeStore>,
@@ -212,7 +212,7 @@ impl PrettierStore {
     }
 
     fn start_prettier(
-        node: Arc<dyn NodeRuntime>,
+        node: NodeRuntime,
         prettier_dir: PathBuf,
         worktree_id: Option<WorktreeId>,
         cx: &mut ModelContext<Self>,
@@ -241,7 +241,7 @@ impl PrettierStore {
     }
 
     fn start_default_prettier(
-        node: Arc<dyn NodeRuntime>,
+        node: NodeRuntime,
         worktree_id: Option<WorktreeId>,
         cx: &mut ModelContext<PrettierStore>,
     ) -> Task<anyhow::Result<PrettierTask>> {
@@ -749,7 +749,7 @@ impl DefaultPrettier {
 
     pub fn prettier_task(
         &mut self,
-        node: &Arc<dyn NodeRuntime>,
+        node: &NodeRuntime,
         worktree_id: Option<WorktreeId>,
         cx: &mut ModelContext<PrettierStore>,
     ) -> Option<Task<anyhow::Result<PrettierTask>>> {
@@ -767,7 +767,7 @@ impl DefaultPrettier {
 impl PrettierInstance {
     pub fn prettier_task(
         &mut self,
-        node: &Arc<dyn NodeRuntime>,
+        node: &NodeRuntime,
         prettier_dir: Option<&Path>,
         worktree_id: Option<WorktreeId>,
         cx: &mut ModelContext<PrettierStore>,
@@ -786,7 +786,7 @@ impl PrettierInstance {
             None => match prettier_dir {
                 Some(prettier_dir) => {
                     let new_task = PrettierStore::start_prettier(
-                        Arc::clone(node),
+                        node.clone(),
                         prettier_dir.to_path_buf(),
                         worktree_id,
                         cx,
@@ -797,7 +797,7 @@ impl PrettierInstance {
                 }
                 None => {
                     self.attempt += 1;
-                    let node = Arc::clone(node);
+                    let node = node.clone();
                     cx.spawn(|prettier_store, mut cx| async move {
                         prettier_store
                             .update(&mut cx, |_, cx| {
@@ -818,7 +818,7 @@ impl PrettierInstance {
 async fn install_prettier_packages(
     fs: &dyn Fs,
     plugins_to_install: HashSet<Arc<str>>,
-    node: Arc<dyn NodeRuntime>,
+    node: NodeRuntime,
 ) -> anyhow::Result<()> {
     let packages_to_versions = future::try_join_all(
         plugins_to_install
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index dc9337674b7eb7..0015af380292e1 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -153,7 +153,7 @@ pub struct Project {
     git_diff_debouncer: DebouncedDelay<Self>,
     remotely_created_models: Arc<Mutex<RemotelyCreatedModels>>,
     terminals: Terminals,
-    node: Option<Arc<dyn NodeRuntime>>,
+    node: Option<NodeRuntime>,
     tasks: Model<Inventory>,
     hosted_project_id: Option<ProjectId>,
     dev_server_project_id: Option<client::DevServerProjectId>,
@@ -579,7 +579,7 @@ impl Project {
 
     pub fn local(
         client: Arc<Client>,
-        node: Arc<dyn NodeRuntime>,
+        node: NodeRuntime,
         user_store: Model<UserStore>,
         languages: Arc<LanguageRegistry>,
         fs: Arc<dyn Fs>,
@@ -675,7 +675,7 @@ impl Project {
     pub fn ssh(
         ssh: Arc<SshSession>,
         client: Arc<Client>,
-        node: Arc<dyn NodeRuntime>,
+        node: NodeRuntime,
         user_store: Model<UserStore>,
         languages: Arc<LanguageRegistry>,
         fs: Arc<dyn Fs>,
@@ -1064,7 +1064,7 @@ impl Project {
             .update(|cx| {
                 Project::local(
                     client,
-                    node_runtime::FakeNodeRuntime::new(),
+                    node_runtime::NodeRuntime::unavailable(),
                     user_store,
                     Arc::new(languages),
                     fs,
@@ -1104,7 +1104,7 @@ impl Project {
         let project = cx.update(|cx| {
             Project::local(
                 client,
-                node_runtime::FakeNodeRuntime::new(),
+                node_runtime::NodeRuntime::unavailable(),
                 user_store,
                 Arc::new(languages),
                 fs,
@@ -1157,7 +1157,7 @@ impl Project {
         self.user_store.clone()
     }
 
-    pub fn node_runtime(&self) -> Option<&Arc<dyn NodeRuntime>> {
+    pub fn node_runtime(&self) -> Option<&NodeRuntime> {
         self.node.as_ref()
     }
 
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index 904efe0a6b01f0..d6f5600a551ef4 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -34,6 +34,10 @@ pub struct ProjectSettings {
     #[serde(default)]
     pub git: GitSettings,
 
+    /// Configuration for Node-related features
+    #[serde(default)]
+    pub node: NodeBinarySettings,
+
     /// Configuration for how direnv configuration should be loaded
     #[serde(default)]
     pub load_direnv: DirenvSettings,
@@ -43,6 +47,17 @@ pub struct ProjectSettings {
     pub session: SessionSettings,
 }
 
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
+pub struct NodeBinarySettings {
+    /// The path to the node binary
+    pub path: Option<String>,
+    ///  The path to the npm binary Zed should use (defaults to .path/../npm)
+    pub npm_path: Option<String>,
+    /// If disabled, zed will download its own copy of node.
+    #[serde(default)]
+    pub disable_path_lookup: Option<bool>,
+}
+
 #[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum DirenvSettings {
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 0d644a64a6aa7a..87c9583077c4d9 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -2,7 +2,7 @@ use anyhow::{anyhow, Result};
 use fs::Fs;
 use gpui::{AppContext, AsyncAppContext, Context, Model, ModelContext};
 use language::{proto::serialize_operation, Buffer, BufferEvent, LanguageRegistry};
-use node_runtime::DummyNodeRuntime;
+use node_runtime::NodeRuntime;
 use project::{
     buffer_store::{BufferStore, BufferStoreEvent},
     project_settings::SettingsObserver,
@@ -57,7 +57,7 @@ impl HeadlessProject {
         });
         let prettier_store = cx.new_model(|cx| {
             PrettierStore::new(
-                DummyNodeRuntime::new(),
+                NodeRuntime::unavailable(),
                 fs.clone(),
                 languages.clone(),
                 worktree_store.clone(),
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index b5ab1c40070a09..ba59d310c81b88 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -9,7 +9,7 @@ use language::{
     Buffer, FakeLspAdapter, LanguageConfig, LanguageMatcher, LanguageRegistry, LanguageServerName,
 };
 use lsp::{CompletionContext, CompletionResponse, CompletionTriggerKind};
-use node_runtime::FakeNodeRuntime;
+use node_runtime::NodeRuntime;
 use project::{
     search::{SearchQuery, SearchResult},
     Project,
@@ -502,7 +502,7 @@ fn build_project(ssh: Arc<SshSession>, cx: &mut TestAppContext) -> Model<Project
         )
     });
 
-    let node = FakeNodeRuntime::new();
+    let node = NodeRuntime::unavailable();
     let user_store = cx.new_model(|cx| UserStore::new(client.clone(), cx));
     let languages = Arc::new(LanguageRegistry::test(cx.executor()));
     let fs = FakeFs::new(cx.executor());
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 92bfc8c5c56d4d..b732eb5bc70c1b 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -556,7 +556,7 @@ pub struct AppState {
     pub workspace_store: Model<WorkspaceStore>,
     pub fs: Arc<dyn fs::Fs>,
     pub build_window_options: fn(Option<Uuid>, &mut AppContext) -> WindowOptions,
-    pub node_runtime: Arc<dyn NodeRuntime>,
+    pub node_runtime: NodeRuntime,
     pub session: Model<AppSession>,
 }
 
@@ -590,7 +590,7 @@ impl AppState {
 
     #[cfg(any(test, feature = "test-support"))]
     pub fn test(cx: &mut AppContext) -> Arc<Self> {
-        use node_runtime::FakeNodeRuntime;
+        use node_runtime::NodeRuntime;
         use session::Session;
         use settings::SettingsStore;
         use ui::Context as _;
@@ -619,7 +619,7 @@ impl AppState {
             languages,
             user_store,
             workspace_store,
-            node_runtime: FakeNodeRuntime::new(),
+            node_runtime: NodeRuntime::unavailable(),
             build_window_options: |_, _| Default::default(),
             session,
         })
@@ -4418,7 +4418,7 @@ impl Workspace {
 
     #[cfg(any(test, feature = "test-support"))]
     pub fn test_new(project: Model<Project>, cx: &mut ViewContext<Self>) -> Self {
-        use node_runtime::FakeNodeRuntime;
+        use node_runtime::NodeRuntime;
         use session::Session;
 
         let client = project.read(cx).client();
@@ -4434,7 +4434,7 @@ impl Workspace {
             user_store,
             fs: project.read(cx).fs().clone(),
             build_window_options: |_, _| Default::default(),
-            node_runtime: FakeNodeRuntime::new(),
+            node_runtime: NodeRuntime::unavailable(),
             session,
         });
         let workspace = Self::new(Default::default(), project, app_state, cx);
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index ad2e7cd48c67d8..65724480f62334 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -19,6 +19,7 @@ activity_indicator.workspace = true
 anyhow.workspace = true
 assets.workspace = true
 assistant.workspace = true
+async-watch.workspace = true
 audio.workspace = true
 auto_update.workspace = true
 backtrace = "0.3"
@@ -92,6 +93,7 @@ serde_json.workspace = true
 session.workspace = true
 settings.workspace = true
 settings_ui.workspace = true
+shellexpand.workspace = true
 simplelog.workspace = true
 smol.workspace = true
 snippet_provider.workspace = true
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index d3eb97c9aa506e..309931f6163528 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -29,8 +29,9 @@ use language::LanguageRegistry;
 use log::LevelFilter;
 
 use assets::Assets;
-use node_runtime::RealNodeRuntime;
+use node_runtime::{NodeBinaryOptions, NodeRuntime};
 use parking_lot::Mutex;
+use project::project_settings::ProjectSettings;
 use recent_projects::open_ssh_project;
 use release_channel::{AppCommitSha, AppVersion};
 use session::{AppSession, Session};
@@ -43,7 +44,7 @@ use std::{
     env,
     fs::OpenOptions,
     io::{IsTerminal, Write},
-    path::Path,
+    path::{Path, PathBuf},
     process,
     sync::Arc,
 };
@@ -477,7 +478,32 @@ fn main() {
         let mut languages = LanguageRegistry::new(cx.background_executor().clone());
         languages.set_language_server_download_dir(paths::languages_dir().clone());
         let languages = Arc::new(languages);
-        let node_runtime = RealNodeRuntime::new(client.http_client());
+        let (tx, rx) = async_watch::channel(None);
+        cx.observe_global::<SettingsStore>(move |cx| {
+            let settings = &ProjectSettings::get_global(cx).node;
+            let options = NodeBinaryOptions {
+                allow_path_lookup: !settings.disable_path_lookup.unwrap_or_default(),
+                // TODO: Expose this setting
+                allow_binary_download: true,
+                use_paths: settings.path.as_ref().map(|node_path| {
+                    let node_path = PathBuf::from(shellexpand::tilde(node_path).as_ref());
+                    let npm_path = settings
+                        .npm_path
+                        .as_ref()
+                        .map(|path| PathBuf::from(shellexpand::tilde(&path).as_ref()));
+                    (
+                        node_path.clone(),
+                        npm_path.unwrap_or_else(|| {
+                            let base_path = PathBuf::new();
+                            node_path.parent().unwrap_or(&base_path).join("npm")
+                        }),
+                    )
+                }),
+            };
+            tx.send(Some(options)).log_err();
+        })
+        .detach();
+        let node_runtime = NodeRuntime::new(client.http_client(), rx);
 
         language::init(cx);
         languages::init(languages.clone(), node_runtime.clone(), cx);
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index b0e023f42e0a01..8f4f1af24331c0 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -3365,7 +3365,7 @@ mod tests {
         cx.set_global(settings);
         let languages = LanguageRegistry::test(cx.executor());
         let languages = Arc::new(languages);
-        let node_runtime = node_runtime::FakeNodeRuntime::new();
+        let node_runtime = node_runtime::NodeRuntime::unavailable();
         cx.update(|cx| {
             languages::init(languages.clone(), node_runtime, cx);
         });

From d989183f94725f4b2f42c6e7db79e37e0fdbddd5 Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Mon, 23 Sep 2024 16:21:24 -0600
Subject: [PATCH 283/762] Remove `Debug` constraint on `SumTree` (and its
 related traits/structs) (#18248)

Release Notes:

- N/A

Co-authored-by: Nathan <nathan@zed.dev>
---
 crates/editor/src/selections_collection.rs |  4 +-
 crates/sum_tree/src/cursor.rs              |  6 +--
 crates/sum_tree/src/sum_tree.rs            | 53 ++++++++++++++++++++--
 crates/sum_tree/src/tree_map.rs            | 34 +++++++-------
 4 files changed, 69 insertions(+), 28 deletions(-)

diff --git a/crates/editor/src/selections_collection.rs b/crates/editor/src/selections_collection.rs
index 35df9c1b53f72d..c85e60fdaa92e5 100644
--- a/crates/editor/src/selections_collection.rs
+++ b/crates/editor/src/selections_collection.rs
@@ -109,7 +109,7 @@ impl SelectionsCollection {
 
     pub fn all<'a, D>(&self, cx: &AppContext) -> Vec<Selection<D>>
     where
-        D: 'a + TextDimension + Ord + Sub<D, Output = D> + std::fmt::Debug,
+        D: 'a + TextDimension + Ord + Sub<D, Output = D>,
     {
         let disjoint_anchors = &self.disjoint;
         let mut disjoint =
@@ -850,7 +850,7 @@ pub(crate) fn resolve_multiple<'a, D, I>(
     snapshot: &MultiBufferSnapshot,
 ) -> impl 'a + Iterator<Item = Selection<D>>
 where
-    D: TextDimension + Ord + Sub<D, Output = D> + std::fmt::Debug,
+    D: TextDimension + Ord + Sub<D, Output = D>,
     I: 'a + IntoIterator<Item = &'a Selection<Anchor>>,
 {
     let (to_summarize, selections) = selections.into_iter().tee();
diff --git a/crates/sum_tree/src/cursor.rs b/crates/sum_tree/src/cursor.rs
index 6da43a8de5ce39..773e7db88bad3d 100644
--- a/crates/sum_tree/src/cursor.rs
+++ b/crates/sum_tree/src/cursor.rs
@@ -431,11 +431,9 @@ where
         aggregate: &mut dyn SeekAggregate<'a, T>,
         cx: &<T::Summary as Summary>::Context,
     ) -> bool {
-        debug_assert!(
+        assert!(
             target.cmp(&self.position, cx) >= Ordering::Equal,
-            "cannot seek backward from {:?} to {:?}",
-            self.position,
-            target
+            "cannot seek backward",
         );
 
         if !self.did_seek {
diff --git a/crates/sum_tree/src/sum_tree.rs b/crates/sum_tree/src/sum_tree.rs
index ca351d67cea76f..965413d3190aa2 100644
--- a/crates/sum_tree/src/sum_tree.rs
+++ b/crates/sum_tree/src/sum_tree.rs
@@ -34,7 +34,7 @@ pub trait KeyedItem: Item {
 ///
 /// Each Summary type can have multiple [`Dimensions`] that it measures,
 /// which can be used to navigate the tree
-pub trait Summary: Clone + fmt::Debug {
+pub trait Summary: Clone {
     type Context;
 
     fn zero(cx: &Self::Context) -> Self;
@@ -49,7 +49,7 @@ pub trait Summary: Clone + fmt::Debug {
 /// # Example:
 /// Zed's rope has a `TextSummary` type that summarizes lines, characters, and bytes.
 /// Each of these are different dimensions we may want to seek to
-pub trait Dimension<'a, S: Summary>: Clone + fmt::Debug {
+pub trait Dimension<'a, S: Summary>: Clone {
     fn zero(cx: &S::Context) -> Self;
 
     fn add_summary(&mut self, summary: &'a S, cx: &S::Context);
@@ -71,7 +71,7 @@ impl<'a, T: Summary> Dimension<'a, T> for T {
     }
 }
 
-pub trait SeekTarget<'a, S: Summary, D: Dimension<'a, S>>: fmt::Debug {
+pub trait SeekTarget<'a, S: Summary, D: Dimension<'a, S>> {
     fn cmp(&self, cursor_location: &D, cx: &S::Context) -> Ordering;
 }
 
@@ -173,9 +173,19 @@ impl Bias {
 /// The maximum number of items per node is `TREE_BASE * 2`.
 ///
 /// Any [`Dimension`] supported by the [`Summary`] type can be used to seek to a specific location in the tree.
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct SumTree<T: Item>(Arc<Node<T>>);
 
+impl<T> fmt::Debug for SumTree<T>
+where
+    T: fmt::Debug + Item,
+    T::Summary: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_tuple("SumTree").field(&self.0).finish()
+    }
+}
+
 impl<T: Item> SumTree<T> {
     pub fn new(cx: &<T::Summary as Summary>::Context) -> Self {
         SumTree(Arc::new(Node::Leaf {
@@ -763,7 +773,7 @@ where
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub enum Node<T: Item> {
     Internal {
         height: u8,
@@ -778,6 +788,39 @@ pub enum Node<T: Item> {
     },
 }
 
+impl<T> fmt::Debug for Node<T>
+where
+    T: Item + fmt::Debug,
+    T::Summary: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Node::Internal {
+                height,
+                summary,
+                child_summaries,
+                child_trees,
+            } => f
+                .debug_struct("Internal")
+                .field("height", height)
+                .field("summary", summary)
+                .field("child_summaries", child_summaries)
+                .field("child_trees", child_trees)
+                .finish(),
+            Node::Leaf {
+                summary,
+                items,
+                item_summaries,
+            } => f
+                .debug_struct("Leaf")
+                .field("summary", summary)
+                .field("items", items)
+                .field("item_summaries", item_summaries)
+                .finish(),
+        }
+    }
+}
+
 impl<T: Item> Node<T> {
     fn is_leaf(&self) -> bool {
         matches!(self, Node::Leaf { .. })
diff --git a/crates/sum_tree/src/tree_map.rs b/crates/sum_tree/src/tree_map.rs
index 72465b1a99cabd..b7eadb566d3ed7 100644
--- a/crates/sum_tree/src/tree_map.rs
+++ b/crates/sum_tree/src/tree_map.rs
@@ -5,8 +5,8 @@ use crate::{Bias, Dimension, Edit, Item, KeyedItem, SeekTarget, SumTree, Summary
 #[derive(Clone, PartialEq, Eq)]
 pub struct TreeMap<K, V>(SumTree<MapEntry<K, V>>)
 where
-    K: Clone + Debug + Ord,
-    V: Clone + Debug;
+    K: Clone + Ord,
+    V: Clone;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct MapEntry<K, V> {
@@ -35,9 +35,9 @@ impl<'a, K> Default for MapKeyRef<'a, K> {
 #[derive(Clone)]
 pub struct TreeSet<K>(TreeMap<K, ()>)
 where
-    K: Clone + Debug + Ord;
+    K: Clone + Ord;
 
-impl<K: Clone + Debug + Ord, V: Clone + Debug> TreeMap<K, V> {
+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
@@ -172,7 +172,7 @@ impl<K: Clone + Debug + Ord, V: Clone + Debug> TreeMap<K, V> {
     }
 }
 
-impl<K: Debug, V: Debug> Debug for TreeMap<K, V>
+impl<K, V> Debug for TreeMap<K, V>
 where
     K: Clone + Debug + Ord,
     V: Clone + Debug,
@@ -185,7 +185,7 @@ where
 #[derive(Debug)]
 struct MapSeekTargetAdaptor<'a, T>(&'a T);
 
-impl<'a, K: Debug + Clone + Ord, T: MapSeekTarget<K>> SeekTarget<'a, MapKey<K>, MapKeyRef<'a, K>>
+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 {
@@ -197,11 +197,11 @@ impl<'a, K: Debug + Clone + Ord, T: MapSeekTarget<K>> SeekTarget<'a, MapKey<K>,
     }
 }
 
-pub trait MapSeekTarget<K>: Debug {
+pub trait MapSeekTarget<K> {
     fn cmp_cursor(&self, cursor_location: &K) -> Ordering;
 }
 
-impl<K: Debug + Ord> MapSeekTarget<K> for K {
+impl<K: Ord> MapSeekTarget<K> for K {
     fn cmp_cursor(&self, cursor_location: &K) -> Ordering {
         self.cmp(cursor_location)
     }
@@ -209,8 +209,8 @@ impl<K: Debug + Ord> MapSeekTarget<K> for K {
 
 impl<K, V> Default for TreeMap<K, V>
 where
-    K: Clone + Debug + Ord,
-    V: Clone + Debug,
+    K: Clone + Ord,
+    V: Clone,
 {
     fn default() -> Self {
         Self(Default::default())
@@ -219,7 +219,7 @@ where
 
 impl<K, V> Item for MapEntry<K, V>
 where
-    K: Clone + Debug + Ord,
+    K: Clone + Ord,
     V: Clone,
 {
     type Summary = MapKey<K>;
@@ -231,7 +231,7 @@ where
 
 impl<K, V> KeyedItem for MapEntry<K, V>
 where
-    K: Clone + Debug + Ord,
+    K: Clone + Ord,
     V: Clone,
 {
     type Key = MapKey<K>;
@@ -243,7 +243,7 @@ where
 
 impl<K> Summary for MapKey<K>
 where
-    K: Clone + Debug,
+    K: Clone,
 {
     type Context = ();
 
@@ -258,7 +258,7 @@ where
 
 impl<'a, K> Dimension<'a, MapKey<K>> for MapKeyRef<'a, K>
 where
-    K: Clone + Debug + Ord,
+    K: Clone + Ord,
 {
     fn zero(_cx: &()) -> Self {
         Default::default()
@@ -271,7 +271,7 @@ where
 
 impl<'a, K> SeekTarget<'a, MapKey<K>, MapKeyRef<'a, K>> for MapKeyRef<'_, K>
 where
-    K: Clone + Debug + Ord,
+    K: Clone + Ord,
 {
     fn cmp(&self, cursor_location: &MapKeyRef<K>, _: &()) -> Ordering {
         Ord::cmp(&self.0, &cursor_location.0)
@@ -280,7 +280,7 @@ where
 
 impl<K> Default for TreeSet<K>
 where
-    K: Clone + Debug + Ord,
+    K: Clone + Ord,
 {
     fn default() -> Self {
         Self(Default::default())
@@ -289,7 +289,7 @@ where
 
 impl<K> TreeSet<K>
 where
-    K: Clone + Debug + Ord,
+    K: Clone + Ord,
 {
     pub fn from_ordered_entries(entries: impl IntoIterator<Item = K>) -> Self {
         Self(TreeMap::from_ordered_entries(

From 20c06545b6c9d51e6329f3194bc89123b7f7f9f4 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Mon, 23 Sep 2024 15:47:25 -0700
Subject: [PATCH 284/762] SSH Remoting: Add the ability to resolve file paths
 on the remote host (#18250)

Release Notes:

- N/A
---
 crates/project/src/project.rs                 | 67 +++++++++++--------
 crates/proto/proto/zed.proto                  | 15 ++++-
 crates/proto/src/proto.rs                     |  8 ++-
 crates/remote_server/src/headless_project.rs  | 17 +++++
 .../remote_server/src/remote_editing_tests.rs | 45 ++++++++++++-
 5 files changed, 119 insertions(+), 33 deletions(-)

diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 0015af380292e1..199b5a8f5c5755 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -3037,15 +3037,11 @@ impl Project {
         buffer: &Model<Buffer>,
         cx: &mut ModelContext<Self>,
     ) -> Task<Option<ResolvedPath>> {
-        // TODO: ssh based remoting.
-        if self.ssh_session.is_some() {
-            return Task::ready(None);
-        }
-
-        if self.is_local_or_ssh() {
-            let expanded = PathBuf::from(shellexpand::tilde(&path).into_owned());
+        let path_buf = PathBuf::from(path);
+        if path_buf.is_absolute() || path.starts_with("~") {
+            if self.is_local() {
+                let expanded = PathBuf::from(shellexpand::tilde(&path).into_owned());
 
-            if expanded.is_absolute() {
                 let fs = self.fs.clone();
                 cx.background_executor().spawn(async move {
                     let path = expanded.as_path();
@@ -3053,16 +3049,24 @@ impl Project {
 
                     exists.then(|| ResolvedPath::AbsPath(expanded))
                 })
+            } else if let Some(ssh_session) = self.ssh_session.as_ref() {
+                let request = ssh_session.request(proto::CheckFileExists {
+                    project_id: SSH_PROJECT_ID,
+                    path: path.to_string(),
+                });
+                cx.background_executor().spawn(async move {
+                    let response = request.await.log_err()?;
+                    if response.exists {
+                        Some(ResolvedPath::AbsPath(PathBuf::from(response.path)))
+                    } else {
+                        None
+                    }
+                })
             } else {
-                self.resolve_path_in_worktrees(expanded, buffer, cx)
-            }
-        } else {
-            let path = PathBuf::from(path);
-            if path.is_absolute() || path.starts_with("~") {
                 return Task::ready(None);
             }
-
-            self.resolve_path_in_worktrees(path, buffer, cx)
+        } else {
+            self.resolve_path_in_worktrees(path_buf, buffer, cx)
         }
     }
 
@@ -4016,17 +4020,7 @@ impl Project {
     }
 
     pub fn worktree_metadata_protos(&self, cx: &AppContext) -> Vec<proto::WorktreeMetadata> {
-        self.worktrees(cx)
-            .map(|worktree| {
-                let worktree = worktree.read(cx);
-                proto::WorktreeMetadata {
-                    id: worktree.id().to_proto(),
-                    root_name: worktree.root_name().into(),
-                    visible: worktree.is_visible(),
-                    abs_path: worktree.abs_path().to_string_lossy().into(),
-                }
-            })
-            .collect()
+        self.worktree_store.read(cx).worktree_metadata_protos(cx)
     }
 
     fn set_worktrees_from_proto(
@@ -4035,10 +4029,9 @@ impl Project {
         cx: &mut ModelContext<Project>,
     ) -> Result<()> {
         cx.notify();
-        let result = self.worktree_store.update(cx, |worktree_store, cx| {
+        self.worktree_store.update(cx, |worktree_store, cx| {
             worktree_store.set_worktrees_from_proto(worktrees, self.replica_id(), cx)
-        });
-        result
+        })
     }
 
     fn set_collaborators_from_proto(
@@ -4547,6 +4540,22 @@ pub enum ResolvedPath {
     AbsPath(PathBuf),
 }
 
+impl ResolvedPath {
+    pub fn abs_path(&self) -> Option<&Path> {
+        match self {
+            Self::AbsPath(path) => Some(path.as_path()),
+            _ => None,
+        }
+    }
+
+    pub fn project_path(&self) -> Option<&ProjectPath> {
+        match self {
+            Self::ProjectPath(path) => Some(&path),
+            _ => None,
+        }
+    }
+}
+
 impl Item for Buffer {
     fn try_open(
         project: &Model<Project>,
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index a18bbe8ecf5141..475ed139edfb87 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -293,7 +293,10 @@ message Envelope {
 
         TryExec try_exec = 252;
         ReadTextFile read_text_file = 253;
-        ReadTextFileResponse read_text_file_response = 254; // current max
+        ReadTextFileResponse read_text_file_response = 254;
+
+        CheckFileExists check_file_exists = 255;
+        CheckFileExistsResponse check_file_exists_response = 256; // current max
     }
 
     reserved 158 to 161;
@@ -2574,3 +2577,13 @@ message TryExec {
 message TryExecResponse {
     string text = 1;
 }
+
+message CheckFileExists {
+    uint64 project_id = 1;
+    string path = 2;
+}
+
+message CheckFileExistsResponse {
+    bool exists = 1;
+    string path = 2;
+}
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index b5a00d16704c41..4146a47409ad71 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -372,7 +372,9 @@ messages!(
     (ShellEnvResponse, Foreground),
     (TryExec, Foreground),
     (ReadTextFile, Foreground),
-    (ReadTextFileResponse, Foreground)
+    (ReadTextFileResponse, Foreground),
+    (CheckFileExists, Background),
+    (CheckFileExistsResponse, Background)
 );
 
 request_messages!(
@@ -501,6 +503,7 @@ request_messages!(
     (ShellEnv, ShellEnvResponse),
     (ReadTextFile, ReadTextFileResponse),
     (TryExec, Ack),
+    (CheckFileExists, CheckFileExistsResponse)
 );
 
 entity_messages!(
@@ -578,7 +581,8 @@ entity_messages!(
     WhichCommand,
     ShellEnv,
     TryExec,
-    ReadTextFile
+    ReadTextFile,
+    CheckFileExists,
 );
 
 entity_messages!(
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 87c9583077c4d9..043f7e95ee026c 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -108,6 +108,7 @@ impl HeadlessProject {
         session.subscribe_to_entity(SSH_PROJECT_ID, &settings_observer);
 
         client.add_request_handler(cx.weak_model(), Self::handle_list_remote_directory);
+        client.add_request_handler(cx.weak_model(), Self::handle_check_file_exists);
 
         client.add_model_request_handler(Self::handle_add_worktree);
         client.add_model_request_handler(Self::handle_open_buffer_by_path);
@@ -298,4 +299,20 @@ impl HeadlessProject {
         }
         Ok(proto::ListRemoteDirectoryResponse { entries })
     }
+
+    pub async fn handle_check_file_exists(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::CheckFileExists>,
+        cx: AsyncAppContext,
+    ) -> Result<proto::CheckFileExistsResponse> {
+        let fs = cx.read_model(&this, |this, _| this.fs.clone())?;
+        let expanded = shellexpand::tilde(&envelope.payload.path).to_string();
+
+        let exists = fs.is_file(&PathBuf::from(expanded.clone())).await;
+
+        Ok(proto::CheckFileExistsResponse {
+            exists,
+            path: expanded,
+        })
+    }
 }
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index ba59d310c81b88..18eb12b445b97b 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -12,7 +12,7 @@ use lsp::{CompletionContext, CompletionResponse, CompletionTriggerKind};
 use node_runtime::NodeRuntime;
 use project::{
     search::{SearchQuery, SearchResult},
-    Project,
+    Project, ProjectPath,
 };
 use remote::SshSession;
 use serde_json::json;
@@ -440,6 +440,49 @@ async fn test_remote_lsp(cx: &mut TestAppContext, server_cx: &mut TestAppContext
     })
 }
 
+#[gpui::test]
+async fn test_remote_resolve_file_path(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {
+    let (project, _headless, _fs) = init_test(cx, server_cx).await;
+    let (worktree, _) = project
+        .update(cx, |project, cx| {
+            project.find_or_create_worktree("/code/project1", true, cx)
+        })
+        .await
+        .unwrap();
+
+    let worktree_id = cx.update(|cx| worktree.read(cx).id());
+
+    let buffer = project
+        .update(cx, |project, cx| {
+            project.open_buffer((worktree_id, Path::new("src/lib.rs")), cx)
+        })
+        .await
+        .unwrap();
+
+    let path = project
+        .update(cx, |project, cx| {
+            project.resolve_existing_file_path("/code/project1/README.md", &buffer, cx)
+        })
+        .await
+        .unwrap();
+    assert_eq!(
+        path.abs_path().unwrap().to_string_lossy(),
+        "/code/project1/README.md"
+    );
+
+    let path = project
+        .update(cx, |project, cx| {
+            project.resolve_existing_file_path("../README.md", &buffer, cx)
+        })
+        .await
+        .unwrap();
+
+    assert_eq!(
+        path.project_path().unwrap().clone(),
+        ProjectPath::from((worktree_id, "README.md"))
+    );
+}
+
 fn init_logger() {
     if std::env::var("RUST_LOG").is_ok() {
         env_logger::try_init().ok();

From 6b56530a4ab0b45d072ce5fe2c19e10e8cd3f58b Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 23 Sep 2024 23:53:28 +0000
Subject: [PATCH 285/762] lua: Bump to v0.1.0 (#18246)

This PR bumps the Lua extension to v0.1.0

- https://github.com/zed-industries/zed/pull/18199
- https://github.com/zed-industries/zed/pull/16955
---
 Cargo.lock                    | 2 +-
 extensions/lua/Cargo.toml     | 2 +-
 extensions/lua/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 894dd00f6d7f79..09a68973340a57 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14621,7 +14621,7 @@ dependencies = [
 
 [[package]]
 name = "zed_lua"
-version = "0.0.3"
+version = "0.1.0"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/lua/Cargo.toml b/extensions/lua/Cargo.toml
index ace7f4700caebf..f577ce18712c4b 100644
--- a/extensions/lua/Cargo.toml
+++ b/extensions/lua/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_lua"
-version = "0.0.3"
+version = "0.1.0"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/lua/extension.toml b/extensions/lua/extension.toml
index cd00bbc7c1ad7a..82026f48ba90dc 100644
--- a/extensions/lua/extension.toml
+++ b/extensions/lua/extension.toml
@@ -1,7 +1,7 @@
 id = "lua"
 name = "Lua"
 description = "Lua support."
-version = "0.0.3"
+version = "0.1.0"
 schema_version = 1
 authors = ["Max Brunsfeld <max@zed.dev>"]
 repository = "https://github.com/zed-industries/zed"

From dbc325ea12b7c06183149e472008f67a2ce0ce5f Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 24 Sep 2024 09:52:20 +0200
Subject: [PATCH 286/762] vtsls: Move all default configuration to
 workspace_configuration (#18259)

This fixes https://github.com/zed-industries/zed/issues/18014 by fixing
the regression that was introduced in
https://github.com/zed-industries/zed/pull/17757.

In short: after digging into the `vtsls` code, it looks like it
essentially doesn't need any `initialization_options`, it's all
workspace configuration, since it tries to use the built-in settings
from VS Code.

I tested the completions, the inlay hints, the max memory - all of it
now works after moving to `workspace_configuration`.

Closes #18014.

Release Notes:

- Fixed `vtsls` being initialized the wrong way, which would mean the
wrong options were used to enable completions or inlay hints.
---
 crates/languages/src/vtsls.rs    | 43 ++++++---------
 docs/src/languages/typescript.md | 93 +++++++++++++++++++++++++++-----
 2 files changed, 96 insertions(+), 40 deletions(-)

diff --git a/crates/languages/src/vtsls.rs b/crates/languages/src/vtsls.rs
index 3c1cf0fcbe151b..de6d575a8ee9fd 100644
--- a/crates/languages/src/vtsls.rs
+++ b/crates/languages/src/vtsls.rs
@@ -6,14 +6,14 @@ use language::{LanguageServerName, LspAdapter, LspAdapterDelegate};
 use lsp::{CodeActionKind, LanguageServerBinary};
 use node_runtime::NodeRuntime;
 use project::{lsp_store::language_server_settings, project_settings::BinarySettings};
-use serde_json::{json, Value};
+use serde_json::Value;
 use std::{
     any::Any,
     ffi::OsString,
     path::{Path, PathBuf},
     sync::Arc,
 };
-use util::{maybe, ResultExt};
+use util::{maybe, merge_json_value_into, ResultExt};
 
 fn typescript_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
     vec![server_path.into(), "--stdio".into()]
@@ -212,11 +212,12 @@ impl LspAdapter for VtslsLspAdapter {
         })
     }
 
-    async fn initialization_options(
+    async fn workspace_configuration(
         self: Arc<Self>,
-        adapter: &Arc<dyn LspAdapterDelegate>,
-    ) -> Result<Option<serde_json::Value>> {
-        let tsdk_path = Self::tsdk_path(adapter).await;
+        delegate: &Arc<dyn LspAdapterDelegate>,
+        cx: &mut AsyncAppContext,
+    ) -> Result<Value> {
+        let tsdk_path = Self::tsdk_path(delegate).await;
         let config = serde_json::json!({
             "tsdk": tsdk_path,
             "suggest": {
@@ -243,10 +244,13 @@ impl LspAdapter for VtslsLspAdapter {
                 "enumMemberValues": {
                     "enabled": true
                 }
-            }
+            },
+            "tsserver": {
+                "maxTsServerMemory": 8092
+            },
         });
 
-        Ok(Some(json!({
+        let mut default_workspace_configuration = serde_json::json!({
             "typescript": config,
             "javascript": config,
             "vtsls": {
@@ -258,33 +262,18 @@ impl LspAdapter for VtslsLspAdapter {
                 },
                "autoUseWorkspaceTsdk": true
             }
-        })))
-    }
+        });
 
-    async fn workspace_configuration(
-        self: Arc<Self>,
-        delegate: &Arc<dyn LspAdapterDelegate>,
-        cx: &mut AsyncAppContext,
-    ) -> Result<Value> {
         let override_options = cx.update(|cx| {
             language_server_settings(delegate.as_ref(), &SERVER_NAME, cx)
                 .and_then(|s| s.settings.clone())
         })?;
 
-        if let Some(options) = override_options {
-            return Ok(options);
+        if let Some(override_options) = override_options {
+            merge_json_value_into(override_options, &mut default_workspace_configuration)
         }
 
-        let config = serde_json::json!({
-            "tsserver": {
-                "maxTsServerMemory": 8092
-            },
-        });
-
-        Ok(serde_json::json!({
-            "typescript": config,
-            "javascript": config
-        }))
+        Ok(default_workspace_configuration)
     }
 
     fn language_ids(&self) -> HashMap<String, String> {
diff --git a/docs/src/languages/typescript.md b/docs/src/languages/typescript.md
index 080d41efb33c28..fa9827cb06f89e 100644
--- a/docs/src/languages/typescript.md
+++ b/docs/src/languages/typescript.md
@@ -68,21 +68,25 @@ Prettier will also be used for TypeScript files by default. To disable this:
 Zed sets the following initialization options to make the language server send back inlay hints
 (that is, when Zed has inlay hints enabled in the settings).
 
-You can override these settings in your configuration file:
+You can override these settings in your Zed settings file.
+
+When using `typescript-language-server`:
 
 ```json
-"lsp": {
-  "$LANGUAGE_SERVER_NAME": {
-    "initialization_options": {
-      "preferences": {
-      "includeInlayParameterNameHints": "all",
-        "includeInlayParameterNameHintsWhenArgumentMatchesName": true,
-        "includeInlayFunctionParameterTypeHints": true,
-        "includeInlayVariableTypeHints": true,
-        "includeInlayVariableTypeHintsWhenTypeMatchesName": true,
-        "includeInlayPropertyDeclarationTypeHints": true,
-        "includeInlayFunctionLikeReturnTypeHints": true,
-        "includeInlayEnumMemberValueHints": true,
+{
+  "lsp": {
+    "typescript-language-server": {
+      "initialization_options": {
+        "preferences": {
+          "includeInlayParameterNameHints": "all",
+          "includeInlayParameterNameHintsWhenArgumentMatchesName": true,
+          "includeInlayFunctionParameterTypeHints": true,
+          "includeInlayVariableTypeHints": true,
+          "includeInlayVariableTypeHintsWhenTypeMatchesName": true,
+          "includeInlayPropertyDeclarationTypeHints": true,
+          "includeInlayFunctionLikeReturnTypeHints": true,
+          "includeInlayEnumMemberValueHints": true
+        }
       }
     }
   }
@@ -91,6 +95,69 @@ You can override these settings in your configuration file:
 
 See [typescript-language-server inlayhints documentation](https://github.com/typescript-language-server/typescript-language-server?tab=readme-ov-file#inlay-hints-textdocumentinlayhint) for more information.
 
+When using `vtsls`:
+
+```json
+{
+  "lsp": {
+    "vtsls": {
+      "settings": {
+        // For JavaScript:
+        "javascript": {
+          "inlayHints": {
+            "parameterNames": {
+              "enabled": "all",
+              "suppressWhenArgumentMatchesName": false
+            },
+            "parameterTypes": {
+              "enabled": true
+            },
+            "variableTypes": {
+              "enabled": true,
+              "suppressWhenTypeMatchesName": true
+            },
+            "propertyDeclarationTypes": {
+              "enabled": true
+            },
+            "functionLikeReturnTypes": {
+              "enabled": true
+            },
+            "enumMemberValues": {
+              "enabled": true
+            }
+          }
+        },
+        // For TypeScript:
+        "typescript": {
+          "inlayHints": {
+            "parameterNames": {
+              "enabled": "all",
+              "suppressWhenArgumentMatchesName": false
+            },
+            "parameterTypes": {
+              "enabled": true
+            },
+            "variableTypes": {
+              "enabled": true,
+              "suppressWhenTypeMatchesName": true
+            },
+            "propertyDeclarationTypes": {
+              "enabled": true
+            },
+            "functionLikeReturnTypes": {
+              "enabled": true
+            },
+            "enumMemberValues": {
+              "enabled": true
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
 ## See also
 
 - [Zed Yarn documentation](./yarn.md) for a walkthrough of configuring your project to use Yarn.

From 399e094f021561a51e3e2ff76993bfb0cef0a5c2 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Tue, 24 Sep 2024 15:36:05 +0300
Subject: [PATCH 287/762] Properly use default search options in the buffer
 search bar (#18271)

Only replace current search options if the search was dismissed and the
new options are different from the default ones.

Follow-up of https://github.com/zed-industries/zed/pull/17179
Closes https://github.com/zed-industries/zed/issues/18166


Release Notes:

- Fixed buffer search options toggling unexpectedly on redeploys
([#18166](https://github.com/zed-industries/zed/issues/18166))
---
 crates/search/src/buffer_search.rs | 132 +++++++++++++++++++++++++++--
 1 file changed, 126 insertions(+), 6 deletions(-)

diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs
index 3a7cccfbb916c9..1c37bfd481dcb9 100644
--- a/crates/search/src/buffer_search.rs
+++ b/crates/search/src/buffer_search.rs
@@ -87,6 +87,7 @@ pub struct BufferSearchBar {
     pending_search: Option<Task<()>>,
     search_options: SearchOptions,
     default_options: SearchOptions,
+    configured_options: SearchOptions,
     query_contains_error: bool,
     dismissed: bool,
     search_history: SearchHistory,
@@ -517,6 +518,7 @@ impl BufferSearchBar {
             active_match_index: None,
             searchable_items_with_matches: Default::default(),
             default_options: search_options,
+            configured_options: search_options,
             search_options,
             pending_search: None,
             query_contains_error: false,
@@ -605,10 +607,11 @@ impl BufferSearchBar {
             return false;
         };
 
-        self.default_options = SearchOptions::from_settings(&EditorSettings::get_global(cx).search);
-
-        if self.default_options != self.search_options {
-            self.search_options = self.default_options;
+        self.configured_options =
+            SearchOptions::from_settings(&EditorSettings::get_global(cx).search);
+        if self.dismissed && self.configured_options != self.default_options {
+            self.search_options = self.configured_options;
+            self.default_options = self.configured_options;
         }
 
         self.dismissed = false;
@@ -627,6 +630,7 @@ impl BufferSearchBar {
             .map(SearchableItemHandle::supported_options)
             .unwrap_or_default()
     }
+
     pub fn search_suggested(&mut self, cx: &mut ViewContext<Self>) {
         let search = self
             .query_suggestion(cx)
@@ -1195,10 +1199,11 @@ mod tests {
     use std::ops::Range;
 
     use super::*;
-    use editor::{display_map::DisplayRow, DisplayPoint, Editor, MultiBuffer};
-    use gpui::{Context, Hsla, TestAppContext, VisualTestContext};
+    use editor::{display_map::DisplayRow, DisplayPoint, Editor, MultiBuffer, SearchSettings};
+    use gpui::{Context, Hsla, TestAppContext, UpdateGlobal, VisualTestContext};
     use language::{Buffer, Point};
     use project::Project;
+    use settings::SettingsStore;
     use smol::stream::StreamExt as _;
     use unindent::Unindent as _;
 
@@ -2320,4 +2325,119 @@ mod tests {
             assert!(display_points_of(editor.all_text_background_highlights(cx)).is_empty(),);
         });
     }
+
+    #[gpui::test]
+    async fn test_search_options_changes(cx: &mut TestAppContext) {
+        let (_editor, search_bar, cx) = init_test(cx);
+        update_search_settings(
+            SearchSettings {
+                whole_word: false,
+                case_sensitive: false,
+                include_ignored: false,
+                regex: false,
+            },
+            cx,
+        );
+
+        let deploy = Deploy {
+            focus: true,
+            replace_enabled: false,
+            selection_search_enabled: true,
+        };
+
+        search_bar.update(cx, |search_bar, cx| {
+            assert_eq!(
+                search_bar.search_options,
+                SearchOptions::NONE,
+                "Should have no search options enabled by default"
+            );
+            search_bar.toggle_search_option(SearchOptions::WHOLE_WORD, cx);
+            assert_eq!(
+                search_bar.search_options,
+                SearchOptions::WHOLE_WORD,
+                "Should enable the option toggled"
+            );
+            assert!(
+                !search_bar.dismissed,
+                "Search bar should be present and visible"
+            );
+            search_bar.deploy(&deploy, cx);
+            assert_eq!(
+                search_bar.configured_options,
+                SearchOptions::NONE,
+                "Should have configured search options matching the settings"
+            );
+            assert_eq!(
+                search_bar.search_options,
+                SearchOptions::WHOLE_WORD,
+                "After (re)deploying, the option should still be enabled"
+            );
+
+            search_bar.dismiss(&Dismiss, cx);
+            search_bar.deploy(&deploy, cx);
+            assert_eq!(
+                search_bar.search_options,
+                SearchOptions::NONE,
+                "After hiding and showing the search bar, default options should be used"
+            );
+
+            search_bar.toggle_search_option(SearchOptions::REGEX, cx);
+            search_bar.toggle_search_option(SearchOptions::WHOLE_WORD, cx);
+            assert_eq!(
+                search_bar.search_options,
+                SearchOptions::REGEX | SearchOptions::WHOLE_WORD,
+                "Should enable the options toggled"
+            );
+            assert!(
+                !search_bar.dismissed,
+                "Search bar should be present and visible"
+            );
+        });
+
+        update_search_settings(
+            SearchSettings {
+                whole_word: false,
+                case_sensitive: true,
+                include_ignored: false,
+                regex: false,
+            },
+            cx,
+        );
+        search_bar.update(cx, |search_bar, cx| {
+            assert_eq!(
+                search_bar.search_options,
+                SearchOptions::REGEX | SearchOptions::WHOLE_WORD,
+                "Should have no search options enabled by default"
+            );
+
+            search_bar.deploy(&deploy, cx);
+            assert_eq!(
+                search_bar.configured_options,
+                SearchOptions::CASE_SENSITIVE,
+                "Should have configured search options matching the settings"
+            );
+            assert_eq!(
+                search_bar.search_options,
+                SearchOptions::REGEX | SearchOptions::WHOLE_WORD,
+                "Toggling a non-dismissed search bar with custom options should not change the default options"
+            );
+            search_bar.dismiss(&Dismiss, cx);
+            search_bar.deploy(&deploy, cx);
+            assert_eq!(
+                search_bar.search_options,
+                SearchOptions::CASE_SENSITIVE,
+                "After hiding and showing the search bar, default options should be used"
+            );
+        });
+    }
+
+    fn update_search_settings(search_settings: SearchSettings, cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            SettingsStore::update_global(cx, |store, cx| {
+                store.update_user_settings::<EditorSettings>(cx, |settings| {
+                    settings.search = Some(search_settings);
+                });
+            });
+        });
+    }
 }

From f019ad563f643a03e83083f04f23d38d62dd1181 Mon Sep 17 00:00:00 2001
From: Boris Verkhovskiy <boris.verk@gmail.com>
Date: Tue, 24 Sep 2024 06:46:06 -0600
Subject: [PATCH 288/762] Don't highlight Python function arguments as
 variables (#18252)

Works on
- #14892

Follow up to
- #17473
-
https://github.com/zed-industries/zed/pull/17984#issuecomment-2369815207

Release Notes:

- N/A
---
 crates/languages/src/python/highlights.scm | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/languages/src/python/highlights.scm b/crates/languages/src/python/highlights.scm
index 3255677bedc428..5edbefa7be747d 100644
--- a/crates/languages/src/python/highlights.scm
+++ b/crates/languages/src/python/highlights.scm
@@ -1,4 +1,3 @@
-(parameter (identifier) @variable)
 (attribute attribute: (identifier) @property)
 (type (identifier) @type)
 

From 93a4295f66c5a4c393e861deac7dcfb8c8dd45d2 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 24 Sep 2024 15:03:22 +0200
Subject: [PATCH 289/762] project search: Fix search results not being
 highlighted (#18273)

Closes #18254
Closes #18219
Closes #17690

This fixes the project search not highlighting all results.

The problem was relatively simple, even though it took a while to find
it: we inserted multiple excerpts concurrently and the order in the
multi-buffer ended up being wrong. Sorting the resulting `match_ranges`
fixed the problem, but as it turns out, we can do a better job by moving
the concurrency into the method on the MultiBuffer.

Performance is the same, but now the problem is fixed.

Release Notes:

- Fixed search results in project-wide search not being highlighted
consistently and navigation sometimes being broken (#18254, #18219,
#17690)

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/multi_buffer/src/multi_buffer.rs | 220 +++++++++++++++---------
 crates/search/src/project_search.rs     |  73 +++-----
 2 files changed, 163 insertions(+), 130 deletions(-)

diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index 0df196bb9829dc..828b39967d9e1f 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -5,7 +5,7 @@ use anyhow::{anyhow, Result};
 use clock::ReplicaId;
 use collections::{BTreeMap, Bound, HashMap, HashSet};
 use futures::{channel::mpsc, SinkExt};
-use gpui::{AppContext, EntityId, EventEmitter, Model, ModelContext};
+use gpui::{AppContext, EntityId, EventEmitter, Model, ModelContext, Task};
 use itertools::Itertools;
 use language::{
     language_settings::{language_settings, LanguageSettings},
@@ -1130,66 +1130,6 @@ impl MultiBuffer {
         }
     }
 
-    pub fn stream_excerpts_with_context_lines(
-        &mut self,
-        buffer: Model<Buffer>,
-        ranges: Vec<Range<text::Anchor>>,
-        context_line_count: u32,
-        cx: &mut ModelContext<Self>,
-    ) -> mpsc::Receiver<Range<Anchor>> {
-        let (buffer_id, buffer_snapshot) =
-            buffer.update(cx, |buffer, _| (buffer.remote_id(), buffer.snapshot()));
-
-        let (mut tx, rx) = mpsc::channel(256);
-        cx.spawn(move |this, mut cx| async move {
-            let mut excerpt_ranges = Vec::new();
-            let mut range_counts = Vec::new();
-            cx.background_executor()
-                .scoped(|scope| {
-                    scope.spawn(async {
-                        let (ranges, counts) =
-                            build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
-                        excerpt_ranges = ranges;
-                        range_counts = counts;
-                    });
-                })
-                .await;
-
-            let mut ranges = ranges.into_iter();
-            let mut range_counts = range_counts.into_iter();
-            for excerpt_ranges in excerpt_ranges.chunks(100) {
-                let excerpt_ids = match this.update(&mut cx, |this, cx| {
-                    this.push_excerpts(buffer.clone(), excerpt_ranges.iter().cloned(), cx)
-                }) {
-                    Ok(excerpt_ids) => excerpt_ids,
-                    Err(_) => return,
-                };
-
-                for (excerpt_id, range_count) in excerpt_ids.into_iter().zip(range_counts.by_ref())
-                {
-                    for range in ranges.by_ref().take(range_count) {
-                        let start = Anchor {
-                            buffer_id: Some(buffer_id),
-                            excerpt_id,
-                            text_anchor: range.start,
-                        };
-                        let end = Anchor {
-                            buffer_id: Some(buffer_id),
-                            excerpt_id,
-                            text_anchor: range.end,
-                        };
-                        if tx.send(start..end).await.is_err() {
-                            break;
-                        }
-                    }
-                }
-            }
-        })
-        .detach();
-
-        rx
-    }
-
     pub fn push_excerpts<O>(
         &mut self,
         buffer: Model<Buffer>,
@@ -1239,6 +1179,91 @@ impl MultiBuffer {
         anchor_ranges
     }
 
+    pub fn push_multiple_excerpts_with_context_lines(
+        &mut self,
+        buffers_with_ranges: Vec<(Model<Buffer>, Vec<Range<text::Anchor>>)>,
+        context_line_count: u32,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Vec<Range<Anchor>>> {
+        use futures::StreamExt;
+
+        let (excerpt_ranges_tx, mut excerpt_ranges_rx) = mpsc::channel(256);
+
+        let mut buffer_ids = Vec::with_capacity(buffers_with_ranges.len());
+
+        for (buffer, ranges) in buffers_with_ranges {
+            let (buffer_id, buffer_snapshot) =
+                buffer.update(cx, |buffer, _| (buffer.remote_id(), buffer.snapshot()));
+
+            buffer_ids.push(buffer_id);
+
+            cx.background_executor()
+                .spawn({
+                    let mut excerpt_ranges_tx = excerpt_ranges_tx.clone();
+
+                    async move {
+                        let (excerpt_ranges, counts) =
+                            build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
+                        excerpt_ranges_tx
+                            .send((buffer_id, buffer.clone(), ranges, excerpt_ranges, counts))
+                            .await
+                            .ok();
+                    }
+                })
+                .detach()
+        }
+
+        cx.spawn(move |this, mut cx| async move {
+            let mut results_by_buffer_id = HashMap::default();
+            while let Some((buffer_id, buffer, ranges, excerpt_ranges, range_counts)) =
+                excerpt_ranges_rx.next().await
+            {
+                results_by_buffer_id
+                    .insert(buffer_id, (buffer, ranges, excerpt_ranges, range_counts));
+            }
+
+            let mut multi_buffer_ranges = Vec::default();
+            'outer: for buffer_id in buffer_ids {
+                let Some((buffer, ranges, excerpt_ranges, range_counts)) =
+                    results_by_buffer_id.remove(&buffer_id)
+                else {
+                    continue;
+                };
+
+                let mut ranges = ranges.into_iter();
+                let mut range_counts = range_counts.into_iter();
+                for excerpt_ranges in excerpt_ranges.chunks(100) {
+                    let excerpt_ids = match this.update(&mut cx, |this, cx| {
+                        this.push_excerpts(buffer.clone(), excerpt_ranges.iter().cloned(), cx)
+                    }) {
+                        Ok(excerpt_ids) => excerpt_ids,
+                        Err(_) => continue 'outer,
+                    };
+
+                    for (excerpt_id, range_count) in
+                        excerpt_ids.into_iter().zip(range_counts.by_ref())
+                    {
+                        for range in ranges.by_ref().take(range_count) {
+                            let start = Anchor {
+                                buffer_id: Some(buffer_id),
+                                excerpt_id,
+                                text_anchor: range.start,
+                            };
+                            let end = Anchor {
+                                buffer_id: Some(buffer_id),
+                                excerpt_id,
+                                text_anchor: range.end,
+                            };
+                            multi_buffer_ranges.push(start..end);
+                        }
+                    }
+                }
+            }
+
+            multi_buffer_ranges
+        })
+    }
+
     pub fn insert_excerpts_after<O>(
         &mut self,
         prev_excerpt_id: ExcerptId,
@@ -5052,7 +5077,6 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use futures::StreamExt;
     use gpui::{AppContext, Context, TestAppContext};
     use language::{Buffer, Rope};
     use parking_lot::RwLock;
@@ -5601,41 +5625,67 @@ mod tests {
         );
     }
 
-    #[gpui::test]
-    async fn test_stream_excerpts_with_context_lines(cx: &mut TestAppContext) {
-        let buffer = cx.new_model(|cx| Buffer::local(sample_text(20, 3, 'a'), cx));
-        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
-        let anchor_ranges = multibuffer.update(cx, |multibuffer, cx| {
-            let snapshot = buffer.read(cx);
-            let ranges = vec![
-                snapshot.anchor_before(Point::new(3, 2))..snapshot.anchor_before(Point::new(4, 2)),
-                snapshot.anchor_before(Point::new(7, 1))..snapshot.anchor_before(Point::new(7, 3)),
-                snapshot.anchor_before(Point::new(15, 0))
-                    ..snapshot.anchor_before(Point::new(15, 0)),
-            ];
-            multibuffer.stream_excerpts_with_context_lines(buffer.clone(), ranges, 2, cx)
-        });
+    #[gpui::test(iterations = 100)]
+    async fn test_push_multiple_excerpts_with_context_lines(cx: &mut TestAppContext) {
+        let buffer_1 = cx.new_model(|cx| Buffer::local(sample_text(20, 3, 'a'), cx));
+        let buffer_2 = cx.new_model(|cx| Buffer::local(sample_text(15, 4, 'a'), cx));
+        let snapshot_1 = buffer_1.update(cx, |buffer, _| buffer.snapshot());
+        let snapshot_2 = buffer_2.update(cx, |buffer, _| buffer.snapshot());
+        let ranges_1 = vec![
+            snapshot_1.anchor_before(Point::new(3, 2))..snapshot_1.anchor_before(Point::new(4, 2)),
+            snapshot_1.anchor_before(Point::new(7, 1))..snapshot_1.anchor_before(Point::new(7, 3)),
+            snapshot_1.anchor_before(Point::new(15, 0))
+                ..snapshot_1.anchor_before(Point::new(15, 0)),
+        ];
+        let ranges_2 = vec![
+            snapshot_2.anchor_before(Point::new(2, 1))..snapshot_2.anchor_before(Point::new(3, 1)),
+            snapshot_2.anchor_before(Point::new(10, 0))
+                ..snapshot_2.anchor_before(Point::new(10, 2)),
+        ];
 
-        let anchor_ranges = anchor_ranges.collect::<Vec<_>>().await;
+        let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
+        let anchor_ranges = multibuffer
+            .update(cx, |multibuffer, cx| {
+                multibuffer.push_multiple_excerpts_with_context_lines(
+                    vec![(buffer_1.clone(), ranges_1), (buffer_2.clone(), ranges_2)],
+                    2,
+                    cx,
+                )
+            })
+            .await;
 
         let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
         assert_eq!(
             snapshot.text(),
             concat!(
-                "bbb\n", //
+                "bbb\n", // buffer_1
                 "ccc\n", //
-                "ddd\n", //
-                "eee\n", //
+                "ddd\n", // <-- excerpt 1
+                "eee\n", // <-- excerpt 1
                 "fff\n", //
                 "ggg\n", //
-                "hhh\n", //
+                "hhh\n", // <-- excerpt 2
                 "iii\n", //
                 "jjj\n", //
+                //
                 "nnn\n", //
                 "ooo\n", //
-                "ppp\n", //
+                "ppp\n", // <-- excerpt 3
                 "qqq\n", //
-                "rrr",   //
+                "rrr\n", //
+                //
+                "aaaa\n", // buffer 2
+                "bbbb\n", //
+                "cccc\n", // <-- excerpt 4
+                "dddd\n", // <-- excerpt 4
+                "eeee\n", //
+                "ffff\n", //
+                //
+                "iiii\n", //
+                "jjjj\n", //
+                "kkkk\n", // <-- excerpt 5
+                "llll\n", //
+                "mmmm",   //
             )
         );
 
@@ -5647,7 +5697,9 @@ mod tests {
             vec![
                 Point::new(2, 2)..Point::new(3, 2),
                 Point::new(6, 1)..Point::new(6, 3),
-                Point::new(11, 0)..Point::new(11, 0)
+                Point::new(11, 0)..Point::new(11, 0),
+                Point::new(16, 1)..Point::new(17, 1),
+                Point::new(22, 0)..Point::new(22, 2)
             ]
         );
     }
diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs
index d5b719a657628e..ea94d27daf61d5 100644
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -263,54 +263,35 @@ impl ProjectSearch {
 
             let mut limit_reached = false;
             while let Some(results) = matches.next().await {
-                let tasks = results
-                    .into_iter()
-                    .map(|result| {
-                        let this = this.clone();
-
-                        cx.spawn(|mut cx| async move {
-                            match result {
-                                project::search::SearchResult::Buffer { buffer, ranges } => {
-                                    let mut match_ranges_rx =
-                                        this.update(&mut cx, |this, cx| {
-                                            this.excerpts.update(cx, |excerpts, cx| {
-                                                excerpts.stream_excerpts_with_context_lines(
-                                                    buffer,
-                                                    ranges,
-                                                    editor::DEFAULT_MULTIBUFFER_CONTEXT,
-                                                    cx,
-                                                )
-                                            })
-                                        })?;
-
-                                    let mut match_ranges = vec![];
-                                    while let Some(range) = match_ranges_rx.next().await {
-                                        match_ranges.push(range);
-                                    }
-                                    anyhow::Ok((match_ranges, false))
-                                }
-                                project::search::SearchResult::LimitReached => {
-                                    anyhow::Ok((vec![], true))
-                                }
-                            }
-                        })
-                    })
-                    .collect::<Vec<_>>();
-
-                let result_ranges = futures::future::join_all(tasks).await;
-                let mut combined_ranges = vec![];
-                for (ranges, result_limit_reached) in result_ranges.into_iter().flatten() {
-                    combined_ranges.extend(ranges);
-                    if result_limit_reached {
-                        limit_reached = result_limit_reached;
+                let mut buffers_with_ranges = Vec::with_capacity(results.len());
+                for result in results {
+                    match result {
+                        project::search::SearchResult::Buffer { buffer, ranges } => {
+                            buffers_with_ranges.push((buffer, ranges));
+                        }
+                        project::search::SearchResult::LimitReached => {
+                            limit_reached = true;
+                        }
                     }
                 }
+
+                let match_ranges = this
+                    .update(&mut cx, |this, cx| {
+                        this.excerpts.update(cx, |excerpts, cx| {
+                            excerpts.push_multiple_excerpts_with_context_lines(
+                                buffers_with_ranges,
+                                editor::DEFAULT_MULTIBUFFER_CONTEXT,
+                                cx,
+                            )
+                        })
+                    })
+                    .ok()?
+                    .await;
+
                 this.update(&mut cx, |this, cx| {
-                    if !combined_ranges.is_empty() {
-                        this.no_results = Some(false);
-                        this.match_ranges.extend(combined_ranges);
-                        cx.notify();
-                    }
+                    this.no_results = Some(false);
+                    this.match_ranges.extend(match_ranges);
+                    cx.notify();
                 })
                 .ok()?;
             }
@@ -2745,7 +2726,7 @@ pub mod tests {
                 search_view
                     .results_editor
                     .update(cx, |editor, cx| editor.display_text(cx)),
-                "\n\n\nconst TWO: usize = one::ONE + one::ONE;\n\n\n\n\nconst ONE: usize = 1;\n",
+                "\n\n\nconst ONE: usize = 1;\n\n\n\n\nconst TWO: usize = one::ONE + one::ONE;\n",
                 "New search in directory should have a filter that matches a certain directory"
             );
                 })

From 336b4a5690cee0714ae704348cb4944544fcdc99 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 24 Sep 2024 09:15:25 -0400
Subject: [PATCH 290/762] Tweak close stale issues configuration (#18275)

Release Notes:

- N/A
---
 .github/workflows/close_stale_issues.yml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/close_stale_issues.yml
index afc28ec180b15e..be69ee2682cfc6 100644
--- a/.github/workflows/close_stale_issues.yml
+++ b/.github/workflows/close_stale_issues.yml
@@ -18,10 +18,14 @@ jobs:
 
             Thanks for your help!
           close-issue-message: "This issue was closed due to inactivity; feel free to open a new issue if you're still experiencing this problem!"
+          # We will increase `days-before-stale` to 365 on or after Jan 24th,
+          # 2024. This date marks one year since migrating issues from
+          # 'community' to 'zed' repository. The migration added activity to all
+          # issues, preventing 365 days from working until then.
           days-before-stale: 180
           days-before-close: 7
           any-of-issue-labels: "defect,panic / crash"
-          operations-per-run: 100
+          operations-per-run: 200
           ascending: true
           enable-statistics: true
           stale-issue-label: "stale"

From 3a2f0653d16bdbacf2e090c15bcf424d96de9e64 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 24 Sep 2024 09:44:27 -0400
Subject: [PATCH 291/762] Bump operations-per-run parameter in stale issues
 action (#18276)

Release Notes:

- N/A
---
 .github/workflows/close_stale_issues.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/close_stale_issues.yml
index be69ee2682cfc6..1f287fb5e3d4b9 100644
--- a/.github/workflows/close_stale_issues.yml
+++ b/.github/workflows/close_stale_issues.yml
@@ -25,7 +25,7 @@ jobs:
           days-before-stale: 180
           days-before-close: 7
           any-of-issue-labels: "defect,panic / crash"
-          operations-per-run: 200
+          operations-per-run: 1000
           ascending: true
           enable-statistics: true
           stale-issue-label: "stale"

From 437bcc0ce6a270487fe6b2e2c42117433abe0946 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 24 Sep 2024 16:46:11 +0200
Subject: [PATCH 292/762] ssh project: Handle multiple paths and worktrees
 correctly (#18277)

This makes SSH projects work with `ssh_connections` that have multiple
paths:

```json
{
  "ssh_connections": [
    {
      "host": "127.0.0.1",
      "projects": [
        {
          "paths": [
            "/Users/thorstenball/work/projs/go-proj",
            "/Users/thorstenball/work/projs/rust-proj"
          ]
        }
      ]
    }
  ]
}
```

@ConradIrwin @mikayla-maki since this wasn't really released yet, we
didn't create a full-on migration, so old ssh projects that were already
serialized need to either be manually deleted from the database, or the
whole local DB wiped.

Release Notes:

- N/A

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/recent_projects/src/recent_projects.rs |  8 +--
 crates/workspace/src/persistence.rs           | 64 ++++++++++---------
 crates/workspace/src/persistence/model.rs     | 42 +++++++-----
 crates/workspace/src/workspace.rs             |  8 +--
 4 files changed, 66 insertions(+), 56 deletions(-)

diff --git a/crates/recent_projects/src/recent_projects.rs b/crates/recent_projects/src/recent_projects.rs
index cb3d3ab65950f0..20393d63e1a3df 100644
--- a/crates/recent_projects/src/recent_projects.rs
+++ b/crates/recent_projects/src/recent_projects.rs
@@ -268,7 +268,7 @@ impl PickerDelegate for RecentProjectsDelegate {
                                 .as_ref()
                                 .map(|port| port.to_string())
                                 .unwrap_or_default(),
-                            ssh_project.path,
+                            ssh_project.paths.join(","),
                             ssh_project
                                 .user
                                 .as_ref()
@@ -403,7 +403,7 @@ impl PickerDelegate for RecentProjectsDelegate {
                                 password: None,
                             };
 
-                            let paths = vec![PathBuf::from(ssh_project.path.clone())];
+                            let paths = ssh_project.paths.iter().map(PathBuf::from).collect();
 
                             cx.spawn(|_, mut cx| async move {
                                 open_ssh_project(connection_options, paths, app_state, open_options, &mut cx).await
@@ -460,9 +460,7 @@ impl PickerDelegate for RecentProjectsDelegate {
                     .filter_map(|i| paths.paths().get(*i).cloned())
                     .collect(),
             ),
-            SerializedWorkspaceLocation::Ssh(ssh_project) => {
-                Arc::new(vec![PathBuf::from(ssh_project.ssh_url())])
-            }
+            SerializedWorkspaceLocation::Ssh(ssh_project) => Arc::new(ssh_project.ssh_urls()),
             SerializedWorkspaceLocation::DevServer(dev_server_project) => {
                 Arc::new(vec![PathBuf::from(format!(
                     "{}:{}",
diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs
index 034328a30b2ffa..3a0b8eabb90e6b 100644
--- a/crates/workspace/src/persistence.rs
+++ b/crates/workspace/src/persistence.rs
@@ -366,6 +366,9 @@ define_connection! {
         );
         ALTER TABLE workspaces ADD COLUMN ssh_project_id INTEGER REFERENCES ssh_projects(id) ON DELETE CASCADE;
     ),
+    sql!(
+        ALTER TABLE ssh_projects RENAME COLUMN path TO paths;
+    ),
     ];
 }
 
@@ -769,39 +772,40 @@ impl WorkspaceDb {
         &self,
         host: String,
         port: Option<u16>,
-        path: String,
+        paths: Vec<String>,
         user: Option<String>,
     ) -> Result<SerializedSshProject> {
+        let paths = serde_json::to_string(&paths)?;
         if let Some(project) = self
-            .get_ssh_project(host.clone(), port, path.clone(), user.clone())
+            .get_ssh_project(host.clone(), port, paths.clone(), user.clone())
             .await?
         {
             Ok(project)
         } else {
-            self.insert_ssh_project(host, port, path, user)
+            self.insert_ssh_project(host, port, paths, user)
                 .await?
                 .ok_or_else(|| anyhow!("failed to insert ssh project"))
         }
     }
 
     query! {
-        async fn get_ssh_project(host: String, port: Option<u16>, path: String, user: Option<String>) -> Result<Option<SerializedSshProject>> {
-            SELECT id, host, port, path, user
+        async fn get_ssh_project(host: String, port: Option<u16>, paths: String, user: Option<String>) -> Result<Option<SerializedSshProject>> {
+            SELECT id, host, port, paths, user
             FROM ssh_projects
-            WHERE host IS ? AND port IS ? AND path IS ? AND user IS ?
+            WHERE host IS ? AND port IS ? AND paths IS ? AND user IS ?
             LIMIT 1
         }
     }
 
     query! {
-        async fn insert_ssh_project(host: String, port: Option<u16>, path: String, user: Option<String>) -> Result<Option<SerializedSshProject>> {
+        async fn insert_ssh_project(host: String, port: Option<u16>, paths: String, user: Option<String>) -> Result<Option<SerializedSshProject>> {
             INSERT INTO ssh_projects(
                 host,
                 port,
-                path,
+                paths,
                 user
             ) VALUES (?1, ?2, ?3, ?4)
-            RETURNING id, host, port, path, user
+            RETURNING id, host, port, paths, user
         }
     }
 
@@ -840,7 +844,7 @@ impl WorkspaceDb {
 
     query! {
         fn ssh_projects() -> Result<Vec<SerializedSshProject>> {
-            SELECT id, host, port, path, user
+            SELECT id, host, port, paths, user
             FROM ssh_projects
         }
     }
@@ -1656,45 +1660,45 @@ mod tests {
     async fn test_get_or_create_ssh_project() {
         let db = WorkspaceDb(open_test_db("test_get_or_create_ssh_project").await);
 
-        let (host, port, path, user) = (
+        let (host, port, paths, user) = (
             "example.com".to_string(),
             Some(22_u16),
-            "/home/user".to_string(),
+            vec!["/home/user".to_string(), "/etc/nginx".to_string()],
             Some("user".to_string()),
         );
 
         let project = db
-            .get_or_create_ssh_project(host.clone(), port, path.clone(), user.clone())
+            .get_or_create_ssh_project(host.clone(), port, paths.clone(), user.clone())
             .await
             .unwrap();
 
         assert_eq!(project.host, host);
-        assert_eq!(project.path, path);
+        assert_eq!(project.paths, paths);
         assert_eq!(project.user, user);
 
         // Test that calling the function again with the same parameters returns the same project
         let same_project = db
-            .get_or_create_ssh_project(host.clone(), port, path.clone(), user.clone())
+            .get_or_create_ssh_project(host.clone(), port, paths.clone(), user.clone())
             .await
             .unwrap();
 
         assert_eq!(project.id, same_project.id);
 
         // Test with different parameters
-        let (host2, path2, user2) = (
+        let (host2, paths2, user2) = (
             "otherexample.com".to_string(),
-            "/home/otheruser".to_string(),
+            vec!["/home/otheruser".to_string()],
             Some("otheruser".to_string()),
         );
 
         let different_project = db
-            .get_or_create_ssh_project(host2.clone(), None, path2.clone(), user2.clone())
+            .get_or_create_ssh_project(host2.clone(), None, paths2.clone(), user2.clone())
             .await
             .unwrap();
 
         assert_ne!(project.id, different_project.id);
         assert_eq!(different_project.host, host2);
-        assert_eq!(different_project.path, path2);
+        assert_eq!(different_project.paths, paths2);
         assert_eq!(different_project.user, user2);
     }
 
@@ -1702,25 +1706,25 @@ mod tests {
     async fn test_get_or_create_ssh_project_with_null_user() {
         let db = WorkspaceDb(open_test_db("test_get_or_create_ssh_project_with_null_user").await);
 
-        let (host, port, path, user) = (
+        let (host, port, paths, user) = (
             "example.com".to_string(),
             None,
-            "/home/user".to_string(),
+            vec!["/home/user".to_string()],
             None,
         );
 
         let project = db
-            .get_or_create_ssh_project(host.clone(), port, path.clone(), None)
+            .get_or_create_ssh_project(host.clone(), port, paths.clone(), None)
             .await
             .unwrap();
 
         assert_eq!(project.host, host);
-        assert_eq!(project.path, path);
+        assert_eq!(project.paths, paths);
         assert_eq!(project.user, None);
 
         // Test that calling the function again with the same parameters returns the same project
         let same_project = db
-            .get_or_create_ssh_project(host.clone(), port, path.clone(), user.clone())
+            .get_or_create_ssh_project(host.clone(), port, paths.clone(), user.clone())
             .await
             .unwrap();
 
@@ -1735,32 +1739,32 @@ mod tests {
             (
                 "example.com".to_string(),
                 None,
-                "/home/user".to_string(),
+                vec!["/home/user".to_string()],
                 None,
             ),
             (
                 "anotherexample.com".to_string(),
                 Some(123_u16),
-                "/home/user2".to_string(),
+                vec!["/home/user2".to_string()],
                 Some("user2".to_string()),
             ),
             (
                 "yetanother.com".to_string(),
                 Some(345_u16),
-                "/home/user3".to_string(),
+                vec!["/home/user3".to_string(), "/proc/1234/exe".to_string()],
                 None,
             ),
         ];
 
-        for (host, port, path, user) in projects.iter() {
+        for (host, port, paths, user) in projects.iter() {
             let project = db
-                .get_or_create_ssh_project(host.clone(), *port, path.clone(), user.clone())
+                .get_or_create_ssh_project(host.clone(), *port, paths.clone(), user.clone())
                 .await
                 .unwrap();
 
             assert_eq!(&project.host, host);
             assert_eq!(&project.port, port);
-            assert_eq!(&project.path, path);
+            assert_eq!(&project.paths, paths);
             assert_eq!(&project.user, user);
         }
 
diff --git a/crates/workspace/src/persistence/model.rs b/crates/workspace/src/persistence/model.rs
index 0ad3fa5e606e5b..7528e4c3934c57 100644
--- a/crates/workspace/src/persistence/model.rs
+++ b/crates/workspace/src/persistence/model.rs
@@ -26,24 +26,29 @@ pub struct SerializedSshProject {
     pub id: SshProjectId,
     pub host: String,
     pub port: Option<u16>,
-    pub path: String,
+    pub paths: Vec<String>,
     pub user: Option<String>,
 }
 
 impl SerializedSshProject {
-    pub fn ssh_url(&self) -> String {
-        let mut result = String::from("ssh://");
-        if let Some(user) = &self.user {
-            result.push_str(user);
-            result.push('@');
-        }
-        result.push_str(&self.host);
-        if let Some(port) = &self.port {
-            result.push(':');
-            result.push_str(&port.to_string());
-        }
-        result.push_str(&self.path);
-        result
+    pub fn ssh_urls(&self) -> Vec<PathBuf> {
+        self.paths
+            .iter()
+            .map(|path| {
+                let mut result = String::new();
+                if let Some(user) = &self.user {
+                    result.push_str(user);
+                    result.push('@');
+                }
+                result.push_str(&self.host);
+                if let Some(port) = &self.port {
+                    result.push(':');
+                    result.push_str(&port.to_string());
+                }
+                result.push_str(path);
+                PathBuf::from(result)
+            })
+            .collect()
     }
 }
 
@@ -58,7 +63,8 @@ impl Bind for &SerializedSshProject {
         let next_index = statement.bind(&self.id.0, start_index)?;
         let next_index = statement.bind(&self.host, next_index)?;
         let next_index = statement.bind(&self.port, next_index)?;
-        let next_index = statement.bind(&self.path, next_index)?;
+        let raw_paths = serde_json::to_string(&self.paths)?;
+        let next_index = statement.bind(&raw_paths, next_index)?;
         statement.bind(&self.user, next_index)
     }
 }
@@ -68,7 +74,9 @@ impl Column for SerializedSshProject {
         let id = statement.column_int64(start_index)?;
         let host = statement.column_text(start_index + 1)?.to_string();
         let (port, _) = Option::<u16>::column(statement, start_index + 2)?;
-        let path = statement.column_text(start_index + 3)?.to_string();
+        let raw_paths = statement.column_text(start_index + 3)?.to_string();
+        let paths: Vec<String> = serde_json::from_str(&raw_paths)?;
+
         let (user, _) = Option::<String>::column(statement, start_index + 4)?;
 
         Ok((
@@ -76,7 +84,7 @@ impl Column for SerializedSshProject {
                 id: SshProjectId(id as u64),
                 host,
                 port,
-                path,
+                paths,
                 user,
             },
             start_index + 5,
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index b732eb5bc70c1b..98f793c234aaeb 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -5516,14 +5516,14 @@ pub fn open_ssh_project(
     cx: &mut AppContext,
 ) -> Task<Result<()>> {
     cx.spawn(|mut cx| async move {
-        // TODO: Handle multiple paths
-        let path = paths.iter().next().cloned().unwrap_or_default();
-
         let serialized_ssh_project = persistence::DB
             .get_or_create_ssh_project(
                 connection_options.host.clone(),
                 connection_options.port,
-                path.to_string_lossy().to_string(),
+                paths
+                    .iter()
+                    .map(|path| path.to_string_lossy().to_string())
+                    .collect::<Vec<_>>(),
                 connection_options.username.clone(),
             )
             .await?;

From e87d6da2a67c46839c32512c1287ed7a435e2d0d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastijan=20Kelneri=C4=8D?= <sebastijan.kelneric@sebba.dev>
Date: Tue, 24 Sep 2024 16:49:07 +0200
Subject: [PATCH 293/762] Implement grapheme support for supermaven completions
 (#18279)

Closes [#18278](https://github.com/zed-industries/zed/issues/18278)

Release Notes:

- Fixed a panic when graphemes are included in supermaven completions
---
 Cargo.lock                                    |  1 +
 crates/supermaven/Cargo.toml                  |  1 +
 .../src/supermaven_completion_provider.rs     | 22 ++++++++++---------
 3 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 09a68973340a57..9c6d2fb7b9b842 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11006,6 +11006,7 @@ dependencies = [
  "text",
  "theme",
  "ui",
+ "unicode-segmentation",
  "util",
  "windows 0.58.0",
 ]
diff --git a/crates/supermaven/Cargo.toml b/crates/supermaven/Cargo.toml
index b8f85c0f056184..e04d0ef51bbf83 100644
--- a/crates/supermaven/Cargo.toml
+++ b/crates/supermaven/Cargo.toml
@@ -29,6 +29,7 @@ supermaven_api.workspace = true
 smol.workspace = true
 text.workspace = true
 ui.workspace = true
+unicode-segmentation.workspace = true
 util.workspace = true
 
 [target.'cfg(target_os = "windows")'.dependencies]
diff --git a/crates/supermaven/src/supermaven_completion_provider.rs b/crates/supermaven/src/supermaven_completion_provider.rs
index 261ce372d9f717..2a7fc31c0db8fe 100644
--- a/crates/supermaven/src/supermaven_completion_provider.rs
+++ b/crates/supermaven/src/supermaven_completion_provider.rs
@@ -12,6 +12,7 @@ use std::{
     time::Duration,
 };
 use text::{ToOffset, ToPoint};
+use unicode_segmentation::UnicodeSegmentation;
 
 pub const DEBOUNCE_TIMEOUT: Duration = Duration::from_millis(75);
 
@@ -54,33 +55,34 @@ fn completion_state_from_diff(
 ) -> CompletionProposal {
     let buffer_text = snapshot
         .text_for_range(delete_range.clone())
-        .collect::<String>()
-        .chars()
-        .collect::<Vec<char>>();
+        .collect::<String>();
 
     let mut inlays: Vec<InlayProposal> = Vec::new();
 
-    let completion = completion_text.chars().collect::<Vec<char>>();
+    let completion_graphemes: Vec<&str> = completion_text.graphemes(true).collect();
+    let buffer_graphemes: Vec<&str> = buffer_text.graphemes(true).collect();
 
     let mut offset = position.to_offset(&snapshot);
 
     let mut i = 0;
     let mut j = 0;
-    while i < completion.len() && j < buffer_text.len() {
+    while i < completion_graphemes.len() && j < buffer_graphemes.len() {
         // find the next instance of the buffer text in the completion text.
-        let k = completion[i..].iter().position(|c| *c == buffer_text[j]);
+        let k = completion_graphemes[i..]
+            .iter()
+            .position(|c| *c == buffer_graphemes[j]);
         match k {
             Some(k) => {
                 if k != 0 {
                     // the range from the current position to item is an inlay.
                     inlays.push(InlayProposal::Suggestion(
                         snapshot.anchor_after(offset),
-                        completion_text[i..i + k].into(),
+                        completion_graphemes[i..i + k].join("").into(),
                     ));
                 }
                 i += k + 1;
                 j += 1;
-                offset.add_assign(1);
+                offset.add_assign(buffer_graphemes[j - 1].len());
             }
             None => {
                 // there are no more matching completions, so drop the remaining
@@ -90,11 +92,11 @@ fn completion_state_from_diff(
         }
     }
 
-    if j == buffer_text.len() && i < completion.len() {
+    if j == buffer_graphemes.len() && i < completion_graphemes.len() {
         // there is leftover completion text, so drop it as an inlay.
         inlays.push(InlayProposal::Suggestion(
             snapshot.anchor_after(offset),
-            completion_text[i..completion_text.len()].into(),
+            completion_graphemes[i..].join("").into(),
         ));
     }
 

From 2470db490115322720f85e2ad57e922de930ee1b Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Tue, 24 Sep 2024 18:21:26 +0300
Subject: [PATCH 294/762] Reuse buffer search queries on tab switch (#18281)

Before this change, with a large chunk of text as a search query (N*10^5
in my experiments) and the buffer search bar visible, switching between
editor tabs was very slow, even if the editors were N*10^2 lines long.

The slow switch was caused by Zed always re-creating the Aho-Corasick
queries, which is now reused.

Release Notes:

- Improved buffer search performance when switching tabs

Co-authored-by: Piotr Osiewicz <piotr@zed.dev>
---
 crates/search/src/buffer_search.rs | 98 +++++++++++++++++-------------
 1 file changed, 55 insertions(+), 43 deletions(-)

diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs
index 1c37bfd481dcb9..9ba7dfd7965b15 100644
--- a/crates/search/src/buffer_search.rs
+++ b/crates/search/src/buffer_search.rs
@@ -440,7 +440,7 @@ impl ToolbarItemView for BufferSearchBar {
                 ));
 
             self.active_searchable_item = Some(searchable_item_handle);
-            drop(self.update_matches(cx));
+            drop(self.update_matches(true, cx));
             if !self.dismissed {
                 return ToolbarItemLocation::Secondary;
             }
@@ -701,7 +701,8 @@ impl BufferSearchBar {
         cx: &mut ViewContext<Self>,
     ) -> oneshot::Receiver<()> {
         let options = options.unwrap_or(self.default_options);
-        if query != self.query(cx) || self.search_options != options {
+        let updated = query != self.query(cx) || self.search_options != options;
+        if updated {
             self.query_editor.update(cx, |query_editor, cx| {
                 query_editor.buffer().update(cx, |query_buffer, cx| {
                     let len = query_buffer.len(cx);
@@ -712,7 +713,7 @@ impl BufferSearchBar {
             self.clear_matches(cx);
             cx.notify();
         }
-        self.update_matches(cx)
+        self.update_matches(!updated, cx)
     }
 
     fn render_search_option_button(
@@ -738,7 +739,7 @@ impl BufferSearchBar {
     ) {
         self.search_options.toggle(search_option);
         self.default_options = self.search_options;
-        drop(self.update_matches(cx));
+        drop(self.update_matches(false, cx));
         cx.notify();
     }
 
@@ -841,7 +842,7 @@ impl BufferSearchBar {
             editor::EditorEvent::Edited { .. } => {
                 self.smartcase(cx);
                 self.clear_matches(cx);
-                let search = self.update_matches(cx);
+                let search = self.update_matches(false, cx);
 
                 let width = editor.update(cx, |editor, cx| {
                     let text_layout_details = editor.text_layout_details(cx);
@@ -879,7 +880,7 @@ impl BufferSearchBar {
     fn on_active_searchable_item_event(&mut self, event: &SearchEvent, cx: &mut ViewContext<Self>) {
         match event {
             SearchEvent::MatchesInvalidated => {
-                drop(self.update_matches(cx));
+                drop(self.update_matches(false, cx));
             }
             SearchEvent::ActiveMatchChanged => self.update_match_index(cx),
         }
@@ -897,7 +898,7 @@ impl BufferSearchBar {
         if let Some(active_item) = self.active_searchable_item.as_mut() {
             self.selection_search_enabled = !self.selection_search_enabled;
             active_item.toggle_filtered_search_ranges(self.selection_search_enabled, cx);
-            drop(self.update_matches(cx));
+            drop(self.update_matches(false, cx));
             cx.notify();
         }
     }
@@ -937,7 +938,11 @@ impl BufferSearchBar {
             .extend(active_item_matches);
     }
 
-    fn update_matches(&mut self, cx: &mut ViewContext<Self>) -> oneshot::Receiver<()> {
+    fn update_matches(
+        &mut self,
+        reuse_existing_query: bool,
+        cx: &mut ViewContext<Self>,
+    ) -> oneshot::Receiver<()> {
         let (done_tx, done_rx) = oneshot::channel();
         let query = self.query(cx);
         self.pending_search.take();
@@ -949,44 +954,51 @@ impl BufferSearchBar {
                 let _ = done_tx.send(());
                 cx.notify();
             } else {
-                let query: Arc<_> = if self.search_options.contains(SearchOptions::REGEX) {
-                    match SearchQuery::regex(
-                        query,
-                        self.search_options.contains(SearchOptions::WHOLE_WORD),
-                        self.search_options.contains(SearchOptions::CASE_SENSITIVE),
-                        false,
-                        Default::default(),
-                        Default::default(),
-                        None,
-                    ) {
-                        Ok(query) => query.with_replacement(self.replacement(cx)),
-                        Err(_) => {
-                            self.query_contains_error = true;
-                            self.clear_active_searchable_item_matches(cx);
-                            cx.notify();
-                            return done_rx;
-                        }
-                    }
+                let query: Arc<_> = if let Some(search) =
+                    self.active_search.take().filter(|_| reuse_existing_query)
+                {
+                    search
                 } else {
-                    match SearchQuery::text(
-                        query,
-                        self.search_options.contains(SearchOptions::WHOLE_WORD),
-                        self.search_options.contains(SearchOptions::CASE_SENSITIVE),
-                        false,
-                        Default::default(),
-                        Default::default(),
-                        None,
-                    ) {
-                        Ok(query) => query.with_replacement(self.replacement(cx)),
-                        Err(_) => {
-                            self.query_contains_error = true;
-                            self.clear_active_searchable_item_matches(cx);
-                            cx.notify();
-                            return done_rx;
+                    if self.search_options.contains(SearchOptions::REGEX) {
+                        match SearchQuery::regex(
+                            query,
+                            self.search_options.contains(SearchOptions::WHOLE_WORD),
+                            self.search_options.contains(SearchOptions::CASE_SENSITIVE),
+                            false,
+                            Default::default(),
+                            Default::default(),
+                            None,
+                        ) {
+                            Ok(query) => query.with_replacement(self.replacement(cx)),
+                            Err(_) => {
+                                self.query_contains_error = true;
+                                self.clear_active_searchable_item_matches(cx);
+                                cx.notify();
+                                return done_rx;
+                            }
+                        }
+                    } else {
+                        match SearchQuery::text(
+                            query,
+                            self.search_options.contains(SearchOptions::WHOLE_WORD),
+                            self.search_options.contains(SearchOptions::CASE_SENSITIVE),
+                            false,
+                            Default::default(),
+                            Default::default(),
+                            None,
+                        ) {
+                            Ok(query) => query.with_replacement(self.replacement(cx)),
+                            Err(_) => {
+                                self.query_contains_error = true;
+                                self.clear_active_searchable_item_matches(cx);
+                                cx.notify();
+                                return done_rx;
+                            }
                         }
                     }
-                }
-                .into();
+                    .into()
+                };
+
                 self.active_search = Some(query.clone());
                 let query_text = query.as_str().to_string();
 

From 21be70f278acc2818c628bb0e8d33c8648655e34 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 24 Sep 2024 11:40:08 -0400
Subject: [PATCH 295/762] Improve diff hunks (#18283)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR improves the display of diff hunks:

- Deleted hunks now show a regular line indicator in the gutter when
expanded
- The rounding on the diff indicators in the gutter has been removed.

We also did some refactoring to ensure the sizing of the diff indicators
in the gutter were consistent.

#### Collapsed

<img width="1624" alt="Screenshot 2024-09-24 at 11 13 26 AM"
src="https://github.com/user-attachments/assets/f864dc83-cbbc-4d81-a62b-65c406ed310a">

#### Expanded

<img width="1624" alt="Screenshot 2024-09-24 at 11 13 35 AM"
src="https://github.com/user-attachments/assets/04d382ca-e0e6-4f1c-92eb-cd1e3a031c2c">


Release Notes:

- Improved the appearance of diff hunks in the editor.

---------

Co-authored-by: Max <max@zed.dev>
---
 crates/editor/src/editor.rs    |   5 --
 crates/editor/src/element.rs   | 120 +++++++++++++++++++++++++--------
 crates/editor/src/git.rs       |   4 +-
 crates/editor/src/hunk_diff.rs |  77 +++++++++------------
 4 files changed, 124 insertions(+), 82 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index dc536471023f08..a32910e78ab973 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -12473,11 +12473,6 @@ impl Editor {
         Some(gpui::Point::new(source_x, source_y))
     }
 
-    fn gutter_bounds(&self) -> Option<Bounds<Pixels>> {
-        let bounds = self.last_bounds?;
-        Some(element::gutter_bounds(bounds, self.gutter_dimensions))
-    }
-
     pub fn has_active_completions_menu(&self) -> bool {
         self.context_menu.read().as_ref().map_or(false, |menu| {
             menu.visible() && matches!(menu, ContextMenu::Completions(_))
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index d4075431ff602b..3be71aeefba942 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -1269,6 +1269,7 @@ impl EditorElement {
         line_height: Pixels,
         gutter_hitbox: &Hitbox,
         display_rows: Range<DisplayRow>,
+        anchor_range: Range<Anchor>,
         snapshot: &EditorSnapshot,
         cx: &mut WindowContext,
     ) -> Vec<(DisplayDiffHunk, Option<Hitbox>)> {
@@ -1289,30 +1290,84 @@ impl EditorElement {
             .git
             .git_gutter
             .unwrap_or_default();
-        let display_hunks = buffer_snapshot
-            .git_diff_hunks_in_range(buffer_start_row..buffer_end_row)
-            .map(|hunk| diff_hunk_to_display(&hunk, snapshot))
-            .dedup()
-            .map(|hunk| match git_gutter_setting {
-                GitGutterSetting::TrackedFiles => {
-                    let hitbox = match hunk {
-                        DisplayDiffHunk::Unfolded { .. } => {
-                            let hunk_bounds = Self::diff_hunk_bounds(
-                                snapshot,
-                                line_height,
-                                gutter_hitbox.bounds,
-                                &hunk,
-                            );
-                            Some(cx.insert_hitbox(hunk_bounds, true))
+
+        self.editor.update(cx, |editor, cx| {
+            let expanded_hunks = &editor.expanded_hunks.hunks;
+            let expanded_hunks_start_ix = expanded_hunks
+                .binary_search_by(|hunk| {
+                    hunk.hunk_range
+                        .end
+                        .cmp(&anchor_range.start, &buffer_snapshot)
+                        .then(Ordering::Less)
+                })
+                .unwrap_err();
+            let mut expanded_hunks = expanded_hunks[expanded_hunks_start_ix..].iter().peekable();
+
+            let display_hunks = buffer_snapshot
+                .git_diff_hunks_in_range(buffer_start_row..buffer_end_row)
+                .filter_map(|hunk| {
+                    let mut display_hunk = diff_hunk_to_display(&hunk, snapshot);
+
+                    if let DisplayDiffHunk::Unfolded {
+                        multi_buffer_range,
+                        status,
+                        ..
+                    } = &mut display_hunk
+                    {
+                        let mut is_expanded = false;
+                        while let Some(expanded_hunk) = expanded_hunks.peek() {
+                            match expanded_hunk
+                                .hunk_range
+                                .start
+                                .cmp(&multi_buffer_range.start, &buffer_snapshot)
+                            {
+                                Ordering::Less => {
+                                    expanded_hunks.next();
+                                }
+                                Ordering::Equal => {
+                                    is_expanded = true;
+                                    break;
+                                }
+                                Ordering::Greater => {
+                                    break;
+                                }
+                            }
                         }
-                        DisplayDiffHunk::Folded { .. } => None,
-                    };
-                    (hunk, hitbox)
-                }
-                GitGutterSetting::Hide => (hunk, None),
-            })
-            .collect();
-        display_hunks
+                        match status {
+                            DiffHunkStatus::Added => {}
+                            DiffHunkStatus::Modified => {}
+                            DiffHunkStatus::Removed => {
+                                if is_expanded {
+                                    return None;
+                                }
+                            }
+                        }
+                    }
+
+                    Some(display_hunk)
+                })
+                .dedup()
+                .map(|hunk| match git_gutter_setting {
+                    GitGutterSetting::TrackedFiles => {
+                        let hitbox = match hunk {
+                            DisplayDiffHunk::Unfolded { .. } => {
+                                let hunk_bounds = Self::diff_hunk_bounds(
+                                    snapshot,
+                                    line_height,
+                                    gutter_hitbox.bounds,
+                                    &hunk,
+                                );
+                                Some(cx.insert_hitbox(hunk_bounds, true))
+                            }
+                            DisplayDiffHunk::Folded { .. } => None,
+                        };
+                        (hunk, hitbox)
+                    }
+                    GitGutterSetting::Hide => (hunk, None),
+                })
+                .collect();
+            display_hunks
+        })
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -3187,7 +3242,7 @@ impl EditorElement {
                         Some((
                             hunk_bounds,
                             cx.theme().status().modified,
-                            Corners::all(1. * line_height),
+                            Corners::all(px(0.)),
                         ))
                     }
                     DisplayDiffHunk::Unfolded { status, .. } => {
@@ -3195,12 +3250,12 @@ impl EditorElement {
                             DiffHunkStatus::Added => (
                                 hunk_hitbox.bounds,
                                 cx.theme().status().created,
-                                Corners::all(0.05 * line_height),
+                                Corners::all(px(0.)),
                             ),
                             DiffHunkStatus::Modified => (
                                 hunk_hitbox.bounds,
                                 cx.theme().status().modified,
-                                Corners::all(0.05 * line_height),
+                                Corners::all(px(0.)),
                             ),
                             DiffHunkStatus::Removed => (
                                 Bounds::new(
@@ -3244,7 +3299,7 @@ impl EditorElement {
                 let start_y = display_row.as_f32() * line_height - scroll_top;
                 let end_y = start_y + line_height;
 
-                let width = 0.275 * line_height;
+                let width = Self::diff_hunk_strip_width(line_height);
                 let highlight_origin = gutter_bounds.origin + point(px(0.), start_y);
                 let highlight_size = size(width, end_y - start_y);
                 Bounds::new(highlight_origin, highlight_size)
@@ -3277,7 +3332,7 @@ impl EditorElement {
                     let start_y = start_row.as_f32() * line_height - scroll_top;
                     let end_y = end_row_in_current_excerpt.as_f32() * line_height - scroll_top;
 
-                    let width = 0.275 * line_height;
+                    let width = Self::diff_hunk_strip_width(line_height);
                     let highlight_origin = gutter_bounds.origin + point(px(0.), start_y);
                     let highlight_size = size(width, end_y - start_y);
                     Bounds::new(highlight_origin, highlight_size)
@@ -3289,7 +3344,7 @@ impl EditorElement {
                     let start_y = row.as_f32() * line_height - offset - scroll_top;
                     let end_y = start_y + line_height;
 
-                    let width = 0.35 * line_height;
+                    let width = (0.35 * line_height).floor();
                     let highlight_origin = gutter_bounds.origin + point(px(0.), start_y);
                     let highlight_size = size(width, end_y - start_y);
                     Bounds::new(highlight_origin, highlight_size)
@@ -3298,6 +3353,12 @@ impl EditorElement {
         }
     }
 
+    /// Returns the width of the diff strip that will be displayed in the gutter.
+    pub(super) fn diff_hunk_strip_width(line_height: Pixels) -> Pixels {
+        // We floor the value to prevent pixel rounding.
+        (0.275 * line_height).floor()
+    }
+
     fn paint_gutter_indicators(&self, layout: &mut EditorLayout, cx: &mut WindowContext) {
         cx.paint_layer(layout.gutter_hitbox.bounds, |cx| {
             cx.with_element_namespace("gutter_fold_toggles", |cx| {
@@ -5158,6 +5219,7 @@ impl Element for EditorElement {
                         line_height,
                         &gutter_hitbox,
                         start_row..end_row,
+                        start_anchor..end_anchor,
                         &snapshot,
                         cx,
                     );
diff --git a/crates/editor/src/git.rs b/crates/editor/src/git.rs
index 79b78d5d148488..fb18ca45a2a2ff 100644
--- a/crates/editor/src/git.rs
+++ b/crates/editor/src/git.rs
@@ -90,8 +90,8 @@ pub fn diff_hunk_to_display(
         let hunk_end_row = hunk.row_range.end.max(hunk.row_range.start);
         let hunk_end_point = Point::new(hunk_end_row.0, 0);
 
-        let multi_buffer_start = snapshot.buffer_snapshot.anchor_after(hunk_start_point);
-        let multi_buffer_end = snapshot.buffer_snapshot.anchor_before(hunk_end_point);
+        let multi_buffer_start = snapshot.buffer_snapshot.anchor_before(hunk_start_point);
+        let multi_buffer_end = snapshot.buffer_snapshot.anchor_after(hunk_end_point);
         let end = hunk_end_point.to_display_point(snapshot).row();
 
         DisplayDiffHunk::Unfolded {
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index 917d07ec4ee85b..90836cee51683c 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -14,8 +14,8 @@ use multi_buffer::{
 use settings::SettingsStore;
 use text::{BufferId, Point};
 use ui::{
-    div, h_flex, rems, v_flex, ActiveTheme, Context as _, ContextMenu, InteractiveElement,
-    IntoElement, ParentElement, Pixels, Styled, ViewContext, VisualContext,
+    prelude::*, ActiveTheme, ContextMenu, InteractiveElement, IntoElement, ParentElement, Pixels,
+    Styled, ViewContext, VisualContext,
 };
 use util::{debug_panic, RangeExt};
 
@@ -38,7 +38,7 @@ pub(super) struct HoveredHunk {
 
 #[derive(Debug, Default)]
 pub(super) struct ExpandedHunks {
-    hunks: Vec<ExpandedHunk>,
+    pub(crate) hunks: Vec<ExpandedHunk>,
     diff_base: HashMap<BufferId, DiffBaseBuffer>,
     hunk_update_tasks: HashMap<Option<BufferId>, Task<()>>,
 }
@@ -414,39 +414,22 @@ impl Editor {
                 style: BlockStyle::Flex,
                 disposition: BlockDisposition::Above,
                 render: Box::new(move |cx| {
-                    let Some(gutter_bounds) = editor.read(cx).gutter_bounds() else {
-                        return div().into_any_element();
-                    };
-                    let (gutter_dimensions, hunk_bounds, close_button) =
-                        editor.update(cx.context, |editor, cx| {
-                            let editor_snapshot = editor.snapshot(cx);
-                            let hunk_display_range = hunk
-                                .multi_buffer_range
-                                .clone()
-                                .to_display_points(&editor_snapshot);
-                            let gutter_dimensions = editor.gutter_dimensions;
-                            let hunk_bounds = EditorElement::diff_hunk_bounds(
-                                &editor_snapshot,
-                                cx.line_height(),
-                                gutter_bounds,
-                                &DisplayDiffHunk::Unfolded {
-                                    diff_base_byte_range: hunk.diff_base_byte_range.clone(),
-                                    multi_buffer_range: hunk.multi_buffer_range.clone(),
-                                    display_row_range: hunk_display_range.start.row()
-                                        ..hunk_display_range.end.row(),
-                                    status: hunk.status,
-                                },
-                            );
-
-                            let close_button = editor.close_hunk_diff_button(
-                                hunk.clone(),
-                                hunk_display_range.start.row(),
-                                cx,
-                            );
-                            (gutter_dimensions, hunk_bounds, close_button)
-                        });
-                    let click_editor = editor.clone();
-                    let clicked_hunk = hunk.clone();
+                    let width = EditorElement::diff_hunk_strip_width(cx.line_height());
+                    let gutter_dimensions = editor.read(cx.context).gutter_dimensions;
+
+                    let close_button = editor.update(cx.context, |editor, cx| {
+                        let editor_snapshot = editor.snapshot(cx);
+                        let hunk_display_range = hunk
+                            .multi_buffer_range
+                            .clone()
+                            .to_display_points(&editor_snapshot);
+                        editor.close_hunk_diff_button(
+                            hunk.clone(),
+                            hunk_display_range.start.row(),
+                            cx,
+                        )
+                    });
+
                     h_flex()
                         .id("gutter with editor")
                         .bg(deleted_hunk_color)
@@ -461,27 +444,29 @@ impl Editor {
                                 .child(
                                     h_flex()
                                         .id("gutter hunk")
+                                        .bg(cx.theme().status().deleted)
                                         .pl(gutter_dimensions.margin
                                             + gutter_dimensions
                                                 .git_blame_entries_width
                                                 .unwrap_or_default())
-                                        .max_w(hunk_bounds.size.width)
-                                        .min_w(hunk_bounds.size.width)
+                                        .max_w(width)
+                                        .min_w(width)
                                         .size_full()
                                         .cursor(CursorStyle::PointingHand)
                                         .on_mouse_down(MouseButton::Left, {
-                                            let click_hunk = hunk.clone();
-                                            move |e, cx| {
-                                                let modifiers = e.modifiers;
+                                            let editor = editor.clone();
+                                            let hunk = hunk.clone();
+                                            move |event, cx| {
+                                                let modifiers = event.modifiers;
                                                 if modifiers.control || modifiers.platform {
-                                                    click_editor.update(cx, |editor, cx| {
-                                                        editor.toggle_hovered_hunk(&click_hunk, cx);
+                                                    editor.update(cx, |editor, cx| {
+                                                        editor.toggle_hovered_hunk(&hunk, cx);
                                                     });
                                                 } else {
-                                                    click_editor.update(cx, |editor, cx| {
+                                                    editor.update(cx, |editor, cx| {
                                                         editor.open_hunk_context_menu(
-                                                            clicked_hunk.clone(),
-                                                            e.position,
+                                                            hunk.clone(),
+                                                            event.position,
                                                             cx,
                                                         );
                                                     });

From 5e62bbfd29172c966c4a9e494d0063acdba639b9 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 24 Sep 2024 09:44:53 -0600
Subject: [PATCH 296/762] Run system npm directly (#18280)

Release Notes:

- N/A
---
 crates/node_runtime/src/node_runtime.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/node_runtime/src/node_runtime.rs b/crates/node_runtime/src/node_runtime.rs
index 72c74ce7cf9830..9507eb75364859 100644
--- a/crates/node_runtime/src/node_runtime.rs
+++ b/crates/node_runtime/src/node_runtime.rs
@@ -538,11 +538,10 @@ impl NodeRuntimeTrait for SystemNodeRuntime {
         subcommand: &str,
         args: &[&str],
     ) -> anyhow::Result<Output> {
-        let mut command = Command::new(self.node.clone());
+        let mut command = Command::new(self.npm.clone());
         command
             .env_clear()
             .env("PATH", std::env::var_os("PATH").unwrap_or_default())
-            .arg(self.npm.clone())
             .arg(subcommand)
             .args(["--cache".into(), self.scratch_dir.join("cache")])
             .args([

From 0e86ba0983bfa186030996c62e0163778665bfef Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 24 Sep 2024 10:13:53 -0600
Subject: [PATCH 297/762] Fix get_cached_binary for eslint (#18286)

Release Notes:

- Fixed running ESLint offline.
---
 crates/language/src/language.rs    |  3 +-
 crates/languages/src/typescript.rs | 46 +++++++++++++-----------------
 2 files changed, 22 insertions(+), 27 deletions(-)

diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index 166d846f86e8bc..d70650cf449356 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -384,8 +384,9 @@ pub trait LspAdapter: 'static + Send + Sync {
                     .await
                 {
                     log::info!(
-                        "failed to fetch newest version of language server {:?}. falling back to using {:?}",
+                        "failed to fetch newest version of language server {:?}. error: {:?}, falling back to using {:?}",
                         self.name(),
+                        error,
                         prev_downloaded_binary.path
                     );
                     binary = Ok(prev_downloaded_binary);
diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs
index 25a97c8014d0a1..b7eb21132d52c4 100644
--- a/crates/languages/src/typescript.rs
+++ b/crates/languages/src/typescript.rs
@@ -297,7 +297,8 @@ pub struct EsLintLspAdapter {
 }
 
 impl EsLintLspAdapter {
-    const CURRENT_VERSION: &'static str = "release/2.4.4";
+    const CURRENT_VERSION: &'static str = "2.4.4";
+    const CURRENT_VERSION_TAG_NAME: &'static str = "release/2.4.4";
 
     #[cfg(not(windows))]
     const GITHUB_ASSET_KIND: AssetKind = AssetKind::TarGz;
@@ -313,6 +314,10 @@ impl EsLintLspAdapter {
     pub fn new(node: NodeRuntime) -> Self {
         EsLintLspAdapter { node }
     }
+
+    fn build_destination_path(container_dir: &Path) -> PathBuf {
+        container_dir.join(format!("vscode-eslint-{}", Self::CURRENT_VERSION))
+    }
 }
 
 #[async_trait(?Send)]
@@ -413,7 +418,7 @@ impl LspAdapter for EsLintLspAdapter {
     ) -> Result<Box<dyn 'static + Send + Any>> {
         let url = build_asset_url(
             "microsoft/vscode-eslint",
-            Self::CURRENT_VERSION,
+            Self::CURRENT_VERSION_TAG_NAME,
             Self::GITHUB_ASSET_KIND,
         )?;
 
@@ -430,7 +435,7 @@ impl LspAdapter for EsLintLspAdapter {
         delegate: &dyn LspAdapterDelegate,
     ) -> Result<LanguageServerBinary> {
         let version = version.downcast::<GitHubLspBinaryVersion>().unwrap();
-        let destination_path = container_dir.join(format!("vscode-eslint-{}", version.name));
+        let destination_path = Self::build_destination_path(&container_dir);
         let server_path = destination_path.join(Self::SERVER_PATH);
 
         if fs::metadata(&server_path).await.is_err() {
@@ -496,38 +501,27 @@ impl LspAdapter for EsLintLspAdapter {
         container_dir: PathBuf,
         _: &dyn LspAdapterDelegate,
     ) -> Option<LanguageServerBinary> {
-        get_cached_eslint_server_binary(container_dir, &self.node).await
+        let server_path =
+            Self::build_destination_path(&container_dir).join(EsLintLspAdapter::SERVER_PATH);
+        Some(LanguageServerBinary {
+            path: self.node.binary_path().await.ok()?,
+            env: None,
+            arguments: eslint_server_binary_arguments(&server_path),
+        })
     }
 
     async fn installation_test_binary(
         &self,
         container_dir: PathBuf,
     ) -> Option<LanguageServerBinary> {
-        get_cached_eslint_server_binary(container_dir, &self.node).await
-    }
-}
-
-async fn get_cached_eslint_server_binary(
-    container_dir: PathBuf,
-    node: &NodeRuntime,
-) -> Option<LanguageServerBinary> {
-    maybe!(async {
-        // This is unfortunate but we don't know what the version is to build a path directly
-        let mut dir = fs::read_dir(&container_dir).await?;
-        let first = dir.next().await.ok_or(anyhow!("missing first file"))??;
-        if !first.file_type().await?.is_dir() {
-            return Err(anyhow!("First entry is not a directory"));
-        }
-        let server_path = first.path().join(EsLintLspAdapter::SERVER_PATH);
-
-        Ok(LanguageServerBinary {
-            path: node.binary_path().await?,
+        let server_path =
+            Self::build_destination_path(&container_dir).join(EsLintLspAdapter::SERVER_PATH);
+        Some(LanguageServerBinary {
+            path: self.node.binary_path().await.ok()?,
             env: None,
             arguments: eslint_server_binary_arguments(&server_path),
         })
-    })
-    .await
-    .log_err()
+    }
 }
 
 #[cfg(target_os = "windows")]

From b69c6ee7dfdcffd94024491776c68189a9e9d6ea Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 24 Sep 2024 10:17:43 -0600
Subject: [PATCH 298/762] Exclude initialization failed errors from slack
 (#18232)

Release Notes:

- N/A
---
 crates/collab/src/api/events.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index f8ae53201304fb..1632c2d798ef15 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -369,6 +369,10 @@ fn report_to_slack(panic: &Panic) -> bool {
             return false;
         }
 
+        if panic.payload.contains("ERROR_INITIALIZATION_FAILED") {
+            return false;
+        }
+
         if panic
             .payload
             .contains("GPU has crashed, and no debug information is available")

From 4a4d8c1cabcf8f898cdba496e08b2b27a4386922 Mon Sep 17 00:00:00 2001
From: "Sergio C." <sergiobg.engineer@gmail.com>
Date: Tue, 24 Sep 2024 13:21:57 -0300
Subject: [PATCH 299/762] vim: Add ability to spawn multicursors at
 beginning/end of line (#18183)

Closes #17842

Release Notes:

- Added the ability to spawn multiple cursors through the g-A and g-I
motions while in visual select mode.
---
 assets/keymaps/vim.json  |  2 +
 crates/vim/src/visual.rs | 85 +++++++++++++++++++++++++++++++++++++++-
 2 files changed, 86 insertions(+), 1 deletion(-)

diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index 8d933f19afb1dd..6656ea0ddf22c3 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -292,6 +292,8 @@
       "g ctrl-x": ["vim::Decrement", { "step": true }],
       "shift-i": "vim::InsertBefore",
       "shift-a": "vim::InsertAfter",
+      "g I": "vim::VisualInsertFirstNonWhiteSpace",
+      "g A": "vim::VisualInsertEndOfLine",
       "shift-j": "vim::JoinLines",
       "r": ["vim::PushOperator", "Replace"],
       "ctrl-c": ["vim::SwitchMode", "Normal"],
diff --git a/crates/vim/src/visual.rs b/crates/vim/src/visual.rs
index 55dc7885200b04..1503eaac1b6b43 100644
--- a/crates/vim/src/visual.rs
+++ b/crates/vim/src/visual.rs
@@ -15,7 +15,7 @@ use util::ResultExt;
 use workspace::searchable::Direction;
 
 use crate::{
-    motion::{start_of_line, Motion},
+    motion::{first_non_whitespace, next_line_end, start_of_line, Motion},
     object::Object,
     state::{Mode, Operator},
     Vim,
@@ -37,6 +37,8 @@ actions!(
         SelectNextMatch,
         SelectPreviousMatch,
         RestoreVisualSelection,
+        VisualInsertEndOfLine,
+        VisualInsertFirstNonWhiteSpace,
     ]
 );
 
@@ -51,6 +53,8 @@ pub fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {
         vim.toggle_mode(Mode::VisualBlock, cx)
     });
     Vim::action(editor, cx, Vim::other_end);
+    Vim::action(editor, cx, Vim::visual_insert_end_of_line);
+    Vim::action(editor, cx, Vim::visual_insert_first_non_white_space);
     Vim::action(editor, cx, |vim, _: &VisualDelete, cx| {
         vim.record_current_action(cx);
         vim.visual_delete(false, cx);
@@ -374,6 +378,39 @@ impl Vim {
         }
     }
 
+    fn visual_insert_end_of_line(&mut self, _: &VisualInsertEndOfLine, cx: &mut ViewContext<Self>) {
+        self.update_editor(cx, |_, editor, cx| {
+            editor.split_selection_into_lines(&Default::default(), cx);
+            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                s.move_cursors_with(|map, cursor, _| {
+                    (next_line_end(map, cursor, 1), SelectionGoal::None)
+                });
+            });
+        });
+
+        self.switch_mode(Mode::Insert, false, cx);
+    }
+
+    fn visual_insert_first_non_white_space(
+        &mut self,
+        _: &VisualInsertFirstNonWhiteSpace,
+        cx: &mut ViewContext<Self>,
+    ) {
+        self.update_editor(cx, |_, editor, cx| {
+            editor.split_selection_into_lines(&Default::default(), cx);
+            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                s.move_cursors_with(|map, cursor, _| {
+                    (
+                        first_non_whitespace(map, false, cursor),
+                        SelectionGoal::None,
+                    )
+                });
+            });
+        });
+
+        self.switch_mode(Mode::Insert, false, cx);
+    }
+
     fn toggle_mode(&mut self, mode: Mode, cx: &mut ViewContext<Self>) {
         if self.mode == mode {
             self.switch_mode(Mode::Normal, false, cx);
@@ -714,6 +751,52 @@ mod test {
             ˇ"});
     }
 
+    #[gpui::test]
+    async fn test_visual_insert_first_non_whitespace(cx: &mut gpui::TestAppContext) {
+        let mut cx = VimTestContext::new(cx, true).await;
+
+        cx.set_state(
+            indoc! {
+                "«The quick brown
+                fox jumps over
+                the lazy dogˇ»"
+            },
+            Mode::Visual,
+        );
+        cx.simulate_keystrokes("g I");
+        cx.assert_state(
+            indoc! {
+                "ˇThe quick brown
+                ˇfox jumps over
+                ˇthe lazy dog"
+            },
+            Mode::Insert,
+        );
+    }
+
+    #[gpui::test]
+    async fn test_visual_insert_end_of_line(cx: &mut gpui::TestAppContext) {
+        let mut cx = VimTestContext::new(cx, true).await;
+
+        cx.set_state(
+            indoc! {
+                "«The quick brown
+                fox jumps over
+                the lazy dogˇ»"
+            },
+            Mode::Visual,
+        );
+        cx.simulate_keystrokes("g A");
+        cx.assert_state(
+            indoc! {
+                "The quick brownˇ
+                fox jumps overˇ
+                the lazy dogˇ"
+            },
+            Mode::Insert,
+        );
+    }
+
     #[gpui::test]
     async fn test_enter_visual_line_mode(cx: &mut gpui::TestAppContext) {
         let mut cx = NeovimBackedTestContext::new(cx).await;

From fd07fef4dbc475381706c338e9600bd099af162d Mon Sep 17 00:00:00 2001
From: ClanEver <562211524@qq.com>
Date: Wed, 25 Sep 2024 00:27:29 +0800
Subject: [PATCH 300/762] Fix proxy settings retrieval on startup (#18171)

Closes https://github.com/zed-industries/zed/issues/18155

Release Notes:

- N/A
---
 crates/zed/src/main.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 309931f6163528..e3fe2baefa9b6c 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -443,6 +443,8 @@ fn main() {
             AppCommitSha::set_global(AppCommitSha(build_sha.into()), cx);
         }
         settings::init(cx);
+        handle_settings_file_changes(user_settings_file_rx, cx, handle_settings_changed);
+        handle_keymap_file_changes(user_keymap_file_rx, cx, handle_keymap_changed);
         client::init_settings(cx);
         let user_agent = format!(
             "Zed/{} ({}; {})",
@@ -470,9 +472,6 @@ fn main() {
 
         OpenListener::set_global(cx, open_listener.clone());
 
-        handle_settings_file_changes(user_settings_file_rx, cx, handle_settings_changed);
-        handle_keymap_file_changes(user_keymap_file_rx, cx, handle_keymap_changed);
-
         let client = Client::production(cx);
         cx.set_http_client(client.http_client().clone());
         let mut languages = LanguageRegistry::new(cx.background_executor().clone());

From 8a7ef4db59668f9dda841a9550abd1cc78651fa3 Mon Sep 17 00:00:00 2001
From: John Cummings <jcummings5@gmail.com>
Date: Tue, 24 Sep 2024 11:17:17 -0600
Subject: [PATCH 301/762] ollama: Add max tokens for qwen2.5-coder (#18290)

---
 crates/ollama/src/ollama.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/ollama/src/ollama.rs b/crates/ollama/src/ollama.rs
index 51c48290488147..e592bfa17717d3 100644
--- a/crates/ollama/src/ollama.rs
+++ b/crates/ollama/src/ollama.rs
@@ -82,7 +82,8 @@ fn get_max_tokens(name: &str) -> usize {
         "llama3" | "gemma2" | "gemma" | "codegemma" | "starcoder" | "aya" => 8192,
         "codellama" | "starcoder2" => 16384,
         "mistral" | "codestral" | "mixstral" | "llava" | "qwen2" | "dolphin-mixtral" => 32768,
-        "llama3.1" | "phi3" | "phi3.5" | "command-r" | "deepseek-coder-v2" | "yi-coder" => 128000,
+        "llama3.1" | "phi3" | "phi3.5" | "command-r" | "deepseek-coder-v2" | "yi-coder"
+        | "qwen2.5-coder" => 128000,
         _ => DEFAULT_TOKENS,
     }
     .clamp(1, MAXIMUM_TOKENS)

From f39e54decc613314b1302cfbb1d581a056a6eb68 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 24 Sep 2024 12:23:39 -0600
Subject: [PATCH 302/762] Start work on reload buffers (#18245)

Release Notes:

- Fixed: ssh-remote reload buffers

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 crates/project/src/buffer_store.rs            | 309 +++++++++++++-----
 crates/project/src/project.rs                 | 139 +-------
 crates/remote_server/src/headless_project.rs  |   3 +-
 .../remote_server/src/remote_editing_tests.rs |  82 ++++-
 4 files changed, 325 insertions(+), 208 deletions(-)

diff --git a/crates/project/src/buffer_store.rs b/crates/project/src/buffer_store.rs
index 0045aba2e89ecf..b69679d6ac3b3a 100644
--- a/crates/project/src/buffer_store.rs
+++ b/crates/project/src/buffer_store.rs
@@ -14,7 +14,10 @@ use gpui::{
 };
 use http_client::Url;
 use language::{
-    proto::{deserialize_line_ending, deserialize_version, serialize_version, split_operations},
+    proto::{
+        deserialize_line_ending, deserialize_version, serialize_line_ending, serialize_version,
+        split_operations,
+    },
     Buffer, BufferEvent, Capability, File as _, Language, Operation,
 };
 use rpc::{proto, AnyProtoClient, ErrorExt as _, TypedEnvelope};
@@ -29,9 +32,8 @@ use worktree::{
 
 /// A set of open buffers.
 pub struct BufferStore {
-    downstream_client: Option<AnyProtoClient>,
-    remote_id: Option<u64>,
-    #[allow(unused)]
+    state: BufferStoreState,
+    downstream_client: Option<(AnyProtoClient, u64)>,
     worktree_store: Model<WorktreeStore>,
     opened_buffers: HashMap<BufferId, OpenBuffer>,
     local_buffer_ids_by_path: HashMap<ProjectPath, BufferId>,
@@ -44,12 +46,11 @@ pub struct BufferStore {
     loading_remote_buffers_by_id: HashMap<BufferId, Model<Buffer>>,
     remote_buffer_listeners:
         HashMap<BufferId, Vec<oneshot::Sender<Result<Model<Buffer>, anyhow::Error>>>>,
-    shared_buffers: HashMap<proto::PeerId, HashSet<BufferId>>,
+    shared_buffers: HashMap<proto::PeerId, HashSet<Model<Buffer>>>,
 }
 
 enum OpenBuffer {
-    Strong(Model<Buffer>),
-    Weak(WeakModel<Buffer>),
+    Buffer(WeakModel<Buffer>),
     Operations(Vec<Operation>),
 }
 
@@ -62,6 +63,15 @@ pub enum BufferStoreEvent {
     },
 }
 
+enum BufferStoreState {
+    Remote {
+        shared_with_me: HashSet<Model<Buffer>>,
+        upstream_client: AnyProtoClient,
+        project_id: u64,
+    },
+    Local {},
+}
+
 #[derive(Default, Debug)]
 pub struct ProjectTransaction(pub HashMap<Model<Buffer>, language::Transaction>);
 
@@ -75,17 +85,36 @@ impl BufferStore {
         client.add_model_message_handler(Self::handle_update_diff_base);
         client.add_model_request_handler(Self::handle_save_buffer);
         client.add_model_request_handler(Self::handle_blame_buffer);
+        client.add_model_request_handler(Self::handle_reload_buffers);
     }
 
     /// Creates a buffer store, optionally retaining its buffers.
-    ///
-    /// If `retain_buffers` is `true`, then buffers are owned by the buffer store
-    /// and won't be released unless they are explicitly removed, or `retain_buffers`
-    /// is set to `false` via `set_retain_buffers`. Otherwise, buffers are stored as
-    /// weak handles.
-    pub fn new(
+    pub fn local(worktree_store: Model<WorktreeStore>, cx: &mut ModelContext<Self>) -> Self {
+        cx.subscribe(&worktree_store, |this, _, event, cx| {
+            if let WorktreeStoreEvent::WorktreeAdded(worktree) = event {
+                this.subscribe_to_worktree(worktree, cx);
+            }
+        })
+        .detach();
+
+        Self {
+            state: BufferStoreState::Local {},
+            downstream_client: None,
+            worktree_store,
+            opened_buffers: Default::default(),
+            remote_buffer_listeners: Default::default(),
+            loading_remote_buffers_by_id: Default::default(),
+            local_buffer_ids_by_path: Default::default(),
+            local_buffer_ids_by_entry_id: Default::default(),
+            loading_buffers_by_path: Default::default(),
+            shared_buffers: Default::default(),
+        }
+    }
+
+    pub fn remote(
         worktree_store: Model<WorktreeStore>,
-        remote_id: Option<u64>,
+        upstream_client: AnyProtoClient,
+        remote_id: u64,
         cx: &mut ModelContext<Self>,
     ) -> Self {
         cx.subscribe(&worktree_store, |this, _, event, cx| {
@@ -96,7 +125,11 @@ impl BufferStore {
         .detach();
 
         Self {
-            remote_id,
+            state: BufferStoreState::Remote {
+                shared_with_me: Default::default(),
+                upstream_client,
+                project_id: remote_id,
+            },
             downstream_client: None,
             worktree_store,
             opened_buffers: Default::default(),
@@ -288,16 +321,14 @@ impl BufferStore {
                         buffer.set_diff_base(diff_base.clone(), cx);
                         buffer.remote_id().to_proto()
                     });
-                    if let Some(project_id) = this.remote_id {
-                        if let Some(client) = &this.downstream_client {
-                            client
-                                .send(proto::UpdateDiffBase {
-                                    project_id,
-                                    buffer_id,
-                                    diff_base,
-                                })
-                                .log_err();
-                        }
+                    if let Some((client, project_id)) = &this.downstream_client {
+                        client
+                            .send(proto::UpdateDiffBase {
+                                project_id: *project_id,
+                                buffer_id,
+                                diff_base,
+                            })
+                            .log_err();
                     }
                 }
             })
@@ -496,8 +527,8 @@ impl BufferStore {
             let new_file = save.await?;
             let mtime = new_file.mtime;
             this.update(&mut cx, |this, cx| {
-                if let Some(downstream_client) = this.downstream_client.as_ref() {
-                    let project_id = this.remote_id.unwrap_or(0);
+                if let Some((downstream_client, project_id)) = this.downstream_client.as_ref() {
+                    let project_id = *project_id;
                     if has_changed_file {
                         downstream_client
                             .send(proto::UpdateBufferFile {
@@ -620,11 +651,7 @@ impl BufferStore {
     fn add_buffer(&mut self, buffer: Model<Buffer>, cx: &mut ModelContext<Self>) -> Result<()> {
         let remote_id = buffer.read(cx).remote_id();
         let is_remote = buffer.read(cx).replica_id() != 0;
-        let open_buffer = if self.remote_id.is_some() {
-            OpenBuffer::Strong(buffer.clone())
-        } else {
-            OpenBuffer::Weak(buffer.downgrade())
-        };
+        let open_buffer = OpenBuffer::Buffer(buffer.downgrade());
 
         let handle = cx.handle().downgrade();
         buffer.update(cx, move |_, cx| {
@@ -768,8 +795,7 @@ impl BufferStore {
     }
 
     pub fn disconnected_from_host(&mut self, cx: &mut AppContext) {
-        self.downstream_client.take();
-        self.set_remote_id(None, cx);
+        self.drop_unnecessary_buffers(cx);
 
         for buffer in self.buffers() {
             buffer.update(cx, |buffer, cx| {
@@ -786,32 +812,20 @@ impl BufferStore {
         &mut self,
         remote_id: u64,
         downstream_client: AnyProtoClient,
-        cx: &mut AppContext,
+        _cx: &mut AppContext,
     ) {
-        self.downstream_client = Some(downstream_client);
-        self.set_remote_id(Some(remote_id), cx);
+        self.downstream_client = Some((downstream_client, remote_id));
     }
 
     pub fn unshared(&mut self, _cx: &mut ModelContext<Self>) {
-        self.remote_id.take();
+        self.downstream_client.take();
+        self.forget_shared_buffers();
     }
 
-    fn set_remote_id(&mut self, remote_id: Option<u64>, cx: &mut AppContext) {
-        self.remote_id = remote_id;
+    fn drop_unnecessary_buffers(&mut self, cx: &mut AppContext) {
         for open_buffer in self.opened_buffers.values_mut() {
-            if remote_id.is_some() {
-                if let OpenBuffer::Weak(buffer) = open_buffer {
-                    if let Some(buffer) = buffer.upgrade() {
-                        *open_buffer = OpenBuffer::Strong(buffer);
-                    }
-                }
-            } else {
-                if let Some(buffer) = open_buffer.upgrade() {
-                    buffer.update(cx, |buffer, _| buffer.give_up_waiting());
-                }
-                if let OpenBuffer::Strong(buffer) = open_buffer {
-                    *open_buffer = OpenBuffer::Weak(buffer.downgrade());
-                }
+            if let Some(buffer) = open_buffer.upgrade() {
+                buffer.update(cx, |buffer, _| buffer.give_up_waiting());
             }
         }
     }
@@ -881,8 +895,26 @@ impl BufferStore {
         event: &BufferEvent,
         cx: &mut ModelContext<Self>,
     ) {
-        if event == &BufferEvent::FileHandleChanged {
-            self.buffer_changed_file(buffer, cx);
+        match event {
+            BufferEvent::FileHandleChanged => {
+                self.buffer_changed_file(buffer, cx);
+            }
+            BufferEvent::Reloaded => {
+                let Some((downstream_client, project_id)) = self.downstream_client.as_ref() else {
+                    return;
+                };
+                let buffer = buffer.read(cx);
+                downstream_client
+                    .send(proto::BufferReloaded {
+                        project_id: *project_id,
+                        buffer_id: buffer.remote_id().to_proto(),
+                        version: serialize_version(&buffer.version()),
+                        mtime: buffer.saved_mtime().map(|t| t.into()),
+                        line_ending: serialize_line_ending(buffer.line_ending()) as i32,
+                    })
+                    .log_err();
+            }
+            _ => {}
         }
     }
 
@@ -986,16 +1018,14 @@ impl BufferStore {
                 }
             }
 
-            if let Some(project_id) = self.remote_id {
-                if let Some(client) = &self.downstream_client {
-                    client
-                        .send(proto::UpdateBufferFile {
-                            project_id,
-                            buffer_id: buffer_id.to_proto(),
-                            file: Some(new_file.to_proto(cx)),
-                        })
-                        .ok();
-                }
+            if let Some((client, project_id)) = &self.downstream_client {
+                client
+                    .send(proto::UpdateBufferFile {
+                        project_id: *project_id,
+                        buffer_id: buffer_id.to_proto(),
+                        file: Some(new_file.to_proto(cx)),
+                    })
+                    .ok();
             }
 
             buffer.file_updated(Arc::new(new_file), cx);
@@ -1050,11 +1080,8 @@ impl BufferStore {
         this.update(&mut cx, |this, cx| {
             match this.opened_buffers.entry(buffer_id) {
                 hash_map::Entry::Occupied(mut e) => match e.get_mut() {
-                    OpenBuffer::Strong(buffer) => {
-                        buffer.update(cx, |buffer, cx| buffer.apply_ops(ops, cx));
-                    }
                     OpenBuffer::Operations(operations) => operations.extend_from_slice(&ops),
-                    OpenBuffer::Weak(buffer) => {
+                    OpenBuffer::Buffer(buffer) => {
                         if let Some(buffer) = buffer.upgrade() {
                             buffer.update(cx, |buffer, cx| buffer.apply_ops(ops, cx));
                         }
@@ -1090,7 +1117,7 @@ impl BufferStore {
                 self.shared_buffers
                     .entry(guest_id)
                     .or_default()
-                    .insert(buffer_id);
+                    .insert(buffer.clone());
 
                 let buffer = buffer.read(cx);
                 response.buffers.push(proto::BufferVersion {
@@ -1230,6 +1257,19 @@ impl BufferStore {
                     }
                 } else if chunk.is_last {
                     self.loading_remote_buffers_by_id.remove(&buffer_id);
+                    // retain buffers sent by peers to avoid races.
+                    match &mut self.state {
+                        BufferStoreState::Remote {
+                            ref mut shared_with_me,
+                            upstream_client,
+                            ..
+                        } => {
+                            if upstream_client.is_via_collab() {
+                                shared_with_me.insert(buffer.clone());
+                            }
+                        }
+                        _ => {}
+                    }
                     self.add_buffer(buffer, cx)?;
                 }
             }
@@ -1303,7 +1343,10 @@ impl BufferStore {
         let (buffer, project_id) = this.update(&mut cx, |this, _| {
             anyhow::Ok((
                 this.get_existing(buffer_id)?,
-                this.remote_id.context("project is not shared")?,
+                this.downstream_client
+                    .as_ref()
+                    .map(|(_, project_id)| *project_id)
+                    .context("project is not shared")?,
             ))
         })??;
         buffer
@@ -1340,12 +1383,14 @@ impl BufferStore {
         let peer_id = envelope.sender_id;
         let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
         this.update(&mut cx, |this, _| {
-            if let Some(shared) = this.shared_buffers.get_mut(&peer_id) {
-                if shared.remove(&buffer_id) {
-                    if shared.is_empty() {
-                        this.shared_buffers.remove(&peer_id);
+            if let Some(buffer) = this.get(buffer_id) {
+                if let Some(shared) = this.shared_buffers.get_mut(&peer_id) {
+                    if shared.remove(&buffer) {
+                        if shared.is_empty() {
+                            this.shared_buffers.remove(&peer_id);
+                        }
+                        return;
                     }
-                    return;
                 }
             };
             debug_panic!(
@@ -1429,6 +1474,98 @@ impl BufferStore {
         }
     }
 
+    pub fn reload_buffers(
+        &self,
+        buffers: HashSet<Model<Buffer>>,
+        push_to_history: bool,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<ProjectTransaction>> {
+        let mut local_buffers = Vec::new();
+        let mut remote_buffers = Vec::new();
+        for buffer_handle in buffers {
+            let buffer = buffer_handle.read(cx);
+            if buffer.is_dirty() {
+                if let Some(file) = File::from_dyn(buffer.file()) {
+                    if file.is_local() {
+                        local_buffers.push(buffer_handle);
+                    } else {
+                        remote_buffers.push(buffer_handle);
+                    }
+                }
+            }
+        }
+
+        let client = self.upstream_client();
+
+        cx.spawn(move |this, mut cx| async move {
+            let mut project_transaction = ProjectTransaction::default();
+            if let Some((client, project_id)) = client {
+                let response = client
+                    .request(proto::ReloadBuffers {
+                        project_id,
+                        buffer_ids: remote_buffers
+                            .iter()
+                            .filter_map(|buffer| {
+                                buffer
+                                    .update(&mut cx, |buffer, _| buffer.remote_id().into())
+                                    .ok()
+                            })
+                            .collect(),
+                    })
+                    .await?
+                    .transaction
+                    .ok_or_else(|| anyhow!("missing transaction"))?;
+                BufferStore::deserialize_project_transaction(
+                    this,
+                    response,
+                    push_to_history,
+                    cx.clone(),
+                )
+                .await?;
+            }
+
+            for buffer in local_buffers {
+                let transaction = buffer
+                    .update(&mut cx, |buffer, cx| buffer.reload(cx))?
+                    .await?;
+                buffer.update(&mut cx, |buffer, cx| {
+                    if let Some(transaction) = transaction {
+                        if !push_to_history {
+                            buffer.forget_transaction(transaction.id);
+                        }
+                        project_transaction.0.insert(cx.handle(), transaction);
+                    }
+                })?;
+            }
+
+            Ok(project_transaction)
+        })
+    }
+
+    async fn handle_reload_buffers(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::ReloadBuffers>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::ReloadBuffersResponse> {
+        let sender_id = envelope.original_sender_id().unwrap_or_default();
+        let reload = this.update(&mut cx, |this, cx| {
+            let mut buffers = HashSet::default();
+            for buffer_id in &envelope.payload.buffer_ids {
+                let buffer_id = BufferId::new(*buffer_id)?;
+                buffers.insert(this.get_existing(buffer_id)?);
+            }
+            Ok::<_, anyhow::Error>(this.reload_buffers(buffers, false, cx))
+        })??;
+
+        let project_transaction = reload.await?;
+        let project_transaction = this.update(&mut cx, |this, cx| {
+            this.serialize_project_transaction_for_peer(project_transaction, sender_id, cx)
+        })?;
+        Ok(proto::ReloadBuffersResponse {
+            transaction: Some(project_transaction),
+        })
+    }
+
     pub fn create_buffer_for_peer(
         &mut self,
         buffer: &Model<Buffer>,
@@ -1440,12 +1577,12 @@ impl BufferStore {
             .shared_buffers
             .entry(peer_id)
             .or_default()
-            .insert(buffer_id)
+            .insert(buffer.clone())
         {
             return Task::ready(Ok(()));
         }
 
-        let Some((client, project_id)) = self.downstream_client.clone().zip(self.remote_id) else {
+        let Some((client, project_id)) = self.downstream_client.clone() else {
             return Task::ready(Ok(()));
         };
 
@@ -1492,6 +1629,17 @@ impl BufferStore {
         })
     }
 
+    pub fn upstream_client(&self) -> Option<(AnyProtoClient, u64)> {
+        match &self.state {
+            BufferStoreState::Remote {
+                upstream_client,
+                project_id,
+                ..
+            } => Some((upstream_client.clone(), *project_id)),
+            BufferStoreState::Local { .. } => None,
+        }
+    }
+
     pub fn forget_shared_buffers(&mut self) {
         self.shared_buffers.clear();
     }
@@ -1506,7 +1654,7 @@ impl BufferStore {
         }
     }
 
-    pub fn shared_buffers(&self) -> &HashMap<proto::PeerId, HashSet<BufferId>> {
+    pub fn shared_buffers(&self) -> &HashMap<proto::PeerId, HashSet<Model<Buffer>>> {
         &self.shared_buffers
     }
 
@@ -1572,8 +1720,7 @@ impl BufferStore {
 impl OpenBuffer {
     fn upgrade(&self) -> Option<Model<Buffer>> {
         match self {
-            OpenBuffer::Strong(handle) => Some(handle.clone()),
-            OpenBuffer::Weak(handle) => handle.upgrade(),
+            OpenBuffer::Buffer(handle) => handle.upgrade(),
             OpenBuffer::Operations(_) => None,
         }
     }
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 199b5a8f5c5755..454a7586c8856c 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -42,10 +42,7 @@ use gpui::{
 use itertools::Itertools;
 use language::{
     language_settings::InlayHintKind,
-    proto::{
-        deserialize_anchor, serialize_anchor, serialize_line_ending, serialize_version,
-        split_operations,
-    },
+    proto::{deserialize_anchor, serialize_anchor, split_operations},
     Buffer, BufferEvent, CachedLspAdapter, Capability, CodeLabel, ContextProvider, DiagnosticEntry,
     Documentation, File as _, Language, LanguageRegistry, LanguageServerName, PointUtf16, ToOffset,
     ToPointUtf16, Transaction, Unclipped,
@@ -559,7 +556,6 @@ impl Project {
         client.add_model_message_handler(Self::handle_unshare_project);
         client.add_model_request_handler(Self::handle_update_buffer);
         client.add_model_message_handler(Self::handle_update_worktree);
-        client.add_model_request_handler(Self::handle_reload_buffers);
         client.add_model_request_handler(Self::handle_synchronize_buffers);
 
         client.add_model_request_handler(Self::handle_search_project);
@@ -599,8 +595,7 @@ impl Project {
             cx.subscribe(&worktree_store, Self::on_worktree_store_event)
                 .detach();
 
-            let buffer_store =
-                cx.new_model(|cx| BufferStore::new(worktree_store.clone(), None, cx));
+            let buffer_store = cx.new_model(|cx| BufferStore::local(worktree_store.clone(), cx));
             cx.subscribe(&buffer_store, Self::on_buffer_store_event)
                 .detach();
 
@@ -695,8 +690,14 @@ impl Project {
             cx.subscribe(&worktree_store, Self::on_worktree_store_event)
                 .detach();
 
-            let buffer_store =
-                cx.new_model(|cx| BufferStore::new(worktree_store.clone(), None, cx));
+            let buffer_store = cx.new_model(|cx| {
+                BufferStore::remote(
+                    worktree_store.clone(),
+                    ssh.clone().into(),
+                    SSH_PROJECT_ID,
+                    cx,
+                )
+            });
             cx.subscribe(&buffer_store, Self::on_buffer_store_event)
                 .detach();
 
@@ -851,8 +852,9 @@ impl Project {
                     .map(DevServerProjectId),
             )
         })?;
-        let buffer_store =
-            cx.new_model(|cx| BufferStore::new(worktree_store.clone(), Some(remote_id), cx))?;
+        let buffer_store = cx.new_model(|cx| {
+            BufferStore::remote(worktree_store.clone(), client.clone().into(), remote_id, cx)
+        })?;
 
         let lsp_store = cx.new_model(|cx| {
             let mut lsp_store = LspStore::new_remote(
@@ -2167,23 +2169,6 @@ impl Project {
                 .ok();
             }
 
-            BufferEvent::Reloaded => {
-                if self.is_local_or_ssh() {
-                    if let Some(project_id) = self.remote_id() {
-                        let buffer = buffer.read(cx);
-                        self.client
-                            .send(proto::BufferReloaded {
-                                project_id,
-                                buffer_id: buffer.remote_id().to_proto(),
-                                version: serialize_version(&buffer.version()),
-                                mtime: buffer.saved_mtime().map(|t| t.into()),
-                                line_ending: serialize_line_ending(buffer.line_ending()) as i32,
-                            })
-                            .log_err();
-                    }
-                }
-            }
-
             _ => {}
         }
 
@@ -2347,67 +2332,8 @@ impl Project {
         push_to_history: bool,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<ProjectTransaction>> {
-        let mut local_buffers = Vec::new();
-        let mut remote_buffers = None;
-        for buffer_handle in buffers {
-            let buffer = buffer_handle.read(cx);
-            if buffer.is_dirty() {
-                if let Some(file) = File::from_dyn(buffer.file()) {
-                    if file.is_local() {
-                        local_buffers.push(buffer_handle);
-                    } else {
-                        remote_buffers.get_or_insert(Vec::new()).push(buffer_handle);
-                    }
-                }
-            }
-        }
-
-        let remote_buffers = self.remote_id().zip(remote_buffers);
-        let client = self.client.clone();
-
-        cx.spawn(move |this, mut cx| async move {
-            let mut project_transaction = ProjectTransaction::default();
-
-            if let Some((project_id, remote_buffers)) = remote_buffers {
-                let response = client
-                    .request(proto::ReloadBuffers {
-                        project_id,
-                        buffer_ids: remote_buffers
-                            .iter()
-                            .filter_map(|buffer| {
-                                buffer
-                                    .update(&mut cx, |buffer, _| buffer.remote_id().into())
-                                    .ok()
-                            })
-                            .collect(),
-                    })
-                    .await?
-                    .transaction
-                    .ok_or_else(|| anyhow!("missing transaction"))?;
-                BufferStore::deserialize_project_transaction(
-                    this.read_with(&cx, |this, _| this.buffer_store.downgrade())?,
-                    response,
-                    push_to_history,
-                    cx.clone(),
-                )
-                .await?;
-            }
-
-            for buffer in local_buffers {
-                let transaction = buffer
-                    .update(&mut cx, |buffer, cx| buffer.reload(cx))?
-                    .await?;
-                buffer.update(&mut cx, |buffer, cx| {
-                    if let Some(transaction) = transaction {
-                        if !push_to_history {
-                            buffer.forget_transaction(transaction.id);
-                        }
-                        project_transaction.0.insert(cx.handle(), transaction);
-                    }
-                })?;
-            }
-
-            Ok(project_transaction)
+        self.buffer_store.update(cx, |buffer_store, cx| {
+            buffer_store.reload_buffers(buffers, push_to_history, cx)
         })
     }
 
@@ -3589,30 +3515,6 @@ impl Project {
         })?
     }
 
-    async fn handle_reload_buffers(
-        this: Model<Self>,
-        envelope: TypedEnvelope<proto::ReloadBuffers>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::ReloadBuffersResponse> {
-        let sender_id = envelope.original_sender_id()?;
-        let reload = this.update(&mut cx, |this, cx| {
-            let mut buffers = HashSet::default();
-            for buffer_id in &envelope.payload.buffer_ids {
-                let buffer_id = BufferId::new(*buffer_id)?;
-                buffers.insert(this.buffer_store.read(cx).get_existing(buffer_id)?);
-            }
-            Ok::<_, anyhow::Error>(this.reload_buffers(buffers, false, cx))
-        })??;
-
-        let project_transaction = reload.await?;
-        let project_transaction = this.update(&mut cx, |this, cx| {
-            this.serialize_project_transaction_for_peer(project_transaction, sender_id, cx)
-        })?;
-        Ok(proto::ReloadBuffersResponse {
-            transaction: Some(project_transaction),
-        })
-    }
-
     async fn handle_synchronize_buffers(
         this: Model<Self>,
         envelope: TypedEnvelope<proto::SynchronizeBuffers>,
@@ -3896,17 +3798,6 @@ impl Project {
         })?
     }
 
-    fn serialize_project_transaction_for_peer(
-        &mut self,
-        project_transaction: ProjectTransaction,
-        peer_id: proto::PeerId,
-        cx: &mut AppContext,
-    ) -> proto::ProjectTransaction {
-        self.buffer_store.update(cx, |buffer_store, cx| {
-            buffer_store.serialize_project_transaction_for_peer(project_transaction, peer_id, cx)
-        })
-    }
-
     fn create_buffer_for_peer(
         &mut self,
         buffer: &Model<Buffer>,
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 043f7e95ee026c..0af0d6bb1570dd 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -50,8 +50,7 @@ impl HeadlessProject {
             store
         });
         let buffer_store = cx.new_model(|cx| {
-            let mut buffer_store =
-                BufferStore::new(worktree_store.clone(), Some(SSH_PROJECT_ID), cx);
+            let mut buffer_store = BufferStore::local(worktree_store.clone(), cx);
             buffer_store.shared(SSH_PROJECT_ID, session.clone().into(), cx);
             buffer_store
         });
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 18eb12b445b97b..eca65f1349845c 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -7,6 +7,7 @@ use http_client::FakeHttpClient;
 use language::{
     language_settings::{all_language_settings, AllLanguageSettings},
     Buffer, FakeLspAdapter, LanguageConfig, LanguageMatcher, LanguageRegistry, LanguageServerName,
+    LineEnding,
 };
 use lsp::{CompletionContext, CompletionResponse, CompletionTriggerKind};
 use node_runtime::NodeRuntime;
@@ -18,7 +19,10 @@ use remote::SshSession;
 use serde_json::json;
 use settings::{Settings, SettingsLocation, SettingsStore};
 use smol::stream::StreamExt;
-use std::{path::Path, sync::Arc};
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 
 #[gpui::test]
 async fn test_basic_remote_editing(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {
@@ -440,6 +444,54 @@ async fn test_remote_lsp(cx: &mut TestAppContext, server_cx: &mut TestAppContext
     })
 }
 
+#[gpui::test]
+async fn test_remote_reload(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {
+    let (project, _headless, fs) = init_test(cx, server_cx).await;
+    let (worktree, _) = project
+        .update(cx, |project, cx| {
+            project.find_or_create_worktree("/code/project1", true, cx)
+        })
+        .await
+        .unwrap();
+
+    let worktree_id = cx.update(|cx| worktree.read(cx).id());
+
+    let buffer = project
+        .update(cx, |project, cx| {
+            project.open_buffer((worktree_id, Path::new("src/lib.rs")), cx)
+        })
+        .await
+        .unwrap();
+    buffer.update(cx, |buffer, cx| {
+        buffer.edit([(0..0, "a")], None, cx);
+    });
+
+    fs.save(
+        &PathBuf::from("/code/project1/src/lib.rs"),
+        &("bloop".to_string().into()),
+        LineEnding::Unix,
+    )
+    .await
+    .unwrap();
+
+    cx.run_until_parked();
+    cx.update(|cx| {
+        assert!(buffer.read(cx).has_conflict());
+    });
+
+    project
+        .update(cx, |project, cx| {
+            project.reload_buffers([buffer.clone()].into_iter().collect(), false, cx)
+        })
+        .await
+        .unwrap();
+    cx.run_until_parked();
+
+    cx.update(|cx| {
+        assert!(!buffer.read(cx).has_conflict());
+    });
+}
+
 #[gpui::test]
 async fn test_remote_resolve_file_path(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {
     let (project, _headless, _fs) = init_test(cx, server_cx).await;
@@ -483,6 +535,34 @@ async fn test_remote_resolve_file_path(cx: &mut TestAppContext, server_cx: &mut
     );
 }
 
+#[gpui::test(iterations = 10)]
+async fn test_canceling_buffer_opening(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {
+    let (project, _headless, _fs) = init_test(cx, server_cx).await;
+    let (worktree, _) = project
+        .update(cx, |project, cx| {
+            project.find_or_create_worktree("/code/project1", true, cx)
+        })
+        .await
+        .unwrap();
+    let worktree_id = worktree.read_with(cx, |tree, _| tree.id());
+
+    // Open a buffer on the client but cancel after a random amount of time.
+    let buffer = project.update(cx, |p, cx| p.open_buffer((worktree_id, "src/lib.rs"), cx));
+    cx.executor().simulate_random_delay().await;
+    drop(buffer);
+
+    // Try opening the same buffer again as the client, and ensure we can
+    // still do it despite the cancellation above.
+    let buffer = project
+        .update(cx, |p, cx| p.open_buffer((worktree_id, "src/lib.rs"), cx))
+        .await
+        .unwrap();
+
+    buffer.read_with(cx, |buf, _| {
+        assert_eq!(buf.text(), "fn one() -> usize { 1 }")
+    });
+}
+
 fn init_logger() {
     if std::env::var("RUST_LOG").is_ok() {
         env_logger::try_init().ok();

From 96068584362a43ef4dd20055f5c8b3c9710066fd Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Tue, 24 Sep 2024 12:08:22 -0700
Subject: [PATCH 303/762] Fix unnecessarily-specific struct pattern in rust
 outline query (#18297)

Fixes https://github.com/zed-industries/zed/issues/18294

Release Notes:

- Fixed a recent regression where tuple and unit structs were omitted
from the outline view in Rust (#18294).
---
 crates/languages/src/rust/outline.scm | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/languages/src/rust/outline.scm b/crates/languages/src/rust/outline.scm
index 98892ce93cfb35..3012995e2a7f23 100644
--- a/crates/languages/src/rust/outline.scm
+++ b/crates/languages/src/rust/outline.scm
@@ -4,8 +4,7 @@
 (struct_item
     (visibility_modifier)? @context
     "struct" @context
-    name: (_) @name
-    body: (_ "{" @open (_)* "}" @close)) @item
+    name: (_) @name) @item
 
 (enum_item
     (visibility_modifier)? @context

From 87ac4cff60c05bac9d118df25b13987df6f1a5bd Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 24 Sep 2024 15:42:26 -0400
Subject: [PATCH 304/762] Update close_stale_issues configuration (#18298)

@notpeter and I decided on these things:

- Give users 10 days to respond
- Only run once a week: Tuesday @7AM ET

Release Notes:

- N/A
---
 .github/workflows/close_stale_issues.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/close_stale_issues.yml
index 1f287fb5e3d4b9..2d4085524bb8d0 100644
--- a/.github/workflows/close_stale_issues.yml
+++ b/.github/workflows/close_stale_issues.yml
@@ -1,7 +1,7 @@
 name: "Close Stale Issues"
 on:
   schedule:
-    - cron: "0 1 * * *"
+    - cron: "0 11 * * 2"
   workflow_dispatch:
 
 jobs:
@@ -14,7 +14,7 @@ jobs:
           stale-issue-message: >
             Hi there! 👋
 
-            We're working to clean up our issue tracker by closing older issues that might not be relevant anymore. Are you able to reproduce this issue in the latest version of Zed? If so, please let us know by commenting on this issue and we will keep it open; otherwise, we'll close it in a week. Feel free to open a new issue if you're seeing this message after the issue has been closed.
+            We're working to clean up our issue tracker by closing older issues that might not be relevant anymore. Are you able to reproduce this issue in the latest version of Zed? If so, please let us know by commenting on this issue and we will keep it open; otherwise, we'll close it in 10 days. Feel free to open a new issue if you're seeing this message after the issue has been closed.
 
             Thanks for your help!
           close-issue-message: "This issue was closed due to inactivity; feel free to open a new issue if you're still experiencing this problem!"
@@ -23,7 +23,7 @@ jobs:
           # 'community' to 'zed' repository. The migration added activity to all
           # issues, preventing 365 days from working until then.
           days-before-stale: 180
-          days-before-close: 7
+          days-before-close: 10
           any-of-issue-labels: "defect,panic / crash"
           operations-per-run: 1000
           ascending: true

From 692590bff435da3bdb7a0bd1bf9f139c3bdc6eb1 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 24 Sep 2024 15:44:55 -0400
Subject: [PATCH 305/762] collab: Fix GitHub user retrieval in seed script
 (#18296)

This PR fixes the GitHub user retrieval in the database seed script.

The users returned from the [list
users](https://docs.github.com/en/rest/users/users?apiVersion=2022-11-28#list-users)
endpoint don't have a `created_at` timestamp, so we need to fetch them
individually.

I want to rework this further at a later date, this is just a bandaid to
get things working again.

Release Notes:

- N/A
---
 crates/collab/src/db/queries/users.rs |  6 ++++
 crates/collab/src/seed.rs             | 43 +++++++++++++++++++++++----
 2 files changed, 44 insertions(+), 5 deletions(-)

diff --git a/crates/collab/src/db/queries/users.rs b/crates/collab/src/db/queries/users.rs
index b755476e338b60..4443d751542b50 100644
--- a/crates/collab/src/db/queries/users.rs
+++ b/crates/collab/src/db/queries/users.rs
@@ -298,6 +298,12 @@ impl Database {
         result
     }
 
+    /// Returns all feature flags.
+    pub async fn list_feature_flags(&self) -> Result<Vec<feature_flag::Model>> {
+        self.transaction(|tx| async move { Ok(feature_flag::Entity::find().all(&*tx).await?) })
+            .await
+    }
+
     /// Creates a new feature flag.
     pub async fn create_user_flag(&self, flag: &str, enabled_for_all: bool) -> Result<FlagId> {
         self.transaction(|tx| async move {
diff --git a/crates/collab/src/seed.rs b/crates/collab/src/seed.rs
index 15aa9d159183f8..035d58109b596d 100644
--- a/crates/collab/src/seed.rs
+++ b/crates/collab/src/seed.rs
@@ -16,13 +16,23 @@ struct GithubUser {
     created_at: DateTime<Utc>,
 }
 
+/// A GitHub user returned from the [List users](https://docs.github.com/en/rest/users/users?apiVersion=2022-11-28#list-users) endpoint.
+///
+/// Notably, this data type does not have the `created_at` field.
+#[derive(Debug, Deserialize)]
+struct ListGithubUser {
+    id: i32,
+    login: String,
+    email: Option<String>,
+}
+
 #[derive(Deserialize)]
 struct SeedConfig {
-    // Which users to create as admins.
+    /// Which users to create as admins.
     admins: Vec<String>,
-    // Which channels to create (all admins are invited to all channels)
+    /// Which channels to create (all admins are invited to all channels).
     channels: Vec<String>,
-    // Number of random users to create from the Github API
+    /// Number of random users to create from the Github API.
     number_of_users: Option<usize>,
 }
 
@@ -47,11 +57,21 @@ pub async fn seed(config: &Config, db: &Database, force: bool) -> anyhow::Result
     let flag_names = ["remoting", "language-models"];
     let mut flags = Vec::new();
 
+    let existing_feature_flags = db.list_feature_flags().await?;
+
     for flag_name in flag_names {
+        if existing_feature_flags
+            .iter()
+            .any(|flag| flag.flag == flag_name)
+        {
+            log::info!("Flag {flag_name:?} already exists");
+            continue;
+        }
+
         let flag = db
             .create_user_flag(flag_name, false)
             .await
-            .unwrap_or_else(|_| panic!("failed to create flag: '{flag_name}'"));
+            .unwrap_or_else(|err| panic!("failed to create flag: '{flag_name}': {err}"));
         flags.push(flag);
     }
 
@@ -121,9 +141,19 @@ pub async fn seed(config: &Config, db: &Database, force: bool) -> anyhow::Result
             if let Some(last_user_id) = last_user_id {
                 write!(&mut uri, "&since={}", last_user_id).unwrap();
             }
-            let users = fetch_github::<Vec<GithubUser>>(&client, &uri).await;
+            let users = fetch_github::<Vec<ListGithubUser>>(&client, &uri).await;
 
             for github_user in users {
+                log::info!("Seeding {:?} from GitHub", github_user.login);
+
+                // Fetch the user to get their `created_at` timestamp, since it
+                // isn't on the list response.
+                let github_user: GithubUser = fetch_github(
+                    &client,
+                    &format!("https://api.github.com/user/{}", github_user.id),
+                )
+                .await;
+
                 last_user_id = Some(github_user.id);
                 user_count += 1;
                 let user = db
@@ -143,6 +173,9 @@ pub async fn seed(config: &Config, db: &Database, force: bool) -> anyhow::Result
                         flag, user.id
                     ))?;
                 }
+
+                // Sleep to avoid getting rate-limited by GitHub.
+                tokio::time::sleep(std::time::Duration::from_millis(250)).await;
             }
         }
     }

From d2ffad0f34322d9a332860e566f63aec01a83fe7 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 24 Sep 2024 16:35:09 -0400
Subject: [PATCH 306/762] collab: Seed GitHub users from static data (#18301)

This PR updates the collab seed script to seed the GitHub users from a
set of static data.

This removes the need to hit the GitHub API to retrieve these users.

Release Notes:

- N/A
---
 crates/collab/README.md              |   3 +-
 crates/collab/seed.default.json      |   3 +-
 crates/collab/seed/github_users.json | 602 +++++++++++++++++++++++++++
 crates/collab/src/seed.rs            |  89 ++--
 4 files changed, 630 insertions(+), 67 deletions(-)
 create mode 100644 crates/collab/seed/github_users.json

diff --git a/crates/collab/README.md b/crates/collab/README.md
index 345e82aefed78f..5aa964ee792fee 100644
--- a/crates/collab/README.md
+++ b/crates/collab/README.md
@@ -23,8 +23,7 @@ To use a different set of admin users, create `crates/collab/seed.json`.
 ```json
 {
   "admins": ["yourgithubhere"],
-  "channels": ["zed"],
-  "number_of_users": 20
+  "channels": ["zed"]
 }
 ```
 
diff --git a/crates/collab/seed.default.json b/crates/collab/seed.default.json
index 1abec644beed9f..dee924e103d620 100644
--- a/crates/collab/seed.default.json
+++ b/crates/collab/seed.default.json
@@ -8,6 +8,5 @@
     "JosephTLyons",
     "rgbkrk"
   ],
-  "channels": ["zed"],
-  "number_of_users": 100
+  "channels": ["zed"]
 }
diff --git a/crates/collab/seed/github_users.json b/crates/collab/seed/github_users.json
new file mode 100644
index 00000000000000..88acd6aa54a709
--- /dev/null
+++ b/crates/collab/seed/github_users.json
@@ -0,0 +1,602 @@
+[
+  {
+    "id": 1,
+    "login": "mojombo",
+    "email": "tom@mojombo.com",
+    "created_at": "2007-10-20T05:24:19Z"
+  },
+  {
+    "id": 2,
+    "login": "defunkt",
+    "email": null,
+    "created_at": "2007-10-20T05:24:19Z"
+  },
+  {
+    "id": 3,
+    "login": "pjhyett",
+    "email": "pj@hyett.com",
+    "created_at": "2008-01-07T17:54:22Z"
+  },
+  {
+    "id": 4,
+    "login": "wycats",
+    "email": "wycats@gmail.com",
+    "created_at": "2008-01-12T05:38:33Z"
+  },
+  {
+    "id": 5,
+    "login": "ezmobius",
+    "email": null,
+    "created_at": "2008-01-12T07:51:46Z"
+  },
+  {
+    "id": 6,
+    "login": "ivey",
+    "email": "ivey@gweezlebur.com",
+    "created_at": "2008-01-12T15:15:00Z"
+  },
+  {
+    "id": 7,
+    "login": "evanphx",
+    "email": "evan@phx.io",
+    "created_at": "2008-01-12T16:46:24Z"
+  },
+  {
+    "id": 17,
+    "login": "vanpelt",
+    "email": "vanpelt@wandb.com",
+    "created_at": "2008-01-13T05:57:18Z"
+  },
+  {
+    "id": 18,
+    "login": "wayneeseguin",
+    "email": "wayneeseguin@gmail.com",
+    "created_at": "2008-01-13T06:02:21Z"
+  },
+  {
+    "id": 19,
+    "login": "brynary",
+    "email": null,
+    "created_at": "2008-01-13T10:19:47Z"
+  },
+  {
+    "id": 20,
+    "login": "kevinclark",
+    "email": "kevin.clark@gmail.com",
+    "created_at": "2008-01-13T18:33:26Z"
+  },
+  {
+    "id": 21,
+    "login": "technoweenie",
+    "email": "technoweenie@hey.com",
+    "created_at": "2008-01-14T04:33:35Z"
+  },
+  {
+    "id": 22,
+    "login": "macournoyer",
+    "email": "macournoyer@gmail.com",
+    "created_at": "2008-01-14T10:49:35Z"
+  },
+  {
+    "id": 23,
+    "login": "takeo",
+    "email": "toby@takeo.email",
+    "created_at": "2008-01-14T11:25:49Z"
+  },
+  {
+    "id": 25,
+    "login": "caged",
+    "email": "encytemedia@gmail.com",
+    "created_at": "2008-01-15T04:47:24Z"
+  },
+  {
+    "id": 26,
+    "login": "topfunky",
+    "email": null,
+    "created_at": "2008-01-15T05:40:05Z"
+  },
+  {
+    "id": 27,
+    "login": "anotherjesse",
+    "email": "anotherjesse@gmail.com",
+    "created_at": "2008-01-15T07:49:30Z"
+  },
+  {
+    "id": 28,
+    "login": "roland",
+    "email": null,
+    "created_at": "2008-01-15T08:12:51Z"
+  },
+  {
+    "id": 29,
+    "login": "lukas",
+    "email": "lukas@wandb.com",
+    "created_at": "2008-01-15T12:50:02Z"
+  },
+  {
+    "id": 30,
+    "login": "fanvsfan",
+    "email": null,
+    "created_at": "2008-01-15T14:15:23Z"
+  },
+  {
+    "id": 31,
+    "login": "tomtt",
+    "email": null,
+    "created_at": "2008-01-15T15:44:31Z"
+  },
+  {
+    "id": 32,
+    "login": "railsjitsu",
+    "email": null,
+    "created_at": "2008-01-16T04:57:23Z"
+  },
+  {
+    "id": 34,
+    "login": "nitay",
+    "email": null,
+    "created_at": "2008-01-18T14:09:11Z"
+  },
+  {
+    "id": 35,
+    "login": "kevwil",
+    "email": null,
+    "created_at": "2008-01-19T05:50:12Z"
+  },
+  {
+    "id": 36,
+    "login": "KirinDave",
+    "email": null,
+    "created_at": "2008-01-19T08:01:02Z"
+  },
+  {
+    "id": 37,
+    "login": "jamesgolick",
+    "email": "jamesgolick@gmail.com",
+    "created_at": "2008-01-19T22:52:30Z"
+  },
+  {
+    "id": 38,
+    "login": "atmos",
+    "email": "atmos@atmos.org",
+    "created_at": "2008-01-22T09:14:11Z"
+  },
+  {
+    "id": 44,
+    "login": "errfree",
+    "email": null,
+    "created_at": "2008-01-24T02:08:37Z"
+  },
+  {
+    "id": 45,
+    "login": "mojodna",
+    "email": null,
+    "created_at": "2008-01-24T04:40:22Z"
+  },
+  {
+    "id": 46,
+    "login": "bmizerany",
+    "email": "blake.mizerany@gmail.com",
+    "created_at": "2008-01-24T04:44:30Z"
+  },
+  {
+    "id": 47,
+    "login": "jnewland",
+    "email": "jesse@jnewland.com",
+    "created_at": "2008-01-25T02:28:12Z"
+  },
+  {
+    "id": 48,
+    "login": "joshknowles",
+    "email": "joshknowles@gmail.com",
+    "created_at": "2008-01-25T21:30:42Z"
+  },
+  {
+    "id": 49,
+    "login": "hornbeck",
+    "email": "hornbeck@gmail.com",
+    "created_at": "2008-01-25T21:49:23Z"
+  },
+  {
+    "id": 50,
+    "login": "jwhitmire",
+    "email": "jeff@jwhitmire.com",
+    "created_at": "2008-01-25T22:07:48Z"
+  },
+  {
+    "id": 51,
+    "login": "elbowdonkey",
+    "email": null,
+    "created_at": "2008-01-25T22:08:20Z"
+  },
+  {
+    "id": 52,
+    "login": "reinh",
+    "email": null,
+    "created_at": "2008-01-25T22:16:29Z"
+  },
+  {
+    "id": 53,
+    "login": "knzai",
+    "email": "git@knz.ai",
+    "created_at": "2008-01-25T22:33:10Z"
+  },
+  {
+    "id": 68,
+    "login": "bs",
+    "email": "yap@bri.tt",
+    "created_at": "2008-01-27T01:46:29Z"
+  },
+  {
+    "id": 69,
+    "login": "rsanheim",
+    "email": null,
+    "created_at": "2008-01-27T07:09:47Z"
+  },
+  {
+    "id": 70,
+    "login": "schacon",
+    "email": "schacon@gmail.com",
+    "created_at": "2008-01-27T17:19:28Z"
+  },
+  {
+    "id": 71,
+    "login": "uggedal",
+    "email": null,
+    "created_at": "2008-01-27T22:18:57Z"
+  },
+  {
+    "id": 72,
+    "login": "bruce",
+    "email": "brwcodes@gmail.com",
+    "created_at": "2008-01-28T07:16:45Z"
+  },
+  {
+    "id": 73,
+    "login": "sam",
+    "email": "ssmoot@gmail.com",
+    "created_at": "2008-01-28T19:01:26Z"
+  },
+  {
+    "id": 74,
+    "login": "mmower",
+    "email": "self@mattmower.com",
+    "created_at": "2008-01-28T19:47:50Z"
+  },
+  {
+    "id": 75,
+    "login": "abhay",
+    "email": null,
+    "created_at": "2008-01-28T21:08:23Z"
+  },
+  {
+    "id": 76,
+    "login": "rabble",
+    "email": "evan@protest.net",
+    "created_at": "2008-01-28T23:27:02Z"
+  },
+  {
+    "id": 77,
+    "login": "benburkert",
+    "email": "ben@benburkert.com",
+    "created_at": "2008-01-28T23:44:14Z"
+  },
+  {
+    "id": 78,
+    "login": "indirect",
+    "email": "andre@arko.net",
+    "created_at": "2008-01-29T07:59:27Z"
+  },
+  {
+    "id": 79,
+    "login": "fearoffish",
+    "email": "me@fearof.fish",
+    "created_at": "2008-01-29T08:43:10Z"
+  },
+  {
+    "id": 80,
+    "login": "ry",
+    "email": "ry@tinyclouds.org",
+    "created_at": "2008-01-29T08:50:34Z"
+  },
+  {
+    "id": 81,
+    "login": "engineyard",
+    "email": null,
+    "created_at": "2008-01-29T09:51:30Z"
+  },
+  {
+    "id": 82,
+    "login": "jsierles",
+    "email": null,
+    "created_at": "2008-01-29T11:10:25Z"
+  },
+  {
+    "id": 83,
+    "login": "tweibley",
+    "email": null,
+    "created_at": "2008-01-29T13:52:07Z"
+  },
+  {
+    "id": 84,
+    "login": "peimei",
+    "email": "james@railsjitsu.com",
+    "created_at": "2008-01-29T15:44:11Z"
+  },
+  {
+    "id": 85,
+    "login": "brixen",
+    "email": "brixen@gmail.com",
+    "created_at": "2008-01-29T16:47:55Z"
+  },
+  {
+    "id": 87,
+    "login": "tmornini",
+    "email": null,
+    "created_at": "2008-01-29T18:43:39Z"
+  },
+  {
+    "id": 88,
+    "login": "outerim",
+    "email": "lee@outerim.com",
+    "created_at": "2008-01-29T18:48:32Z"
+  },
+  {
+    "id": 89,
+    "login": "daksis",
+    "email": null,
+    "created_at": "2008-01-29T19:18:16Z"
+  },
+  {
+    "id": 90,
+    "login": "sr",
+    "email": "me@simonrozet.com",
+    "created_at": "2008-01-29T20:37:53Z"
+  },
+  {
+    "id": 91,
+    "login": "lifo",
+    "email": null,
+    "created_at": "2008-01-29T23:09:30Z"
+  },
+  {
+    "id": 92,
+    "login": "rsl",
+    "email": "sconds@gmail.com",
+    "created_at": "2008-01-29T23:13:36Z"
+  },
+  {
+    "id": 93,
+    "login": "imownbey",
+    "email": null,
+    "created_at": "2008-01-29T23:13:44Z"
+  },
+  {
+    "id": 94,
+    "login": "dylanegan",
+    "email": null,
+    "created_at": "2008-01-29T23:15:18Z"
+  },
+  {
+    "id": 95,
+    "login": "jm",
+    "email": "jeremymcanally@gmail.com",
+    "created_at": "2008-01-29T23:15:32Z"
+  },
+  {
+    "id": 100,
+    "login": "kmarsh",
+    "email": "kevin.marsh@gmail.com",
+    "created_at": "2008-01-29T23:48:24Z"
+  },
+  {
+    "id": 101,
+    "login": "jvantuyl",
+    "email": "jayson@aggressive.ly",
+    "created_at": "2008-01-30T01:11:50Z"
+  },
+  {
+    "id": 102,
+    "login": "BrianTheCoder",
+    "email": "wbsmith83@gmail.com",
+    "created_at": "2008-01-30T02:22:32Z"
+  },
+  {
+    "id": 103,
+    "login": "freeformz",
+    "email": "freeformz@gmail.com",
+    "created_at": "2008-01-30T06:19:57Z"
+  },
+  {
+    "id": 104,
+    "login": "hassox",
+    "email": "dneighman@gmail.com",
+    "created_at": "2008-01-30T06:31:06Z"
+  },
+  {
+    "id": 105,
+    "login": "automatthew",
+    "email": "automatthew@gmail.com",
+    "created_at": "2008-01-30T19:00:58Z"
+  },
+  {
+    "id": 106,
+    "login": "queso",
+    "email": "Joshua.owens@gmail.com",
+    "created_at": "2008-01-30T19:48:45Z"
+  },
+  {
+    "id": 107,
+    "login": "lancecarlson",
+    "email": null,
+    "created_at": "2008-01-30T19:53:29Z"
+  },
+  {
+    "id": 108,
+    "login": "drnic",
+    "email": "drnicwilliams@gmail.com",
+    "created_at": "2008-01-30T23:19:18Z"
+  },
+  {
+    "id": 109,
+    "login": "lukesutton",
+    "email": null,
+    "created_at": "2008-01-31T04:01:02Z"
+  },
+  {
+    "id": 110,
+    "login": "danwrong",
+    "email": null,
+    "created_at": "2008-01-31T08:51:31Z"
+  },
+  {
+    "id": 111,
+    "login": "HamptonMakes",
+    "email": "hampton@hamptoncatlin.com",
+    "created_at": "2008-01-31T17:03:51Z"
+  },
+  {
+    "id": 112,
+    "login": "jfrost",
+    "email": null,
+    "created_at": "2008-01-31T22:14:27Z"
+  },
+  {
+    "id": 113,
+    "login": "mattetti",
+    "email": null,
+    "created_at": "2008-01-31T22:56:31Z"
+  },
+  {
+    "id": 114,
+    "login": "ctennis",
+    "email": "c@leb.tennis",
+    "created_at": "2008-01-31T23:43:14Z"
+  },
+  {
+    "id": 115,
+    "login": "lawrencepit",
+    "email": "lawrence.pit@gmail.com",
+    "created_at": "2008-01-31T23:57:16Z"
+  },
+  {
+    "id": 116,
+    "login": "marcjeanson",
+    "email": "github@marcjeanson.com",
+    "created_at": "2008-02-01T01:27:19Z"
+  },
+  {
+    "id": 117,
+    "login": "grempe",
+    "email": null,
+    "created_at": "2008-02-01T04:12:42Z"
+  },
+  {
+    "id": 118,
+    "login": "peterc",
+    "email": "git@peterc.org",
+    "created_at": "2008-02-02T01:00:36Z"
+  },
+  {
+    "id": 119,
+    "login": "ministrycentered",
+    "email": null,
+    "created_at": "2008-02-02T03:50:26Z"
+  },
+  {
+    "id": 120,
+    "login": "afarnham",
+    "email": null,
+    "created_at": "2008-02-02T05:11:03Z"
+  },
+  {
+    "id": 121,
+    "login": "up_the_irons",
+    "email": null,
+    "created_at": "2008-02-02T10:59:51Z"
+  },
+  {
+    "id": 122,
+    "login": "cristibalan",
+    "email": "cristibalan@gmail.com",
+    "created_at": "2008-02-02T11:29:45Z"
+  },
+  {
+    "id": 123,
+    "login": "heavysixer",
+    "email": null,
+    "created_at": "2008-02-02T15:06:53Z"
+  },
+  {
+    "id": 124,
+    "login": "brosner",
+    "email": "brosner@gmail.com",
+    "created_at": "2008-02-02T19:03:54Z"
+  },
+  {
+    "id": 125,
+    "login": "danielmorrison",
+    "email": "daniel@collectiveidea.com",
+    "created_at": "2008-02-02T19:46:35Z"
+  },
+  {
+    "id": 126,
+    "login": "danielharan",
+    "email": "chebuctonian@gmail.com",
+    "created_at": "2008-02-02T21:42:21Z"
+  },
+  {
+    "id": 127,
+    "login": "kvnsmth",
+    "email": null,
+    "created_at": "2008-02-02T22:00:03Z"
+  },
+  {
+    "id": 128,
+    "login": "collectiveidea",
+    "email": "info@collectiveidea.com",
+    "created_at": "2008-02-02T22:34:46Z"
+  },
+  {
+    "id": 129,
+    "login": "canadaduane",
+    "email": "duane.johnson@gmail.com",
+    "created_at": "2008-02-02T23:25:39Z"
+  },
+  {
+    "id": 130,
+    "login": "corasaurus-hex",
+    "email": "cora@sutton.me",
+    "created_at": "2008-02-03T04:20:22Z"
+  },
+  {
+    "id": 131,
+    "login": "dstrelau",
+    "email": null,
+    "created_at": "2008-02-03T14:59:12Z"
+  },
+  {
+    "id": 132,
+    "login": "sunny",
+    "email": "sunny@sunfox.org",
+    "created_at": "2008-02-03T15:43:43Z"
+  },
+  {
+    "id": 133,
+    "login": "dkubb",
+    "email": "github@dan.kubb.ca",
+    "created_at": "2008-02-03T20:40:13Z"
+  },
+  {
+    "id": 134,
+    "login": "jnicklas",
+    "email": "jonas@jnicklas.com",
+    "created_at": "2008-02-03T20:43:50Z"
+  },
+  {
+    "id": 135,
+    "login": "richcollins",
+    "email": "richcollins@gmail.com",
+    "created_at": "2008-02-03T21:11:25Z"
+  }
+]
diff --git a/crates/collab/src/seed.rs b/crates/collab/src/seed.rs
index 035d58109b596d..5de6515ae3ac89 100644
--- a/crates/collab/src/seed.rs
+++ b/crates/collab/src/seed.rs
@@ -4,10 +4,13 @@ use anyhow::Context;
 use chrono::{DateTime, Utc};
 use db::Database;
 use serde::{de::DeserializeOwned, Deserialize};
-use std::{fmt::Write, fs, path::Path};
+use std::{fs, path::Path};
 
 use crate::Config;
 
+/// A GitHub user.
+///
+/// This representation corresponds to the entries in the `seed/github_users.json` file.
 #[derive(Debug, Deserialize)]
 struct GithubUser {
     id: i32,
@@ -16,24 +19,12 @@ struct GithubUser {
     created_at: DateTime<Utc>,
 }
 
-/// A GitHub user returned from the [List users](https://docs.github.com/en/rest/users/users?apiVersion=2022-11-28#list-users) endpoint.
-///
-/// Notably, this data type does not have the `created_at` field.
-#[derive(Debug, Deserialize)]
-struct ListGithubUser {
-    id: i32,
-    login: String,
-    email: Option<String>,
-}
-
 #[derive(Deserialize)]
 struct SeedConfig {
     /// Which users to create as admins.
     admins: Vec<String>,
     /// Which channels to create (all admins are invited to all channels).
     channels: Vec<String>,
-    /// Number of random users to create from the Github API.
-    number_of_users: Option<usize>,
 }
 
 pub async fn seed(config: &Config, db: &Database, force: bool) -> anyhow::Result<()> {
@@ -126,57 +117,29 @@ pub async fn seed(config: &Config, db: &Database, force: bool) -> anyhow::Result
         }
     }
 
-    // TODO: Fix this later
-    if let Some(number_of_users) = seed_config.number_of_users {
-        // Fetch 100 other random users from GitHub and insert them into the database
-        // (for testing autocompleters, etc.)
-        let mut user_count = db
-            .get_all_users(0, 200)
+    let github_users_filepath = seed_path.parent().unwrap().join("seed/github_users.json");
+    let github_users: Vec<GithubUser> =
+        serde_json::from_str(&fs::read_to_string(github_users_filepath)?)?;
+
+    for github_user in github_users {
+        log::info!("Seeding {:?} from GitHub", github_user.login);
+
+        let user = db
+            .get_or_create_user_by_github_account(
+                &github_user.login,
+                github_user.id,
+                github_user.email.as_deref(),
+                github_user.created_at,
+                None,
+            )
             .await
-            .expect("failed to load users from db")
-            .len();
-        let mut last_user_id = None;
-        while user_count < number_of_users {
-            let mut uri = "https://api.github.com/users?per_page=100".to_string();
-            if let Some(last_user_id) = last_user_id {
-                write!(&mut uri, "&since={}", last_user_id).unwrap();
-            }
-            let users = fetch_github::<Vec<ListGithubUser>>(&client, &uri).await;
-
-            for github_user in users {
-                log::info!("Seeding {:?} from GitHub", github_user.login);
-
-                // Fetch the user to get their `created_at` timestamp, since it
-                // isn't on the list response.
-                let github_user: GithubUser = fetch_github(
-                    &client,
-                    &format!("https://api.github.com/user/{}", github_user.id),
-                )
-                .await;
-
-                last_user_id = Some(github_user.id);
-                user_count += 1;
-                let user = db
-                    .get_or_create_user_by_github_account(
-                        &github_user.login,
-                        github_user.id,
-                        github_user.email.as_deref(),
-                        github_user.created_at,
-                        None,
-                    )
-                    .await
-                    .expect("failed to insert user");
-
-                for flag in &flags {
-                    db.add_user_flag(user.id, *flag).await.context(format!(
-                        "Unable to enable flag '{}' for user '{}'",
-                        flag, user.id
-                    ))?;
-                }
-
-                // Sleep to avoid getting rate-limited by GitHub.
-                tokio::time::sleep(std::time::Duration::from_millis(250)).await;
-            }
+            .expect("failed to insert user");
+
+        for flag in &flags {
+            db.add_user_flag(user.id, *flag).await.context(format!(
+                "Unable to enable flag '{}' for user '{}'",
+                flag, user.id
+            ))?;
         }
     }
 

From 2d71c36ad3ec7b4b000c6144089c7a2294d0a19c Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 25 Sep 2024 00:29:56 +0300
Subject: [PATCH 307/762] Allow clearning activity indicators on click (#18305)

All indicators without the click action are now could be hidden with a click.

Sometimes, I see a few language server updates statuses get stuck due to npm desperately attempting to access its registry (3 times per each package, with the timeout a bit under 1 minute per each request).
So, while the message seems stuck, npm desperately tries to do some work in the background.

https://docs.npmjs.com/cli/v10/using-npm/config has options for timeouts & retries for __package fetching__ but that does not include the actual __registry access attempts__.

It's unclear how to proceed with npm on this case now, but at least we should allow hiding these redundant messages.

Release Notes:

- Improved activity indicators' UX by allowing more of them to be hidden on click
---
 .../src/activity_indicator.rs                 | 72 +++++++++++++++----
 1 file changed, 59 insertions(+), 13 deletions(-)

diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs
index fee0ef73f7bee1..52e6acc393d299 100644
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -227,10 +227,10 @@ impl ActivityIndicator {
         for status in &self.statuses {
             match status.status {
                 LanguageServerBinaryStatus::CheckingForUpdate => {
-                    checking_for_update.push(status.name.0.as_ref())
+                    checking_for_update.push(status.name.clone())
                 }
-                LanguageServerBinaryStatus::Downloading => downloading.push(status.name.0.as_ref()),
-                LanguageServerBinaryStatus::Failed { .. } => failed.push(status.name.0.as_ref()),
+                LanguageServerBinaryStatus::Downloading => downloading.push(status.name.clone()),
+                LanguageServerBinaryStatus::Failed { .. } => failed.push(status.name.clone()),
                 LanguageServerBinaryStatus::None => {}
             }
         }
@@ -242,8 +242,24 @@ impl ActivityIndicator {
                         .size(IconSize::Small)
                         .into_any_element(),
                 ),
-                message: format!("Downloading {}...", downloading.join(", "),),
-                on_click: None,
+                message: format!(
+                    "Downloading {}...",
+                    downloading.iter().map(|name| name.0.as_ref()).fold(
+                        String::new(),
+                        |mut acc, s| {
+                            if !acc.is_empty() {
+                                acc.push_str(", ");
+                            }
+                            acc.push_str(s);
+                            acc
+                        }
+                    )
+                ),
+                on_click: Some(Arc::new(move |this, cx| {
+                    this.statuses
+                        .retain(|status| !downloading.contains(&status.name));
+                    this.dismiss_error_message(&DismissErrorMessage, cx)
+                })),
             });
         }
 
@@ -256,9 +272,22 @@ impl ActivityIndicator {
                 ),
                 message: format!(
                     "Checking for updates to {}...",
-                    checking_for_update.join(", "),
+                    checking_for_update.iter().map(|name| name.0.as_ref()).fold(
+                        String::new(),
+                        |mut acc, s| {
+                            if !acc.is_empty() {
+                                acc.push_str(", ");
+                            }
+                            acc.push_str(s);
+                            acc
+                        }
+                    ),
                 ),
-                on_click: None,
+                on_click: Some(Arc::new(move |this, cx| {
+                    this.statuses
+                        .retain(|status| !checking_for_update.contains(&status.name));
+                    this.dismiss_error_message(&DismissErrorMessage, cx)
+                })),
             });
         }
 
@@ -271,7 +300,16 @@ impl ActivityIndicator {
                 ),
                 message: format!(
                     "Failed to download {}. Click to show error.",
-                    failed.join(", "),
+                    failed
+                        .iter()
+                        .map(|name| name.0.as_ref())
+                        .fold(String::new(), |mut acc, s| {
+                            if !acc.is_empty() {
+                                acc.push_str(", ");
+                            }
+                            acc.push_str(s);
+                            acc
+                        }),
                 ),
                 on_click: Some(Arc::new(|this, cx| {
                     this.show_error_message(&Default::default(), cx)
@@ -304,7 +342,9 @@ impl ActivityIndicator {
                             .into_any_element(),
                     ),
                     message: "Checking for Zed updates…".to_string(),
-                    on_click: None,
+                    on_click: Some(Arc::new(|this, cx| {
+                        this.dismiss_error_message(&DismissErrorMessage, cx)
+                    })),
                 }),
                 AutoUpdateStatus::Downloading => Some(Content {
                     icon: Some(
@@ -313,7 +353,9 @@ impl ActivityIndicator {
                             .into_any_element(),
                     ),
                     message: "Downloading Zed update…".to_string(),
-                    on_click: None,
+                    on_click: Some(Arc::new(|this, cx| {
+                        this.dismiss_error_message(&DismissErrorMessage, cx)
+                    })),
                 }),
                 AutoUpdateStatus::Installing => Some(Content {
                     icon: Some(
@@ -322,7 +364,9 @@ impl ActivityIndicator {
                             .into_any_element(),
                     ),
                     message: "Installing Zed update…".to_string(),
-                    on_click: None,
+                    on_click: Some(Arc::new(|this, cx| {
+                        this.dismiss_error_message(&DismissErrorMessage, cx)
+                    })),
                 }),
                 AutoUpdateStatus::Updated { binary_path } => Some(Content {
                     icon: None,
@@ -342,7 +386,7 @@ impl ActivityIndicator {
                     ),
                     message: "Auto update failed".to_string(),
                     on_click: Some(Arc::new(|this, cx| {
-                        this.dismiss_error_message(&Default::default(), cx)
+                        this.dismiss_error_message(&DismissErrorMessage, cx)
                     })),
                 }),
                 AutoUpdateStatus::Idle => None,
@@ -360,7 +404,9 @@ impl ActivityIndicator {
                             .into_any_element(),
                     ),
                     message: format!("Updating {extension_id} extension…"),
-                    on_click: None,
+                    on_click: Some(Arc::new(|this, cx| {
+                        this.dismiss_error_message(&DismissErrorMessage, cx)
+                    })),
                 });
             }
         }

From 5045f984a90dd26ba0c0e2fc8ce6cbab70ba5b75 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 24 Sep 2024 15:37:09 -0600
Subject: [PATCH 308/762] Tidy up some broken menu items (#18306)

Release Notes:

- ssh-remoting: Don't show "reveal in finder" in menu
---
 crates/outline_panel/src/outline_panel.rs | 6 ++++--
 crates/project_panel/src/project_panel.rs | 9 ++++++---
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/crates/outline_panel/src/outline_panel.rs b/crates/outline_panel/src/outline_panel.rs
index 73570dd5afc775..da66ca40313d89 100644
--- a/crates/outline_panel/src/outline_panel.rs
+++ b/crates/outline_panel/src/outline_panel.rs
@@ -3906,9 +3906,11 @@ impl Render for OutlinePanel {
             .on_action(cx.listener(Self::toggle_active_editor_pin))
             .on_action(cx.listener(Self::unfold_directory))
             .on_action(cx.listener(Self::fold_directory))
-            .when(project.is_local_or_ssh(), |el| {
+            .when(project.is_local(), |el| {
                 el.on_action(cx.listener(Self::reveal_in_finder))
-                    .on_action(cx.listener(Self::open_in_terminal))
+            })
+            .when(project.is_local_or_ssh(), |el| {
+                el.on_action(cx.listener(Self::open_in_terminal))
             })
             .on_mouse_down(
                 MouseButton::Right,
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index cd4196dbc67b15..8e741134f0e446 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -484,6 +484,7 @@ impl ProjectPanel {
             let worktree_id = worktree.id();
             let is_read_only = project.is_read_only();
             let is_remote = project.is_via_collab() && project.dev_server_project_id().is_none();
+            let is_local = project.is_local();
 
             let context_menu = ContextMenu::build(cx, |menu, cx| {
                 menu.context(self.focus_handle.clone()).map(|menu| {
@@ -495,13 +496,15 @@ impl ProjectPanel {
                         menu.action("New File", Box::new(NewFile))
                             .action("New Folder", Box::new(NewDirectory))
                             .separator()
-                            .when(cfg!(target_os = "macos"), |menu| {
+                            .when(is_local && cfg!(target_os = "macos"), |menu| {
                                 menu.action("Reveal in Finder", Box::new(RevealInFileManager))
                             })
-                            .when(cfg!(not(target_os = "macos")), |menu| {
+                            .when(is_local && cfg!(not(target_os = "macos")), |menu| {
                                 menu.action("Reveal in File Manager", Box::new(RevealInFileManager))
                             })
-                            .action("Open in Default App", Box::new(OpenWithSystem))
+                            .when(is_local, |menu| {
+                                menu.action("Open in Default App", Box::new(OpenWithSystem))
+                            })
                             .action("Open in Terminal", Box::new(OpenInTerminal))
                             .when(is_dir, |menu| {
                                 menu.separator()

From da1ef13442e095414e23db86623a5b5acd117cd3 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Tue, 24 Sep 2024 14:39:44 -0700
Subject: [PATCH 309/762] Fix detection that a diff hunk is expanded (#18302)

Release Notes:

- N/A

---------

Co-authored-by: Marshall <marshall@zed.dev>
---
 crates/collab/src/tests/editor_tests.rs | 5 +----
 crates/editor/src/element.rs            | 6 +++++-
 crates/editor/src/hunk_diff.rs          | 8 ++++++--
 3 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/crates/collab/src/tests/editor_tests.rs b/crates/collab/src/tests/editor_tests.rs
index 7fb1a49f870d97..121c93656305a6 100644
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -2214,10 +2214,7 @@ struct Row10;"#};
         let snapshot = editor.snapshot(cx);
         let all_hunks = editor_hunks(editor, &snapshot, cx);
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(5)..=DisplayRow(5)]
-        );
+        assert_eq!(expanded_hunks_background_highlights(editor, cx), Vec::new());
         assert_eq!(
             all_hunks,
             vec![(
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 3be71aeefba942..31e4efb83b60e7 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -1335,7 +1335,11 @@ impl EditorElement {
                         }
                         match status {
                             DiffHunkStatus::Added => {}
-                            DiffHunkStatus::Modified => {}
+                            DiffHunkStatus::Modified => {
+                                if is_expanded {
+                                    *status = DiffHunkStatus::Added;
+                                }
+                            }
                             DiffHunkStatus::Removed => {
                                 if is_expanded {
                                     return None;
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index 90836cee51683c..2f7bb49e853491 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -279,8 +279,12 @@ impl Editor {
                                 ..Point::new(remaining_hunk.row_range.end.0, 0);
                         hunks_to_expand.push(HoveredHunk {
                             status: hunk_status(&remaining_hunk),
-                            multi_buffer_range: remaining_hunk_point_range
-                                .to_anchors(&snapshot.buffer_snapshot),
+                            multi_buffer_range: snapshot
+                                .buffer_snapshot
+                                .anchor_before(remaining_hunk_point_range.start)
+                                ..snapshot
+                                    .buffer_snapshot
+                                    .anchor_after(remaining_hunk_point_range.end),
                             diff_base_byte_range: remaining_hunk.diff_base_byte_range.clone(),
                         });
                     }

From c4e0f5e0ee83e02567a5512b0f5fafef49225e66 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 24 Sep 2024 15:52:30 -0600
Subject: [PATCH 310/762] Rebuild buffer store to be aware of remote/local
 distinction (#18303)

Release Notes:

- N/A

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 .../remote_editing_collaboration_tests.rs     |   27 +-
 crates/project/src/buffer_store.rs            | 1981 ++++++++++-------
 crates/project/src/lsp_command.rs             |   23 +-
 crates/project/src/lsp_store.rs               |   33 +-
 crates/project/src/project.rs                 |   18 +-
 .../remote_server/src/remote_editing_tests.rs |    1 +
 6 files changed, 1192 insertions(+), 891 deletions(-)

diff --git a/crates/collab/src/tests/remote_editing_collaboration_tests.rs b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
index a81166bb00ceec..bad5ef9053ce70 100644
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -3,6 +3,7 @@ use call::ActiveCall;
 use fs::{FakeFs, Fs as _};
 use gpui::{Context as _, TestAppContext};
 use language::language_settings::all_language_settings;
+use project::ProjectPath;
 use remote::SshSession;
 use remote_server::HeadlessProject;
 use serde_json::json;
@@ -108,14 +109,36 @@ async fn test_sharing_an_ssh_remote_project(
     });
 
     project_b
-        .update(cx_b, |project, cx| project.save_buffer(buffer_b, cx))
+        .update(cx_b, |project, cx| {
+            project.save_buffer_as(
+                buffer_b.clone(),
+                ProjectPath {
+                    worktree_id: worktree_id.to_owned(),
+                    path: Arc::from(Path::new("src/renamed.rs")),
+                },
+                cx,
+            )
+        })
         .await
         .unwrap();
     assert_eq!(
         remote_fs
-            .load("/code/project1/src/lib.rs".as_ref())
+            .load("/code/project1/src/renamed.rs".as_ref())
             .await
             .unwrap(),
         "fn one() -> usize { 100 }"
     );
+    cx_b.run_until_parked();
+    cx_b.update(|cx| {
+        assert_eq!(
+            buffer_b
+                .read(cx)
+                .file()
+                .unwrap()
+                .path()
+                .to_string_lossy()
+                .to_string(),
+            "src/renamed.rs".to_string()
+        );
+    });
 }
diff --git a/crates/project/src/buffer_store.rs b/crates/project/src/buffer_store.rs
index b69679d6ac3b3a..aa86a8f7e256e8 100644
--- a/crates/project/src/buffer_store.rs
+++ b/crates/project/src/buffer_store.rs
@@ -10,7 +10,8 @@ use fs::Fs;
 use futures::{channel::oneshot, stream::FuturesUnordered, StreamExt};
 use git::blame::Blame;
 use gpui::{
-    AppContext, AsyncAppContext, Context as _, EventEmitter, Model, ModelContext, Task, WeakModel,
+    AppContext, AsyncAppContext, Context as _, EventEmitter, Model, ModelContext, Subscription,
+    Task, WeakModel,
 };
 use http_client::Url;
 use language::{
@@ -25,27 +26,72 @@ use smol::channel::Receiver;
 use std::{io, path::Path, str::FromStr as _, sync::Arc, time::Instant};
 use text::BufferId;
 use util::{debug_panic, maybe, ResultExt as _, TryFutureExt};
-use worktree::{
-    File, PathChange, ProjectEntryId, RemoteWorktree, UpdatedGitRepositoriesSet, Worktree,
-    WorktreeId,
-};
+use worktree::{File, PathChange, ProjectEntryId, UpdatedGitRepositoriesSet, Worktree, WorktreeId};
 
-/// A set of open buffers.
-pub struct BufferStore {
-    state: BufferStoreState,
-    downstream_client: Option<(AnyProtoClient, u64)>,
+trait BufferStoreImpl {
+    fn open_buffer(
+        &self,
+        path: Arc<Path>,
+        worktree: Model<Worktree>,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<Model<Buffer>>>;
+
+    fn save_buffer(
+        &self,
+        buffer: Model<Buffer>,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<()>>;
+
+    fn save_buffer_as(
+        &self,
+        buffer: Model<Buffer>,
+        path: ProjectPath,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<()>>;
+
+    fn create_buffer(&self, cx: &mut ModelContext<BufferStore>) -> Task<Result<Model<Buffer>>>;
+
+    fn reload_buffers(
+        &self,
+        buffers: Vec<Model<Buffer>>,
+        push_to_history: bool,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<ProjectTransaction>>;
+
+    fn as_remote(&self) -> Option<Model<RemoteBufferStore>>;
+    fn as_local(&self) -> Option<Model<LocalBufferStore>>;
+}
+
+struct RemoteBufferStore {
+    shared_with_me: HashSet<Model<Buffer>>,
+    upstream_client: AnyProtoClient,
+    project_id: u64,
+    loading_remote_buffers_by_id: HashMap<BufferId, Model<Buffer>>,
+    remote_buffer_listeners:
+        HashMap<BufferId, Vec<oneshot::Sender<Result<Model<Buffer>, anyhow::Error>>>>,
     worktree_store: Model<WorktreeStore>,
-    opened_buffers: HashMap<BufferId, OpenBuffer>,
+    buffer_store: WeakModel<BufferStore>,
+}
+
+struct LocalBufferStore {
     local_buffer_ids_by_path: HashMap<ProjectPath, BufferId>,
     local_buffer_ids_by_entry_id: HashMap<ProjectEntryId, BufferId>,
+    buffer_store: WeakModel<BufferStore>,
+    worktree_store: Model<WorktreeStore>,
+    _subscription: Subscription,
+}
+
+/// A set of open buffers.
+pub struct BufferStore {
+    state: Box<dyn BufferStoreImpl>,
     #[allow(clippy::type_complexity)]
     loading_buffers_by_path: HashMap<
         ProjectPath,
         postage::watch::Receiver<Option<Result<Model<Buffer>, Arc<anyhow::Error>>>>,
     >,
-    loading_remote_buffers_by_id: HashMap<BufferId, Model<Buffer>>,
-    remote_buffer_listeners:
-        HashMap<BufferId, Vec<oneshot::Sender<Result<Model<Buffer>, anyhow::Error>>>>,
+    worktree_store: Model<WorktreeStore>,
+    opened_buffers: HashMap<BufferId, OpenBuffer>,
+    downstream_client: Option<(AnyProtoClient, u64)>,
     shared_buffers: HashMap<proto::PeerId, HashSet<Model<Buffer>>>,
 }
 
@@ -63,19 +109,858 @@ pub enum BufferStoreEvent {
     },
 }
 
-enum BufferStoreState {
-    Remote {
-        shared_with_me: HashSet<Model<Buffer>>,
-        upstream_client: AnyProtoClient,
-        project_id: u64,
-    },
-    Local {},
+#[derive(Default, Debug)]
+pub struct ProjectTransaction(pub HashMap<Model<Buffer>, language::Transaction>);
+
+impl EventEmitter<BufferStoreEvent> for BufferStore {}
+
+impl RemoteBufferStore {
+    pub fn wait_for_remote_buffer(
+        &mut self,
+        id: BufferId,
+        cx: &mut AppContext,
+    ) -> Task<Result<Model<Buffer>>> {
+        let buffer_store = self.buffer_store.clone();
+        let (tx, rx) = oneshot::channel();
+        self.remote_buffer_listeners.entry(id).or_default().push(tx);
+
+        cx.spawn(|cx| async move {
+            if let Some(buffer) = buffer_store
+                .read_with(&cx, |buffer_store, _| buffer_store.get(id))
+                .ok()
+                .flatten()
+            {
+                return Ok(buffer);
+            }
+
+            cx.background_executor()
+                .spawn(async move { rx.await? })
+                .await
+        })
+    }
+
+    fn save_remote_buffer(
+        &self,
+        buffer_handle: Model<Buffer>,
+        new_path: Option<proto::ProjectPath>,
+        cx: &ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        let buffer = buffer_handle.read(cx);
+        let buffer_id = buffer.remote_id().into();
+        let version = buffer.version();
+        let rpc = self.upstream_client.clone();
+        let project_id = self.project_id;
+        cx.spawn(move |_, mut cx| async move {
+            let response = rpc
+                .request(proto::SaveBuffer {
+                    project_id,
+                    buffer_id,
+                    new_path,
+                    version: serialize_version(&version),
+                })
+                .await?;
+            let version = deserialize_version(&response.version);
+            let mtime = response.mtime.map(|mtime| mtime.into());
+
+            buffer_handle.update(&mut cx, |buffer, cx| {
+                buffer.did_save(version.clone(), mtime, cx);
+            })?;
+
+            Ok(())
+        })
+    }
+
+    pub fn handle_create_buffer_for_peer(
+        &mut self,
+        envelope: TypedEnvelope<proto::CreateBufferForPeer>,
+        replica_id: u16,
+        capability: Capability,
+        cx: &mut ModelContext<Self>,
+    ) -> Result<Option<Model<Buffer>>> {
+        match envelope
+            .payload
+            .variant
+            .ok_or_else(|| anyhow!("missing variant"))?
+        {
+            proto::create_buffer_for_peer::Variant::State(mut state) => {
+                let buffer_id = BufferId::new(state.id)?;
+
+                let buffer_result = maybe!({
+                    let mut buffer_file = None;
+                    if let Some(file) = state.file.take() {
+                        let worktree_id = worktree::WorktreeId::from_proto(file.worktree_id);
+                        let worktree = self
+                            .worktree_store
+                            .read(cx)
+                            .worktree_for_id(worktree_id, cx)
+                            .ok_or_else(|| {
+                                anyhow!("no worktree found for id {}", file.worktree_id)
+                            })?;
+                        buffer_file = Some(Arc::new(File::from_proto(file, worktree.clone(), cx)?)
+                            as Arc<dyn language::File>);
+                    }
+                    Buffer::from_proto(replica_id, capability, state, buffer_file)
+                });
+
+                match buffer_result {
+                    Ok(buffer) => {
+                        let buffer = cx.new_model(|_| buffer);
+                        self.loading_remote_buffers_by_id.insert(buffer_id, buffer);
+                    }
+                    Err(error) => {
+                        if let Some(listeners) = self.remote_buffer_listeners.remove(&buffer_id) {
+                            for listener in listeners {
+                                listener.send(Err(anyhow!(error.cloned()))).ok();
+                            }
+                        }
+                    }
+                }
+            }
+            proto::create_buffer_for_peer::Variant::Chunk(chunk) => {
+                let buffer_id = BufferId::new(chunk.buffer_id)?;
+                let buffer = self
+                    .loading_remote_buffers_by_id
+                    .get(&buffer_id)
+                    .cloned()
+                    .ok_or_else(|| {
+                        anyhow!(
+                            "received chunk for buffer {} without initial state",
+                            chunk.buffer_id
+                        )
+                    })?;
+
+                let result = maybe!({
+                    let operations = chunk
+                        .operations
+                        .into_iter()
+                        .map(language::proto::deserialize_operation)
+                        .collect::<Result<Vec<_>>>()?;
+                    buffer.update(cx, |buffer, cx| buffer.apply_ops(operations, cx));
+                    anyhow::Ok(())
+                });
+
+                if let Err(error) = result {
+                    self.loading_remote_buffers_by_id.remove(&buffer_id);
+                    if let Some(listeners) = self.remote_buffer_listeners.remove(&buffer_id) {
+                        for listener in listeners {
+                            listener.send(Err(error.cloned())).ok();
+                        }
+                    }
+                } else if chunk.is_last {
+                    self.loading_remote_buffers_by_id.remove(&buffer_id);
+                    if self.upstream_client.is_via_collab() {
+                        // retain buffers sent by peers to avoid races.
+                        self.shared_with_me.insert(buffer.clone());
+                    }
+
+                    if let Some(senders) = self.remote_buffer_listeners.remove(&buffer_id) {
+                        for sender in senders {
+                            sender.send(Ok(buffer.clone())).ok();
+                        }
+                    }
+                    return Ok(Some(buffer));
+                }
+            }
+        }
+        return Ok(None);
+    }
+
+    pub fn incomplete_buffer_ids(&self) -> Vec<BufferId> {
+        self.loading_remote_buffers_by_id
+            .keys()
+            .copied()
+            .collect::<Vec<_>>()
+    }
+
+    pub fn deserialize_project_transaction(
+        &self,
+        message: proto::ProjectTransaction,
+        push_to_history: bool,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<ProjectTransaction>> {
+        cx.spawn(|this, mut cx| async move {
+            let mut project_transaction = ProjectTransaction::default();
+            for (buffer_id, transaction) in message.buffer_ids.into_iter().zip(message.transactions)
+            {
+                let buffer_id = BufferId::new(buffer_id)?;
+                let buffer = this
+                    .update(&mut cx, |this, cx| {
+                        this.wait_for_remote_buffer(buffer_id, cx)
+                    })?
+                    .await?;
+                let transaction = language::proto::deserialize_transaction(transaction)?;
+                project_transaction.0.insert(buffer, transaction);
+            }
+
+            for (buffer, transaction) in &project_transaction.0 {
+                buffer
+                    .update(&mut cx, |buffer, _| {
+                        buffer.wait_for_edits(transaction.edit_ids.iter().copied())
+                    })?
+                    .await?;
+
+                if push_to_history {
+                    buffer.update(&mut cx, |buffer, _| {
+                        buffer.push_transaction(transaction.clone(), Instant::now());
+                    })?;
+                }
+            }
+
+            Ok(project_transaction)
+        })
+    }
 }
 
-#[derive(Default, Debug)]
-pub struct ProjectTransaction(pub HashMap<Model<Buffer>, language::Transaction>);
+impl BufferStoreImpl for Model<RemoteBufferStore> {
+    fn as_remote(&self) -> Option<Model<RemoteBufferStore>> {
+        Some(self.clone())
+    }
+
+    fn as_local(&self) -> Option<Model<LocalBufferStore>> {
+        None
+    }
+
+    fn save_buffer(
+        &self,
+        buffer: Model<Buffer>,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<()>> {
+        self.update(cx, |this, cx| {
+            this.save_remote_buffer(buffer.clone(), None, cx)
+        })
+    }
+    fn save_buffer_as(
+        &self,
+        buffer: Model<Buffer>,
+        path: ProjectPath,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<()>> {
+        self.update(cx, |this, cx| {
+            this.save_remote_buffer(buffer, Some(path.to_proto()), cx)
+        })
+    }
+
+    fn open_buffer(
+        &self,
+        path: Arc<Path>,
+        worktree: Model<Worktree>,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<Model<Buffer>>> {
+        self.update(cx, |this, cx| {
+            let worktree_id = worktree.read(cx).id().to_proto();
+            let project_id = this.project_id;
+            let client = this.upstream_client.clone();
+            let path_string = path.clone().to_string_lossy().to_string();
+            cx.spawn(move |this, mut cx| async move {
+                let response = client
+                    .request(proto::OpenBufferByPath {
+                        project_id,
+                        worktree_id,
+                        path: path_string,
+                    })
+                    .await?;
+                let buffer_id = BufferId::new(response.buffer_id)?;
+
+                let buffer = this
+                    .update(&mut cx, {
+                        |this, cx| this.wait_for_remote_buffer(buffer_id, cx)
+                    })?
+                    .await?;
+
+                Ok(buffer)
+            })
+        })
+    }
+
+    fn create_buffer(&self, cx: &mut ModelContext<BufferStore>) -> Task<Result<Model<Buffer>>> {
+        self.update(cx, |this, cx| {
+            let create = this.upstream_client.request(proto::OpenNewBuffer {
+                project_id: this.project_id,
+            });
+            cx.spawn(|this, mut cx| async move {
+                let response = create.await?;
+                let buffer_id = BufferId::new(response.buffer_id)?;
+
+                this.update(&mut cx, |this, cx| {
+                    this.wait_for_remote_buffer(buffer_id, cx)
+                })?
+                .await
+            })
+        })
+    }
+
+    fn reload_buffers(
+        &self,
+        buffers: Vec<Model<Buffer>>,
+        push_to_history: bool,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<ProjectTransaction>> {
+        self.update(cx, |this, cx| {
+            let request = this.upstream_client.request(proto::ReloadBuffers {
+                project_id: this.project_id,
+                buffer_ids: buffers
+                    .iter()
+                    .map(|buffer| buffer.read(cx).remote_id().to_proto())
+                    .collect(),
+            });
+
+            cx.spawn(|this, mut cx| async move {
+                let response = request
+                    .await?
+                    .transaction
+                    .ok_or_else(|| anyhow!("missing transaction"))?;
+                this.update(&mut cx, |this, cx| {
+                    this.deserialize_project_transaction(response, push_to_history, cx)
+                })?
+                .await
+            })
+        })
+    }
+}
+
+impl LocalBufferStore {
+    fn save_local_buffer(
+        &self,
+        buffer_handle: Model<Buffer>,
+        worktree: Model<Worktree>,
+        path: Arc<Path>,
+        mut has_changed_file: bool,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        let buffer = buffer_handle.read(cx);
+
+        let text = buffer.as_rope().clone();
+        let line_ending = buffer.line_ending();
+        let version = buffer.version();
+        let buffer_id = buffer.remote_id();
+        if buffer.file().is_some_and(|file| !file.is_created()) {
+            has_changed_file = true;
+        }
+
+        let save = worktree.update(cx, |worktree, cx| {
+            worktree.write_file(path.as_ref(), text, line_ending, cx)
+        });
+
+        cx.spawn(move |this, mut cx| async move {
+            let new_file = save.await?;
+            let mtime = new_file.mtime;
+            this.update(&mut cx, |this, cx| {
+                if let Some((downstream_client, project_id)) = this.downstream_client(cx) {
+                    if has_changed_file {
+                        downstream_client
+                            .send(proto::UpdateBufferFile {
+                                project_id,
+                                buffer_id: buffer_id.to_proto(),
+                                file: Some(language::File::to_proto(&*new_file, cx)),
+                            })
+                            .log_err();
+                    }
+                    downstream_client
+                        .send(proto::BufferSaved {
+                            project_id,
+                            buffer_id: buffer_id.to_proto(),
+                            version: serialize_version(&version),
+                            mtime: mtime.map(|time| time.into()),
+                        })
+                        .log_err();
+                }
+            })?;
+            buffer_handle.update(&mut cx, |buffer, cx| {
+                if has_changed_file {
+                    buffer.file_updated(new_file, cx);
+                }
+                buffer.did_save(version.clone(), mtime, cx);
+            })
+        })
+    }
+
+    fn subscribe_to_worktree(&mut self, worktree: &Model<Worktree>, cx: &mut ModelContext<Self>) {
+        cx.subscribe(worktree, |this, worktree, event, cx| {
+            if worktree.read(cx).is_local() {
+                match event {
+                    worktree::Event::UpdatedEntries(changes) => {
+                        this.local_worktree_entries_changed(&worktree, changes, cx);
+                    }
+                    worktree::Event::UpdatedGitRepositories(updated_repos) => {
+                        this.local_worktree_git_repos_changed(worktree.clone(), updated_repos, cx)
+                    }
+                    _ => {}
+                }
+            }
+        })
+        .detach();
+    }
+
+    fn local_worktree_entries_changed(
+        &mut self,
+        worktree_handle: &Model<Worktree>,
+        changes: &[(Arc<Path>, ProjectEntryId, PathChange)],
+        cx: &mut ModelContext<Self>,
+    ) {
+        let snapshot = worktree_handle.read(cx).snapshot();
+        for (path, entry_id, _) in changes {
+            self.local_worktree_entry_changed(*entry_id, path, worktree_handle, &snapshot, cx);
+        }
+    }
+
+    fn local_worktree_git_repos_changed(
+        &mut self,
+        worktree_handle: Model<Worktree>,
+        changed_repos: &UpdatedGitRepositoriesSet,
+        cx: &mut ModelContext<Self>,
+    ) {
+        debug_assert!(worktree_handle.read(cx).is_local());
+        let Some(buffer_store) = self.buffer_store.upgrade() else {
+            return;
+        };
+
+        // Identify the loading buffers whose containing repository that has changed.
+        let (future_buffers, current_buffers) = buffer_store.update(cx, |buffer_store, cx| {
+            let future_buffers = buffer_store
+                .loading_buffers()
+                .filter_map(|(project_path, receiver)| {
+                    if project_path.worktree_id != worktree_handle.read(cx).id() {
+                        return None;
+                    }
+                    let path = &project_path.path;
+                    changed_repos
+                        .iter()
+                        .find(|(work_dir, _)| path.starts_with(work_dir))?;
+                    let path = path.clone();
+                    Some(async move {
+                        BufferStore::wait_for_loading_buffer(receiver)
+                            .await
+                            .ok()
+                            .map(|buffer| (buffer, path))
+                    })
+                })
+                .collect::<FuturesUnordered<_>>();
+
+            // Identify the current buffers whose containing repository has changed.
+            let current_buffers = buffer_store
+                .buffers()
+                .filter_map(|buffer| {
+                    let file = File::from_dyn(buffer.read(cx).file())?;
+                    if file.worktree != worktree_handle {
+                        return None;
+                    }
+                    changed_repos
+                        .iter()
+                        .find(|(work_dir, _)| file.path.starts_with(work_dir))?;
+                    Some((buffer, file.path.clone()))
+                })
+                .collect::<Vec<_>>();
+            (future_buffers, current_buffers)
+        });
+
+        if future_buffers.len() + current_buffers.len() == 0 {
+            return;
+        }
+
+        cx.spawn(move |this, mut cx| async move {
+            // Wait for all of the buffers to load.
+            let future_buffers = future_buffers.collect::<Vec<_>>().await;
+
+            // Reload the diff base for every buffer whose containing git repository has changed.
+            let snapshot =
+                worktree_handle.update(&mut cx, |tree, _| tree.as_local().unwrap().snapshot())?;
+            let diff_bases_by_buffer = cx
+                .background_executor()
+                .spawn(async move {
+                    let mut diff_base_tasks = future_buffers
+                        .into_iter()
+                        .flatten()
+                        .chain(current_buffers)
+                        .filter_map(|(buffer, path)| {
+                            let (repo_entry, local_repo_entry) = snapshot.repo_for_path(&path)?;
+                            let relative_path = repo_entry.relativize(&snapshot, &path).ok()?;
+                            Some(async move {
+                                let base_text =
+                                    local_repo_entry.repo().load_index_text(&relative_path);
+                                Some((buffer, base_text))
+                            })
+                        })
+                        .collect::<FuturesUnordered<_>>();
+
+                    let mut diff_bases = Vec::with_capacity(diff_base_tasks.len());
+                    while let Some(diff_base) = diff_base_tasks.next().await {
+                        if let Some(diff_base) = diff_base {
+                            diff_bases.push(diff_base);
+                        }
+                    }
+                    diff_bases
+                })
+                .await;
+
+            this.update(&mut cx, |this, cx| {
+                // Assign the new diff bases on all of the buffers.
+                for (buffer, diff_base) in diff_bases_by_buffer {
+                    let buffer_id = buffer.update(cx, |buffer, cx| {
+                        buffer.set_diff_base(diff_base.clone(), cx);
+                        buffer.remote_id().to_proto()
+                    });
+                    if let Some((client, project_id)) = &this.downstream_client(cx) {
+                        client
+                            .send(proto::UpdateDiffBase {
+                                project_id: *project_id,
+                                buffer_id,
+                                diff_base,
+                            })
+                            .log_err();
+                    }
+                }
+            })
+        })
+        .detach_and_log_err(cx);
+    }
+
+    fn local_worktree_entry_changed(
+        &mut self,
+        entry_id: ProjectEntryId,
+        path: &Arc<Path>,
+        worktree: &Model<worktree::Worktree>,
+        snapshot: &worktree::Snapshot,
+        cx: &mut ModelContext<Self>,
+    ) -> Option<()> {
+        let project_path = ProjectPath {
+            worktree_id: snapshot.id(),
+            path: path.clone(),
+        };
+        let buffer_id = match self.local_buffer_ids_by_entry_id.get(&entry_id) {
+            Some(&buffer_id) => buffer_id,
+            None => self.local_buffer_ids_by_path.get(&project_path).copied()?,
+        };
+        let buffer = self
+            .buffer_store
+            .update(cx, |buffer_store, _| {
+                if let Some(buffer) = buffer_store.get(buffer_id) {
+                    Some(buffer)
+                } else {
+                    buffer_store.opened_buffers.remove(&buffer_id);
+                    None
+                }
+            })
+            .ok()
+            .flatten();
+        let buffer = if let Some(buffer) = buffer {
+            buffer
+        } else {
+            self.local_buffer_ids_by_path.remove(&project_path);
+            self.local_buffer_ids_by_entry_id.remove(&entry_id);
+            return None;
+        };
+
+        let events = buffer.update(cx, |buffer, cx| {
+            let file = buffer.file()?;
+            let old_file = File::from_dyn(Some(file))?;
+            if old_file.worktree != *worktree {
+                return None;
+            }
+
+            let new_file = if let Some(entry) = old_file
+                .entry_id
+                .and_then(|entry_id| snapshot.entry_for_id(entry_id))
+            {
+                File {
+                    is_local: true,
+                    entry_id: Some(entry.id),
+                    mtime: entry.mtime,
+                    path: entry.path.clone(),
+                    worktree: worktree.clone(),
+                    is_deleted: false,
+                    is_private: entry.is_private,
+                }
+            } else if let Some(entry) = snapshot.entry_for_path(old_file.path.as_ref()) {
+                File {
+                    is_local: true,
+                    entry_id: Some(entry.id),
+                    mtime: entry.mtime,
+                    path: entry.path.clone(),
+                    worktree: worktree.clone(),
+                    is_deleted: false,
+                    is_private: entry.is_private,
+                }
+            } else {
+                File {
+                    is_local: true,
+                    entry_id: old_file.entry_id,
+                    path: old_file.path.clone(),
+                    mtime: old_file.mtime,
+                    worktree: worktree.clone(),
+                    is_deleted: true,
+                    is_private: old_file.is_private,
+                }
+            };
+
+            if new_file == *old_file {
+                return None;
+            }
+
+            let mut events = Vec::new();
+            if new_file.path != old_file.path {
+                self.local_buffer_ids_by_path.remove(&ProjectPath {
+                    path: old_file.path.clone(),
+                    worktree_id: old_file.worktree_id(cx),
+                });
+                self.local_buffer_ids_by_path.insert(
+                    ProjectPath {
+                        worktree_id: new_file.worktree_id(cx),
+                        path: new_file.path.clone(),
+                    },
+                    buffer_id,
+                );
+                events.push(BufferStoreEvent::BufferChangedFilePath {
+                    buffer: cx.handle(),
+                    old_file: buffer.file().cloned(),
+                });
+            }
+
+            if new_file.entry_id != old_file.entry_id {
+                if let Some(entry_id) = old_file.entry_id {
+                    self.local_buffer_ids_by_entry_id.remove(&entry_id);
+                }
+                if let Some(entry_id) = new_file.entry_id {
+                    self.local_buffer_ids_by_entry_id
+                        .insert(entry_id, buffer_id);
+                }
+            }
+
+            if let Some((client, project_id)) = &self.downstream_client(cx) {
+                client
+                    .send(proto::UpdateBufferFile {
+                        project_id: *project_id,
+                        buffer_id: buffer_id.to_proto(),
+                        file: Some(new_file.to_proto(cx)),
+                    })
+                    .ok();
+            }
+
+            buffer.file_updated(Arc::new(new_file), cx);
+            Some(events)
+        })?;
+        self.buffer_store
+            .update(cx, |_buffer_store, cx| {
+                for event in events {
+                    cx.emit(event);
+                }
+            })
+            .log_err()?;
+
+        None
+    }
+
+    fn downstream_client(&self, cx: &AppContext) -> Option<(AnyProtoClient, u64)> {
+        self.buffer_store
+            .upgrade()?
+            .read(cx)
+            .downstream_client
+            .clone()
+    }
+
+    fn buffer_changed_file(&mut self, buffer: Model<Buffer>, cx: &mut AppContext) -> Option<()> {
+        let file = File::from_dyn(buffer.read(cx).file())?;
+
+        let remote_id = buffer.read(cx).remote_id();
+        if let Some(entry_id) = file.entry_id {
+            match self.local_buffer_ids_by_entry_id.get(&entry_id) {
+                Some(_) => {
+                    return None;
+                }
+                None => {
+                    self.local_buffer_ids_by_entry_id
+                        .insert(entry_id, remote_id);
+                }
+            }
+        };
+        self.local_buffer_ids_by_path.insert(
+            ProjectPath {
+                worktree_id: file.worktree_id(cx),
+                path: file.path.clone(),
+            },
+            remote_id,
+        );
+
+        Some(())
+    }
+}
+
+impl BufferStoreImpl for Model<LocalBufferStore> {
+    fn as_remote(&self) -> Option<Model<RemoteBufferStore>> {
+        None
+    }
+
+    fn as_local(&self) -> Option<Model<LocalBufferStore>> {
+        Some(self.clone())
+    }
+
+    fn save_buffer(
+        &self,
+        buffer: Model<Buffer>,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<()>> {
+        self.update(cx, |this, cx| {
+            let Some(file) = File::from_dyn(buffer.read(cx).file()) else {
+                return Task::ready(Err(anyhow!("buffer doesn't have a file")));
+            };
+            let worktree = file.worktree.clone();
+            this.save_local_buffer(buffer, worktree, file.path.clone(), false, cx)
+        })
+    }
+
+    fn save_buffer_as(
+        &self,
+        buffer: Model<Buffer>,
+        path: ProjectPath,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<()>> {
+        self.update(cx, |this, cx| {
+            let Some(worktree) = this
+                .worktree_store
+                .read(cx)
+                .worktree_for_id(path.worktree_id, cx)
+            else {
+                return Task::ready(Err(anyhow!("no such worktree")));
+            };
+            this.save_local_buffer(buffer, worktree, path.path.clone(), true, cx)
+        })
+    }
+
+    fn open_buffer(
+        &self,
+        path: Arc<Path>,
+        worktree: Model<Worktree>,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<Model<Buffer>>> {
+        let buffer_store = cx.weak_model();
+        self.update(cx, |_, cx| {
+            let load_buffer = worktree.update(cx, |worktree, cx| {
+                let load_file = worktree.load_file(path.as_ref(), cx);
+                let reservation = cx.reserve_model();
+                let buffer_id = BufferId::from(reservation.entity_id().as_non_zero_u64());
+                cx.spawn(move |_, mut cx| async move {
+                    let loaded = load_file.await?;
+                    let text_buffer = cx
+                        .background_executor()
+                        .spawn(async move { text::Buffer::new(0, buffer_id, loaded.text) })
+                        .await;
+                    cx.insert_model(reservation, |_| {
+                        Buffer::build(
+                            text_buffer,
+                            loaded.diff_base,
+                            Some(loaded.file),
+                            Capability::ReadWrite,
+                        )
+                    })
+                })
+            });
+
+            cx.spawn(move |this, mut cx| async move {
+                let buffer = match load_buffer.await {
+                    Ok(buffer) => Ok(buffer),
+                    Err(error) if is_not_found_error(&error) => cx.new_model(|cx| {
+                        let buffer_id = BufferId::from(cx.entity_id().as_non_zero_u64());
+                        let text_buffer = text::Buffer::new(0, buffer_id, "".into());
+                        Buffer::build(
+                            text_buffer,
+                            None,
+                            Some(Arc::new(File {
+                                worktree,
+                                path,
+                                mtime: None,
+                                entry_id: None,
+                                is_local: true,
+                                is_deleted: false,
+                                is_private: false,
+                            })),
+                            Capability::ReadWrite,
+                        )
+                    }),
+                    Err(e) => Err(e),
+                }?;
+                this.update(&mut cx, |this, cx| {
+                    buffer_store.update(cx, |buffer_store, cx| {
+                        buffer_store.add_buffer(buffer.clone(), cx)
+                    })??;
+                    let buffer_id = buffer.read(cx).remote_id();
+                    if let Some(file) = File::from_dyn(buffer.read(cx).file()) {
+                        this.local_buffer_ids_by_path.insert(
+                            ProjectPath {
+                                worktree_id: file.worktree_id(cx),
+                                path: file.path.clone(),
+                            },
+                            buffer_id,
+                        );
+
+                        if let Some(entry_id) = file.entry_id {
+                            this.local_buffer_ids_by_entry_id
+                                .insert(entry_id, buffer_id);
+                        }
+                    }
+
+                    anyhow::Ok(())
+                })??;
+
+                Ok(buffer)
+            })
+        })
+    }
+
+    fn create_buffer(&self, cx: &mut ModelContext<BufferStore>) -> Task<Result<Model<Buffer>>> {
+        let handle = self.clone();
+        cx.spawn(|buffer_store, mut cx| async move {
+            let buffer = cx.new_model(|cx| {
+                Buffer::local("", cx).with_language(language::PLAIN_TEXT.clone(), cx)
+            })?;
+            buffer_store.update(&mut cx, |buffer_store, cx| {
+                buffer_store.add_buffer(buffer.clone(), cx).log_err();
+                let buffer_id = buffer.read(cx).remote_id();
+                handle.update(cx, |this, cx| {
+                    if let Some(file) = File::from_dyn(buffer.read(cx).file()) {
+                        this.local_buffer_ids_by_path.insert(
+                            ProjectPath {
+                                worktree_id: file.worktree_id(cx),
+                                path: file.path.clone(),
+                            },
+                            buffer_id,
+                        );
+
+                        if let Some(entry_id) = file.entry_id {
+                            this.local_buffer_ids_by_entry_id
+                                .insert(entry_id, buffer_id);
+                        }
+                    }
+                });
+            })?;
+            Ok(buffer)
+        })
+    }
+
+    fn reload_buffers(
+        &self,
+        buffers: Vec<Model<Buffer>>,
+        push_to_history: bool,
+        cx: &mut ModelContext<BufferStore>,
+    ) -> Task<Result<ProjectTransaction>> {
+        cx.spawn(move |_, mut cx| async move {
+            let mut project_transaction = ProjectTransaction::default();
+            for buffer in buffers {
+                let transaction = buffer
+                    .update(&mut cx, |buffer, cx| buffer.reload(cx))?
+                    .await?;
+                buffer.update(&mut cx, |buffer, cx| {
+                    if let Some(transaction) = transaction {
+                        if !push_to_history {
+                            buffer.forget_transaction(transaction.id);
+                        }
+                        project_transaction.0.insert(cx.handle(), transaction);
+                    }
+                })?;
+            }
 
-impl EventEmitter<BufferStoreEvent> for BufferStore {}
+            Ok(project_transaction)
+        })
+    }
+}
 
 impl BufferStore {
     pub fn init(client: &AnyProtoClient) {
@@ -90,24 +975,31 @@ impl BufferStore {
 
     /// Creates a buffer store, optionally retaining its buffers.
     pub fn local(worktree_store: Model<WorktreeStore>, cx: &mut ModelContext<Self>) -> Self {
-        cx.subscribe(&worktree_store, |this, _, event, cx| {
-            if let WorktreeStoreEvent::WorktreeAdded(worktree) = event {
-                this.subscribe_to_worktree(worktree, cx);
-            }
-        })
-        .detach();
-
+        let this = cx.weak_model();
         Self {
-            state: BufferStoreState::Local {},
+            state: Box::new(cx.new_model(|cx| {
+                let subscription = cx.subscribe(
+                    &worktree_store,
+                    |this: &mut LocalBufferStore, _, event, cx| {
+                        if let WorktreeStoreEvent::WorktreeAdded(worktree) = event {
+                            this.subscribe_to_worktree(worktree, cx);
+                        }
+                    },
+                );
+
+                LocalBufferStore {
+                    local_buffer_ids_by_path: Default::default(),
+                    local_buffer_ids_by_entry_id: Default::default(),
+                    buffer_store: this,
+                    worktree_store: worktree_store.clone(),
+                    _subscription: subscription,
+                }
+            })),
             downstream_client: None,
-            worktree_store,
             opened_buffers: Default::default(),
-            remote_buffer_listeners: Default::default(),
-            loading_remote_buffers_by_id: Default::default(),
-            local_buffer_ids_by_path: Default::default(),
-            local_buffer_ids_by_entry_id: Default::default(),
-            loading_buffers_by_path: Default::default(),
             shared_buffers: Default::default(),
+            loading_buffers_by_path: Default::default(),
+            worktree_store,
         }
     }
 
@@ -117,28 +1009,22 @@ impl BufferStore {
         remote_id: u64,
         cx: &mut ModelContext<Self>,
     ) -> Self {
-        cx.subscribe(&worktree_store, |this, _, event, cx| {
-            if let WorktreeStoreEvent::WorktreeAdded(worktree) = event {
-                this.subscribe_to_worktree(worktree, cx);
-            }
-        })
-        .detach();
-
+        let this = cx.weak_model();
         Self {
-            state: BufferStoreState::Remote {
+            state: Box::new(cx.new_model(|_| RemoteBufferStore {
                 shared_with_me: Default::default(),
-                upstream_client,
+                loading_remote_buffers_by_id: Default::default(),
+                remote_buffer_listeners: Default::default(),
                 project_id: remote_id,
-            },
+                upstream_client,
+                worktree_store: worktree_store.clone(),
+                buffer_store: this,
+            })),
             downstream_client: None,
-            worktree_store,
             opened_buffers: Default::default(),
-            remote_buffer_listeners: Default::default(),
-            loading_remote_buffers_by_id: Default::default(),
-            local_buffer_ids_by_path: Default::default(),
-            local_buffer_ids_by_entry_id: Default::default(),
             loading_buffers_by_path: Default::default(),
             shared_buffers: Default::default(),
+            worktree_store,
         }
     }
 
@@ -171,18 +1057,13 @@ impl BufferStore {
                 entry.insert(rx.clone());
 
                 let project_path = project_path.clone();
-                let load_buffer = match worktree.read(cx) {
-                    Worktree::Local(_) => {
-                        self.open_local_buffer_internal(project_path.path.clone(), worktree, cx)
-                    }
-                    Worktree::Remote(tree) => {
-                        self.open_remote_buffer_internal(&project_path.path, tree, cx)
-                    }
-                };
+                let load_buffer = self
+                    .state
+                    .open_buffer(project_path.path.clone(), worktree, cx);
 
                 cx.spawn(move |this, mut cx| async move {
                     let load_result = load_buffer.await;
-                    *tx.borrow_mut() = Some(this.update(&mut cx, |this, _| {
+                    *tx.borrow_mut() = Some(this.update(&mut cx, |this, _cx| {
                         // Record the fact that the buffer is no longer loading.
                         this.loading_buffers_by_path.remove(&project_path);
                         let buffer = load_result.map_err(Arc::new)?;
@@ -201,391 +1082,32 @@ impl BufferStore {
                 .map_err(|e| e.cloned())
         })
     }
-
-    fn subscribe_to_worktree(&mut self, worktree: &Model<Worktree>, cx: &mut ModelContext<Self>) {
-        cx.subscribe(worktree, |this, worktree, event, cx| {
-            if worktree.read(cx).is_local() {
-                match event {
-                    worktree::Event::UpdatedEntries(changes) => {
-                        this.local_worktree_entries_changed(&worktree, changes, cx);
-                    }
-                    worktree::Event::UpdatedGitRepositories(updated_repos) => {
-                        this.local_worktree_git_repos_changed(worktree.clone(), updated_repos, cx)
-                    }
-                    _ => {}
-                }
-            }
-        })
-        .detach();
-    }
-
-    fn local_worktree_entries_changed(
-        &mut self,
-        worktree_handle: &Model<Worktree>,
-        changes: &[(Arc<Path>, ProjectEntryId, PathChange)],
-        cx: &mut ModelContext<Self>,
-    ) {
-        let snapshot = worktree_handle.read(cx).snapshot();
-        for (path, entry_id, _) in changes {
-            self.local_worktree_entry_changed(*entry_id, path, worktree_handle, &snapshot, cx);
-        }
-    }
-
-    fn local_worktree_git_repos_changed(
-        &mut self,
-        worktree_handle: Model<Worktree>,
-        changed_repos: &UpdatedGitRepositoriesSet,
-        cx: &mut ModelContext<Self>,
-    ) {
-        debug_assert!(worktree_handle.read(cx).is_local());
-
-        // Identify the loading buffers whose containing repository that has changed.
-        let future_buffers = self
-            .loading_buffers()
-            .filter_map(|(project_path, receiver)| {
-                if project_path.worktree_id != worktree_handle.read(cx).id() {
-                    return None;
-                }
-                let path = &project_path.path;
-                changed_repos
-                    .iter()
-                    .find(|(work_dir, _)| path.starts_with(work_dir))?;
-                let path = path.clone();
-                Some(async move {
-                    Self::wait_for_loading_buffer(receiver)
-                        .await
-                        .ok()
-                        .map(|buffer| (buffer, path))
-                })
-            })
-            .collect::<FuturesUnordered<_>>();
-
-        // Identify the current buffers whose containing repository has changed.
-        let current_buffers = self
-            .buffers()
-            .filter_map(|buffer| {
-                let file = File::from_dyn(buffer.read(cx).file())?;
-                if file.worktree != worktree_handle {
-                    return None;
-                }
-                changed_repos
-                    .iter()
-                    .find(|(work_dir, _)| file.path.starts_with(work_dir))?;
-                Some((buffer, file.path.clone()))
-            })
-            .collect::<Vec<_>>();
-
-        if future_buffers.len() + current_buffers.len() == 0 {
-            return;
-        }
-
-        cx.spawn(move |this, mut cx| async move {
-            // Wait for all of the buffers to load.
-            let future_buffers = future_buffers.collect::<Vec<_>>().await;
-
-            // Reload the diff base for every buffer whose containing git repository has changed.
-            let snapshot =
-                worktree_handle.update(&mut cx, |tree, _| tree.as_local().unwrap().snapshot())?;
-            let diff_bases_by_buffer = cx
-                .background_executor()
-                .spawn(async move {
-                    let mut diff_base_tasks = future_buffers
-                        .into_iter()
-                        .flatten()
-                        .chain(current_buffers)
-                        .filter_map(|(buffer, path)| {
-                            let (repo_entry, local_repo_entry) = snapshot.repo_for_path(&path)?;
-                            let relative_path = repo_entry.relativize(&snapshot, &path).ok()?;
-                            Some(async move {
-                                let base_text =
-                                    local_repo_entry.repo().load_index_text(&relative_path);
-                                Some((buffer, base_text))
-                            })
-                        })
-                        .collect::<FuturesUnordered<_>>();
-
-                    let mut diff_bases = Vec::with_capacity(diff_base_tasks.len());
-                    while let Some(diff_base) = diff_base_tasks.next().await {
-                        if let Some(diff_base) = diff_base {
-                            diff_bases.push(diff_base);
-                        }
-                    }
-                    diff_bases
-                })
-                .await;
-
-            this.update(&mut cx, |this, cx| {
-                // Assign the new diff bases on all of the buffers.
-                for (buffer, diff_base) in diff_bases_by_buffer {
-                    let buffer_id = buffer.update(cx, |buffer, cx| {
-                        buffer.set_diff_base(diff_base.clone(), cx);
-                        buffer.remote_id().to_proto()
-                    });
-                    if let Some((client, project_id)) = &this.downstream_client {
-                        client
-                            .send(proto::UpdateDiffBase {
-                                project_id: *project_id,
-                                buffer_id,
-                                diff_base,
-                            })
-                            .log_err();
-                    }
-                }
-            })
-        })
-        .detach_and_log_err(cx);
-    }
-
-    fn open_local_buffer_internal(
-        &mut self,
-        path: Arc<Path>,
-        worktree: Model<Worktree>,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<Model<Buffer>>> {
-        let load_buffer = worktree.update(cx, |worktree, cx| {
-            let load_file = worktree.load_file(path.as_ref(), cx);
-            let reservation = cx.reserve_model();
-            let buffer_id = BufferId::from(reservation.entity_id().as_non_zero_u64());
-            cx.spawn(move |_, mut cx| async move {
-                let loaded = load_file.await?;
-                let text_buffer = cx
-                    .background_executor()
-                    .spawn(async move { text::Buffer::new(0, buffer_id, loaded.text) })
-                    .await;
-                cx.insert_model(reservation, |_| {
-                    Buffer::build(
-                        text_buffer,
-                        loaded.diff_base,
-                        Some(loaded.file),
-                        Capability::ReadWrite,
-                    )
-                })
-            })
-        });
-
-        cx.spawn(move |this, mut cx| async move {
-            let buffer = match load_buffer.await {
-                Ok(buffer) => Ok(buffer),
-                Err(error) if is_not_found_error(&error) => cx.new_model(|cx| {
-                    let buffer_id = BufferId::from(cx.entity_id().as_non_zero_u64());
-                    let text_buffer = text::Buffer::new(0, buffer_id, "".into());
-                    Buffer::build(
-                        text_buffer,
-                        None,
-                        Some(Arc::new(File {
-                            worktree,
-                            path,
-                            mtime: None,
-                            entry_id: None,
-                            is_local: true,
-                            is_deleted: false,
-                            is_private: false,
-                        })),
-                        Capability::ReadWrite,
-                    )
-                }),
-                Err(e) => Err(e),
-            }?;
-            this.update(&mut cx, |this, cx| {
-                this.add_buffer(buffer.clone(), cx).log_err();
-            })?;
-            Ok(buffer)
-        })
-    }
-
-    fn open_remote_buffer_internal(
-        &self,
-        path: &Arc<Path>,
-        worktree: &RemoteWorktree,
-        cx: &ModelContext<Self>,
-    ) -> Task<Result<Model<Buffer>>> {
-        let worktree_id = worktree.id().to_proto();
-        let project_id = worktree.project_id();
-        let client = worktree.client();
-        let path_string = path.clone().to_string_lossy().to_string();
-        cx.spawn(move |this, mut cx| async move {
-            let response = client
-                .request(proto::OpenBufferByPath {
-                    project_id,
-                    worktree_id,
-                    path: path_string,
-                })
-                .await?;
-            let buffer_id = BufferId::new(response.buffer_id)?;
-            this.update(&mut cx, |this, cx| {
-                this.wait_for_remote_buffer(buffer_id, cx)
-            })?
-            .await
-        })
-    }
-
-    pub fn create_buffer(
-        &mut self,
-        remote_client: Option<(AnyProtoClient, u64)>,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<Model<Buffer>>> {
-        if let Some((remote_client, project_id)) = remote_client {
-            let create = remote_client.request(proto::OpenNewBuffer { project_id });
-            cx.spawn(|this, mut cx| async move {
-                let response = create.await?;
-                let buffer_id = BufferId::new(response.buffer_id)?;
-
-                this.update(&mut cx, |this, cx| {
-                    this.wait_for_remote_buffer(buffer_id, cx)
-                })?
-                .await
-            })
-        } else {
-            Task::ready(Ok(self.create_local_buffer("", None, cx)))
-        }
-    }
-
-    pub fn create_local_buffer(
-        &mut self,
-        text: &str,
-        language: Option<Arc<Language>>,
-        cx: &mut ModelContext<Self>,
-    ) -> Model<Buffer> {
-        let buffer = cx.new_model(|cx| {
-            Buffer::local(text, cx)
-                .with_language(language.unwrap_or_else(|| language::PLAIN_TEXT.clone()), cx)
-        });
-        self.add_buffer(buffer.clone(), cx).log_err();
-        buffer
-    }
-
-    pub fn save_buffer(
-        &mut self,
-        buffer: Model<Buffer>,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<()>> {
-        let Some(file) = File::from_dyn(buffer.read(cx).file()) else {
-            return Task::ready(Err(anyhow!("buffer doesn't have a file")));
-        };
-        match file.worktree.read(cx) {
-            Worktree::Local(_) => {
-                self.save_local_buffer(file.worktree.clone(), buffer, file.path.clone(), false, cx)
-            }
-            Worktree::Remote(tree) => self.save_remote_buffer(buffer, None, tree, cx),
-        }
-    }
-
-    pub fn save_buffer_as(
-        &mut self,
-        buffer: Model<Buffer>,
-        path: ProjectPath,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<()>> {
-        let Some(worktree) = self
-            .worktree_store
-            .read(cx)
-            .worktree_for_id(path.worktree_id, cx)
-        else {
-            return Task::ready(Err(anyhow!("no such worktree")));
-        };
-
-        let old_file = buffer.read(cx).file().cloned();
-
-        let task = match worktree.read(cx) {
-            Worktree::Local(_) => {
-                self.save_local_buffer(worktree, buffer.clone(), path.path, true, cx)
-            }
-            Worktree::Remote(tree) => {
-                self.save_remote_buffer(buffer.clone(), Some(path.to_proto()), tree, cx)
-            }
-        };
-        cx.spawn(|this, mut cx| async move {
-            task.await?;
-            this.update(&mut cx, |_, cx| {
-                cx.emit(BufferStoreEvent::BufferChangedFilePath { buffer, old_file });
-            })
-        })
+
+    pub fn create_buffer(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<Model<Buffer>>> {
+        self.state.create_buffer(cx)
     }
 
-    fn save_local_buffer(
-        &self,
-        worktree: Model<Worktree>,
-        buffer_handle: Model<Buffer>,
-        path: Arc<Path>,
-        mut has_changed_file: bool,
+    pub fn save_buffer(
+        &mut self,
+        buffer: Model<Buffer>,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<()>> {
-        let buffer = buffer_handle.read(cx);
-        let text = buffer.as_rope().clone();
-        let line_ending = buffer.line_ending();
-        let version = buffer.version();
-        let buffer_id = buffer.remote_id();
-        if buffer.file().is_some_and(|file| !file.is_created()) {
-            has_changed_file = true;
-        }
-
-        let save = worktree.update(cx, |worktree, cx| {
-            worktree.write_file(path.as_ref(), text, line_ending, cx)
-        });
-
-        cx.spawn(move |this, mut cx| async move {
-            let new_file = save.await?;
-            let mtime = new_file.mtime;
-            this.update(&mut cx, |this, cx| {
-                if let Some((downstream_client, project_id)) = this.downstream_client.as_ref() {
-                    let project_id = *project_id;
-                    if has_changed_file {
-                        downstream_client
-                            .send(proto::UpdateBufferFile {
-                                project_id,
-                                buffer_id: buffer_id.to_proto(),
-                                file: Some(language::File::to_proto(&*new_file, cx)),
-                            })
-                            .log_err();
-                    }
-                    downstream_client
-                        .send(proto::BufferSaved {
-                            project_id,
-                            buffer_id: buffer_id.to_proto(),
-                            version: serialize_version(&version),
-                            mtime: mtime.map(|time| time.into()),
-                        })
-                        .log_err();
-                }
-            })?;
-            buffer_handle.update(&mut cx, |buffer, cx| {
-                if has_changed_file {
-                    buffer.file_updated(new_file, cx);
-                }
-                buffer.did_save(version.clone(), mtime, cx);
-            })
-        })
+        self.state.save_buffer(buffer, cx)
     }
 
-    fn save_remote_buffer(
-        &self,
-        buffer_handle: Model<Buffer>,
-        new_path: Option<proto::ProjectPath>,
-        tree: &RemoteWorktree,
-        cx: &ModelContext<Self>,
+    pub fn save_buffer_as(
+        &mut self,
+        buffer: Model<Buffer>,
+        path: ProjectPath,
+        cx: &mut ModelContext<Self>,
     ) -> Task<Result<()>> {
-        let buffer = buffer_handle.read(cx);
-        let buffer_id = buffer.remote_id().into();
-        let version = buffer.version();
-        let rpc = tree.client();
-        let project_id = tree.project_id();
-        cx.spawn(move |_, mut cx| async move {
-            let response = rpc
-                .request(proto::SaveBuffer {
-                    project_id,
-                    buffer_id,
-                    new_path,
-                    version: serialize_version(&version),
-                })
-                .await?;
-            let version = deserialize_version(&response.version);
-            let mtime = response.mtime.map(|mtime| mtime.into());
-
-            buffer_handle.update(&mut cx, |buffer, cx| {
-                buffer.did_save(version.clone(), mtime, cx);
-            })?;
-
-            Ok(())
+        let old_file = buffer.read(cx).file().cloned();
+        let task = self.state.save_buffer_as(buffer.clone(), path, cx);
+        cx.spawn(|this, mut cx| async move {
+            task.await?;
+            this.update(&mut cx, |_, cx| {
+                cx.emit(BufferStoreEvent::BufferChangedFilePath { buffer, old_file });
+            })
         })
     }
 
@@ -684,29 +1206,6 @@ impl BufferStore {
             }
         }
 
-        if let Some(senders) = self.remote_buffer_listeners.remove(&remote_id) {
-            for sender in senders {
-                sender.send(Ok(buffer.clone())).ok();
-            }
-        }
-
-        if let Some(file) = File::from_dyn(buffer.read(cx).file()) {
-            if file.is_local {
-                self.local_buffer_ids_by_path.insert(
-                    ProjectPath {
-                        worktree_id: file.worktree_id(cx),
-                        path: file.path.clone(),
-                    },
-                    remote_id,
-                );
-
-                if let Some(entry_id) = file.entry_id {
-                    self.local_buffer_ids_by_entry_id
-                        .insert(entry_id, remote_id);
-                }
-            }
-        }
-
         cx.subscribe(&buffer, Self::on_buffer_event).detach();
         cx.emit(BufferStoreEvent::BufferAdded(buffer));
         Ok(())
@@ -753,23 +1252,20 @@ impl BufferStore {
             .ok_or_else(|| anyhow!("unknown buffer id {}", buffer_id))
     }
 
-    pub fn get_possibly_incomplete(&self, buffer_id: BufferId) -> Option<Model<Buffer>> {
-        self.get(buffer_id)
-            .or_else(|| self.loading_remote_buffers_by_id.get(&buffer_id).cloned())
-    }
-
-    pub fn wait_for_remote_buffer(
-        &mut self,
-        id: BufferId,
-        cx: &mut AppContext,
-    ) -> Task<Result<Model<Buffer>>> {
-        let buffer = self.get(id);
-        if let Some(buffer) = buffer {
-            return Task::ready(Ok(buffer));
-        }
-        let (tx, rx) = oneshot::channel();
-        self.remote_buffer_listeners.entry(id).or_default().push(tx);
-        cx.background_executor().spawn(async move { rx.await? })
+    pub fn get_possibly_incomplete(
+        &self,
+        buffer_id: BufferId,
+        cx: &AppContext,
+    ) -> Option<Model<Buffer>> {
+        self.get(buffer_id).or_else(|| {
+            self.state.as_remote().and_then(|remote| {
+                remote
+                    .read(cx)
+                    .loading_remote_buffers_by_id
+                    .get(&buffer_id)
+                    .cloned()
+            })
+        })
     }
 
     pub fn buffer_version_info(
@@ -787,15 +1283,19 @@ impl BufferStore {
             })
             .collect();
         let incomplete_buffer_ids = self
-            .loading_remote_buffers_by_id
-            .keys()
-            .copied()
-            .collect::<Vec<_>>();
+            .state
+            .as_remote()
+            .map(|remote| remote.read(cx).incomplete_buffer_ids())
+            .unwrap_or_default();
         (buffers, incomplete_buffer_ids)
     }
 
     pub fn disconnected_from_host(&mut self, cx: &mut AppContext) {
-        self.drop_unnecessary_buffers(cx);
+        for open_buffer in self.opened_buffers.values_mut() {
+            if let Some(buffer) = open_buffer.upgrade() {
+                buffer.update(cx, |buffer, _| buffer.give_up_waiting());
+            }
+        }
 
         for buffer in self.buffers() {
             buffer.update(cx, |buffer, cx| {
@@ -803,9 +1303,13 @@ impl BufferStore {
             });
         }
 
-        // Wake up all futures currently waiting on a buffer to get opened,
-        // to give them a chance to fail now that we've disconnected.
-        self.remote_buffer_listeners.clear();
+        if let Some(remote) = self.state.as_remote() {
+            remote.update(cx, |remote, _| {
+                // Wake up all futures currently waiting on a buffer to get opened,
+                // to give them a chance to fail now that we've disconnected.
+                remote.remote_buffer_listeners.clear()
+            })
+        }
     }
 
     pub fn shared(
@@ -822,14 +1326,6 @@ impl BufferStore {
         self.forget_shared_buffers();
     }
 
-    fn drop_unnecessary_buffers(&mut self, cx: &mut AppContext) {
-        for open_buffer in self.opened_buffers.values_mut() {
-            if let Some(buffer) = open_buffer.upgrade() {
-                buffer.update(cx, |buffer, _| buffer.give_up_waiting());
-            }
-        }
-    }
-
     pub fn discard_incomplete(&mut self) {
         self.opened_buffers
             .retain(|_, buffer| !matches!(buffer, OpenBuffer::Operations(_)));
@@ -897,7 +1393,11 @@ impl BufferStore {
     ) {
         match event {
             BufferEvent::FileHandleChanged => {
-                self.buffer_changed_file(buffer, cx);
+                if let Some(local) = self.state.as_local() {
+                    local.update(cx, |local, cx| {
+                        local.buffer_changed_file(buffer, cx);
+                    })
+                }
             }
             BufferEvent::Reloaded => {
                 let Some((downstream_client, project_id)) = self.downstream_client.as_ref() else {
@@ -905,164 +1405,17 @@ impl BufferStore {
                 };
                 let buffer = buffer.read(cx);
                 downstream_client
-                    .send(proto::BufferReloaded {
-                        project_id: *project_id,
-                        buffer_id: buffer.remote_id().to_proto(),
-                        version: serialize_version(&buffer.version()),
-                        mtime: buffer.saved_mtime().map(|t| t.into()),
-                        line_ending: serialize_line_ending(buffer.line_ending()) as i32,
-                    })
-                    .log_err();
-            }
-            _ => {}
-        }
-    }
-
-    fn local_worktree_entry_changed(
-        &mut self,
-        entry_id: ProjectEntryId,
-        path: &Arc<Path>,
-        worktree: &Model<worktree::Worktree>,
-        snapshot: &worktree::Snapshot,
-        cx: &mut ModelContext<Self>,
-    ) -> Option<()> {
-        let project_path = ProjectPath {
-            worktree_id: snapshot.id(),
-            path: path.clone(),
-        };
-        let buffer_id = match self.local_buffer_ids_by_entry_id.get(&entry_id) {
-            Some(&buffer_id) => buffer_id,
-            None => self.local_buffer_ids_by_path.get(&project_path).copied()?,
-        };
-        let buffer = if let Some(buffer) = self.get(buffer_id) {
-            buffer
-        } else {
-            self.opened_buffers.remove(&buffer_id);
-            self.local_buffer_ids_by_path.remove(&project_path);
-            self.local_buffer_ids_by_entry_id.remove(&entry_id);
-            return None;
-        };
-
-        let events = buffer.update(cx, |buffer, cx| {
-            let file = buffer.file()?;
-            let old_file = File::from_dyn(Some(file))?;
-            if old_file.worktree != *worktree {
-                return None;
-            }
-
-            let new_file = if let Some(entry) = old_file
-                .entry_id
-                .and_then(|entry_id| snapshot.entry_for_id(entry_id))
-            {
-                File {
-                    is_local: true,
-                    entry_id: Some(entry.id),
-                    mtime: entry.mtime,
-                    path: entry.path.clone(),
-                    worktree: worktree.clone(),
-                    is_deleted: false,
-                    is_private: entry.is_private,
-                }
-            } else if let Some(entry) = snapshot.entry_for_path(old_file.path.as_ref()) {
-                File {
-                    is_local: true,
-                    entry_id: Some(entry.id),
-                    mtime: entry.mtime,
-                    path: entry.path.clone(),
-                    worktree: worktree.clone(),
-                    is_deleted: false,
-                    is_private: entry.is_private,
-                }
-            } else {
-                File {
-                    is_local: true,
-                    entry_id: old_file.entry_id,
-                    path: old_file.path.clone(),
-                    mtime: old_file.mtime,
-                    worktree: worktree.clone(),
-                    is_deleted: true,
-                    is_private: old_file.is_private,
-                }
-            };
-
-            if new_file == *old_file {
-                return None;
-            }
-
-            let mut events = Vec::new();
-            if new_file.path != old_file.path {
-                self.local_buffer_ids_by_path.remove(&ProjectPath {
-                    path: old_file.path.clone(),
-                    worktree_id: old_file.worktree_id(cx),
-                });
-                self.local_buffer_ids_by_path.insert(
-                    ProjectPath {
-                        worktree_id: new_file.worktree_id(cx),
-                        path: new_file.path.clone(),
-                    },
-                    buffer_id,
-                );
-                events.push(BufferStoreEvent::BufferChangedFilePath {
-                    buffer: cx.handle(),
-                    old_file: buffer.file().cloned(),
-                });
-            }
-
-            if new_file.entry_id != old_file.entry_id {
-                if let Some(entry_id) = old_file.entry_id {
-                    self.local_buffer_ids_by_entry_id.remove(&entry_id);
-                }
-                if let Some(entry_id) = new_file.entry_id {
-                    self.local_buffer_ids_by_entry_id
-                        .insert(entry_id, buffer_id);
-                }
-            }
-
-            if let Some((client, project_id)) = &self.downstream_client {
-                client
-                    .send(proto::UpdateBufferFile {
+                    .send(proto::BufferReloaded {
                         project_id: *project_id,
-                        buffer_id: buffer_id.to_proto(),
-                        file: Some(new_file.to_proto(cx)),
+                        buffer_id: buffer.remote_id().to_proto(),
+                        version: serialize_version(&buffer.version()),
+                        mtime: buffer.saved_mtime().map(|t| t.into()),
+                        line_ending: serialize_line_ending(buffer.line_ending()) as i32,
                     })
-                    .ok();
+                    .log_err();
             }
-
-            buffer.file_updated(Arc::new(new_file), cx);
-            Some(events)
-        })?;
-
-        for event in events {
-            cx.emit(event);
+            _ => {}
         }
-
-        None
-    }
-
-    fn buffer_changed_file(&mut self, buffer: Model<Buffer>, cx: &mut AppContext) -> Option<()> {
-        let file = File::from_dyn(buffer.read(cx).file())?;
-
-        let remote_id = buffer.read(cx).remote_id();
-        if let Some(entry_id) = file.entry_id {
-            match self.local_buffer_ids_by_entry_id.get(&entry_id) {
-                Some(_) => {
-                    return None;
-                }
-                None => {
-                    self.local_buffer_ids_by_entry_id
-                        .insert(entry_id, remote_id);
-                }
-            }
-        };
-        self.local_buffer_ids_by_path.insert(
-            ProjectPath {
-                worktree_id: file.worktree_id(cx),
-                path: file.path.clone(),
-            },
-            remote_id,
-        );
-
-        Some(())
     }
 
     pub async fn handle_update_buffer(
@@ -1186,93 +1539,14 @@ impl BufferStore {
         capability: Capability,
         cx: &mut ModelContext<Self>,
     ) -> Result<()> {
-        match envelope
-            .payload
-            .variant
-            .ok_or_else(|| anyhow!("missing variant"))?
-        {
-            proto::create_buffer_for_peer::Variant::State(mut state) => {
-                let buffer_id = BufferId::new(state.id)?;
-
-                let buffer_result = maybe!({
-                    let mut buffer_file = None;
-                    if let Some(file) = state.file.take() {
-                        let worktree_id = worktree::WorktreeId::from_proto(file.worktree_id);
-                        let worktree = self
-                            .worktree_store
-                            .read(cx)
-                            .worktree_for_id(worktree_id, cx)
-                            .ok_or_else(|| {
-                                anyhow!("no worktree found for id {}", file.worktree_id)
-                            })?;
-                        buffer_file = Some(Arc::new(File::from_proto(file, worktree.clone(), cx)?)
-                            as Arc<dyn language::File>);
-                    }
-                    Buffer::from_proto(replica_id, capability, state, buffer_file)
-                });
-
-                match buffer_result {
-                    Ok(buffer) => {
-                        let buffer = cx.new_model(|_| buffer);
-                        self.loading_remote_buffers_by_id.insert(buffer_id, buffer);
-                    }
-                    Err(error) => {
-                        if let Some(listeners) = self.remote_buffer_listeners.remove(&buffer_id) {
-                            for listener in listeners {
-                                listener.send(Err(anyhow!(error.cloned()))).ok();
-                            }
-                        }
-                    }
-                }
-            }
-            proto::create_buffer_for_peer::Variant::Chunk(chunk) => {
-                let buffer_id = BufferId::new(chunk.buffer_id)?;
-                let buffer = self
-                    .loading_remote_buffers_by_id
-                    .get(&buffer_id)
-                    .cloned()
-                    .ok_or_else(|| {
-                        anyhow!(
-                            "received chunk for buffer {} without initial state",
-                            chunk.buffer_id
-                        )
-                    })?;
-
-                let result = maybe!({
-                    let operations = chunk
-                        .operations
-                        .into_iter()
-                        .map(language::proto::deserialize_operation)
-                        .collect::<Result<Vec<_>>>()?;
-                    buffer.update(cx, |buffer, cx| buffer.apply_ops(operations, cx));
-                    anyhow::Ok(())
-                });
+        let Some(remote) = self.state.as_remote() else {
+            return Err(anyhow!("buffer store is not a remote"));
+        };
 
-                if let Err(error) = result {
-                    self.loading_remote_buffers_by_id.remove(&buffer_id);
-                    if let Some(listeners) = self.remote_buffer_listeners.remove(&buffer_id) {
-                        for listener in listeners {
-                            listener.send(Err(error.cloned())).ok();
-                        }
-                    }
-                } else if chunk.is_last {
-                    self.loading_remote_buffers_by_id.remove(&buffer_id);
-                    // retain buffers sent by peers to avoid races.
-                    match &mut self.state {
-                        BufferStoreState::Remote {
-                            ref mut shared_with_me,
-                            upstream_client,
-                            ..
-                        } => {
-                            if upstream_client.is_via_collab() {
-                                shared_with_me.insert(buffer.clone());
-                            }
-                        }
-                        _ => {}
-                    }
-                    self.add_buffer(buffer, cx)?;
-                }
-            }
+        if let Some(buffer) = remote.update(cx, |remote, cx| {
+            remote.handle_create_buffer_for_peer(envelope, replica_id, capability, cx)
+        })? {
+            self.add_buffer(buffer, cx)?;
         }
 
         Ok(())
@@ -1288,7 +1562,7 @@ impl BufferStore {
 
         this.update(&mut cx, |this, cx| {
             let payload = envelope.payload.clone();
-            if let Some(buffer) = this.get_possibly_incomplete(buffer_id) {
+            if let Some(buffer) = this.get_possibly_incomplete(buffer_id, cx) {
                 let file = payload.file.ok_or_else(|| anyhow!("invalid file"))?;
                 let worktree = this
                     .worktree_store
@@ -1313,6 +1587,15 @@ impl BufferStore {
                     cx.emit(BufferStoreEvent::BufferChangedFilePath { buffer, old_file });
                 }
             }
+            if let Some((downstream_client, project_id)) = this.downstream_client.as_ref() {
+                downstream_client
+                    .send(proto::UpdateBufferFile {
+                        project_id: *project_id,
+                        buffer_id: buffer_id.into(),
+                        file: envelope.payload.file,
+                    })
+                    .log_err();
+            }
             Ok(())
         })?
     }
@@ -1325,11 +1608,20 @@ impl BufferStore {
         this.update(&mut cx, |this, cx| {
             let buffer_id = envelope.payload.buffer_id;
             let buffer_id = BufferId::new(buffer_id)?;
-            if let Some(buffer) = this.get_possibly_incomplete(buffer_id) {
+            if let Some(buffer) = this.get_possibly_incomplete(buffer_id, cx) {
                 buffer.update(cx, |buffer, cx| {
-                    buffer.set_diff_base(envelope.payload.diff_base, cx)
+                    buffer.set_diff_base(envelope.payload.diff_base.clone(), cx)
                 });
             }
+            if let Some((downstream_client, project_id)) = this.downstream_client.as_ref() {
+                downstream_client
+                    .send(proto::UpdateDiffBase {
+                        project_id: *project_id,
+                        buffer_id: buffer_id.into(),
+                        diff_base: envelope.payload.diff_base,
+                    })
+                    .log_err();
+            }
             Ok(())
         })?
     }
@@ -1408,13 +1700,24 @@ impl BufferStore {
     ) -> Result<()> {
         let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
         let version = deserialize_version(&envelope.payload.version);
-        let mtime = envelope.payload.mtime.map(|time| time.into());
-        this.update(&mut cx, |this, cx| {
-            if let Some(buffer) = this.get_possibly_incomplete(buffer_id) {
+        let mtime = envelope.payload.mtime.clone().map(|time| time.into());
+        this.update(&mut cx, move |this, cx| {
+            if let Some(buffer) = this.get_possibly_incomplete(buffer_id, cx) {
                 buffer.update(cx, |buffer, cx| {
                     buffer.did_save(version, mtime, cx);
                 });
             }
+
+            if let Some((downstream_client, project_id)) = this.downstream_client.as_ref() {
+                downstream_client
+                    .send(proto::BufferSaved {
+                        project_id: *project_id,
+                        buffer_id: buffer_id.into(),
+                        mtime: envelope.payload.mtime,
+                        version: envelope.payload.version,
+                    })
+                    .log_err();
+            }
         })
     }
 
@@ -1425,17 +1728,29 @@ impl BufferStore {
     ) -> Result<()> {
         let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
         let version = deserialize_version(&envelope.payload.version);
-        let mtime = envelope.payload.mtime.map(|time| time.into());
+        let mtime = envelope.payload.mtime.clone().map(|time| time.into());
         let line_ending = deserialize_line_ending(
             proto::LineEnding::from_i32(envelope.payload.line_ending)
                 .ok_or_else(|| anyhow!("missing line ending"))?,
         );
         this.update(&mut cx, |this, cx| {
-            if let Some(buffer) = this.get_possibly_incomplete(buffer_id) {
+            if let Some(buffer) = this.get_possibly_incomplete(buffer_id, cx) {
                 buffer.update(cx, |buffer, cx| {
                     buffer.did_reload(version, line_ending, mtime, cx);
                 });
             }
+
+            if let Some((downstream_client, project_id)) = this.downstream_client.as_ref() {
+                downstream_client
+                    .send(proto::BufferReloaded {
+                        project_id: *project_id,
+                        buffer_id: buffer_id.into(),
+                        mtime: envelope.payload.mtime,
+                        version: envelope.payload.version,
+                        line_ending: envelope.payload.line_ending,
+                    })
+                    .log_err();
+            }
         })
     }
 
@@ -1480,66 +1795,14 @@ impl BufferStore {
         push_to_history: bool,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<ProjectTransaction>> {
-        let mut local_buffers = Vec::new();
-        let mut remote_buffers = Vec::new();
-        for buffer_handle in buffers {
-            let buffer = buffer_handle.read(cx);
-            if buffer.is_dirty() {
-                if let Some(file) = File::from_dyn(buffer.file()) {
-                    if file.is_local() {
-                        local_buffers.push(buffer_handle);
-                    } else {
-                        remote_buffers.push(buffer_handle);
-                    }
-                }
-            }
+        let buffers: Vec<Model<Buffer>> = buffers
+            .into_iter()
+            .filter(|buffer| buffer.read(cx).is_dirty())
+            .collect();
+        if buffers.is_empty() {
+            return Task::ready(Ok(ProjectTransaction::default()));
         }
-
-        let client = self.upstream_client();
-
-        cx.spawn(move |this, mut cx| async move {
-            let mut project_transaction = ProjectTransaction::default();
-            if let Some((client, project_id)) = client {
-                let response = client
-                    .request(proto::ReloadBuffers {
-                        project_id,
-                        buffer_ids: remote_buffers
-                            .iter()
-                            .filter_map(|buffer| {
-                                buffer
-                                    .update(&mut cx, |buffer, _| buffer.remote_id().into())
-                                    .ok()
-                            })
-                            .collect(),
-                    })
-                    .await?
-                    .transaction
-                    .ok_or_else(|| anyhow!("missing transaction"))?;
-                BufferStore::deserialize_project_transaction(
-                    this,
-                    response,
-                    push_to_history,
-                    cx.clone(),
-                )
-                .await?;
-            }
-
-            for buffer in local_buffers {
-                let transaction = buffer
-                    .update(&mut cx, |buffer, cx| buffer.reload(cx))?
-                    .await?;
-                buffer.update(&mut cx, |buffer, cx| {
-                    if let Some(transaction) = transaction {
-                        if !push_to_history {
-                            buffer.forget_transaction(transaction.id);
-                        }
-                        project_transaction.0.insert(cx.handle(), transaction);
-                    }
-                })?;
-            }
-
-            Ok(project_transaction)
-        })
+        self.state.reload_buffers(buffers, push_to_history, cx)
     }
 
     async fn handle_reload_buffers(
@@ -1629,17 +1892,6 @@ impl BufferStore {
         })
     }
 
-    pub fn upstream_client(&self) -> Option<(AnyProtoClient, u64)> {
-        match &self.state {
-            BufferStoreState::Remote {
-                upstream_client,
-                project_id,
-                ..
-            } => Some((upstream_client.clone(), *project_id)),
-            BufferStoreState::Local { .. } => None,
-        }
-    }
-
     pub fn forget_shared_buffers(&mut self) {
         self.shared_buffers.clear();
     }
@@ -1658,6 +1910,72 @@ impl BufferStore {
         &self.shared_buffers
     }
 
+    pub fn create_local_buffer(
+        &mut self,
+        text: &str,
+        language: Option<Arc<Language>>,
+        cx: &mut ModelContext<Self>,
+    ) -> Model<Buffer> {
+        let buffer = cx.new_model(|cx| {
+            Buffer::local(text, cx)
+                .with_language(language.unwrap_or_else(|| language::PLAIN_TEXT.clone()), cx)
+        });
+
+        self.add_buffer(buffer.clone(), cx).log_err();
+        let buffer_id = buffer.read(cx).remote_id();
+
+        let local = self
+            .state
+            .as_local()
+            .expect("local-only method called in a non-local context");
+        local.update(cx, |this, cx| {
+            if let Some(file) = File::from_dyn(buffer.read(cx).file()) {
+                this.local_buffer_ids_by_path.insert(
+                    ProjectPath {
+                        worktree_id: file.worktree_id(cx),
+                        path: file.path.clone(),
+                    },
+                    buffer_id,
+                );
+
+                if let Some(entry_id) = file.entry_id {
+                    this.local_buffer_ids_by_entry_id
+                        .insert(entry_id, buffer_id);
+                }
+            }
+        });
+        buffer
+    }
+
+    pub fn deserialize_project_transaction(
+        &mut self,
+        message: proto::ProjectTransaction,
+        push_to_history: bool,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<ProjectTransaction>> {
+        if let Some(remote) = self.state.as_remote() {
+            remote.update(cx, |remote, cx| {
+                remote.deserialize_project_transaction(message, push_to_history, cx)
+            })
+        } else {
+            debug_panic!("not a remote buffer store");
+            Task::ready(Err(anyhow!("not a remote buffer store")))
+        }
+    }
+
+    pub fn wait_for_remote_buffer(
+        &self,
+        id: BufferId,
+        cx: &mut AppContext,
+    ) -> Task<Result<Model<Buffer>>> {
+        if let Some(remote) = self.state.as_remote() {
+            remote.update(cx, |remote, cx| remote.wait_for_remote_buffer(id, cx))
+        } else {
+            debug_panic!("not a remote buffer store");
+            Task::ready(Err(anyhow!("not a remote buffer store")))
+        }
+    }
+
     pub fn serialize_project_transaction_for_peer(
         &mut self,
         project_transaction: ProjectTransaction,
@@ -1680,41 +1998,6 @@ impl BufferStore {
         }
         serialized_transaction
     }
-
-    pub async fn deserialize_project_transaction(
-        this: WeakModel<Self>,
-        message: proto::ProjectTransaction,
-        push_to_history: bool,
-        mut cx: AsyncAppContext,
-    ) -> Result<ProjectTransaction> {
-        let mut project_transaction = ProjectTransaction::default();
-        for (buffer_id, transaction) in message.buffer_ids.into_iter().zip(message.transactions) {
-            let buffer_id = BufferId::new(buffer_id)?;
-            let buffer = this
-                .update(&mut cx, |this, cx| {
-                    this.wait_for_remote_buffer(buffer_id, cx)
-                })?
-                .await?;
-            let transaction = language::proto::deserialize_transaction(transaction)?;
-            project_transaction.0.insert(buffer, transaction);
-        }
-
-        for (buffer, transaction) in &project_transaction.0 {
-            buffer
-                .update(&mut cx, |buffer, _| {
-                    buffer.wait_for_edits(transaction.edit_ids.iter().copied())
-                })?
-                .await?;
-
-            if push_to_history {
-                buffer.update(&mut cx, |buffer, _| {
-                    buffer.push_transaction(transaction.clone(), Instant::now());
-                })?;
-            }
-        }
-
-        Ok(project_transaction)
-    }
 }
 
 impl OpenBuffer {
diff --git a/crates/project/src/lsp_command.rs b/crates/project/src/lsp_command.rs
index 2b7b10d9b369a9..96eb327e8c4344 100644
--- a/crates/project/src/lsp_command.rs
+++ b/crates/project/src/lsp_command.rs
@@ -1,10 +1,9 @@
 mod signature_help;
 
 use crate::{
-    buffer_store::BufferStore, lsp_store::LspStore, CodeAction, CoreCompletion, DocumentHighlight,
-    Hover, HoverBlock, HoverBlockKind, InlayHint, InlayHintLabel, InlayHintLabelPart,
-    InlayHintLabelPartTooltip, InlayHintTooltip, Location, LocationLink, MarkupContent,
-    ProjectTransaction, ResolveState,
+    lsp_store::LspStore, CodeAction, CoreCompletion, DocumentHighlight, Hover, HoverBlock,
+    HoverBlockKind, InlayHint, InlayHintLabel, InlayHintLabelPart, InlayHintLabelPartTooltip,
+    InlayHintTooltip, Location, LocationLink, MarkupContent, ProjectTransaction, ResolveState,
 };
 use anyhow::{anyhow, Context, Result};
 use async_trait::async_trait;
@@ -417,18 +416,18 @@ impl LspCommand for PerformRename {
         message: proto::PerformRenameResponse,
         lsp_store: Model<LspStore>,
         _: Model<Buffer>,
-        cx: AsyncAppContext,
+        mut cx: AsyncAppContext,
     ) -> Result<ProjectTransaction> {
         let message = message
             .transaction
             .ok_or_else(|| anyhow!("missing transaction"))?;
-        BufferStore::deserialize_project_transaction(
-            lsp_store.read_with(&cx, |lsp_store, _| lsp_store.buffer_store().downgrade())?,
-            message,
-            self.push_to_history,
-            cx,
-        )
-        .await
+        lsp_store
+            .update(&mut cx, |lsp_store, cx| {
+                lsp_store.buffer_store().update(cx, |buffer_store, cx| {
+                    buffer_store.deserialize_project_transaction(message, self.push_to_history, cx)
+                })
+            })?
+            .await
     }
 
     fn buffer_id_from_proto(message: &proto::PerformRename) -> Result<BufferId> {
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 6c71d4baebf563..8d859c091bfe93 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -1601,19 +1601,19 @@ impl LspStore {
                 buffer_id: buffer_handle.read(cx).remote_id().into(),
                 action: Some(Self::serialize_code_action(&action)),
             };
-            cx.spawn(move |this, cx| async move {
+            let buffer_store = self.buffer_store();
+            cx.spawn(move |_, mut cx| async move {
                 let response = upstream_client
                     .request(request)
                     .await?
                     .transaction
                     .ok_or_else(|| anyhow!("missing transaction"))?;
-                BufferStore::deserialize_project_transaction(
-                    this.read_with(&cx, |this, _| this.buffer_store.downgrade())?,
-                    response,
-                    push_to_history,
-                    cx,
-                )
-                .await
+
+                buffer_store
+                    .update(&mut cx, |buffer_store, cx| {
+                        buffer_store.deserialize_project_transaction(response, push_to_history, cx)
+                    })?
+                    .await
             })
         } else {
             let buffer = buffer_handle.read(cx);
@@ -5062,6 +5062,7 @@ impl LspStore {
                 .spawn(this.languages.language_for_name(language_name.0.as_ref()))
                 .detach();
 
+            // host
             let adapter = this.languages.get_or_register_lsp_adapter(
                 language_name.clone(),
                 server_name.clone(),
@@ -5259,7 +5260,8 @@ impl LspStore {
                 result
             })
         } else if let Some((client, project_id)) = self.upstream_client() {
-            cx.spawn(move |this, mut cx| async move {
+            let buffer_store = self.buffer_store();
+            cx.spawn(move |_, mut cx| async move {
                 let response = client
                     .request(proto::FormatBuffers {
                         project_id,
@@ -5274,13 +5276,12 @@ impl LspStore {
                     .await?
                     .transaction
                     .ok_or_else(|| anyhow!("missing transaction"))?;
-                BufferStore::deserialize_project_transaction(
-                    this.read_with(&cx, |this, _| this.buffer_store.downgrade())?,
-                    response,
-                    push_to_history,
-                    cx,
-                )
-                .await
+
+                buffer_store
+                    .update(&mut cx, |buffer_store, cx| {
+                        buffer_store.deserialize_project_transaction(response, push_to_history, cx)
+                    })?
+                    .await
             })
         } else {
             Task::ready(Ok(ProjectTransaction::default()))
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 454a7586c8856c..fe4d2d6b01545e 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -1667,16 +1667,8 @@ impl Project {
     }
 
     pub fn create_buffer(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<Model<Buffer>>> {
-        self.buffer_store.update(cx, |buffer_store, cx| {
-            buffer_store.create_buffer(
-                if self.is_via_collab() {
-                    Some((self.client.clone().into(), self.remote_id().unwrap()))
-                } else {
-                    None
-                },
-                cx,
-            )
-        })
+        self.buffer_store
+            .update(cx, |buffer_store, cx| buffer_store.create_buffer(cx))
     }
 
     pub fn create_local_buffer(
@@ -1685,7 +1677,7 @@ impl Project {
         language: Option<Arc<Language>>,
         cx: &mut ModelContext<Self>,
     ) -> Model<Buffer> {
-        if self.is_via_collab() {
+        if self.is_via_collab() || self.is_via_ssh() {
             panic!("called create_local_buffer on a remote project")
         }
         self.buffer_store.update(cx, |buffer_store, cx| {
@@ -3770,7 +3762,9 @@ impl Project {
         envelope: TypedEnvelope<proto::OpenNewBuffer>,
         mut cx: AsyncAppContext,
     ) -> Result<proto::OpenBufferResponse> {
-        let buffer = this.update(&mut cx, |this, cx| this.create_local_buffer("", None, cx))?;
+        let buffer = this
+            .update(&mut cx, |this, cx| this.create_buffer(cx))?
+            .await?;
         let peer_id = envelope.original_sender_id()?;
 
         Project::respond_to_open_buffer_request(this, buffer, peer_id, &mut cx)
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index eca65f1349845c..084fcf9929f014 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -56,6 +56,7 @@ async fn test_basic_remote_editing(cx: &mut TestAppContext, server_cx: &mut Test
         })
         .await
         .unwrap();
+
     buffer.update(cx, |buffer, cx| {
         assert_eq!(buffer.text(), "fn one() -> usize { 1 }");
         assert_eq!(

From fdb03d30587d3269fbb76a9f44a6f08a7f51df97 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Tue, 24 Sep 2024 15:16:27 -0700
Subject: [PATCH 311/762] Move DisplayDiffHunk into hunk_diff module (#18307)

Release Notes:

- N/A

Co-authored-by: Marshall <marshall@zed.dev>
---
 crates/editor/src/editor.rs    |   3 +-
 crates/editor/src/element.rs   |   7 +-
 crates/editor/src/git.rs       | 308 -----------------------------
 crates/editor/src/hunk_diff.rs | 340 ++++++++++++++++++++++++++++++---
 4 files changed, 320 insertions(+), 338 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index a32910e78ab973..316d945ca4df63 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -71,7 +71,6 @@ pub use element::{
 use futures::{future, FutureExt};
 use fuzzy::{StringMatch, StringMatchCandidate};
 use git::blame::GitBlame;
-use git::diff_hunk_to_display;
 use gpui::{
     div, impl_actions, point, prelude::*, px, relative, size, uniform_list, Action, AnyElement,
     AppContext, AsyncWindowContext, AvailableSpace, BackgroundExecutor, Bounds, ClipboardEntry,
@@ -84,8 +83,8 @@ use gpui::{
 };
 use highlight_matching_bracket::refresh_matching_bracket_highlights;
 use hover_popover::{hide_hover, HoverState};
-use hunk_diff::ExpandedHunks;
 pub(crate) use hunk_diff::HoveredHunk;
+use hunk_diff::{diff_hunk_to_display, ExpandedHunks};
 use indent_guides::ActiveIndentGuidesState;
 use inlay_hint_cache::{InlayHintCache, InlaySplice, InvalidationStrategy};
 pub use inline_completion_provider::*;
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 31e4efb83b60e7..cf8edb67dccbc6 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -7,14 +7,11 @@ use crate::{
         CurrentLineHighlight, DoubleClickInMultibuffer, MultiCursorModifier, ScrollBeyondLastLine,
         ShowScrollbar,
     },
-    git::{
-        blame::{CommitDetails, GitBlame},
-        diff_hunk_to_display, DisplayDiffHunk,
-    },
+    git::blame::{CommitDetails, GitBlame},
     hover_popover::{
         self, hover_at, HOVER_POPOVER_GAP, MIN_POPOVER_CHARACTER_WIDTH, MIN_POPOVER_LINE_HEIGHT,
     },
-    hunk_diff::ExpandedHunk,
+    hunk_diff::{diff_hunk_to_display, DisplayDiffHunk, ExpandedHunk},
     hunk_status,
     items::BufferSearchHighlights,
     mouse_context_menu::{self, MenuPosition, MouseContextMenu},
diff --git a/crates/editor/src/git.rs b/crates/editor/src/git.rs
index fb18ca45a2a2ff..080babe4c682a5 100644
--- a/crates/editor/src/git.rs
+++ b/crates/editor/src/git.rs
@@ -1,309 +1 @@
 pub mod blame;
-
-use std::ops::Range;
-
-use git::diff::DiffHunkStatus;
-use language::Point;
-use multi_buffer::{Anchor, MultiBufferDiffHunk};
-
-use crate::{
-    display_map::{DisplaySnapshot, ToDisplayPoint},
-    hunk_status, AnchorRangeExt, DisplayRow,
-};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum DisplayDiffHunk {
-    Folded {
-        display_row: DisplayRow,
-    },
-
-    Unfolded {
-        diff_base_byte_range: Range<usize>,
-        display_row_range: Range<DisplayRow>,
-        multi_buffer_range: Range<Anchor>,
-        status: DiffHunkStatus,
-    },
-}
-
-impl DisplayDiffHunk {
-    pub fn start_display_row(&self) -> DisplayRow {
-        match self {
-            &DisplayDiffHunk::Folded { display_row } => display_row,
-            DisplayDiffHunk::Unfolded {
-                display_row_range, ..
-            } => display_row_range.start,
-        }
-    }
-
-    pub fn contains_display_row(&self, display_row: DisplayRow) -> bool {
-        let range = match self {
-            &DisplayDiffHunk::Folded { display_row } => display_row..=display_row,
-
-            DisplayDiffHunk::Unfolded {
-                display_row_range, ..
-            } => display_row_range.start..=display_row_range.end,
-        };
-
-        range.contains(&display_row)
-    }
-}
-
-pub fn diff_hunk_to_display(
-    hunk: &MultiBufferDiffHunk,
-    snapshot: &DisplaySnapshot,
-) -> DisplayDiffHunk {
-    let hunk_start_point = Point::new(hunk.row_range.start.0, 0);
-    let hunk_start_point_sub = Point::new(hunk.row_range.start.0.saturating_sub(1), 0);
-    let hunk_end_point_sub = Point::new(
-        hunk.row_range
-            .end
-            .0
-            .saturating_sub(1)
-            .max(hunk.row_range.start.0),
-        0,
-    );
-
-    let status = hunk_status(hunk);
-    let is_removal = status == DiffHunkStatus::Removed;
-
-    let folds_start = Point::new(hunk.row_range.start.0.saturating_sub(2), 0);
-    let folds_end = Point::new(hunk.row_range.end.0 + 2, 0);
-    let folds_range = folds_start..folds_end;
-
-    let containing_fold = snapshot.folds_in_range(folds_range).find(|fold| {
-        let fold_point_range = fold.range.to_point(&snapshot.buffer_snapshot);
-        let fold_point_range = fold_point_range.start..=fold_point_range.end;
-
-        let folded_start = fold_point_range.contains(&hunk_start_point);
-        let folded_end = fold_point_range.contains(&hunk_end_point_sub);
-        let folded_start_sub = fold_point_range.contains(&hunk_start_point_sub);
-
-        (folded_start && folded_end) || (is_removal && folded_start_sub)
-    });
-
-    if let Some(fold) = containing_fold {
-        let row = fold.range.start.to_display_point(snapshot).row();
-        DisplayDiffHunk::Folded { display_row: row }
-    } else {
-        let start = hunk_start_point.to_display_point(snapshot).row();
-
-        let hunk_end_row = hunk.row_range.end.max(hunk.row_range.start);
-        let hunk_end_point = Point::new(hunk_end_row.0, 0);
-
-        let multi_buffer_start = snapshot.buffer_snapshot.anchor_before(hunk_start_point);
-        let multi_buffer_end = snapshot.buffer_snapshot.anchor_after(hunk_end_point);
-        let end = hunk_end_point.to_display_point(snapshot).row();
-
-        DisplayDiffHunk::Unfolded {
-            display_row_range: start..end,
-            multi_buffer_range: multi_buffer_start..multi_buffer_end,
-            status,
-            diff_base_byte_range: hunk.diff_base_byte_range.clone(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::Point;
-    use crate::{editor_tests::init_test, hunk_status};
-    use gpui::{Context, TestAppContext};
-    use language::Capability::ReadWrite;
-    use multi_buffer::{ExcerptRange, MultiBuffer, MultiBufferRow};
-    use project::{FakeFs, Project};
-    use unindent::Unindent;
-    #[gpui::test]
-    async fn test_diff_hunks_in_range(cx: &mut TestAppContext) {
-        use git::diff::DiffHunkStatus;
-        init_test(cx, |_| {});
-
-        let fs = FakeFs::new(cx.background_executor.clone());
-        let project = Project::test(fs, [], cx).await;
-
-        // buffer has two modified hunks with two rows each
-        let buffer_1 = project.update(cx, |project, cx| {
-            project.create_local_buffer(
-                "
-                        1.zero
-                        1.ONE
-                        1.TWO
-                        1.three
-                        1.FOUR
-                        1.FIVE
-                        1.six
-                    "
-                .unindent()
-                .as_str(),
-                None,
-                cx,
-            )
-        });
-        buffer_1.update(cx, |buffer, cx| {
-            buffer.set_diff_base(
-                Some(
-                    "
-                        1.zero
-                        1.one
-                        1.two
-                        1.three
-                        1.four
-                        1.five
-                        1.six
-                    "
-                    .unindent(),
-                ),
-                cx,
-            );
-        });
-
-        // buffer has a deletion hunk and an insertion hunk
-        let buffer_2 = project.update(cx, |project, cx| {
-            project.create_local_buffer(
-                "
-                        2.zero
-                        2.one
-                        2.two
-                        2.three
-                        2.four
-                        2.five
-                        2.six
-                    "
-                .unindent()
-                .as_str(),
-                None,
-                cx,
-            )
-        });
-        buffer_2.update(cx, |buffer, cx| {
-            buffer.set_diff_base(
-                Some(
-                    "
-                        2.zero
-                        2.one
-                        2.one-and-a-half
-                        2.two
-                        2.three
-                        2.four
-                        2.six
-                    "
-                    .unindent(),
-                ),
-                cx,
-            );
-        });
-
-        cx.background_executor.run_until_parked();
-
-        let multibuffer = cx.new_model(|cx| {
-            let mut multibuffer = MultiBuffer::new(ReadWrite);
-            multibuffer.push_excerpts(
-                buffer_1.clone(),
-                [
-                    // excerpt ends in the middle of a modified hunk
-                    ExcerptRange {
-                        context: Point::new(0, 0)..Point::new(1, 5),
-                        primary: Default::default(),
-                    },
-                    // excerpt begins in the middle of a modified hunk
-                    ExcerptRange {
-                        context: Point::new(5, 0)..Point::new(6, 5),
-                        primary: Default::default(),
-                    },
-                ],
-                cx,
-            );
-            multibuffer.push_excerpts(
-                buffer_2.clone(),
-                [
-                    // excerpt ends at a deletion
-                    ExcerptRange {
-                        context: Point::new(0, 0)..Point::new(1, 5),
-                        primary: Default::default(),
-                    },
-                    // excerpt starts at a deletion
-                    ExcerptRange {
-                        context: Point::new(2, 0)..Point::new(2, 5),
-                        primary: Default::default(),
-                    },
-                    // excerpt fully contains a deletion hunk
-                    ExcerptRange {
-                        context: Point::new(1, 0)..Point::new(2, 5),
-                        primary: Default::default(),
-                    },
-                    // excerpt fully contains an insertion hunk
-                    ExcerptRange {
-                        context: Point::new(4, 0)..Point::new(6, 5),
-                        primary: Default::default(),
-                    },
-                ],
-                cx,
-            );
-            multibuffer
-        });
-
-        let snapshot = multibuffer.read_with(cx, |b, cx| b.snapshot(cx));
-
-        assert_eq!(
-            snapshot.text(),
-            "
-                1.zero
-                1.ONE
-                1.FIVE
-                1.six
-                2.zero
-                2.one
-                2.two
-                2.one
-                2.two
-                2.four
-                2.five
-                2.six"
-                .unindent()
-        );
-
-        let expected = [
-            (
-                DiffHunkStatus::Modified,
-                MultiBufferRow(1)..MultiBufferRow(2),
-            ),
-            (
-                DiffHunkStatus::Modified,
-                MultiBufferRow(2)..MultiBufferRow(3),
-            ),
-            //TODO: Define better when and where removed hunks show up at range extremities
-            (
-                DiffHunkStatus::Removed,
-                MultiBufferRow(6)..MultiBufferRow(6),
-            ),
-            (
-                DiffHunkStatus::Removed,
-                MultiBufferRow(8)..MultiBufferRow(8),
-            ),
-            (
-                DiffHunkStatus::Added,
-                MultiBufferRow(10)..MultiBufferRow(11),
-            ),
-        ];
-
-        assert_eq!(
-            snapshot
-                .git_diff_hunks_in_range(MultiBufferRow(0)..MultiBufferRow(12))
-                .map(|hunk| (hunk_status(&hunk), hunk.row_range))
-                .collect::<Vec<_>>(),
-            &expected,
-        );
-
-        assert_eq!(
-            snapshot
-                .git_diff_hunks_in_range_rev(MultiBufferRow(0)..MultiBufferRow(12))
-                .map(|hunk| (hunk_status(&hunk), hunk.row_range))
-                .collect::<Vec<_>>(),
-            expected
-                .iter()
-                .rev()
-                .cloned()
-                .collect::<Vec<_>>()
-                .as_slice(),
-        );
-    }
-}
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index 2f7bb49e853491..67e8a25df58c56 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -1,18 +1,16 @@
-use std::{
-    ops::{Range, RangeInclusive},
-    sync::Arc,
-};
-
 use collections::{hash_map, HashMap, HashSet};
 use git::diff::DiffHunkStatus;
 use gpui::{Action, AppContext, CursorStyle, Hsla, Model, MouseButton, Subscription, Task, View};
-use language::Buffer;
+use language::{Buffer, BufferId, Point};
 use multi_buffer::{
     Anchor, AnchorRangeExt, ExcerptRange, MultiBuffer, MultiBufferDiffHunk, MultiBufferRow,
     MultiBufferSnapshot, ToPoint,
 };
 use settings::SettingsStore;
-use text::{BufferId, Point};
+use std::{
+    ops::{Range, RangeInclusive},
+    sync::Arc,
+};
 use ui::{
     prelude::*, ActiveTheme, ContextMenu, InteractiveElement, IntoElement, ParentElement, Pixels,
     Styled, ViewContext, VisualContext,
@@ -20,13 +18,11 @@ use ui::{
 use util::{debug_panic, RangeExt};
 
 use crate::{
-    editor_settings::CurrentLineHighlight,
-    git::{diff_hunk_to_display, DisplayDiffHunk},
-    hunk_status, hunks_for_selections,
-    mouse_context_menu::MouseContextMenu,
-    BlockDisposition, BlockProperties, BlockStyle, CustomBlockId, DiffRowHighlight, Editor,
-    EditorElement, EditorSnapshot, ExpandAllHunkDiffs, RangeToAnchorExt, RevertFile,
-    RevertSelectedHunks, ToDisplayPoint, ToggleHunkDiff,
+    editor_settings::CurrentLineHighlight, hunk_status, hunks_for_selections,
+    mouse_context_menu::MouseContextMenu, BlockDisposition, BlockProperties, BlockStyle,
+    CustomBlockId, DiffRowHighlight, DisplayRow, DisplaySnapshot, Editor, EditorElement,
+    EditorSnapshot, ExpandAllHunkDiffs, RangeToAnchorExt, RevertFile, RevertSelectedHunks,
+    ToDisplayPoint, ToggleHunkDiff,
 };
 
 #[derive(Debug, Clone)]
@@ -43,12 +39,35 @@ pub(super) struct ExpandedHunks {
     hunk_update_tasks: HashMap<Option<BufferId>, Task<()>>,
 }
 
+#[derive(Debug, Clone)]
+pub(super) struct ExpandedHunk {
+    pub block: Option<CustomBlockId>,
+    pub hunk_range: Range<Anchor>,
+    pub diff_base_byte_range: Range<usize>,
+    pub status: DiffHunkStatus,
+    pub folded: bool,
+}
+
 #[derive(Debug)]
 struct DiffBaseBuffer {
     buffer: Model<Buffer>,
     diff_base_version: usize,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DisplayDiffHunk {
+    Folded {
+        display_row: DisplayRow,
+    },
+
+    Unfolded {
+        diff_base_byte_range: Range<usize>,
+        display_row_range: Range<DisplayRow>,
+        multi_buffer_range: Range<Anchor>,
+        status: DiffHunkStatus,
+    },
+}
+
 impl ExpandedHunks {
     pub fn hunks(&self, include_folded: bool) -> impl Iterator<Item = &ExpandedHunk> {
         self.hunks
@@ -57,15 +76,6 @@ impl ExpandedHunks {
     }
 }
 
-#[derive(Debug, Clone)]
-pub(super) struct ExpandedHunk {
-    pub block: Option<CustomBlockId>,
-    pub hunk_range: Range<Anchor>,
-    pub diff_base_byte_range: Range<usize>,
-    pub status: DiffHunkStatus,
-    pub folded: bool,
-}
-
 impl Editor {
     pub(super) fn open_hunk_context_menu(
         &mut self,
@@ -883,3 +893,287 @@ fn to_inclusive_row_range(
     let new_range = point_range.to_anchors(&snapshot.buffer_snapshot);
     new_range.start..=new_range.end
 }
+
+impl DisplayDiffHunk {
+    pub fn start_display_row(&self) -> DisplayRow {
+        match self {
+            &DisplayDiffHunk::Folded { display_row } => display_row,
+            DisplayDiffHunk::Unfolded {
+                display_row_range, ..
+            } => display_row_range.start,
+        }
+    }
+
+    pub fn contains_display_row(&self, display_row: DisplayRow) -> bool {
+        let range = match self {
+            &DisplayDiffHunk::Folded { display_row } => display_row..=display_row,
+
+            DisplayDiffHunk::Unfolded {
+                display_row_range, ..
+            } => display_row_range.start..=display_row_range.end,
+        };
+
+        range.contains(&display_row)
+    }
+}
+
+pub fn diff_hunk_to_display(
+    hunk: &MultiBufferDiffHunk,
+    snapshot: &DisplaySnapshot,
+) -> DisplayDiffHunk {
+    let hunk_start_point = Point::new(hunk.row_range.start.0, 0);
+    let hunk_start_point_sub = Point::new(hunk.row_range.start.0.saturating_sub(1), 0);
+    let hunk_end_point_sub = Point::new(
+        hunk.row_range
+            .end
+            .0
+            .saturating_sub(1)
+            .max(hunk.row_range.start.0),
+        0,
+    );
+
+    let status = hunk_status(hunk);
+    let is_removal = status == DiffHunkStatus::Removed;
+
+    let folds_start = Point::new(hunk.row_range.start.0.saturating_sub(2), 0);
+    let folds_end = Point::new(hunk.row_range.end.0 + 2, 0);
+    let folds_range = folds_start..folds_end;
+
+    let containing_fold = snapshot.folds_in_range(folds_range).find(|fold| {
+        let fold_point_range = fold.range.to_point(&snapshot.buffer_snapshot);
+        let fold_point_range = fold_point_range.start..=fold_point_range.end;
+
+        let folded_start = fold_point_range.contains(&hunk_start_point);
+        let folded_end = fold_point_range.contains(&hunk_end_point_sub);
+        let folded_start_sub = fold_point_range.contains(&hunk_start_point_sub);
+
+        (folded_start && folded_end) || (is_removal && folded_start_sub)
+    });
+
+    if let Some(fold) = containing_fold {
+        let row = fold.range.start.to_display_point(snapshot).row();
+        DisplayDiffHunk::Folded { display_row: row }
+    } else {
+        let start = hunk_start_point.to_display_point(snapshot).row();
+
+        let hunk_end_row = hunk.row_range.end.max(hunk.row_range.start);
+        let hunk_end_point = Point::new(hunk_end_row.0, 0);
+
+        let multi_buffer_start = snapshot.buffer_snapshot.anchor_before(hunk_start_point);
+        let multi_buffer_end = snapshot.buffer_snapshot.anchor_after(hunk_end_point);
+        let end = hunk_end_point.to_display_point(snapshot).row();
+
+        DisplayDiffHunk::Unfolded {
+            display_row_range: start..end,
+            multi_buffer_range: multi_buffer_start..multi_buffer_end,
+            status,
+            diff_base_byte_range: hunk.diff_base_byte_range.clone(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{editor_tests::init_test, hunk_status};
+    use gpui::{Context, TestAppContext};
+    use language::Capability::ReadWrite;
+    use multi_buffer::{ExcerptRange, MultiBuffer, MultiBufferRow};
+    use project::{FakeFs, Project};
+    use unindent::Unindent as _;
+
+    #[gpui::test]
+    async fn test_diff_hunks_in_range(cx: &mut TestAppContext) {
+        use git::diff::DiffHunkStatus;
+        init_test(cx, |_| {});
+
+        let fs = FakeFs::new(cx.background_executor.clone());
+        let project = Project::test(fs, [], cx).await;
+
+        // buffer has two modified hunks with two rows each
+        let buffer_1 = project.update(cx, |project, cx| {
+            project.create_local_buffer(
+                "
+                        1.zero
+                        1.ONE
+                        1.TWO
+                        1.three
+                        1.FOUR
+                        1.FIVE
+                        1.six
+                    "
+                .unindent()
+                .as_str(),
+                None,
+                cx,
+            )
+        });
+        buffer_1.update(cx, |buffer, cx| {
+            buffer.set_diff_base(
+                Some(
+                    "
+                        1.zero
+                        1.one
+                        1.two
+                        1.three
+                        1.four
+                        1.five
+                        1.six
+                    "
+                    .unindent(),
+                ),
+                cx,
+            );
+        });
+
+        // buffer has a deletion hunk and an insertion hunk
+        let buffer_2 = project.update(cx, |project, cx| {
+            project.create_local_buffer(
+                "
+                        2.zero
+                        2.one
+                        2.two
+                        2.three
+                        2.four
+                        2.five
+                        2.six
+                    "
+                .unindent()
+                .as_str(),
+                None,
+                cx,
+            )
+        });
+        buffer_2.update(cx, |buffer, cx| {
+            buffer.set_diff_base(
+                Some(
+                    "
+                        2.zero
+                        2.one
+                        2.one-and-a-half
+                        2.two
+                        2.three
+                        2.four
+                        2.six
+                    "
+                    .unindent(),
+                ),
+                cx,
+            );
+        });
+
+        cx.background_executor.run_until_parked();
+
+        let multibuffer = cx.new_model(|cx| {
+            let mut multibuffer = MultiBuffer::new(ReadWrite);
+            multibuffer.push_excerpts(
+                buffer_1.clone(),
+                [
+                    // excerpt ends in the middle of a modified hunk
+                    ExcerptRange {
+                        context: Point::new(0, 0)..Point::new(1, 5),
+                        primary: Default::default(),
+                    },
+                    // excerpt begins in the middle of a modified hunk
+                    ExcerptRange {
+                        context: Point::new(5, 0)..Point::new(6, 5),
+                        primary: Default::default(),
+                    },
+                ],
+                cx,
+            );
+            multibuffer.push_excerpts(
+                buffer_2.clone(),
+                [
+                    // excerpt ends at a deletion
+                    ExcerptRange {
+                        context: Point::new(0, 0)..Point::new(1, 5),
+                        primary: Default::default(),
+                    },
+                    // excerpt starts at a deletion
+                    ExcerptRange {
+                        context: Point::new(2, 0)..Point::new(2, 5),
+                        primary: Default::default(),
+                    },
+                    // excerpt fully contains a deletion hunk
+                    ExcerptRange {
+                        context: Point::new(1, 0)..Point::new(2, 5),
+                        primary: Default::default(),
+                    },
+                    // excerpt fully contains an insertion hunk
+                    ExcerptRange {
+                        context: Point::new(4, 0)..Point::new(6, 5),
+                        primary: Default::default(),
+                    },
+                ],
+                cx,
+            );
+            multibuffer
+        });
+
+        let snapshot = multibuffer.read_with(cx, |b, cx| b.snapshot(cx));
+
+        assert_eq!(
+            snapshot.text(),
+            "
+                1.zero
+                1.ONE
+                1.FIVE
+                1.six
+                2.zero
+                2.one
+                2.two
+                2.one
+                2.two
+                2.four
+                2.five
+                2.six"
+                .unindent()
+        );
+
+        let expected = [
+            (
+                DiffHunkStatus::Modified,
+                MultiBufferRow(1)..MultiBufferRow(2),
+            ),
+            (
+                DiffHunkStatus::Modified,
+                MultiBufferRow(2)..MultiBufferRow(3),
+            ),
+            //TODO: Define better when and where removed hunks show up at range extremities
+            (
+                DiffHunkStatus::Removed,
+                MultiBufferRow(6)..MultiBufferRow(6),
+            ),
+            (
+                DiffHunkStatus::Removed,
+                MultiBufferRow(8)..MultiBufferRow(8),
+            ),
+            (
+                DiffHunkStatus::Added,
+                MultiBufferRow(10)..MultiBufferRow(11),
+            ),
+        ];
+
+        assert_eq!(
+            snapshot
+                .git_diff_hunks_in_range(MultiBufferRow(0)..MultiBufferRow(12))
+                .map(|hunk| (hunk_status(&hunk), hunk.row_range))
+                .collect::<Vec<_>>(),
+            &expected,
+        );
+
+        assert_eq!(
+            snapshot
+                .git_diff_hunks_in_range_rev(MultiBufferRow(0)..MultiBufferRow(12))
+                .map(|hunk| (hunk_status(&hunk), hunk.row_range))
+                .collect::<Vec<_>>(),
+            expected
+                .iter()
+                .rev()
+                .cloned()
+                .collect::<Vec<_>>()
+                .as_slice(),
+        );
+    }
+}

From d33600525ee372813293e803d6aa0f2fa7d50fcb Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 24 Sep 2024 16:23:08 -0600
Subject: [PATCH 312/762] ssh remoting: Fix cmd-o (#18308)

Release Notes:

- ssh-remoting: Cmd-O now correctly opens files on the remote host

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 crates/assistant/src/context_store.rs         |  6 --
 .../random_project_collaboration_tests.rs     | 11 ++-
 crates/editor/src/editor.rs                   |  2 +-
 crates/feedback/src/feedback_modal.rs         | 69 ++++++++-----------
 crates/file_finder/src/file_finder.rs         |  2 +-
 crates/language_tools/src/lsp_log.rs          |  4 +-
 crates/outline_panel/src/outline_panel.rs     |  2 +-
 crates/project/src/project.rs                 | 46 +++++++------
 crates/project_panel/src/project_panel.rs     |  5 +-
 crates/tasks_ui/src/lib.rs                    |  2 +-
 crates/tasks_ui/src/modal.rs                  |  2 +-
 crates/terminal_view/src/terminal_panel.rs    |  2 +-
 crates/title_bar/src/collab.rs                |  8 +--
 crates/workspace/src/workspace.rs             | 12 ++--
 crates/zed/src/zed.rs                         |  2 +-
 15 files changed, 84 insertions(+), 91 deletions(-)

diff --git a/crates/assistant/src/context_store.rs b/crates/assistant/src/context_store.rs
index f57a2fbca613c3..f4f03dda377ba7 100644
--- a/crates/assistant/src/context_store.rs
+++ b/crates/assistant/src/context_store.rs
@@ -357,9 +357,6 @@ impl ContextStore {
         let Some(project_id) = project.remote_id() else {
             return Task::ready(Err(anyhow!("project was not remote")));
         };
-        if project.is_local_or_ssh() {
-            return Task::ready(Err(anyhow!("cannot create remote contexts as the host")));
-        }
 
         let replica_id = project.replica_id();
         let capability = project.capability();
@@ -488,9 +485,6 @@ impl ContextStore {
         let Some(project_id) = project.remote_id() else {
             return Task::ready(Err(anyhow!("project was not remote")));
         };
-        if project.is_local_or_ssh() {
-            return Task::ready(Err(anyhow!("cannot open remote contexts as the host")));
-        }
 
         if let Some(context) = self.loaded_context_for_id(&context_id, cx) {
             return Task::ready(Ok(context));
diff --git a/crates/collab/src/tests/random_project_collaboration_tests.rs b/crates/collab/src/tests/random_project_collaboration_tests.rs
index 831114ba1a0c9c..19d37f8786be6f 100644
--- a/crates/collab/src/tests/random_project_collaboration_tests.rs
+++ b/crates/collab/src/tests/random_project_collaboration_tests.rs
@@ -298,8 +298,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                                 continue;
                             };
                             let project_root_name = root_name_for_project(&project, cx);
-                            let is_local =
-                                project.read_with(cx, |project, _| project.is_local_or_ssh());
+                            let is_local = project.read_with(cx, |project, _| project.is_local());
                             let worktree = project.read_with(cx, |project, cx| {
                                 project
                                     .worktrees(cx)
@@ -335,7 +334,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                         continue;
                     };
                     let project_root_name = root_name_for_project(&project, cx);
-                    let is_local = project.read_with(cx, |project, _| project.is_local_or_ssh());
+                    let is_local = project.read_with(cx, |project, _| project.is_local());
 
                     match rng.gen_range(0..100_u32) {
                         // Manipulate an existing buffer
@@ -1256,7 +1255,7 @@ impl RandomizedTest for ProjectCollaborationTest {
             let buffers = client.buffers().clone();
             for (guest_project, guest_buffers) in &buffers {
                 let project_id = if guest_project.read_with(client_cx, |project, _| {
-                    project.is_local_or_ssh() || project.is_disconnected()
+                    project.is_local() || project.is_disconnected()
                 }) {
                     continue;
                 } else {
@@ -1560,9 +1559,7 @@ async fn ensure_project_shared(
     let first_root_name = root_name_for_project(project, cx);
     let active_call = cx.read(ActiveCall::global);
     if active_call.read_with(cx, |call, _| call.room().is_some())
-        && project.read_with(cx, |project, _| {
-            project.is_local_or_ssh() && !project.is_shared()
-        })
+        && project.read_with(cx, |project, _| project.is_local() && !project.is_shared())
     {
         match active_call
             .update(cx, |call, cx| call.share_project(project.clone(), cx))
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 316d945ca4df63..b54889dc0d8c26 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -11819,7 +11819,7 @@ impl Editor {
                             .filter_map(|buffer| {
                                 let buffer = buffer.read(cx);
                                 let language = buffer.language()?;
-                                if project.is_local_or_ssh()
+                                if project.is_local()
                                     && project.language_servers_for_buffer(buffer, cx).count() == 0
                                 {
                                     None
diff --git a/crates/feedback/src/feedback_modal.rs b/crates/feedback/src/feedback_modal.rs
index a4a07ad2ad44d0..4762b228d3e44f 100644
--- a/crates/feedback/src/feedback_modal.rs
+++ b/crates/feedback/src/feedback_modal.rs
@@ -18,8 +18,7 @@ use regex::Regex;
 use serde_derive::Serialize;
 use ui::{prelude::*, Button, ButtonStyle, IconPosition, Tooltip};
 use util::ResultExt;
-use workspace::notifications::NotificationId;
-use workspace::{DismissDecision, ModalView, Toast, Workspace};
+use workspace::{DismissDecision, ModalView, Workspace};
 
 use crate::{system_specs::SystemSpecs, GiveFeedback, OpenZedRepo};
 
@@ -120,44 +119,34 @@ impl FeedbackModal {
     pub fn register(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
         let _handle = cx.view().downgrade();
         workspace.register_action(move |workspace, _: &GiveFeedback, cx| {
-            let markdown = workspace
-                .app_state()
-                .languages
-                .language_for_name("Markdown");
-
-            let project = workspace.project().clone();
-            let is_local_project = project.read(cx).is_local_or_ssh();
-
-            if !is_local_project {
-                struct FeedbackInRemoteProject;
-
-                workspace.show_toast(
-                    Toast::new(
-                        NotificationId::unique::<FeedbackInRemoteProject>(),
-                        "You can only submit feedback in your own project.",
-                    ),
-                    cx,
-                );
-                return;
-            }
-
-            let system_specs = SystemSpecs::new(cx);
-            cx.spawn(|workspace, mut cx| async move {
-                let markdown = markdown.await.log_err();
-                let buffer = project.update(&mut cx, |project, cx| {
-                    project.create_local_buffer("", markdown, cx)
-                })?;
-                let system_specs = system_specs.await;
-
-                workspace.update(&mut cx, |workspace, cx| {
-                    workspace.toggle_modal(cx, move |cx| {
-                        FeedbackModal::new(system_specs, project, buffer, cx)
-                    });
-                })?;
-
-                anyhow::Ok(())
-            })
-            .detach_and_log_err(cx);
+            workspace
+                .with_local_workspace(cx, |workspace, cx| {
+                    let markdown = workspace
+                        .app_state()
+                        .languages
+                        .language_for_name("Markdown");
+
+                    let project = workspace.project().clone();
+
+                    let system_specs = SystemSpecs::new(cx);
+                    cx.spawn(|workspace, mut cx| async move {
+                        let markdown = markdown.await.log_err();
+                        let buffer = project.update(&mut cx, |project, cx| {
+                            project.create_local_buffer("", markdown, cx)
+                        })?;
+                        let system_specs = system_specs.await;
+
+                        workspace.update(&mut cx, |workspace, cx| {
+                            workspace.toggle_modal(cx, move |cx| {
+                                FeedbackModal::new(system_specs, project, buffer, cx)
+                            });
+                        })?;
+
+                        anyhow::Ok(())
+                    })
+                    .detach_and_log_err(cx);
+                })
+                .detach_and_log_err(cx);
         });
     }
 
diff --git a/crates/file_finder/src/file_finder.rs b/crates/file_finder/src/file_finder.rs
index 4c3f92d3c156a0..726a8bcb5e6983 100644
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -884,7 +884,7 @@ impl PickerDelegate for FileFinderDelegate {
                         project
                             .worktree_for_id(history_item.project.worktree_id, cx)
                             .is_some()
-                            || (project.is_local_or_ssh() && history_item.absolute.is_some())
+                            || (project.is_local() && history_item.absolute.is_some())
                     }),
                     self.currently_opened_path.as_ref(),
                     None,
diff --git a/crates/language_tools/src/lsp_log.rs b/crates/language_tools/src/lsp_log.rs
index bde5fe9b199e8d..d8fe3aa51840e4 100644
--- a/crates/language_tools/src/lsp_log.rs
+++ b/crates/language_tools/src/lsp_log.rs
@@ -184,7 +184,7 @@ pub fn init(cx: &mut AppContext) {
 
     cx.observe_new_views(move |workspace: &mut Workspace, cx| {
         let project = workspace.project();
-        if project.read(cx).is_local_or_ssh() {
+        if project.read(cx).is_local() {
             log_store.update(cx, |store, cx| {
                 store.add_project(project, cx);
             });
@@ -193,7 +193,7 @@ pub fn init(cx: &mut AppContext) {
         let log_store = log_store.clone();
         workspace.register_action(move |workspace, _: &OpenLanguageServerLogs, cx| {
             let project = workspace.project().read(cx);
-            if project.is_local_or_ssh() {
+            if project.is_local() {
                 workspace.add_item_to_active_pane(
                     Box::new(cx.new_view(|cx| {
                         LspLogView::new(workspace.project().clone(), log_store.clone(), cx)
diff --git a/crates/outline_panel/src/outline_panel.rs b/crates/outline_panel/src/outline_panel.rs
index da66ca40313d89..4944f770e73a6c 100644
--- a/crates/outline_panel/src/outline_panel.rs
+++ b/crates/outline_panel/src/outline_panel.rs
@@ -3909,7 +3909,7 @@ impl Render for OutlinePanel {
             .when(project.is_local(), |el| {
                 el.on_action(cx.listener(Self::reveal_in_finder))
             })
-            .when(project.is_local_or_ssh(), |el| {
+            .when(project.is_local() || project.is_via_ssh(), |el| {
                 el.on_action(cx.listener(Self::open_in_terminal))
             })
             .on_mouse_down(
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index fe4d2d6b01545e..5a9b235d91cdbf 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -487,7 +487,7 @@ impl DirectoryLister {
     pub fn is_local(&self, cx: &AppContext) -> bool {
         match self {
             DirectoryLister::Local(_) => true,
-            DirectoryLister::Project(project) => project.read(cx).is_local_or_ssh(),
+            DirectoryLister::Project(project) => project.read(cx).is_local(),
         }
     }
 
@@ -1199,7 +1199,13 @@ impl Project {
         self.dev_server_project_id
     }
 
-    pub fn supports_remote_terminal(&self, cx: &AppContext) -> bool {
+    pub fn supports_terminal(&self, cx: &AppContext) -> bool {
+        if self.is_local() {
+            return true;
+        }
+        if self.is_via_ssh() {
+            return true;
+        }
         let Some(id) = self.dev_server_project_id else {
             return false;
         };
@@ -1213,10 +1219,6 @@ impl Project {
     }
 
     pub fn ssh_connection_string(&self, cx: &ModelContext<Self>) -> Option<SharedString> {
-        if self.is_local_or_ssh() {
-            return None;
-        }
-
         let dev_server_id = self.dev_server_project_id()?;
         dev_server_projects::Store::global(cx)
             .read(cx)
@@ -1643,13 +1645,6 @@ impl Project {
         }
     }
 
-    pub fn is_local_or_ssh(&self) -> bool {
-        match &self.client_state {
-            ProjectClientState::Local | ProjectClientState::Shared { .. } => true,
-            ProjectClientState::Remote { .. } => false,
-        }
-    }
-
     pub fn is_via_ssh(&self) -> bool {
         match &self.client_state {
             ProjectClientState::Local | ProjectClientState::Shared { .. } => {
@@ -1735,7 +1730,7 @@ impl Project {
     ) -> Task<Result<Model<Buffer>>> {
         if let Some(buffer) = self.buffer_for_id(id, cx) {
             Task::ready(Ok(buffer))
-        } else if self.is_local_or_ssh() {
+        } else if self.is_local() || self.is_via_ssh() {
             Task::ready(Err(anyhow!("buffer {} does not exist", id)))
         } else if let Some(project_id) = self.remote_id() {
             let request = self.client.request(proto::OpenBufferById {
@@ -1857,7 +1852,7 @@ impl Project {
         let mut changes = rx.ready_chunks(MAX_BATCH_SIZE);
 
         while let Some(changes) = changes.next().await {
-            let is_local = this.update(&mut cx, |this, _| this.is_local_or_ssh())?;
+            let is_local = this.update(&mut cx, |this, _| this.is_local())?;
 
             for change in changes {
                 match change {
@@ -2001,7 +1996,7 @@ impl Project {
                 language_server_id,
                 message,
             } => {
-                if self.is_local_or_ssh() {
+                if self.is_local() {
                     self.enqueue_buffer_ordered_message(
                         BufferOrderedMessage::LanguageServerUpdate {
                             language_server_id: *language_server_id,
@@ -3039,8 +3034,19 @@ impl Project {
         query: String,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Vec<PathBuf>>> {
-        if self.is_local_or_ssh() {
+        if self.is_local() {
             DirectoryLister::Local(self.fs.clone()).list_directory(query, cx)
+        } else if let Some(session) = self.ssh_session.as_ref() {
+            let request = proto::ListRemoteDirectory {
+                dev_server_id: SSH_PROJECT_ID,
+                path: query,
+            };
+
+            let response = session.request(request);
+            cx.background_executor().spawn(async move {
+                let response = response.await?;
+                Ok(response.entries.into_iter().map(PathBuf::from).collect())
+            })
         } else if let Some(dev_server) = self.dev_server_project_id().and_then(|id| {
             dev_server_projects::Store::global(cx)
                 .read(cx)
@@ -3317,7 +3323,7 @@ impl Project {
         mut cx: AsyncAppContext,
     ) -> Result<()> {
         this.update(&mut cx, |this, cx| {
-            if this.is_local_or_ssh() {
+            if this.is_local() || this.is_via_ssh() {
                 this.unshare(cx)?;
             } else {
                 this.disconnected_from_host(cx);
@@ -3995,7 +4001,7 @@ impl Project {
         location: Location,
         cx: &mut ModelContext<'_, Project>,
     ) -> Task<Option<TaskContext>> {
-        if self.is_local_or_ssh() {
+        if self.is_local() {
             let (worktree_id, worktree_abs_path) = if let Some(worktree) = self.task_worktree(cx) {
                 (
                     Some(worktree.read(cx).id()),
@@ -4081,7 +4087,7 @@ impl Project {
         location: Option<Location>,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Vec<(TaskSourceKind, TaskTemplate)>>> {
-        if self.is_local_or_ssh() {
+        if self.is_local() {
             let (file, language) = location
                 .map(|location| {
                     let buffer = location.buffer.read(cx);
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 8e741134f0e446..6958bfb3318e23 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -2722,11 +2722,14 @@ impl Render for ProjectPanel {
                             }
                         }))
                 })
-                .when(project.is_local_or_ssh(), |el| {
+                .when(project.is_local(), |el| {
                     el.on_action(cx.listener(Self::reveal_in_finder))
                         .on_action(cx.listener(Self::open_system))
                         .on_action(cx.listener(Self::open_in_terminal))
                 })
+                .when(project.is_via_ssh(), |el| {
+                    el.on_action(cx.listener(Self::open_in_terminal))
+                })
                 .on_mouse_down(
                     MouseButton::Right,
                     cx.listener(move |this, event: &MouseDownEvent, cx| {
diff --git a/crates/tasks_ui/src/lib.rs b/crates/tasks_ui/src/lib.rs
index 4ea4a8fa2ccdc0..fd14f9aaef2a40 100644
--- a/crates/tasks_ui/src/lib.rs
+++ b/crates/tasks_ui/src/lib.rs
@@ -94,7 +94,7 @@ fn toggle_modal(workspace: &mut Workspace, cx: &mut ViewContext<'_, Workspace>)
         workspace
             .update(&mut cx, |workspace, cx| {
                 if workspace.project().update(cx, |project, cx| {
-                    project.is_local_or_ssh() || project.ssh_connection_string(cx).is_some()
+                    project.is_local() || project.ssh_connection_string(cx).is_some()
                 }) {
                     workspace.toggle_modal(cx, |cx| {
                         TasksModal::new(project, task_context, workspace_handle, cx)
diff --git a/crates/tasks_ui/src/modal.rs b/crates/tasks_ui/src/modal.rs
index 931a0b09c365fb..662e3f11fd05c4 100644
--- a/crates/tasks_ui/src/modal.rs
+++ b/crates/tasks_ui/src/modal.rs
@@ -225,7 +225,7 @@ impl PickerDelegate for TasksModalDelegate {
                                     if project.is_via_collab() && ssh_connection_string.is_none() {
                                         Task::ready((Vec::new(), Vec::new()))
                                     } else {
-                                        let remote_templates = if project.is_local_or_ssh() {
+                                        let remote_templates = if project.is_local() {
                                             None
                                         } else {
                                             project
diff --git a/crates/terminal_view/src/terminal_panel.rs b/crates/terminal_view/src/terminal_panel.rs
index f745fbe348ba40..72f8606fa21765 100644
--- a/crates/terminal_view/src/terminal_panel.rs
+++ b/crates/terminal_view/src/terminal_panel.rs
@@ -144,7 +144,7 @@ impl TerminalPanel {
             cx.subscribe(&pane, Self::handle_pane_event),
         ];
         let project = workspace.project().read(cx);
-        let enabled = project.is_local_or_ssh() || project.supports_remote_terminal(cx);
+        let enabled = project.supports_terminal(cx);
         let this = Self {
             pane,
             fs: workspace.app_state().fs.clone(),
diff --git a/crates/title_bar/src/collab.rs b/crates/title_bar/src/collab.rs
index 1f052e1a5e61ac..e9f89643d5729f 100644
--- a/crates/title_bar/src/collab.rs
+++ b/crates/title_bar/src/collab.rs
@@ -284,14 +284,14 @@ impl TitleBar {
 
         let room = room.read(cx);
         let project = self.project.read(cx);
-        let is_local = project.is_local_or_ssh();
         let is_dev_server_project = project.dev_server_project_id().is_some();
-        let is_shared = (is_local || is_dev_server_project) && project.is_shared();
+        let is_shared = project.is_shared();
         let is_muted = room.is_muted();
         let is_deafened = room.is_deafened().unwrap_or(false);
         let is_screen_sharing = room.is_screen_sharing();
         let can_use_microphone = room.can_use_microphone();
-        let can_share_projects = room.can_share_projects();
+        let can_share_projects = room.can_share_projects()
+            && (is_dev_server_project || project.is_local() || project.is_via_ssh());
         let platform_supported = match self.platform_style {
             PlatformStyle::Mac => true,
             PlatformStyle::Linux | PlatformStyle::Windows => false,
@@ -299,7 +299,7 @@ impl TitleBar {
 
         let mut children = Vec::new();
 
-        if (is_local || is_dev_server_project) && can_share_projects {
+        if can_share_projects {
             children.push(
                 Button::new(
                     "toggle_sharing",
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 98f793c234aaeb..4290e12105a3c7 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -1891,7 +1891,11 @@ impl Workspace {
                 directories: true,
                 multiple: true,
             },
-            DirectoryLister::Local(self.app_state.fs.clone()),
+            if self.project.read(cx).is_via_ssh() {
+                DirectoryLister::Project(self.project.clone())
+            } else {
+                DirectoryLister::Local(self.app_state.fs.clone())
+            },
             cx,
         );
 
@@ -3956,7 +3960,7 @@ impl Workspace {
     fn local_paths(&self, cx: &AppContext) -> Option<Vec<Arc<Path>>> {
         let project = self.project().read(cx);
 
-        if project.is_local_or_ssh() {
+        if project.is_local() {
             Some(
                 project
                     .visible_worktrees(cx)
@@ -5160,7 +5164,7 @@ async fn join_channel_internal(
                         return None;
                     }
 
-                    if (project.is_local_or_ssh() || is_dev_server)
+                    if (project.is_local() || project.is_via_ssh() || is_dev_server)
                         && project.visible_worktrees(cx).any(|tree| {
                             tree.read(cx)
                                 .root_entry()
@@ -5314,7 +5318,7 @@ pub fn local_workspace_windows(cx: &AppContext) -> Vec<WindowHandle<Workspace>>
         .filter(|workspace| {
             workspace
                 .read(cx)
-                .is_ok_and(|workspace| workspace.project.read(cx).is_local_or_ssh())
+                .is_ok_and(|workspace| workspace.project.read(cx).is_local())
         })
         .collect()
 }
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index 8f4f1af24331c0..c631c01f99a1a6 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -230,7 +230,7 @@ pub fn initialize_workspace(
 
         let project = workspace.project().clone();
         if project.update(cx, |project, cx| {
-            project.is_local_or_ssh() || project.ssh_connection_string(cx).is_some()
+            project.is_local() || project.is_via_ssh() || project.ssh_connection_string(cx).is_some()
         }) {
             project.update(cx, |project, cx| {
                 let fs = app_state.fs.clone();

From 9a8601227d99ad7a8b123a1470a89615919ca43e Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 24 Sep 2024 22:23:32 +0000
Subject: [PATCH 313/762] docs: Add example of TOML/taplo LSP settings (#18293)

---
 docs/src/languages/toml.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/docs/src/languages/toml.md b/docs/src/languages/toml.md
index a4aa8436ff0893..3f33925a281b69 100644
--- a/docs/src/languages/toml.md
+++ b/docs/src/languages/toml.md
@@ -18,3 +18,15 @@ include = ["Cargo.toml", "some_directory/**/*.toml"]
 align_entries = true
 reorder_keys = true
 ```
+
+Alternatively, you can pass taplo configuration options via [Zed LSP Settings](../configuring-zed.md#lsp)
+
+```json
+  "lsp": {
+    "taplo": {
+      "settings": {
+        "array_auto_collapse": false
+      }
+    }
+  }
+```

From e9bc9ed5d568997026f3ef0d015cc75880e1b5fd Mon Sep 17 00:00:00 2001
From: CharlesChen0823 <yongchen0823@gmail.com>
Date: Wed, 25 Sep 2024 16:00:17 +0800
Subject: [PATCH 314/762] remote_server: Fix opening a new remote project not
 refreshing the project panel (#18262)

Currently, when open new remote project, project_panel not refresh, we
must `ctrl-p` and select an file to refresh the project_panel. After
that, project_panel will refresh when remote project window active.

Release Notes:

- Fixed remote projects not restoring previous locations and not
refreshing the project panel on open.
---
 crates/workspace/src/workspace.rs | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 4290e12105a3c7..c7ba4ae3faa894 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -5607,6 +5607,9 @@ pub fn join_dev_server_project(
             })
         });
 
+        let serialized_workspace: Option<SerializedWorkspace> =
+            persistence::DB.workspace_for_dev_server_project(dev_server_project_id);
+
         let workspace = if let Some(existing_workspace) = existing_workspace {
             existing_workspace
         } else {
@@ -5620,10 +5623,7 @@ pub fn join_dev_server_project(
             )
             .await?;
 
-            let serialized_workspace: Option<SerializedWorkspace> =
-                persistence::DB.workspace_for_dev_server_project(dev_server_project_id);
-
-            let workspace_id = if let Some(serialized_workspace) = serialized_workspace {
+            let workspace_id = if let Some(ref serialized_workspace) = serialized_workspace {
                 serialized_workspace.id
             } else {
                 persistence::DB.next_id().await?
@@ -5650,10 +5650,13 @@ pub fn join_dev_server_project(
             }
         };
 
-        workspace.update(&mut cx, |_, cx| {
-            cx.activate(true);
-            cx.activate_window();
-        })?;
+        workspace
+            .update(&mut cx, |_, cx| {
+                cx.activate(true);
+                cx.activate_window();
+                open_items(serialized_workspace, vec![], app_state, cx)
+            })?
+            .await?;
 
         anyhow::Ok(workspace)
     })

From fc9db97ac73e56288077b486e1d3d3618d5ee80e Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 25 Sep 2024 10:02:35 +0200
Subject: [PATCH 315/762] client: Remove unused `fs` dependency (#18324)

CI bot notified me about that in
https://github.com/zed-industries/zed/pull/18323


Release Notes:

- N/A
---
 Cargo.lock               | 1 -
 crates/client/Cargo.toml | 1 -
 2 files changed, 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9c6d2fb7b9b842..f1bc684401cb99 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2409,7 +2409,6 @@ dependencies = [
  "cocoa 0.26.0",
  "collections",
  "feature_flags",
- "fs",
  "futures 0.3.30",
  "gpui",
  "http_client",
diff --git a/crates/client/Cargo.toml b/crates/client/Cargo.toml
index 8ae4f15c9796b1..dd420bbbe63184 100644
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -23,7 +23,6 @@ chrono = { workspace = true, features = ["serde"] }
 clock.workspace = true
 collections.workspace = true
 feature_flags.workspace = true
-fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
 http_client.workspace = true

From eb71d2f1a8a606ac467e56c8d22e2d46818f87cf Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 25 Sep 2024 10:03:10 +0200
Subject: [PATCH 316/762] zig: Fix highlighting of keywords like `orelse`,
 `or`, `and` (#18323)

This changes the Zig highlights.scm to tag all keywords with `@keyword`
and not with `@keyword.<subtype>`, so the highlighting works properly.

Closes #9355

Release Notes:

- N/A

Demo:

![screenshot-2024-09-25-09 32
20@2x](https://github.com/user-attachments/assets/567b8817-a522-4741-af7f-dcb1a79ddd40)
---
 extensions/zig/languages/zig/highlights.scm | 78 +++++++--------------
 1 file changed, 24 insertions(+), 54 deletions(-)

diff --git a/extensions/zig/languages/zig/highlights.scm b/extensions/zig/languages/zig/highlights.scm
index 152a66b670b442..aea2d34addb822 100644
--- a/extensions/zig/languages/zig/highlights.scm
+++ b/extensions/zig/languages/zig/highlights.scm
@@ -103,6 +103,7 @@ field_constant: (IDENTIFIER) @constant
 (BlockLabel (IDENTIFIER) @tag)
 
 [
+  "fn"
   "asm"
   "defer"
   "errdefer"
@@ -112,84 +113,53 @@ field_constant: (IDENTIFIER) @constant
   "enum"
   "opaque"
   "error"
-] @keyword
-
-[
+  "try"
+  "catch"
+  "for"
+  "while"
+  "break"
+  "continue"
+  "const"
+  "var"
+  "volatile"
+  "allowzero"
+  "noalias"
+  "addrspace"
+  "align"
+  "callconv"
+  "linksection"
+  "comptime"
+  "export"
+  "extern"
+  "inline"
+  "noinline"
+  "packed"
+  "pub"
+  "threadlocal"
   "async"
   "await"
   "suspend"
   "nosuspend"
   "resume"
-] @keyword.coroutine
-
-[
-  "fn"
-] @keyword
-
-[
   "and"
   "or"
   "orelse"
-] @operator
-
-[
   "return"
-] @keyword.return
-
-[
   "if"
   "else"
   "switch"
-] @keyword.control
-
-[
-  "for"
-  "while"
-  "break"
-  "continue"
 ] @keyword
 
 [
   "usingnamespace"
 ] @constant
 
-[
-  "try"
-  "catch"
-] @keyword
-
 [
   "anytype"
   "anyframe"
   (BuildinTypeExpr)
 ] @type
 
-[
-  "const"
-  "var"
-  "volatile"
-  "allowzero"
-  "noalias"
-] @keyword
-
-[
-  "addrspace"
-  "align"
-  "callconv"
-  "linksection"
-] @keyword.storage
-
-[
-  "comptime"
-  "export"
-  "extern"
-  "inline"
-  "noinline"
-  "packed"
-  "pub"
-  "threadlocal"
-] @keyword
-
 [
   "null"
   "unreachable"

From 7bb510971a0cc59b89ed5ed51cbacbf29f365c06 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 25 Sep 2024 10:26:00 +0200
Subject: [PATCH 317/762] file picker: Use muted color for file icons (#18325)

I think they were too much in-your-face. Muted looks better.

Before:

![image](https://github.com/user-attachments/assets/73d6171a-6276-4450-acfb-52cd44fdfe59)

After:

![image](https://github.com/user-attachments/assets/1d5f4524-b0b9-4ba6-ab66-5eaf619e58f9)

Release Notes:

- N/A
---
 crates/file_finder/src/file_finder.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/file_finder/src/file_finder.rs b/crates/file_finder/src/file_finder.rs
index 726a8bcb5e6983..1a65bd352d61d7 100644
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -1070,7 +1070,9 @@ impl PickerDelegate for FileFinderDelegate {
             self.labels_for_match(path_match, cx, ix);
 
         let file_icon = if settings.file_icons {
-            FileIcons::get_icon(Path::new(&file_name), cx).map(Icon::from_path)
+            FileIcons::get_icon(Path::new(&file_name), cx)
+                .map(Icon::from_path)
+                .map(|icon| icon.color(Color::Muted))
         } else {
             None
         };

From 623a6eca75cb941ea7a368e133097605882efbb9 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Wed, 25 Sep 2024 11:34:27 +0200
Subject: [PATCH 318/762] git: Do not rescan .git on fsmonitor events (#18326)

Fixes #16404 by ignoring events coming from
.git/fsmonitor--daemon/cookies subdirectory.

Closes #16404

Release Notes:

- Improved performance in repositories using Git fsmonitor--daemon
feature.
---
 crates/git/src/git.rs           |  3 +++
 crates/worktree/src/worktree.rs | 27 +++++++++++++++++++++++++--
 2 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/crates/git/src/git.rs b/crates/git/src/git.rs
index 20629899e8c0cf..fb204fba8266ab 100644
--- a/crates/git/src/git.rs
+++ b/crates/git/src/git.rs
@@ -18,6 +18,9 @@ pub mod repository;
 pub mod status;
 
 pub static DOT_GIT: LazyLock<&'static OsStr> = LazyLock::new(|| OsStr::new(".git"));
+pub static COOKIES: LazyLock<&'static OsStr> = LazyLock::new(|| OsStr::new("cookies"));
+pub static FSMONITOR_DAEMON: LazyLock<&'static OsStr> =
+    LazyLock::new(|| OsStr::new("fsmonitor--daemon"));
 pub static GITIGNORE: LazyLock<&'static OsStr> = LazyLock::new(|| OsStr::new(".gitignore"));
 
 #[derive(Clone, Copy, Eq, Hash, PartialEq)]
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index d8555b71a4f67c..550843e51e448c 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -22,7 +22,7 @@ use fuzzy::CharBag;
 use git::{
     repository::{GitFileStatus, GitRepository, RepoPath},
     status::GitStatus,
-    DOT_GIT, GITIGNORE,
+    COOKIES, DOT_GIT, FSMONITOR_DAEMON, GITIGNORE,
 };
 use gpui::{
     AppContext, AsyncAppContext, BackgroundExecutor, Context, EventEmitter, Model, ModelContext,
@@ -3707,9 +3707,32 @@ impl BackgroundScanner {
             let snapshot = &self.state.lock().snapshot;
             {
                 let mut is_git_related = false;
+
+                // We don't want to trigger .git rescan for events within .git/fsmonitor--daemon/cookies directory.
+                #[derive(PartialEq)]
+                enum FsMonitorParseState {
+                    Cookies,
+                    FsMonitor
+                }
+                let mut fsmonitor_parse_state = None;
                 if let Some(dot_git_dir) = abs_path
                     .ancestors()
-                    .find(|ancestor| ancestor.file_name() == Some(*DOT_GIT))
+                    .find(|ancestor| {
+                        let file_name = ancestor.file_name();
+                        if file_name == Some(*COOKIES) {
+                            fsmonitor_parse_state = Some(FsMonitorParseState::Cookies);
+                            false
+                        } else if fsmonitor_parse_state == Some(FsMonitorParseState::Cookies) && file_name == Some(*FSMONITOR_DAEMON) {
+                            fsmonitor_parse_state = Some(FsMonitorParseState::FsMonitor);
+                            false
+                        } else if fsmonitor_parse_state != Some(FsMonitorParseState::FsMonitor) && file_name == Some(*DOT_GIT) {
+                            true
+                        } else {
+                            fsmonitor_parse_state.take();
+                            false
+                        }
+
+                    })
                 {
                     let dot_git_path = dot_git_dir
                         .strip_prefix(&root_canonical_path)

From 9d197ddc99b3b6e4c85f481cc45b0d33c170a494 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 25 Sep 2024 12:03:24 +0200
Subject: [PATCH 319/762] ssh remoting: Fix SSH connection not being closed
 (#18329)

This fixes the `SshSession` being leaked.

There were two leaks:

1. `Arc<SshSession>` itself got leaked into the `SettingsObserver` that
   lives as long as the application. Fixed with a weak reference.
2. The two tasks spawned by an `SshSession` had a circular dependency
   and didn't exit while the other one was running. Fixed by fixing (1)
   and then attaching one of the tasks to the `SshSession`, which means
   it gets dropped with the session itself, which leads the other task
   to error and exit.

Co-authored-by: Bennet <bennet@zed.dev>

Release Notes:

- N/A

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/project/src/project_settings.rs        | 13 +++++---
 crates/recent_projects/src/recent_projects.rs |  2 +-
 crates/remote/src/ssh_session.rs              | 31 ++++++++++++++-----
 crates/rpc/src/proto_client.rs                | 20 +++++++++++-
 crates/worktree/src/worktree.rs               |  2 +-
 5 files changed, 53 insertions(+), 15 deletions(-)

diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index d6f5600a551ef4..68593f8fab0525 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -334,17 +334,20 @@ impl SettingsObserver {
             .log_err();
         }
 
+        let weak_client = ssh.downgrade();
         cx.observe_global::<SettingsStore>(move |_, cx| {
             let new_settings = cx.global::<SettingsStore>().raw_user_settings();
             if &settings != new_settings {
                 settings = new_settings.clone()
             }
             if let Some(content) = serde_json::to_string(&settings).log_err() {
-                ssh.send(proto::UpdateUserSettings {
-                    project_id: 0,
-                    content,
-                })
-                .log_err();
+                if let Some(ssh) = weak_client.upgrade() {
+                    ssh.send(proto::UpdateUserSettings {
+                        project_id: 0,
+                        content,
+                    })
+                    .log_err();
+                }
             }
         })
         .detach();
diff --git a/crates/recent_projects/src/recent_projects.rs b/crates/recent_projects/src/recent_projects.rs
index 20393d63e1a3df..570e9a565c28e6 100644
--- a/crates/recent_projects/src/recent_projects.rs
+++ b/crates/recent_projects/src/recent_projects.rs
@@ -509,7 +509,7 @@ impl PickerDelegate for RecentProjectsDelegate {
                                         .color(Color::Muted)
                                         .into_any_element()
                                 }
-                                SerializedWorkspaceLocation::Ssh(_) => Icon::new(IconName::Screen)
+                                SerializedWorkspaceLocation::Ssh(_) => Icon::new(IconName::Server)
                                     .color(Color::Muted)
                                     .into_any_element(),
                                 SerializedWorkspaceLocation::DevServer(_) => {
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 2bd18aa37e19d1..9d9d916f19b458 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -11,7 +11,7 @@ use futures::{
     future::BoxFuture,
     select_biased, AsyncReadExt as _, AsyncWriteExt as _, Future, FutureExt as _, StreamExt as _,
 };
-use gpui::{AppContext, AsyncAppContext, Model, SemanticVersion};
+use gpui::{AppContext, AsyncAppContext, Model, SemanticVersion, Task};
 use parking_lot::Mutex;
 use rpc::{
     proto::{self, build_typed_envelope, Envelope, EnvelopedMessage, PeerId, RequestMessage},
@@ -51,6 +51,7 @@ pub struct SshSession {
     spawn_process_tx: mpsc::UnboundedSender<SpawnRequest>,
     client_socket: Option<SshSocket>,
     state: Mutex<ProtoMessageHandlerSet>, // Lock
+    _io_task: Option<Task<Result<()>>>,
 }
 
 struct SshClientState {
@@ -173,8 +174,7 @@ impl SshSession {
         let mut child_stdout = remote_server_child.stdout.take().unwrap();
         let mut child_stdin = remote_server_child.stdin.take().unwrap();
 
-        let executor = cx.background_executor().clone();
-        executor.clone().spawn(async move {
+        let io_task = cx.background_executor().spawn(async move {
             let mut stdin_buffer = Vec::new();
             let mut stdout_buffer = Vec::new();
             let mut stderr_buffer = Vec::new();
@@ -264,9 +264,18 @@ impl SshSession {
                     }
                 }
             }
-        }).detach();
+        });
 
-        cx.update(|cx| Self::new(incoming_rx, outgoing_tx, spawn_process_tx, Some(socket), cx))
+        cx.update(|cx| {
+            Self::new(
+                incoming_rx,
+                outgoing_tx,
+                spawn_process_tx,
+                Some(socket),
+                Some(io_task),
+                cx,
+            )
+        })
     }
 
     pub fn server(
@@ -275,7 +284,7 @@ impl SshSession {
         cx: &AppContext,
     ) -> Arc<SshSession> {
         let (tx, _rx) = mpsc::unbounded();
-        Self::new(incoming_rx, outgoing_tx, tx, None, cx)
+        Self::new(incoming_rx, outgoing_tx, tx, None, None, cx)
     }
 
     #[cfg(any(test, feature = "test-support"))]
@@ -293,6 +302,7 @@ impl SshSession {
                     client_to_server_tx,
                     tx.clone(),
                     None, // todo()
+                    None,
                     cx,
                 )
             }),
@@ -302,6 +312,7 @@ impl SshSession {
                     server_to_client_tx,
                     tx.clone(),
                     None,
+                    None,
                     cx,
                 )
             }),
@@ -313,6 +324,7 @@ impl SshSession {
         outgoing_tx: mpsc::UnboundedSender<Envelope>,
         spawn_process_tx: mpsc::UnboundedSender<SpawnRequest>,
         client_socket: Option<SshSocket>,
+        io_task: Option<Task<Result<()>>>,
         cx: &AppContext,
     ) -> Arc<SshSession> {
         let this = Arc::new(Self {
@@ -322,13 +334,18 @@ impl SshSession {
             spawn_process_tx,
             client_socket,
             state: Default::default(),
+            _io_task: io_task,
         });
 
         cx.spawn(|cx| {
-            let this = this.clone();
+            let this = Arc::downgrade(&this);
             async move {
                 let peer_id = PeerId { owner_id: 0, id: 0 };
                 while let Some(incoming) = incoming_rx.next().await {
+                    let Some(this) = this.upgrade() else {
+                        return anyhow::Ok(());
+                    };
+
                     if let Some(request_id) = incoming.responding_to {
                         let request_id = MessageId(request_id);
                         let sender = this.response_channels.lock().remove(&request_id);
diff --git a/crates/rpc/src/proto_client.rs b/crates/rpc/src/proto_client.rs
index 88099102765ed7..56b13688bad2b6 100644
--- a/crates/rpc/src/proto_client.rs
+++ b/crates/rpc/src/proto_client.rs
@@ -10,11 +10,29 @@ use proto::{
     error::ErrorExt as _, AnyTypedEnvelope, EntityMessage, Envelope, EnvelopedMessage,
     RequestMessage, TypedEnvelope,
 };
-use std::{any::TypeId, sync::Arc};
+use std::{
+    any::TypeId,
+    sync::{Arc, Weak},
+};
 
 #[derive(Clone)]
 pub struct AnyProtoClient(Arc<dyn ProtoClient>);
 
+impl AnyProtoClient {
+    pub fn downgrade(&self) -> AnyWeakProtoClient {
+        AnyWeakProtoClient(Arc::downgrade(&self.0))
+    }
+}
+
+#[derive(Clone)]
+pub struct AnyWeakProtoClient(Weak<dyn ProtoClient>);
+
+impl AnyWeakProtoClient {
+    pub fn upgrade(&self) -> Option<AnyProtoClient> {
+        self.0.upgrade().map(AnyProtoClient)
+    }
+}
+
 pub trait ProtoClient: Send + Sync {
     fn request(
         &self,
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index 550843e51e448c..f91a832b80d783 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -472,7 +472,7 @@ impl Worktree {
                 disconnected: false,
             };
 
-            // Apply updates to a separate snapshto in a background task, then
+            // Apply updates to a separate snapshot in a background task, then
             // send them to a foreground task which updates the model.
             cx.background_executor()
                 .spawn(async move {

From a6cb17fb51bd3dca2a8c68bacfc8384234c10105 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Wed, 25 Sep 2024 12:27:57 +0200
Subject: [PATCH 320/762] chore: Fix violations of `elided_named_lifetimes`
 (#18330)

I compile Zed from nightly build pretty often and I've noticed that
we're getting a few hits on new rustc lint:
https://github.com/rust-lang/rust/pull/129207

Release Notes:

- N/A
---
 crates/editor/src/display_map/crease_map.rs | 2 +-
 crates/editor/src/editor.rs                 | 2 +-
 crates/language/src/syntax_map.rs           | 6 +++---
 crates/project/src/project.rs               | 2 +-
 crates/sum_tree/src/sum_tree.rs             | 4 ++--
 crates/sum_tree/src/tree_map.rs             | 2 +-
 crates/workspace/src/workspace.rs           | 2 +-
 7 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/crates/editor/src/display_map/crease_map.rs b/crates/editor/src/display_map/crease_map.rs
index bfc9c7d1a4ffbf..c3f2b0061ac732 100644
--- a/crates/editor/src/display_map/crease_map.rs
+++ b/crates/editor/src/display_map/crease_map.rs
@@ -69,7 +69,7 @@ impl CreaseSnapshot {
         &'a self,
         range: Range<MultiBufferRow>,
         snapshot: &'a MultiBufferSnapshot,
-    ) -> impl '_ + Iterator<Item = &'a Crease> {
+    ) -> impl 'a + Iterator<Item = &'a Crease> {
         let start = snapshot.anchor_before(Point::new(range.start.0, 0));
         let mut cursor = self.creases.cursor::<ItemSummary>(snapshot);
         cursor.seek(&start, Bias::Left, snapshot);
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index b54889dc0d8c26..ad5cd24d73ac46 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -11515,7 +11515,7 @@ impl Editor {
         &'a self,
         position: Anchor,
         buffer: &'a MultiBufferSnapshot,
-    ) -> impl 'a + Iterator<Item = &Range<Anchor>> {
+    ) -> impl 'a + Iterator<Item = &'a Range<Anchor>> {
         let read_highlights = self
             .background_highlights
             .get(&TypeId::of::<DocumentHighlightRead>())
diff --git a/crates/language/src/syntax_map.rs b/crates/language/src/syntax_map.rs
index daae54fb4da62a..55177f79620db7 100644
--- a/crates/language/src/syntax_map.rs
+++ b/crates/language/src/syntax_map.rs
@@ -794,7 +794,7 @@ impl SyntaxSnapshot {
         range: Range<usize>,
         buffer: &'a BufferSnapshot,
         query: fn(&Grammar) -> Option<&Query>,
-    ) -> SyntaxMapCaptures {
+    ) -> SyntaxMapCaptures<'a> {
         SyntaxMapCaptures::new(
             range.clone(),
             buffer.as_rope(),
@@ -808,7 +808,7 @@ impl SyntaxSnapshot {
         range: Range<usize>,
         buffer: &'a BufferSnapshot,
         query: fn(&Grammar) -> Option<&Query>,
-    ) -> SyntaxMapMatches {
+    ) -> SyntaxMapMatches<'a> {
         SyntaxMapMatches::new(
             range.clone(),
             buffer.as_rope(),
@@ -828,7 +828,7 @@ impl SyntaxSnapshot {
         range: Range<T>,
         buffer: &'a BufferSnapshot,
         include_hidden: bool,
-    ) -> impl 'a + Iterator<Item = SyntaxLayer> {
+    ) -> impl 'a + Iterator<Item = SyntaxLayer<'a>> {
         let start_offset = range.start.to_offset(buffer);
         let end_offset = range.end.to_offset(buffer);
         let start = buffer.anchor_before(start_offset);
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 5a9b235d91cdbf..ee7f93a4f933c2 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -3954,7 +3954,7 @@ impl Project {
     pub fn supplementary_language_servers<'a>(
         &'a self,
         cx: &'a AppContext,
-    ) -> impl '_ + Iterator<Item = (LanguageServerId, LanguageServerName)> {
+    ) -> impl 'a + Iterator<Item = (LanguageServerId, LanguageServerName)> {
         self.lsp_store.read(cx).supplementary_language_servers()
     }
 
diff --git a/crates/sum_tree/src/sum_tree.rs b/crates/sum_tree/src/sum_tree.rs
index 965413d3190aa2..7013dc66fd1ed7 100644
--- a/crates/sum_tree/src/sum_tree.rs
+++ b/crates/sum_tree/src/sum_tree.rs
@@ -345,7 +345,7 @@ impl<T: Item> SumTree<T> {
         Iter::new(self)
     }
 
-    pub fn cursor<'a, S>(&'a self, cx: &<T::Summary as Summary>::Context) -> Cursor<T, S>
+    pub fn cursor<'a, S>(&'a self, cx: &<T::Summary as Summary>::Context) -> Cursor<'a, T, S>
     where
         S: Dimension<'a, T::Summary>,
     {
@@ -358,7 +358,7 @@ impl<T: Item> SumTree<T> {
         &'a self,
         cx: &<T::Summary as Summary>::Context,
         filter_node: F,
-    ) -> FilterCursor<F, T, U>
+    ) -> FilterCursor<'a, F, T, U>
     where
         F: FnMut(&T::Summary) -> bool,
         U: Dimension<'a, T::Summary>,
diff --git a/crates/sum_tree/src/tree_map.rs b/crates/sum_tree/src/tree_map.rs
index b7eadb566d3ed7..c57226b681432a 100644
--- a/crates/sum_tree/src/tree_map.rs
+++ b/crates/sum_tree/src/tree_map.rs
@@ -105,7 +105,7 @@ impl<K: Clone + Ord, V: Clone> TreeMap<K, V> {
         cursor.item().map(|item| (&item.key, &item.value))
     }
 
-    pub fn iter_from<'a>(&'a self, from: &'a K) -> impl Iterator<Item = (&K, &V)> + '_ {
+    pub fn iter_from<'a>(&'a self, from: &'a 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, &());
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index c7ba4ae3faa894..4d656294703d42 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -2119,7 +2119,7 @@ impl Workspace {
     pub fn items<'a>(
         &'a self,
         cx: &'a AppContext,
-    ) -> impl 'a + Iterator<Item = &Box<dyn ItemHandle>> {
+    ) -> impl 'a + Iterator<Item = &'a Box<dyn ItemHandle>> {
         self.panes.iter().flat_map(|pane| pane.read(cx).items())
     }
 

From 300bf87f77d3ae4eea93affc088b7f6b4979a277 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 25 Sep 2024 12:45:53 +0200
Subject: [PATCH 321/762] ssh remoting: Kill SSH master process when dropping
 client (#18331)

This was a process leak. Since we use `.spawn()`, the process continued
to run in the background, even if our `SshClientState` was dropped.

Means we need to manually clean it up.

Release Notes:

- N/A

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/remote/src/ssh_session.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 9d9d916f19b458..06a7f810e67210 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -56,7 +56,7 @@ pub struct SshSession {
 
 struct SshClientState {
     socket: SshSocket,
-    _master_process: process::Child,
+    master_process: process::Child,
     _temp_dir: TempDir,
 }
 
@@ -593,7 +593,7 @@ impl SshClientState {
                 connection_options,
                 socket_path,
             },
-            _master_process: master_process,
+            master_process,
             _temp_dir: temp_dir,
         })
     }
@@ -716,6 +716,14 @@ impl SshClientState {
     }
 }
 
+impl Drop for SshClientState {
+    fn drop(&mut self) {
+        if let Err(error) = self.master_process.kill() {
+            log::error!("failed to kill SSH master process: {}", error);
+        }
+    }
+}
+
 impl SshSocket {
     fn ssh_command<S: AsRef<OsStr>>(&self, program: S) -> process::Command {
         let mut command = process::Command::new("ssh");

From 4e2ae06ca6c467e5ff50600bb85cf7452d46ee92 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 25 Sep 2024 12:59:22 +0200
Subject: [PATCH 322/762] recent project: Fix highlighting for matches in SSH
 projs (#18332)

Release Notes:

- N/A

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/recent_projects/src/recent_projects.rs | 26 +++++--------------
 1 file changed, 7 insertions(+), 19 deletions(-)

diff --git a/crates/recent_projects/src/recent_projects.rs b/crates/recent_projects/src/recent_projects.rs
index 570e9a565c28e6..f73e7069d48a94 100644
--- a/crates/recent_projects/src/recent_projects.rs
+++ b/crates/recent_projects/src/recent_projects.rs
@@ -259,23 +259,12 @@ impl PickerDelegate for RecentProjectsDelegate {
                             dev_server_project.paths.join("")
                         )
                     }
-                    SerializedWorkspaceLocation::Ssh(ssh_project) => {
-                        format!(
-                            "{}{}{}{}",
-                            ssh_project.host,
-                            ssh_project
-                                .port
-                                .as_ref()
-                                .map(|port| port.to_string())
-                                .unwrap_or_default(),
-                            ssh_project.paths.join(","),
-                            ssh_project
-                                .user
-                                .as_ref()
-                                .map(|user| user.to_string())
-                                .unwrap_or_default()
-                        )
-                    }
+                    SerializedWorkspaceLocation::Ssh(ssh_project) => ssh_project
+                        .ssh_urls()
+                        .iter()
+                        .map(|path| path.to_string_lossy().to_string())
+                        .collect::<Vec<_>>()
+                        .join(""),
                 };
 
                 StringMatchCandidate::new(id, combined_string)
@@ -458,6 +447,7 @@ impl PickerDelegate for RecentProjectsDelegate {
                     .order()
                     .iter()
                     .filter_map(|i| paths.paths().get(*i).cloned())
+                    .map(|path| path.compact())
                     .collect(),
             ),
             SerializedWorkspaceLocation::Ssh(ssh_project) => Arc::new(ssh_project.ssh_urls()),
@@ -473,7 +463,6 @@ impl PickerDelegate for RecentProjectsDelegate {
         let (match_labels, paths): (Vec<_>, Vec<_>) = paths
             .iter()
             .map(|path| {
-                let path = path.compact();
                 let highlighted_text =
                     highlights_for_path(path.as_ref(), &hit.positions, path_start_offset);
 
@@ -704,7 +693,6 @@ fn highlights_for_path(
         },
     )
 }
-
 impl RecentProjectsDelegate {
     fn delete_recent_project(&self, ix: usize, cx: &mut ViewContext<Picker<Self>>) {
         if let Some(selected_match) = self.matches.get(ix) {

From ccc871c44c3085eef65bf4bcc3603b938691e557 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 25 Sep 2024 13:41:18 +0200
Subject: [PATCH 323/762] ssh remoting: Expand tilde on host side (#18333)

---
 crates/project/src/worktree_store.rs          | 5 +++--
 crates/recent_projects/src/ssh_connections.rs | 9 ++++++++-
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 9f25572fc7ec08..4b1764c3a87fa1 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -221,10 +221,11 @@ impl WorktreeStore {
     ) -> Task<Result<Model<Worktree>, Arc<anyhow::Error>>> {
         let mut abs_path = abs_path.as_ref().to_string_lossy().to_string();
         // If we start with `/~` that means the ssh path was something like `ssh://user@host/~/home-dir-folder/`
-        // in which case want to strip the leading the `/` and expand the tilde.
+        // in which case want to strip the leading the `/`.
+        // On the host-side, the `~` will get expanded.
         // That's what git does too: https://github.com/libgit2/libgit2/issues/3345#issuecomment-127050850
         if abs_path.starts_with("/~") {
-            abs_path = shellexpand::tilde(&abs_path[1..]).to_string();
+            abs_path = abs_path[1..].to_string();
         }
         let root_name = PathBuf::from(abs_path.clone())
             .file_name()
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index ad23a5c8963b4e..1722c58f075399 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -327,7 +327,14 @@ impl SshClientDelegate {
             cx,
         )
         .await
-        .map_err(|e| anyhow::anyhow!("failed to download remote server binary: {}", e))?;
+        .map_err(|e| {
+            anyhow::anyhow!(
+                "failed to download remote server binary (os: {}, arch: {}): {}",
+                platform.os,
+                platform.arch,
+                e
+            )
+        })?;
 
         Ok((binary_path, version))
     }

From 59dc3985a1afa338720912734972f600178a8a85 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 25 Sep 2024 11:41:35 +0000
Subject: [PATCH 324/762] Detect txt files as Plain Text (#18334)

---
 assets/settings/default.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 3e8d3c8c70dd7d..61239b002bedcb 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -762,6 +762,7 @@
   // }
   //
   "file_types": {
+    "Plain Text": ["txt"],
     "JSON": ["flake.lock"],
     "JSONC": [
       "**/.zed/**/*.json",

From 500c3c54a64df3b119e1bd8b0a63822f45d2f4c9 Mon Sep 17 00:00:00 2001
From: Joseph T Lyons <JosephTLyons@gmail.com>
Date: Wed, 25 Sep 2024 11:02:40 -0400
Subject: [PATCH 325/762] v0.156.x dev

---
 Cargo.lock            | 2 +-
 crates/zed/Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f1bc684401cb99..41b2d6d452af53 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14388,7 +14388,7 @@ dependencies = [
 
 [[package]]
 name = "zed"
-version = "0.155.0"
+version = "0.156.0"
 dependencies = [
  "activity_indicator",
  "anyhow",
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index 65724480f62334..eb8f45d92e476d 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -2,7 +2,7 @@
 description = "The fast, collaborative code editor."
 edition = "2021"
 name = "zed"
-version = "0.155.0"
+version = "0.156.0"
 publish = false
 license = "GPL-3.0-or-later"
 authors = ["Zed Team <hi@zed.dev>"]

From bbf5ed2ba158b5a3cf36d4cb83df4ec471728248 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 25 Sep 2024 09:42:07 -0600
Subject: [PATCH 326/762] Fix collab filtering panics better (#18344)

Release Notes:

- N/A
---
 crates/collab/src/api/events.rs | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index 1632c2d798ef15..377741f434c2f8 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -364,21 +364,19 @@ pub async fn post_panic(
 }
 
 fn report_to_slack(panic: &Panic) -> bool {
-    if panic.os_name == "Linux" {
-        if panic.payload.contains("ERROR_SURFACE_LOST_KHR") {
-            return false;
-        }
+    if panic.payload.contains("ERROR_SURFACE_LOST_KHR") {
+        return false;
+    }
 
-        if panic.payload.contains("ERROR_INITIALIZATION_FAILED") {
-            return false;
-        }
+    if panic.payload.contains("ERROR_INITIALIZATION_FAILED") {
+        return false;
+    }
 
-        if panic
-            .payload
-            .contains("GPU has crashed, and no debug information is available")
-        {
-            return false;
-        }
+    if panic
+        .payload
+        .contains("GPU has crashed, and no debug information is available")
+    {
+        return false;
     }
 
     true

From 9300dbc83494d2dbcadd9dcd4373a30bfe53a6e4 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Wed, 25 Sep 2024 12:04:17 -0400
Subject: [PATCH 327/762] Fix typo (#18345)

Release Notes:

- N/A
---
 crates/vim/src/command.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/vim/src/command.rs b/crates/vim/src/command.rs
index 67a674afa6f127..49e739faadfeaf 100644
--- a/crates/vim/src/command.rs
+++ b/crates/vim/src/command.rs
@@ -757,7 +757,7 @@ mod test {
 
         cx.simulate_shared_keystrokes(": j enter").await;
 
-        // hack: our cursor positionining after a join command is wrong
+        // hack: our cursor positioning after a join command is wrong
         cx.simulate_shared_keystrokes("^").await;
         cx.shared_state().await.assert_eq(indoc! {
             "ˇa b

From 19162c316083890f999ef6d33e877856a4235df6 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 25 Sep 2024 18:08:34 +0200
Subject: [PATCH 328/762] ssh remoting: Show error message if project path does
 not exist (#18343)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This now shows an error message if you try open a project over SSH that
doesn't exist. If it's a possible file-path though, it acts like Zed's
`cli` and opens the file so that it can be created.

- Works: `cargo run ssh://127.0.0.1/~/folder-exists/file-does-not-exist`
— this will open `file-does-not-exist`
- Shows error: `cargo run
ssh://127.0.0.1/~/folder-does-not-exist/file-does-not-exist` — this will
show an error

Release Notes:

- N/A

Co-authored-by: Bennet <bennet@zed.dev>
Co-authored-by: Conrad <conrad@zed.dev>
---
 crates/project/src/worktree_store.rs         |  4 +--
 crates/remote_server/Cargo.toml              |  1 +
 crates/remote_server/src/headless_project.rs | 25 ++++++++++++++-
 crates/workspace/src/workspace.rs            | 33 +++++++++++++++-----
 4 files changed, 53 insertions(+), 10 deletions(-)

diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 4b1764c3a87fa1..e445eab2dd6392 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -18,7 +18,7 @@ use gpui::{
 use postage::oneshot;
 use rpc::{
     proto::{self, SSH_PROJECT_ID},
-    AnyProtoClient, TypedEnvelope,
+    AnyProtoClient, ErrorExt, TypedEnvelope,
 };
 use smol::{
     channel::{Receiver, Sender},
@@ -207,7 +207,7 @@ impl WorktreeStore {
         cx.background_executor().spawn(async move {
             match task.await {
                 Ok(worktree) => Ok(worktree),
-                Err(err) => Err(anyhow!("{}", err)),
+                Err(err) => Err((*err).cloned()),
             }
         })
     }
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index ed12b41167cc23..64db2616e9b2f8 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -22,6 +22,7 @@ test-support = ["fs/test-support"]
 
 [dependencies]
 anyhow.workspace = true
+client.workspace = true
 env_logger.workspace = true
 fs.workspace = true
 futures.workspace = true
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 0af0d6bb1570dd..84fb22b282d37d 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -189,11 +189,34 @@ impl HeadlessProject {
         message: TypedEnvelope<proto::AddWorktree>,
         mut cx: AsyncAppContext,
     ) -> Result<proto::AddWorktreeResponse> {
+        use client::ErrorCodeExt;
         let path = shellexpand::tilde(&message.payload.path).to_string();
+
+        let fs = this.read_with(&mut cx, |this, _| this.fs.clone())?;
+        let path = PathBuf::from(path);
+
+        let canonicalized = match fs.canonicalize(&path).await {
+            Ok(path) => path,
+            Err(e) => {
+                let mut parent = path
+                    .parent()
+                    .ok_or(e)
+                    .map_err(|_| anyhow!("{:?} does not exist", path))?;
+                if parent == Path::new("") {
+                    parent = util::paths::home_dir();
+                }
+                let parent = fs.canonicalize(parent).await.map_err(|_| {
+                    anyhow!(proto::ErrorCode::DevServerProjectPathDoesNotExist
+                        .with_tag("path", &path.to_string_lossy().as_ref()))
+                })?;
+                parent.join(path.file_name().unwrap())
+            }
+        };
+
         let worktree = this
             .update(&mut cx.clone(), |this, _| {
                 Worktree::local(
-                    Path::new(&path),
+                    Arc::from(canonicalized),
                     true,
                     this.fs.clone(),
                     this.next_entry_id.clone(),
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 4d656294703d42..cec913851f04df 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -5544,12 +5544,21 @@ pub fn open_ssh_project(
             )
         })?;
 
+        let mut project_paths_to_open = vec![];
+        let mut project_path_errors = vec![];
+
         for path in paths {
-            project
-                .update(&mut cx, |project, cx| {
-                    project.find_or_create_worktree(&path, true, cx)
-                })?
-                .await?;
+            let result = cx
+                .update(|cx| Workspace::project_path_for_path(project.clone(), &path, true, cx))?
+                .await;
+            match result {
+                Ok((_, project_path)) => {
+                    project_paths_to_open.push((path.clone(), Some(project_path)));
+                }
+                Err(error) => {
+                    project_path_errors.push(error);
+                }
+            };
         }
 
         let serialized_workspace =
@@ -5576,11 +5585,21 @@ pub fn open_ssh_project(
             .update(&mut cx, |_, cx| {
                 cx.activate_window();
 
-                open_items(serialized_workspace, vec![], app_state, cx)
+                open_items(serialized_workspace, project_paths_to_open, app_state, cx)
             })?
             .await?;
 
-        Ok(())
+        window.update(&mut cx, |workspace, cx| {
+            for error in project_path_errors {
+                if error.error_code() == proto::ErrorCode::DevServerProjectPathDoesNotExist {
+                    if let Some(path) = error.error_tag("path") {
+                        workspace.show_error(&anyhow!("'{path}' does not exist"), cx)
+                    }
+                } else {
+                    workspace.show_error(&error, cx)
+                }
+            }
+        })
     })
 }
 

From 1f54fde4d2338730eecd46501688b8e777c7bb5c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8B=90=E7=8B=B8?=
 <134658521+Huliiiiii@users.noreply.github.com>
Date: Thu, 26 Sep 2024 01:29:02 +0800
Subject: [PATCH 329/762] toml: Add highlight for escape sequences (#18346)

---
 extensions/toml/languages/toml/highlights.scm | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/extensions/toml/languages/toml/highlights.scm b/extensions/toml/languages/toml/highlights.scm
index 04d83b545925d7..4be265cce74b3d 100644
--- a/extensions/toml/languages/toml/highlights.scm
+++ b/extensions/toml/languages/toml/highlights.scm
@@ -9,9 +9,10 @@
 
 (boolean) @constant
 (comment) @comment
-(string) @string
 (integer) @number
 (float) @number
+(string) @string
+(escape_sequence) @string.escape
 (offset_date_time) @string.special
 (local_date_time) @string.special
 (local_date) @string.special

From dc48af0ca1d5297fac94c7d02bb858d564a6542b Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 25 Sep 2024 11:45:56 -0600
Subject: [PATCH 330/762] lsp: Remove reinstall, update config (#18318)

Release Notes:

- Fixed overriding the path of a language server binary for all language
servers. `{"lsp":{"<lsp-name>":{"binary":{"path": "_"}}}}` will now work
for all language servers including those defined by extensions.
- (breaking change) To disable finding lsp adapters in your path, you
must now specify
`{"lsp":{"<lsp-name>":{"binary":{"ignore_system_version": true}}}}`.
Previously this was `{"lsp":{"<lsp-name>":{"binary":{"path_lookup":
false}}}}`. Note that this setting still does not apply to extensions.
- Removed automatic reinstallation of language servers. (It mostly
didn't work)

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 assets/settings/default.json                  |   2 +-
 .../src/activity_indicator.rs                 |   2 +-
 crates/extension/src/extension_lsp_adapter.rs |  15 +-
 crates/language/src/language.rs               |  73 +-
 crates/language/src/language_registry.rs      | 190 ++----
 crates/languages/src/c.rs                     |  54 +-
 crates/languages/src/css.rs                   |   7 -
 crates/languages/src/go.rs                    |  54 +-
 crates/languages/src/json.rs                  |  19 -
 crates/languages/src/python.rs                |   7 -
 crates/languages/src/rust.rs                  | 104 +--
 crates/languages/src/tailwind.rs              |  39 --
 crates/languages/src/typescript.rs            |  20 -
 crates/languages/src/vtsls.rs                 |  50 +-
 crates/languages/src/yaml.rs                  |  38 --
 crates/lsp/src/lsp.rs                         |   9 +
 crates/project/src/lsp_store.rs               | 628 ++++++++----------
 crates/project/src/project.rs                 |   8 -
 crates/project/src/project_settings.rs        |   4 +-
 crates/zed/src/main.rs                        |   2 +-
 docs/src/languages/rust.md                    |   4 +-
 21 files changed, 397 insertions(+), 932 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 61239b002bedcb..cf0de6a5e7f9aa 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -783,7 +783,7 @@
   /// or to ensure Zed always downloads and installs an isolated version of node:
   /// {
   ///   "node": {
-  ///     "disable_path_lookup": true
+  ///     "ignore_system_version": true,
   ///   }
   /// NOTE: changing this setting currently requires restarting Zed.
   "node": {},
diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs
index 52e6acc393d299..ace972bf877183 100644
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -299,7 +299,7 @@ impl ActivityIndicator {
                         .into_any_element(),
                 ),
                 message: format!(
-                    "Failed to download {}. Click to show error.",
+                    "Failed to run {}. Click to show error.",
                     failed
                         .iter()
                         .map(|name| name.0.as_ref())
diff --git a/crates/extension/src/extension_lsp_adapter.rs b/crates/extension/src/extension_lsp_adapter.rs
index d6125241f11a38..25179acec69ed0 100644
--- a/crates/extension/src/extension_lsp_adapter.rs
+++ b/crates/extension/src/extension_lsp_adapter.rs
@@ -10,16 +10,11 @@ use gpui::AsyncAppContext;
 use language::{
     CodeLabel, HighlightId, Language, LanguageServerName, LspAdapter, LspAdapterDelegate,
 };
-use lsp::{CodeActionKind, LanguageServerBinary};
+use lsp::{CodeActionKind, LanguageServerBinary, LanguageServerBinaryOptions};
 use serde::Serialize;
 use serde_json::Value;
 use std::ops::Range;
-use std::{
-    any::Any,
-    path::{Path, PathBuf},
-    pin::Pin,
-    sync::Arc,
-};
+use std::{any::Any, path::PathBuf, pin::Pin, sync::Arc};
 use util::{maybe, ResultExt};
 use wasmtime_wasi::WasiView as _;
 
@@ -38,8 +33,8 @@ impl LspAdapter for ExtensionLspAdapter {
 
     fn get_language_server_command<'a>(
         self: Arc<Self>,
-        _: Option<Arc<Path>>,
         delegate: Arc<dyn LspAdapterDelegate>,
+        _: LanguageServerBinaryOptions,
         _: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
         _: &'a mut AsyncAppContext,
     ) -> Pin<Box<dyn 'a + Future<Output = Result<LanguageServerBinary>>>> {
@@ -124,10 +119,6 @@ impl LspAdapter for ExtensionLspAdapter {
         unreachable!("get_language_server_command is overridden")
     }
 
-    async fn installation_test_binary(&self, _: PathBuf) -> Option<LanguageServerBinary> {
-        None
-    }
-
     fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
         let code_action_kinds = self
             .extension
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index d70650cf449356..4c75ef4eeb38da 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -29,7 +29,7 @@ use gpui::{AppContext, AsyncAppContext, Model, SharedString, Task};
 pub use highlight_map::HighlightMap;
 use http_client::HttpClient;
 pub use language_registry::LanguageName;
-use lsp::{CodeActionKind, LanguageServerBinary};
+use lsp::{CodeActionKind, LanguageServerBinary, LanguageServerBinaryOptions};
 use parking_lot::Mutex;
 use regex::Regex;
 use schemars::{
@@ -69,7 +69,7 @@ pub use buffer::*;
 pub use diagnostic_set::DiagnosticEntry;
 pub use language_registry::{
     AvailableLanguage, LanguageNotFound, LanguageQueries, LanguageRegistry,
-    LanguageServerBinaryStatus, PendingLanguageServer, QUERY_FILENAME_PREFIXES,
+    LanguageServerBinaryStatus, QUERY_FILENAME_PREFIXES,
 };
 pub use lsp::LanguageServerId;
 pub use outline::*;
@@ -249,28 +249,17 @@ impl CachedLspAdapter {
 
     pub async fn get_language_server_command(
         self: Arc<Self>,
-        container_dir: Option<Arc<Path>>,
         delegate: Arc<dyn LspAdapterDelegate>,
+        binary_options: LanguageServerBinaryOptions,
         cx: &mut AsyncAppContext,
     ) -> Result<LanguageServerBinary> {
         let cached_binary = self.cached_binary.lock().await;
         self.adapter
             .clone()
-            .get_language_server_command(container_dir, delegate, cached_binary, cx)
+            .get_language_server_command(delegate, binary_options, cached_binary, cx)
             .await
     }
 
-    pub fn can_be_reinstalled(&self) -> bool {
-        self.adapter.can_be_reinstalled()
-    }
-
-    pub async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        self.adapter.installation_test_binary(container_dir).await
-    }
-
     pub fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
         self.adapter.code_action_kinds()
     }
@@ -322,6 +311,7 @@ pub trait LspAdapterDelegate: Send + Sync {
     fn worktree_id(&self) -> WorktreeId;
     fn worktree_root_path(&self) -> &Path;
     fn update_status(&self, language: LanguageServerName, status: LanguageServerBinaryStatus);
+    async fn language_server_download_dir(&self, name: &LanguageServerName) -> Option<Arc<Path>>;
 
     async fn which(&self, command: &OsStr) -> Option<PathBuf>;
     async fn shell_env(&self) -> HashMap<String, String>;
@@ -335,8 +325,8 @@ pub trait LspAdapter: 'static + Send + Sync {
 
     fn get_language_server_command<'a>(
         self: Arc<Self>,
-        container_dir: Option<Arc<Path>>,
         delegate: Arc<dyn LspAdapterDelegate>,
+        binary_options: LanguageServerBinaryOptions,
         mut cached_binary: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
         cx: &'a mut AsyncAppContext,
     ) -> Pin<Box<dyn 'a + Future<Output = Result<LanguageServerBinary>>>> {
@@ -352,30 +342,30 @@ pub trait LspAdapter: 'static + Send + Sync {
             // We only want to cache when we fall back to the global one,
             // because we don't want to download and overwrite our global one
             // for each worktree we might have open.
-            if let Some(binary) = self.check_if_user_installed(delegate.as_ref(), cx).await {
-                log::info!(
-                    "found user-installed language server for {}. path: {:?}, arguments: {:?}",
-                    self.name().0,
-                    binary.path,
-                    binary.arguments
-                );
-                return Ok(binary);
+            if binary_options.allow_path_lookup {
+                if let Some(binary) = self.check_if_user_installed(delegate.as_ref(), cx).await {
+                    log::info!(
+                        "found user-installed language server for {}. path: {:?}, arguments: {:?}",
+                        self.name().0,
+                        binary.path,
+                        binary.arguments
+                    );
+                    return Ok(binary);
+                }
+            }
+
+            if !binary_options.allow_binary_download {
+                return Err(anyhow!("downloading language servers disabled"));
             }
 
             if let Some(cached_binary) = cached_binary.as_ref() {
                 return Ok(cached_binary.clone());
             }
 
-            let Some(container_dir) = container_dir else {
+            let Some(container_dir) = delegate.language_server_download_dir(&self.name()).await else {
                 anyhow::bail!("cannot download language servers for remotes (yet)")
             };
 
-            if !container_dir.exists() {
-                smol::fs::create_dir_all(&container_dir)
-                    .await
-                    .context("failed to create container directory")?;
-            }
-
             let mut binary = try_fetch_server_binary(self.as_ref(), &delegate, container_dir.to_path_buf(), cx).await;
 
             if let Err(error) = binary.as_ref() {
@@ -443,21 +433,6 @@ pub trait LspAdapter: 'static + Send + Sync {
         delegate: &dyn LspAdapterDelegate,
     ) -> Option<LanguageServerBinary>;
 
-    /// Returns `true` if a language server can be reinstalled.
-    ///
-    /// If language server initialization fails, a reinstallation will be attempted unless the value returned from this method is `false`.
-    ///
-    /// Implementations that rely on software already installed on user's system
-    /// should have [`can_be_reinstalled`](Self::can_be_reinstalled) return `false`.
-    fn can_be_reinstalled(&self) -> bool {
-        true
-    }
-
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary>;
-
     fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {}
 
     /// Post-processes completions provided by the language server.
@@ -1711,8 +1686,8 @@ impl LspAdapter for FakeLspAdapter {
 
     fn get_language_server_command<'a>(
         self: Arc<Self>,
-        _: Option<Arc<Path>>,
         _: Arc<dyn LspAdapterDelegate>,
+        _: LanguageServerBinaryOptions,
         _: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
         _: &'a mut AsyncAppContext,
     ) -> Pin<Box<dyn 'a + Future<Output = Result<LanguageServerBinary>>>> {
@@ -1743,10 +1718,6 @@ impl LspAdapter for FakeLspAdapter {
         unreachable!();
     }
 
-    async fn installation_test_binary(&self, _: PathBuf) -> Option<LanguageServerBinary> {
-        unreachable!();
-    }
-
     fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {}
 
     fn disk_based_diagnostic_sources(&self) -> Vec<String> {
diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index e264517d5b0300..880ae3b6115c37 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -4,18 +4,17 @@ use crate::{
     },
     task_context::ContextProvider,
     with_parser, CachedLspAdapter, File, Language, LanguageConfig, LanguageId, LanguageMatcher,
-    LanguageServerName, LspAdapter, LspAdapterDelegate, PLAIN_TEXT,
+    LanguageServerName, LspAdapter, PLAIN_TEXT,
 };
 use anyhow::{anyhow, Context, Result};
 use collections::{hash_map, HashMap, HashSet};
 
 use futures::{
     channel::{mpsc, oneshot},
-    future::Shared,
     Future,
 };
 use globset::GlobSet;
-use gpui::{AppContext, BackgroundExecutor, Task};
+use gpui::{AppContext, BackgroundExecutor};
 use lsp::LanguageServerId;
 use parking_lot::{Mutex, RwLock};
 use postage::watch;
@@ -118,12 +117,6 @@ pub enum LanguageServerBinaryStatus {
     Failed { error: String },
 }
 
-pub struct PendingLanguageServer {
-    pub server_id: LanguageServerId,
-    pub task: Task<Result<(lsp::LanguageServer, Option<serde_json::Value>)>>,
-    pub container_dir: Option<Arc<Path>>,
-}
-
 #[derive(Clone)]
 pub struct AvailableLanguage {
     id: LanguageId,
@@ -882,123 +875,53 @@ impl LanguageRegistry {
         self.lsp_binary_status_tx.send(server_name, status);
     }
 
-    #[allow(clippy::too_many_arguments)]
-    pub fn create_pending_language_server(
-        self: &Arc<Self>,
-        stderr_capture: Arc<Mutex<Option<String>>>,
-        _language_name_for_tests: LanguageName,
-        adapter: Arc<CachedLspAdapter>,
-        root_path: Arc<Path>,
-        delegate: Arc<dyn LspAdapterDelegate>,
-        project_environment: Shared<Task<Option<HashMap<String, String>>>>,
-        cx: &mut AppContext,
-    ) -> Option<PendingLanguageServer> {
-        let server_id = self.state.write().next_language_server_id();
-        log::info!(
-            "attempting to start language server {:?}, path: {root_path:?}, id: {server_id}",
-            adapter.name.0
-        );
+    pub fn next_language_server_id(&self) -> LanguageServerId {
+        self.state.write().next_language_server_id()
+    }
 
-        let container_dir: Option<Arc<Path>> = self
-            .language_server_download_dir
+    pub fn language_server_download_dir(&self, name: &LanguageServerName) -> Option<Arc<Path>> {
+        self.language_server_download_dir
             .as_ref()
-            .map(|dir| Arc::from(dir.join(adapter.name.0.as_ref())));
-        let root_path = root_path.clone();
-        let this = Arc::downgrade(self);
-
-        let task = cx.spawn({
-            let container_dir = container_dir.clone();
-            move |mut cx| async move {
-                let project_environment = project_environment.await;
-
-                let binary_result = adapter
-                    .clone()
-                    .get_language_server_command(container_dir, delegate.clone(), &mut cx)
-                    .await;
-
-                delegate.update_status(adapter.name.clone(), LanguageServerBinaryStatus::None);
-
-                let mut binary = binary_result?;
-
-                // If we do have a project environment (either by spawning a shell in in the project directory
-                // or by getting it from the CLI) and the language server command itself
-                // doesn't have an environment (which it would have, if it was found in $PATH), then
-                // we use the project environment.
-                if binary.env.is_none() && project_environment.is_some() {
-                    log::info!(
-                        "using project environment for language server {:?}, id: {server_id}",
-                        adapter.name.0
-                    );
-                    binary.env = project_environment.clone();
-                }
-
-                let options = adapter
-                    .adapter
-                    .clone()
-                    .initialization_options(&delegate)
-                    .await?;
+            .map(|dir| Arc::from(dir.join(name.0.as_ref())))
+    }
 
-                #[cfg(any(test, feature = "test-support"))]
-                if true {
-                    if let Some(this) = this.upgrade() {
-                        if let Some(fake_entry) = this
-                            .state
-                            .write()
-                            .fake_server_entries
-                            .get_mut(&adapter.name)
-                        {
-                            let (server, mut fake_server) = lsp::FakeLanguageServer::new(
-                                server_id,
-                                binary,
-                                adapter.name.0.to_string(),
-                                fake_entry.capabilities.clone(),
-                                cx.clone(),
-                            );
-                            fake_entry._server = Some(fake_server.clone());
-
-                            if let Some(initializer) = &fake_entry.initializer {
-                                initializer(&mut fake_server);
-                            }
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn create_fake_language_server(
+        &self,
+        server_id: LanguageServerId,
+        name: &LanguageServerName,
+        binary: lsp::LanguageServerBinary,
+        cx: gpui::AsyncAppContext,
+    ) -> Option<lsp::LanguageServer> {
+        let mut state = self.state.write();
+        let fake_entry = state.fake_server_entries.get_mut(&name)?;
+        let (server, mut fake_server) = lsp::FakeLanguageServer::new(
+            server_id,
+            binary,
+            name.0.to_string(),
+            fake_entry.capabilities.clone(),
+            cx.clone(),
+        );
+        fake_entry._server = Some(fake_server.clone());
 
-                            let tx = fake_entry.tx.clone();
-                            cx.background_executor()
-                                .spawn(async move {
-                                    if fake_server
-                                        .try_receive_notification::<lsp::notification::Initialized>(
-                                        )
-                                        .await
-                                        .is_some()
-                                    {
-                                        tx.unbounded_send(fake_server.clone()).ok();
-                                    }
-                                })
-                                .detach();
+        if let Some(initializer) = &fake_entry.initializer {
+            initializer(&mut fake_server);
+        }
 
-                            return Ok((server, options));
-                        }
-                    }
+        let tx = fake_entry.tx.clone();
+        cx.background_executor()
+            .spawn(async move {
+                if fake_server
+                    .try_receive_notification::<lsp::notification::Initialized>()
+                    .await
+                    .is_some()
+                {
+                    tx.unbounded_send(fake_server.clone()).ok();
                 }
+            })
+            .detach();
 
-                drop(this);
-                Ok((
-                    lsp::LanguageServer::new(
-                        stderr_capture,
-                        server_id,
-                        binary,
-                        &root_path,
-                        adapter.code_action_kinds(),
-                        cx,
-                    )?,
-                    options,
-                ))
-            }
-        });
-
-        Some(PendingLanguageServer {
-            server_id,
-            task,
-            container_dir,
-        })
+        Some(server)
     }
 
     pub fn language_server_binary_statuses(
@@ -1007,29 +930,16 @@ impl LanguageRegistry {
         self.lsp_binary_status_tx.subscribe()
     }
 
-    pub fn delete_server_container(
-        &self,
-        adapter: Arc<CachedLspAdapter>,
-        cx: &mut AppContext,
-    ) -> Task<()> {
+    pub async fn delete_server_container(&self, name: LanguageServerName) {
         log::info!("deleting server container");
+        let Some(dir) = self.language_server_download_dir(&name) else {
+            return;
+        };
 
-        let download_dir = self
-            .language_server_download_dir
-            .clone()
-            .expect("language server download directory has not been assigned before deleting server container");
-
-        cx.spawn(|_| async move {
-            let container_dir = download_dir.join(adapter.name.0.as_ref());
-            smol::fs::remove_dir_all(container_dir)
-                .await
-                .context("server container removal")
-                .log_err();
-        })
-    }
-
-    pub fn next_language_server_id(&self) -> LanguageServerId {
-        self.state.write().next_language_server_id()
+        smol::fs::remove_dir_all(dir)
+            .await
+            .context("server container removal")
+            .log_err();
     }
 }
 
diff --git a/crates/languages/src/c.rs b/crates/languages/src/c.rs
index 8a04e0aae6f4ef..28a12b5310f38a 100644
--- a/crates/languages/src/c.rs
+++ b/crates/languages/src/c.rs
@@ -5,7 +5,6 @@ use gpui::AsyncAppContext;
 use http_client::github::{latest_github_release, GitHubLspBinaryVersion};
 pub use language::*;
 use lsp::LanguageServerBinary;
-use project::{lsp_store::language_server_settings, project_settings::BinarySettings};
 use smol::fs::{self, File};
 use std::{any::Any, env::consts, path::PathBuf, sync::Arc};
 use util::{fs::remove_matching, maybe, ResultExt};
@@ -25,41 +24,14 @@ impl super::LspAdapter for CLspAdapter {
     async fn check_if_user_installed(
         &self,
         delegate: &dyn LspAdapterDelegate,
-        cx: &AsyncAppContext,
+        _: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
-        let configured_binary = cx.update(|cx| {
-            language_server_settings(delegate, &Self::SERVER_NAME, cx)
-                .and_then(|s| s.binary.clone())
-        });
-
-        match configured_binary {
-            Ok(Some(BinarySettings {
-                path: Some(path),
-                arguments,
-                ..
-            })) => Some(LanguageServerBinary {
-                path: path.into(),
-                arguments: arguments
-                    .unwrap_or_default()
-                    .iter()
-                    .map(|arg| arg.into())
-                    .collect(),
-                env: None,
-            }),
-            Ok(Some(BinarySettings {
-                path_lookup: Some(false),
-                ..
-            })) => None,
-            _ => {
-                let env = delegate.shell_env().await;
-                let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
-                Some(LanguageServerBinary {
-                    path,
-                    arguments: vec![],
-                    env: Some(env),
-                })
-            }
-        }
+        let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
+        Some(LanguageServerBinary {
+            path,
+            arguments: vec![],
+            env: None,
+        })
     }
 
     async fn fetch_latest_server_version(
@@ -141,18 +113,6 @@ impl super::LspAdapter for CLspAdapter {
         get_cached_server_binary(container_dir).await
     }
 
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir)
-            .await
-            .map(|mut binary| {
-                binary.arguments = vec!["--help".into()];
-                binary
-            })
-    }
-
     async fn label_for_completion(
         &self,
         completion: &lsp::CompletionItem,
diff --git a/crates/languages/src/css.rs b/crates/languages/src/css.rs
index 7b7e9ae77f06fc..b4e5feaab76c99 100644
--- a/crates/languages/src/css.rs
+++ b/crates/languages/src/css.rs
@@ -84,13 +84,6 @@ impl LspAdapter for CssLspAdapter {
         get_cached_server_binary(container_dir, &self.node).await
     }
 
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &self.node).await
-    }
-
     async fn initialization_options(
         self: Arc<Self>,
         _: &Arc<dyn LspAdapterDelegate>,
diff --git a/crates/languages/src/go.rs b/crates/languages/src/go.rs
index a1a996c066ee4b..135c080e00a149 100644
--- a/crates/languages/src/go.rs
+++ b/crates/languages/src/go.rs
@@ -6,7 +6,6 @@ use gpui::{AppContext, AsyncAppContext, Task};
 use http_client::github::latest_github_release;
 pub use language::*;
 use lsp::LanguageServerBinary;
-use project::{lsp_store::language_server_settings, project_settings::BinarySettings};
 use regex::Regex;
 use serde_json::json;
 use smol::{fs, process};
@@ -68,41 +67,14 @@ impl super::LspAdapter for GoLspAdapter {
     async fn check_if_user_installed(
         &self,
         delegate: &dyn LspAdapterDelegate,
-        cx: &AsyncAppContext,
+        _: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
-        let configured_binary = cx.update(|cx| {
-            language_server_settings(delegate, &Self::SERVER_NAME, cx)
-                .and_then(|s| s.binary.clone())
-        });
-
-        match configured_binary {
-            Ok(Some(BinarySettings {
-                path: Some(path),
-                arguments,
-                ..
-            })) => Some(LanguageServerBinary {
-                path: path.into(),
-                arguments: arguments
-                    .unwrap_or_default()
-                    .iter()
-                    .map(|arg| arg.into())
-                    .collect(),
-                env: None,
-            }),
-            Ok(Some(BinarySettings {
-                path_lookup: Some(false),
-                ..
-            })) => None,
-            _ => {
-                let env = delegate.shell_env().await;
-                let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
-                Some(LanguageServerBinary {
-                    path,
-                    arguments: server_binary_arguments(),
-                    env: Some(env),
-                })
-            }
-        }
+        let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
+        Some(LanguageServerBinary {
+            path,
+            arguments: server_binary_arguments(),
+            env: None,
+        })
     }
 
     fn will_fetch_server(
@@ -214,18 +186,6 @@ impl super::LspAdapter for GoLspAdapter {
         get_cached_server_binary(container_dir).await
     }
 
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir)
-            .await
-            .map(|mut binary| {
-                binary.arguments = vec!["--help".into()];
-                binary
-            })
-    }
-
     async fn initialization_options(
         self: Arc<Self>,
         _: &Arc<dyn LspAdapterDelegate>,
diff --git a/crates/languages/src/json.rs b/crates/languages/src/json.rs
index 44cc68387676ee..95c4070b13a331 100644
--- a/crates/languages/src/json.rs
+++ b/crates/languages/src/json.rs
@@ -186,13 +186,6 @@ impl LspAdapter for JsonLspAdapter {
         get_cached_server_binary(container_dir, &self.node).await
     }
 
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &self.node).await
-    }
-
     async fn initialization_options(
         self: Arc<Self>,
         _: &Arc<dyn LspAdapterDelegate>,
@@ -374,18 +367,6 @@ impl LspAdapter for NodeVersionAdapter {
     ) -> Option<LanguageServerBinary> {
         get_cached_version_server_binary(container_dir).await
     }
-
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_version_server_binary(container_dir)
-            .await
-            .map(|mut binary| {
-                binary.arguments = vec!["--version".into()];
-                binary
-            })
-    }
 }
 
 async fn get_cached_version_server_binary(container_dir: PathBuf) -> Option<LanguageServerBinary> {
diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs
index 75f124489c3820..964abf42b525fa 100644
--- a/crates/languages/src/python.rs
+++ b/crates/languages/src/python.rs
@@ -97,13 +97,6 @@ impl LspAdapter for PythonLspAdapter {
         get_cached_server_binary(container_dir, &self.node).await
     }
 
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &self.node).await
-    }
-
     async fn process_completions(&self, items: &mut [lsp::CompletionItem]) {
         // Pyright assigns each completion item a `sortText` of the form `XX.YYYY.name`.
         // Where `XX` is the sorting category, `YYYY` is based on most recent usage,
diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs
index eebd573a7e25fa..0d644e1bfef247 100644
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -8,7 +8,6 @@ use http_client::github::{latest_github_release, GitHubLspBinaryVersion};
 pub use language::*;
 use language_settings::all_language_settings;
 use lsp::LanguageServerBinary;
-use project::{lsp_store::language_server_settings, project_settings::BinarySettings};
 use regex::Regex;
 use smol::fs::{self, File};
 use std::{
@@ -37,77 +36,34 @@ impl LspAdapter for RustLspAdapter {
     async fn check_if_user_installed(
         &self,
         delegate: &dyn LspAdapterDelegate,
-        cx: &AsyncAppContext,
+        _: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
-        let configured_binary = cx
-            .update(|cx| {
-                language_server_settings(delegate, &Self::SERVER_NAME, cx)
-                    .and_then(|s| s.binary.clone())
+        let path = delegate.which("rust-analyzer".as_ref()).await?;
+        let env = delegate.shell_env().await;
+
+        // It is surprisingly common for ~/.cargo/bin/rust-analyzer to be a symlink to
+        // /usr/bin/rust-analyzer that fails when you run it; so we need to test it.
+        log::info!("found rust-analyzer in PATH. trying to run `rust-analyzer --help`");
+        let result = delegate
+            .try_exec(LanguageServerBinary {
+                path: path.clone(),
+                arguments: vec!["--help".into()],
+                env: Some(env.clone()),
             })
-            .ok()?;
-
-        let (path, env, arguments) = match configured_binary {
-            // If nothing is configured, or path_lookup explicitly enabled,
-            // we lookup the binary in the path.
-            None
-            | Some(BinarySettings {
-                path: None,
-                path_lookup: Some(true),
-                ..
-            })
-            | Some(BinarySettings {
-                path: None,
-                path_lookup: None,
-                ..
-            }) => {
-                let path = delegate.which("rust-analyzer".as_ref()).await;
-                let env = delegate.shell_env().await;
-
-                if let Some(path) = path {
-                    // It is surprisingly common for ~/.cargo/bin/rust-analyzer to be a symlink to
-                    // /usr/bin/rust-analyzer that fails when you run it; so we need to test it.
-                    log::info!("found rust-analyzer in PATH. trying to run `rust-analyzer --help`");
-                    match delegate
-                        .try_exec(LanguageServerBinary {
-                            path: path.clone(),
-                            arguments: vec!["--help".into()],
-                            env: Some(env.clone()),
-                        })
-                        .await
-                    {
-                        Ok(()) => (Some(path), Some(env), None),
-                        Err(err) => {
-                            log::error!("failed to run rust-analyzer after detecting it in PATH: binary: {:?}: {}", path, err);
-                            (None, None, None)
-                        }
-                    }
-                } else {
-                    (None, None, None)
-                }
-            }
-            // Otherwise, we use the configured binary.
-            Some(BinarySettings {
-                path: Some(path),
-                arguments,
-                path_lookup,
-            }) => {
-                if path_lookup.is_some() {
-                    log::warn!("Both `path` and `path_lookup` are set, ignoring `path_lookup`");
-                }
-                (Some(path.into()), None, arguments)
-            }
-
-            _ => (None, None, None),
-        };
+            .await;
+        if let Err(err) = result {
+            log::error!(
+                "failed to run rust-analyzer after detecting it in PATH: binary: {:?}: {}",
+                path,
+                err
+            );
+            return None;
+        }
 
-        path.map(|path| LanguageServerBinary {
+        Some(LanguageServerBinary {
             path,
-            env,
-            arguments: arguments
-                .unwrap_or_default()
-                .iter()
-                .map(|arg| arg.into())
-                .collect(),
+            env: Some(env),
+            arguments: vec![],
         })
     }
 
@@ -186,18 +142,6 @@ impl LspAdapter for RustLspAdapter {
         get_cached_server_binary(container_dir).await
     }
 
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir)
-            .await
-            .map(|mut binary| {
-                binary.arguments = vec!["--help".into()];
-                binary
-            })
-    }
-
     fn disk_based_diagnostic_sources(&self) -> Vec<String> {
         vec!["rustc".into()]
     }
diff --git a/crates/languages/src/tailwind.rs b/crates/languages/src/tailwind.rs
index 62d967d6a4a267..4ed5c742a9fc8d 100644
--- a/crates/languages/src/tailwind.rs
+++ b/crates/languages/src/tailwind.rs
@@ -46,38 +46,6 @@ impl LspAdapter for TailwindLspAdapter {
         Self::SERVER_NAME.clone()
     }
 
-    async fn check_if_user_installed(
-        &self,
-        delegate: &dyn LspAdapterDelegate,
-        cx: &AsyncAppContext,
-    ) -> Option<LanguageServerBinary> {
-        let configured_binary = cx
-            .update(|cx| {
-                language_server_settings(delegate, &Self::SERVER_NAME, cx)
-                    .and_then(|s| s.binary.clone())
-            })
-            .ok()??;
-
-        let path = if let Some(configured_path) = configured_binary.path.map(PathBuf::from) {
-            configured_path
-        } else {
-            self.node.binary_path().await.ok()?
-        };
-
-        let arguments = configured_binary
-            .arguments
-            .unwrap_or_default()
-            .iter()
-            .map(|arg| arg.into())
-            .collect();
-
-        Some(LanguageServerBinary {
-            path,
-            arguments,
-            env: None,
-        })
-    }
-
     async fn fetch_latest_server_version(
         &self,
         _: &dyn LspAdapterDelegate,
@@ -125,13 +93,6 @@ impl LspAdapter for TailwindLspAdapter {
         get_cached_server_binary(container_dir, &self.node).await
     }
 
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &self.node).await
-    }
-
     async fn initialization_options(
         self: Arc<Self>,
         _: &Arc<dyn LspAdapterDelegate>,
diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs
index b7eb21132d52c4..cfd7e04bc64177 100644
--- a/crates/languages/src/typescript.rs
+++ b/crates/languages/src/typescript.rs
@@ -164,13 +164,6 @@ impl LspAdapter for TypeScriptLspAdapter {
         get_cached_ts_server_binary(container_dir, &self.node).await
     }
 
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_ts_server_binary(container_dir, &self.node).await
-    }
-
     fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
         Some(vec![
             CodeActionKind::QUICKFIX,
@@ -509,19 +502,6 @@ impl LspAdapter for EsLintLspAdapter {
             arguments: eslint_server_binary_arguments(&server_path),
         })
     }
-
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        let server_path =
-            Self::build_destination_path(&container_dir).join(EsLintLspAdapter::SERVER_PATH);
-        Some(LanguageServerBinary {
-            path: self.node.binary_path().await.ok()?,
-            env: None,
-            arguments: eslint_server_binary_arguments(&server_path),
-        })
-    }
 }
 
 #[cfg(target_os = "windows")]
diff --git a/crates/languages/src/vtsls.rs b/crates/languages/src/vtsls.rs
index de6d575a8ee9fd..ff8637dc28dbd8 100644
--- a/crates/languages/src/vtsls.rs
+++ b/crates/languages/src/vtsls.rs
@@ -5,7 +5,7 @@ use gpui::AsyncAppContext;
 use language::{LanguageServerName, LspAdapter, LspAdapterDelegate};
 use lsp::{CodeActionKind, LanguageServerBinary};
 use node_runtime::NodeRuntime;
-use project::{lsp_store::language_server_settings, project_settings::BinarySettings};
+use project::lsp_store::language_server_settings;
 use serde_json::Value;
 use std::{
     any::Any,
@@ -71,40 +71,15 @@ impl LspAdapter for VtslsLspAdapter {
     async fn check_if_user_installed(
         &self,
         delegate: &dyn LspAdapterDelegate,
-        cx: &AsyncAppContext,
+        _: &AsyncAppContext,
     ) -> Option<LanguageServerBinary> {
-        let configured_binary = cx.update(|cx| {
-            language_server_settings(delegate, &SERVER_NAME, cx).and_then(|s| s.binary.clone())
-        });
-
-        match configured_binary {
-            Ok(Some(BinarySettings {
-                path: Some(path),
-                arguments,
-                ..
-            })) => Some(LanguageServerBinary {
-                path: path.into(),
-                arguments: arguments
-                    .unwrap_or_default()
-                    .iter()
-                    .map(|arg| arg.into())
-                    .collect(),
-                env: None,
-            }),
-            Ok(Some(BinarySettings {
-                path_lookup: Some(false),
-                ..
-            })) => None,
-            _ => {
-                let env = delegate.shell_env().await;
-                let path = delegate.which(SERVER_NAME.as_ref()).await?;
-                Some(LanguageServerBinary {
-                    path: path.clone(),
-                    arguments: typescript_server_binary_arguments(&path),
-                    env: Some(env),
-                })
-            }
-        }
+        let env = delegate.shell_env().await;
+        let path = delegate.which(SERVER_NAME.as_ref()).await?;
+        Some(LanguageServerBinary {
+            path: path.clone(),
+            arguments: typescript_server_binary_arguments(&path),
+            env: Some(env),
+        })
     }
 
     async fn fetch_server_binary(
@@ -157,13 +132,6 @@ impl LspAdapter for VtslsLspAdapter {
         get_cached_ts_server_binary(container_dir, &self.node).await
     }
 
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_ts_server_binary(container_dir, &self.node).await
-    }
-
     fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
         Some(vec![
             CodeActionKind::QUICKFIX,
diff --git a/crates/languages/src/yaml.rs b/crates/languages/src/yaml.rs
index 32ca73168ab2d2..642d6c030ac915 100644
--- a/crates/languages/src/yaml.rs
+++ b/crates/languages/src/yaml.rs
@@ -42,37 +42,6 @@ impl LspAdapter for YamlLspAdapter {
         Self::SERVER_NAME.clone()
     }
 
-    async fn check_if_user_installed(
-        &self,
-        delegate: &dyn LspAdapterDelegate,
-        cx: &AsyncAppContext,
-    ) -> Option<LanguageServerBinary> {
-        let configured_binary = cx
-            .update(|cx| {
-                language_server_settings(delegate, &Self::SERVER_NAME, cx)
-                    .and_then(|s| s.binary.clone())
-            })
-            .ok()??;
-
-        let path = if let Some(configured_path) = configured_binary.path.map(PathBuf::from) {
-            configured_path
-        } else {
-            self.node.binary_path().await.ok()?
-        };
-
-        let arguments = configured_binary
-            .arguments
-            .unwrap_or_default()
-            .iter()
-            .map(|arg| arg.into())
-            .collect();
-        Some(LanguageServerBinary {
-            path,
-            arguments,
-            env: None,
-        })
-    }
-
     async fn fetch_latest_server_version(
         &self,
         _: &dyn LspAdapterDelegate,
@@ -120,13 +89,6 @@ impl LspAdapter for YamlLspAdapter {
         get_cached_server_binary(container_dir, &self.node).await
     }
 
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_server_binary(container_dir, &self.node).await
-    }
-
     async fn workspace_configuration(
         self: Arc<Self>,
         delegate: &Arc<dyn LspAdapterDelegate>,
diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs
index c2a5951de72101..e380da052ddc95 100644
--- a/crates/lsp/src/lsp.rs
+++ b/crates/lsp/src/lsp.rs
@@ -64,6 +64,15 @@ pub struct LanguageServerBinary {
     pub env: Option<HashMap<String, String>>,
 }
 
+/// Configures the search (and installation) of language servers.
+#[derive(Debug, Clone, Deserialize)]
+pub struct LanguageServerBinaryOptions {
+    /// Whether the adapter should look at the users system
+    pub allow_path_lookup: bool,
+    /// Whether the adapter should download its own version
+    pub allow_binary_download: bool,
+}
+
 /// A running language server process.
 pub struct LanguageServer {
     server_id: LanguageServerId,
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 8d859c091bfe93..21d5de53e6be28 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -37,16 +37,16 @@ use language::{
     proto::{deserialize_anchor, deserialize_version, serialize_anchor, serialize_version},
     range_from_lsp, Bias, Buffer, BufferSnapshot, CachedLspAdapter, CodeLabel, Diagnostic,
     DiagnosticEntry, DiagnosticSet, Diff, Documentation, File as _, Language, LanguageConfig,
-    LanguageMatcher, LanguageName, LanguageRegistry, LanguageServerName, LocalFile, LspAdapter,
-    LspAdapterDelegate, Patch, PendingLanguageServer, PointUtf16, TextBufferSnapshot, ToOffset,
-    ToPointUtf16, Transaction, Unclipped,
+    LanguageMatcher, LanguageName, LanguageRegistry, LanguageServerBinaryStatus,
+    LanguageServerName, LocalFile, LspAdapter, LspAdapterDelegate, Patch, PointUtf16,
+    TextBufferSnapshot, ToOffset, ToPointUtf16, Transaction, Unclipped,
 };
 use lsp::{
     CodeActionKind, CompletionContext, DiagnosticSeverity, DiagnosticTag,
     DidChangeWatchedFilesRegistrationOptions, Edit, FileSystemWatcher, InsertTextFormat,
-    LanguageServer, LanguageServerBinary, LanguageServerId, LspRequestFuture, MessageActionItem,
-    MessageType, OneOf, ServerHealthStatus, ServerStatus, SymbolKind, TextEdit, Url,
-    WorkDoneProgressCancelParams, WorkspaceFolder,
+    LanguageServer, LanguageServerBinary, LanguageServerBinaryOptions, LanguageServerId,
+    LspRequestFuture, MessageActionItem, MessageType, OneOf, ServerHealthStatus, ServerStatus,
+    SymbolKind, TextEdit, Url, WorkDoneProgressCancelParams, WorkspaceFolder,
 };
 use parking_lot::{Mutex, RwLock};
 use postage::watch;
@@ -67,9 +67,8 @@ use std::{
     iter, mem,
     ops::{ControlFlow, Range},
     path::{self, Path, PathBuf},
-    process::Stdio,
     str,
-    sync::{atomic::Ordering::SeqCst, Arc},
+    sync::Arc,
     time::{Duration, Instant},
 };
 use text::{Anchor, BufferId, LineEnding};
@@ -87,8 +86,6 @@ pub use worktree::{
     FS_WATCH_LATENCY,
 };
 
-const MAX_SERVER_REINSTALL_ATTEMPT_COUNT: u64 = 4;
-const SERVER_REINSTALL_DEBOUNCE_TIMEOUT: Duration = Duration::from_secs(1);
 const SERVER_LAUNCHING_BEFORE_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(5);
 pub const SERVER_PROGRESS_THROTTLE_TIMEOUT: Duration = Duration::from_millis(100);
 
@@ -157,6 +154,7 @@ impl LocalLspStore {
             futures::future::join_all(shutdown_futures).await;
         }
     }
+
     async fn format_locally(
         lsp_store: WeakModel<LspStore>,
         mut buffers_with_paths: Vec<(Model<Buffer>, Option<PathBuf>)>,
@@ -1471,7 +1469,7 @@ impl LspStore {
         }
 
         for (worktree_id, adapter_name) in language_servers_to_stop {
-            self.stop_language_server(worktree_id, adapter_name, cx)
+            self.stop_local_language_server(worktree_id, adapter_name, cx)
                 .detach();
         }
 
@@ -1488,7 +1486,7 @@ impl LspStore {
 
         // Restart all language servers with changed initialization options.
         for (worktree, language) in language_servers_to_restart {
-            self.restart_language_servers(worktree, language, cx);
+            self.restart_local_language_servers(worktree, language, cx);
         }
 
         cx.notify();
@@ -3028,7 +3026,7 @@ impl LspStore {
         })
     }
 
-    pub fn primary_language_server_for_buffer<'a>(
+    fn primary_language_server_for_buffer<'a>(
         &'a self,
         buffer: &'a Buffer,
         cx: &'a AppContext,
@@ -3328,7 +3326,7 @@ impl LspStore {
         Ok(())
     }
 
-    pub fn update_worktree_diagnostics(
+    fn update_worktree_diagnostics(
         &mut self,
         worktree_id: WorktreeId,
         server_id: LanguageServerId,
@@ -5405,9 +5403,6 @@ impl LspStore {
             language_registry: self.languages.clone(),
         }) as Arc<dyn LspAdapterDelegate>;
 
-        // TODO: We should use `adapter` here instead of reaching through the `CachedLspAdapter`.
-        let lsp_adapter = adapter.adapter.clone();
-
         let Some((upstream_client, project_id)) = self.upstream_client() else {
             return;
         };
@@ -5419,17 +5414,11 @@ impl LspStore {
             return;
         };
 
-        let task = cx.spawn(|_, cx| async move {
-            let user_binary_task = lsp_adapter.check_if_user_installed(delegate.as_ref(), &cx);
-            let binary = match user_binary_task.await {
-                Some(binary) => binary,
-                None => {
-                    return Err(anyhow!(
-                        "Downloading language server for ssh host is not supported yet"
-                    ))
-                }
-            };
+        let user_binary_task =
+            self.get_language_server_binary(adapter.clone(), delegate.clone(), false, cx);
 
+        let task = cx.spawn(|_, _| async move {
+            let binary = user_binary_task.await?;
             let name = adapter.name();
             let code_action_kinds = adapter
                 .adapter
@@ -5481,6 +5470,73 @@ impl LspStore {
         .detach();
     }
 
+    fn get_language_server_binary(
+        &self,
+        adapter: Arc<CachedLspAdapter>,
+        delegate: Arc<dyn LspAdapterDelegate>,
+        allow_binary_download: bool,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<LanguageServerBinary>> {
+        let settings = ProjectSettings::get(
+            Some(SettingsLocation {
+                worktree_id: delegate.worktree_id(),
+                path: Path::new(""),
+            }),
+            cx,
+        )
+        .lsp
+        .get(&adapter.name)
+        .and_then(|s| s.binary.clone());
+
+        if settings.as_ref().is_some_and(|b| b.path.is_some()) {
+            let settings = settings.unwrap();
+            return cx.spawn(|_, _| async move {
+                Ok(LanguageServerBinary {
+                    path: PathBuf::from(&settings.path.unwrap()),
+                    env: Some(delegate.shell_env().await),
+                    arguments: settings
+                        .arguments
+                        .unwrap_or_default()
+                        .iter()
+                        .map(Into::into)
+                        .collect(),
+                })
+            });
+        }
+        let lsp_binary_options = LanguageServerBinaryOptions {
+            allow_path_lookup: !settings
+                .as_ref()
+                .and_then(|b| b.ignore_system_version)
+                .unwrap_or_default(),
+            allow_binary_download,
+        };
+        cx.spawn(|_, mut cx| async move {
+            let binary_result = adapter
+                .clone()
+                .get_language_server_command(delegate.clone(), lsp_binary_options, &mut cx)
+                .await;
+
+            delegate.update_status(adapter.name.clone(), LanguageServerBinaryStatus::None);
+
+            let mut binary = binary_result?;
+            if let Some(arguments) = settings.and_then(|b| b.arguments) {
+                binary.arguments = arguments.into_iter().map(Into::into).collect();
+            }
+
+            // If we do have a project environment (either by spawning a shell in in the project directory
+            // or by getting it from the CLI) and the language server command itself
+            // doesn't have an environment, then we use the project environment.
+            if binary.env.is_none() {
+                log::info!(
+                    "using project environment for language server {:?}",
+                    adapter.name()
+                );
+                binary.env = Some(delegate.shell_env().await);
+            }
+            Ok(binary)
+        })
+    }
+
     fn start_language_server(
         &mut self,
         worktree_handle: &Model<Worktree>,
@@ -5496,6 +5552,7 @@ impl LspStore {
         let worktree_id = worktree.id();
         let worktree_path = worktree.abs_path();
         let key = (worktree_id, adapter.name.clone());
+
         if self.language_server_ids.contains_key(&key) {
             return;
         }
@@ -5505,31 +5562,6 @@ impl LspStore {
             return;
         }
 
-        if adapter.reinstall_attempt_count.load(SeqCst) > MAX_SERVER_REINSTALL_ATTEMPT_COUNT {
-            return;
-        }
-
-        let local = self.as_local().unwrap();
-
-        let stderr_capture = Arc::new(Mutex::new(Some(String::new())));
-        let lsp_adapter_delegate = LocalLspAdapterDelegate::for_local(self, worktree_handle, cx);
-        let project_environment = local.environment.update(cx, |environment, cx| {
-            environment.get_environment(Some(worktree_id), Some(worktree_path.clone()), cx)
-        });
-
-        let pending_server = match self.languages.create_pending_language_server(
-            stderr_capture.clone(),
-            language.clone(),
-            adapter.clone(),
-            Arc::clone(&worktree_path),
-            lsp_adapter_delegate.clone(),
-            project_environment,
-            cx,
-        ) {
-            Some(pending_server) => pending_server,
-            None => return,
-        };
-
         let project_settings = ProjectSettings::get(
             Some(SettingsLocation {
                 worktree_id,
@@ -5537,76 +5569,146 @@ impl LspStore {
             }),
             cx,
         );
-
-        // We need some on the SSH client, and some on SSH host
         let lsp = project_settings.lsp.get(&adapter.name);
         let override_options = lsp.and_then(|s| s.initialization_options.clone());
 
-        let server_id = pending_server.server_id;
-        let container_dir = pending_server.container_dir.clone();
-        let state = LanguageServerState::Starting({
+        let stderr_capture = Arc::new(Mutex::new(Some(String::new())));
+        let delegate = LocalLspAdapterDelegate::for_local(self, worktree_handle, cx)
+            as Arc<dyn LspAdapterDelegate>;
+
+        let server_id = self.languages.next_language_server_id();
+        let root_path = worktree_path.clone();
+        log::info!(
+            "attempting to start language server {:?}, path: {root_path:?}, id: {server_id}",
+            adapter.name.0
+        );
+
+        let binary = self.get_language_server_binary(adapter.clone(), delegate.clone(), true, cx);
+
+        let pending_server = cx.spawn({
             let adapter = adapter.clone();
+            let stderr_capture = stderr_capture.clone();
+
+            move |_lsp_store, cx| async move {
+                let binary = binary.await?;
+
+                #[cfg(any(test, feature = "test-support"))]
+                if let Some(server) = _lsp_store
+                    .update(&mut cx.clone(), |this, cx| {
+                        this.languages.create_fake_language_server(
+                            server_id,
+                            &adapter.name,
+                            binary.clone(),
+                            cx.to_async(),
+                        )
+                    })
+                    .ok()
+                    .flatten()
+                {
+                    return Ok(server);
+                }
+
+                lsp::LanguageServer::new(
+                    stderr_capture,
+                    server_id,
+                    binary,
+                    &root_path,
+                    adapter.code_action_kinds(),
+                    cx,
+                )
+            }
+        });
+
+        let state = LanguageServerState::Starting({
             let server_name = adapter.name.0.clone();
+            let delegate = delegate as Arc<dyn LspAdapterDelegate>;
             let language = language.clone();
             let key = key.clone();
+            let adapter = adapter.clone();
 
             cx.spawn(move |this, mut cx| async move {
-                let result = Self::setup_and_insert_language_server(
-                    this.clone(),
-                    lsp_adapter_delegate,
-                    override_options,
-                    pending_server,
-                    adapter.clone(),
-                    language.clone(),
-                    server_id,
-                    key,
-                    &mut cx,
-                )
-                .await;
+                let result = {
+                    let delegate = delegate.clone();
+                    let adapter = adapter.clone();
+                    let this = this.clone();
+                    let mut cx = cx.clone();
+                    async move {
+                        let language_server = pending_server.await?;
 
-                match result {
-                    Ok(server) => {
-                        stderr_capture.lock().take();
-                        server
-                    }
+                        let workspace_config = adapter
+                            .adapter
+                            .clone()
+                            .workspace_configuration(&delegate, &mut cx)
+                            .await?;
 
-                    Err(err) => {
-                        log::error!("failed to start language server {server_name:?}: {err}");
-                        log::error!("server stderr: {:?}", stderr_capture.lock().take());
+                        let mut initialization_options = adapter
+                            .adapter
+                            .clone()
+                            .initialization_options(&(delegate))
+                            .await?;
 
-                        let this = this.upgrade()?;
-                        let container_dir = container_dir?;
+                        Self::setup_lsp_messages(this.clone(), &language_server, delegate, adapter);
 
-                        let attempt_count = adapter.reinstall_attempt_count.fetch_add(1, SeqCst);
-                        if attempt_count >= MAX_SERVER_REINSTALL_ATTEMPT_COUNT {
-                            let max = MAX_SERVER_REINSTALL_ATTEMPT_COUNT;
-                            log::error!("Hit {max} reinstallation attempts for {server_name:?}");
-                            return None;
+                        match (&mut initialization_options, override_options) {
+                            (Some(initialization_options), Some(override_options)) => {
+                                merge_json_value_into(override_options, initialization_options);
+                            }
+                            (None, override_options) => initialization_options = override_options,
+                            _ => {}
                         }
 
-                        log::info!(
-                            "retrying installation of language server {server_name:?} in {}s",
-                            SERVER_REINSTALL_DEBOUNCE_TIMEOUT.as_secs()
-                        );
-                        cx.background_executor()
-                            .timer(SERVER_REINSTALL_DEBOUNCE_TIMEOUT)
-                            .await;
+                        let language_server = cx
+                            .update(|cx| language_server.initialize(initialization_options, cx))?
+                            .await
+                            .inspect_err(|_| {
+                                if let Some(this) = this.upgrade() {
+                                    this.update(&mut cx, |_, cx| {
+                                        cx.emit(LspStoreEvent::LanguageServerRemoved(server_id))
+                                    })
+                                    .ok();
+                                }
+                            })?;
 
-                        let installation_test_binary = adapter
-                            .installation_test_binary(container_dir.to_path_buf())
-                            .await;
+                        language_server
+                            .notify::<lsp::notification::DidChangeConfiguration>(
+                                lsp::DidChangeConfigurationParams {
+                                    settings: workspace_config,
+                                },
+                            )
+                            .ok();
 
-                        this.update(&mut cx, |_, cx| {
-                            Self::check_errored_server(
+                        anyhow::Ok(language_server)
+                    }
+                }
+                .await;
+
+                match result {
+                    Ok(server) => {
+                        this.update(&mut cx, |this, mut cx| {
+                            this.insert_newly_running_language_server(
                                 language,
                                 adapter,
+                                server.clone(),
                                 server_id,
-                                installation_test_binary,
-                                cx,
-                            )
+                                key,
+                                &mut cx,
+                            );
                         })
                         .ok();
+                        stderr_capture.lock().take();
+                        Some(server)
+                    }
 
+                    Err(err) => {
+                        let log = stderr_capture.lock().take().unwrap_or_default();
+                        delegate.update_status(
+                            adapter.name(),
+                            LanguageServerBinaryStatus::Failed {
+                                error: format!("{err}\n-- stderr--\n{}", log),
+                            },
+                        );
+                        log::error!("Failed to start language server {server_name:?}: {err}");
+                        log::error!("server stderr: {:?}", log);
                         None
                     }
                 }
@@ -5620,109 +5722,6 @@ impl LspStore {
         self.language_server_ids.insert(key, server_id);
     }
 
-    #[allow(clippy::too_many_arguments)]
-    async fn setup_and_insert_language_server(
-        this: WeakModel<Self>,
-        delegate: Arc<dyn LspAdapterDelegate>,
-        override_initialization_options: Option<serde_json::Value>,
-        pending_server: PendingLanguageServer,
-        adapter: Arc<CachedLspAdapter>,
-        language: LanguageName,
-        server_id: LanguageServerId,
-        key: (WorktreeId, LanguageServerName),
-        cx: &mut AsyncAppContext,
-    ) -> Result<Option<Arc<LanguageServer>>> {
-        let language_server = Self::setup_pending_language_server(
-            this.clone(),
-            override_initialization_options,
-            pending_server,
-            delegate,
-            adapter.clone(),
-            server_id,
-            cx,
-        )
-        .await?;
-
-        let this = match this.upgrade() {
-            Some(this) => this,
-            None => return Err(anyhow!("failed to upgrade project handle")),
-        };
-
-        this.update(cx, |this, cx| {
-            this.insert_newly_running_language_server(
-                language,
-                adapter,
-                language_server.clone(),
-                server_id,
-                key,
-                cx,
-            )
-        })??;
-
-        Ok(Some(language_server))
-    }
-
-    fn reinstall_language_server(
-        &mut self,
-        language: LanguageName,
-        adapter: Arc<CachedLspAdapter>,
-        server_id: LanguageServerId,
-        cx: &mut ModelContext<Self>,
-    ) -> Option<Task<()>> {
-        log::info!("beginning to reinstall server");
-
-        if let Some(local) = self.as_local_mut() {
-            let existing_server = match local.language_servers.remove(&server_id) {
-                Some(LanguageServerState::Running { server, .. }) => Some(server),
-                _ => None,
-            };
-
-            self.worktree_store.update(cx, |store, cx| {
-                for worktree in store.worktrees() {
-                    let key = (worktree.read(cx).id(), adapter.name.clone());
-                    self.language_server_ids.remove(&key);
-                }
-            });
-
-            Some(cx.spawn(move |this, mut cx| async move {
-                if let Some(task) = existing_server.and_then(|server| server.shutdown()) {
-                    log::info!("shutting down existing server");
-                    task.await;
-                }
-
-                // TODO: This is race-safe with regards to preventing new instances from
-                // starting while deleting, but existing instances in other projects are going
-                // to be very confused and messed up
-                let Some(task) = this
-                    .update(&mut cx, |this, cx| {
-                        this.languages.delete_server_container(adapter.clone(), cx)
-                    })
-                    .log_err()
-                else {
-                    return;
-                };
-                task.await;
-
-                this.update(&mut cx, |this, cx| {
-                    for worktree in this.worktree_store.read(cx).worktrees().collect::<Vec<_>>() {
-                        this.start_language_server(
-                            &worktree,
-                            adapter.clone(),
-                            language.clone(),
-                            cx,
-                        );
-                    }
-                })
-                .ok();
-            }))
-        } else if let Some(_ssh_store) = self.as_ssh() {
-            // TODO
-            None
-        } else {
-            None
-        }
-    }
-
     async fn shutdown_language_server(
         server_state: Option<LanguageServerState>,
         name: LanguageServerName,
@@ -5761,7 +5760,7 @@ impl LspStore {
 
     // Returns a list of all of the worktrees which no longer have a language server and the root path
     // for the stopped server
-    pub fn stop_language_server(
+    fn stop_local_language_server(
         &mut self,
         worktree_id: WorktreeId,
         adapter_name: LanguageServerName,
@@ -5877,7 +5876,6 @@ impl LspStore {
                 .spawn(request)
                 .detach_and_log_err(cx);
         } else {
-            #[allow(clippy::mutable_key_type)]
             let language_server_lookup_info: HashSet<(Model<Worktree>, LanguageName)> = buffers
                 .into_iter()
                 .filter_map(|buffer| {
@@ -5893,12 +5891,12 @@ impl LspStore {
                 .collect();
 
             for (worktree, language) in language_server_lookup_info {
-                self.restart_language_servers(worktree, language, cx);
+                self.restart_local_language_servers(worktree, language, cx);
             }
         }
     }
 
-    pub fn restart_language_servers(
+    fn restart_local_language_servers(
         &mut self,
         worktree: Model<Worktree>,
         language: LanguageName,
@@ -5912,7 +5910,8 @@ impl LspStore {
             .lsp_adapters(&language)
             .iter()
             .map(|adapter| {
-                let stop_task = self.stop_language_server(worktree_id, adapter.name.clone(), cx);
+                let stop_task =
+                    self.stop_local_language_server(worktree_id, adapter.name.clone(), cx);
                 (stop_task, adapter.name.clone())
             })
             .collect::<Vec<_>>();
@@ -5951,93 +5950,14 @@ impl LspStore {
         .detach();
     }
 
-    fn check_errored_server(
-        language: LanguageName,
-        adapter: Arc<CachedLspAdapter>,
-        server_id: LanguageServerId,
-        installation_test_binary: Option<LanguageServerBinary>,
-        cx: &mut ModelContext<Self>,
-    ) {
-        if !adapter.can_be_reinstalled() {
-            log::info!(
-                "Validation check requested for {:?} but it cannot be reinstalled",
-                adapter.name.0
-            );
-            return;
-        }
-
-        cx.spawn(move |this, mut cx| async move {
-            log::info!("About to spawn test binary");
-
-            // A lack of test binary counts as a failure
-            let process = installation_test_binary.and_then(|binary| {
-                smol::process::Command::new(&binary.path)
-                    .current_dir(&binary.path)
-                    .args(binary.arguments)
-                    .stdin(Stdio::piped())
-                    .stdout(Stdio::piped())
-                    .stderr(Stdio::inherit())
-                    .kill_on_drop(true)
-                    .spawn()
-                    .ok()
-            });
-
-            const PROCESS_TIMEOUT: Duration = Duration::from_secs(5);
-            let mut timeout = cx.background_executor().timer(PROCESS_TIMEOUT).fuse();
-
-            let mut errored = false;
-            if let Some(mut process) = process {
-                futures::select! {
-                    status = process.status().fuse() => match status {
-                        Ok(status) => errored = !status.success(),
-                        Err(_) => errored = true,
-                    },
-
-                    _ = timeout => {
-                        log::info!("test binary time-ed out, this counts as a success");
-                        _ = process.kill();
-                    }
-                }
-            } else {
-                log::warn!("test binary failed to launch");
-                errored = true;
-            }
-
-            if errored {
-                log::warn!("test binary check failed");
-                let task = this
-                    .update(&mut cx, move |this, cx| {
-                        this.reinstall_language_server(language, adapter, server_id, cx)
-                    })
-                    .ok()
-                    .flatten();
-
-                if let Some(task) = task {
-                    task.await;
-                }
-            }
-        })
-        .detach();
-    }
-
-    async fn setup_pending_language_server(
+    fn setup_lsp_messages(
         this: WeakModel<Self>,
-        override_options: Option<serde_json::Value>,
-        pending_server: PendingLanguageServer,
+        language_server: &LanguageServer,
         delegate: Arc<dyn LspAdapterDelegate>,
         adapter: Arc<CachedLspAdapter>,
-        server_id: LanguageServerId,
-        cx: &mut AsyncAppContext,
-    ) -> Result<Arc<LanguageServer>> {
-        let workspace_config = adapter
-            .adapter
-            .clone()
-            .workspace_configuration(&delegate, cx)
-            .await?;
-        // This has to come from the server
-        let (language_server, mut initialization_options) = pending_server.task.await?;
-
+    ) {
         let name = language_server.name();
+        let server_id = language_server.server_id();
         language_server
             .on_notification::<lsp::notification::PublishDiagnostics, _>({
                 let adapter = adapter.clone();
@@ -6091,7 +6011,6 @@ impl LspStore {
             })
             .detach();
 
-        let id = language_server.server_id();
         language_server
             .on_request::<lsp::request::WorkspaceFoldersRequest, _, _>({
                 let this = this.clone();
@@ -6099,7 +6018,7 @@ impl LspStore {
                     let this = this.clone();
                     async move {
                         let Some(server) =
-                            this.update(&mut cx, |this, _| this.language_server_for_id(id))?
+                            this.update(&mut cx, |this, _| this.language_server_for_id(server_id))?
                         else {
                             return Ok(None);
                         };
@@ -6375,9 +6294,6 @@ impl LspStore {
             })
             .detach();
 
-        let disk_based_diagnostics_progress_token =
-            adapter.disk_based_diagnostics_progress_token.clone();
-
         language_server
             .on_notification::<ServerStatus, _>({
                 let this = this.clone();
@@ -6448,6 +6364,10 @@ impl LspStore {
                 }
             })
             .detach();
+
+        let disk_based_diagnostics_progress_token =
+            adapter.disk_based_diagnostics_progress_token.clone();
+
         language_server
             .on_notification::<lsp::notification::Progress, _>({
                 let this = this.clone();
@@ -6502,36 +6422,6 @@ impl LspStore {
                 }
             })
             .detach();
-
-        match (&mut initialization_options, override_options) {
-            (Some(initialization_options), Some(override_options)) => {
-                merge_json_value_into(override_options, initialization_options);
-            }
-            (None, override_options) => initialization_options = override_options,
-            _ => {}
-        }
-
-        let language_server = cx
-            .update(|cx| language_server.initialize(initialization_options, cx))?
-            .await
-            .inspect_err(|_| {
-                if let Some(this) = this.upgrade() {
-                    this.update(cx, |_, cx| {
-                        cx.emit(LspStoreEvent::LanguageServerRemoved(server_id))
-                    })
-                    .ok();
-                }
-            })?;
-
-        language_server
-            .notify::<lsp::notification::DidChangeConfiguration>(
-                lsp::DidChangeConfigurationParams {
-                    settings: workspace_config,
-                },
-            )
-            .ok();
-
-        Ok(language_server)
     }
 
     pub fn update_diagnostics(
@@ -6664,7 +6554,7 @@ impl LspStore {
         server_id: LanguageServerId,
         key: (WorktreeId, LanguageServerName),
         cx: &mut ModelContext<Self>,
-    ) -> Result<()> {
+    ) {
         // If the language server for this key doesn't match the server id, don't store the
         // server. Which will cause it to be dropped, killing the process
         if self
@@ -6673,7 +6563,7 @@ impl LspStore {
             .map(|id| id != &server_id)
             .unwrap_or(false)
         {
-            return Ok(());
+            return;
         }
 
         // Update language_servers collection with Running variant of LanguageServerState
@@ -6703,13 +6593,15 @@ impl LspStore {
         cx.emit(LspStoreEvent::LanguageServerAdded(server_id));
 
         if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {
-            downstream_client.send(proto::StartLanguageServer {
-                project_id: *project_id,
-                server: Some(proto::LanguageServer {
-                    id: server_id.0 as u64,
-                    name: language_server.name().to_string(),
-                }),
-            })?;
+            downstream_client
+                .send(proto::StartLanguageServer {
+                    project_id: *project_id,
+                    server: Some(proto::LanguageServer {
+                        id: server_id.0 as u64,
+                        name: language_server.name().to_string(),
+                    }),
+                })
+                .log_err();
         }
 
         // Tell the language server about every open buffer in the worktree that matches the language.
@@ -6756,16 +6648,18 @@ impl LspStore {
                 let version = snapshot.version;
                 let initial_snapshot = &snapshot.snapshot;
                 let uri = lsp::Url::from_file_path(file.abs_path(cx)).unwrap();
-                language_server.notify::<lsp::notification::DidOpenTextDocument>(
-                    lsp::DidOpenTextDocumentParams {
-                        text_document: lsp::TextDocumentItem::new(
-                            uri,
-                            adapter.language_id(&language.name()),
-                            version,
-                            initial_snapshot.text(),
-                        ),
-                    },
-                )?;
+                language_server
+                    .notify::<lsp::notification::DidOpenTextDocument>(
+                        lsp::DidOpenTextDocumentParams {
+                            text_document: lsp::TextDocumentItem::new(
+                                uri,
+                                adapter.language_id(&language.name()),
+                                version,
+                                initial_snapshot.text(),
+                            ),
+                        },
+                    )
+                    .log_err();
 
                 buffer_handle.update(cx, |buffer, cx| {
                     buffer.set_completion_triggers(
@@ -6779,11 +6673,9 @@ impl LspStore {
                     )
                 });
             }
-            anyhow::Ok(())
-        })?;
+        });
 
         cx.notify();
-        Ok(())
     }
 
     fn buffer_snapshot_for_lsp_version(
@@ -6878,7 +6770,7 @@ impl LspStore {
             })
     }
 
-    pub fn register_supplementary_language_server(
+    fn register_supplementary_language_server(
         &mut self,
         id: LanguageServerId,
         name: LanguageServerName,
@@ -6893,7 +6785,7 @@ impl LspStore {
         }
     }
 
-    pub fn unregister_supplementary_language_server(
+    fn unregister_supplementary_language_server(
         &mut self,
         id: LanguageServerId,
         cx: &mut ModelContext<Self>,
@@ -7807,11 +7699,8 @@ impl LspAdapter for SshLspAdapter {
     ) -> Result<LanguageServerBinary> {
         anyhow::bail!("SshLspAdapter does not support fetch_server_binary")
     }
-
-    async fn installation_test_binary(&self, _: PathBuf) -> Option<LanguageServerBinary> {
-        None
-    }
 }
+
 pub fn language_server_settings<'a, 'b: 'a>(
     delegate: &'a dyn LspAdapterDelegate,
     language: &LanguageServerName,
@@ -7855,22 +7744,6 @@ impl LocalLspAdapterDelegate {
         Self::new(lsp_store, worktree, http_client, local.fs.clone(), cx)
     }
 
-    // fn for_ssh(
-    //     lsp_store: &LspStore,
-    //     worktree: &Model<Worktree>,
-    //     upstream_client: AnyProtoClient,
-    //     cx: &mut ModelContext<LspStore>,
-    // ) -> Arc<Self> {
-    //     Self::new(
-    //         lsp_store,
-    //         worktree,
-    //         Arc::new(BlockedHttpClient),
-    //         None,
-    //         Some(upstream_client),
-    //         cx,
-    //     )
-    // }
-
     pub fn new(
         lsp_store: &LspStore,
         worktree: &Model<Worktree>,
@@ -7972,6 +7845,19 @@ impl LspAdapterDelegate for LocalLspAdapterDelegate {
             .update_lsp_status(server_name, status);
     }
 
+    async fn language_server_download_dir(&self, name: &LanguageServerName) -> Option<Arc<Path>> {
+        let dir = self.language_registry.language_server_download_dir(name)?;
+
+        if !dir.exists() {
+            smol::fs::create_dir_all(&dir)
+                .await
+                .context("failed to create container directory")
+                .log_err()?;
+        }
+
+        Some(dir)
+    }
+
     async fn read_text_file(&self, path: PathBuf) -> Result<String> {
         if self.worktree.entry_for_path(&path).is_none() {
             return Err(anyhow!("no such path {path:?}"));
@@ -8056,6 +7942,10 @@ impl LspAdapterDelegate for SshLspAdapterDelegate {
         Ok(())
     }
 
+    async fn language_server_download_dir(&self, _: &LanguageServerName) -> Option<Arc<Path>> {
+        None
+    }
+
     fn update_status(
         &self,
         server_name: LanguageServerName,
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index ee7f93a4f933c2..8d95c8f2f18238 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -3958,14 +3958,6 @@ impl Project {
         self.lsp_store.read(cx).supplementary_language_servers()
     }
 
-    pub fn language_server_adapter_for_id(
-        &self,
-        id: LanguageServerId,
-        cx: &AppContext,
-    ) -> Option<Arc<CachedLspAdapter>> {
-        self.lsp_store.read(cx).language_server_adapter_for_id(id)
-    }
-
     pub fn language_server_for_id(
         &self,
         id: LanguageServerId,
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index 68593f8fab0525..706d3afdce45e2 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -55,7 +55,7 @@ pub struct NodeBinarySettings {
     pub npm_path: Option<String>,
     /// If disabled, zed will download its own copy of node.
     #[serde(default)]
-    pub disable_path_lookup: Option<bool>,
+    pub ignore_system_version: Option<bool>,
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
@@ -143,7 +143,7 @@ const fn true_value() -> bool {
 pub struct BinarySettings {
     pub path: Option<String>,
     pub arguments: Option<Vec<String>>,
-    pub path_lookup: Option<bool>,
+    pub ignore_system_version: Option<bool>,
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index e3fe2baefa9b6c..0f37e06f438f92 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -481,7 +481,7 @@ fn main() {
         cx.observe_global::<SettingsStore>(move |cx| {
             let settings = &ProjectSettings::get_global(cx).node;
             let options = NodeBinaryOptions {
-                allow_path_lookup: !settings.disable_path_lookup.unwrap_or_default(),
+                allow_path_lookup: !settings.ignore_system_version.unwrap_or_default(),
                 // TODO: Expose this setting
                 allow_binary_download: true,
                 use_paths: settings.path.as_ref().map(|node_path| {
diff --git a/docs/src/languages/rust.md b/docs/src/languages/rust.md
index 233c378dae06d3..02e90d60a403b3 100644
--- a/docs/src/languages/rust.md
+++ b/docs/src/languages/rust.md
@@ -64,14 +64,14 @@ You can configure which `rust-analyzer` binary Zed should use.
 
 By default, Zed will try to find a `rust-analyzer` in your `$PATH` and try to use that. If that binary successfully executes `rust-analyzer --help`, it's used. Otherwise, Zed will fall back to installing its own `rust-analyzer` version and using that.
 
-If you want to disable Zed looking for a `rust-analyzer` binary, you can set `path_lookup` to `false` in your `settings.json`:
+If you want to disable Zed looking for a `rust-analyzer` binary, you can set `ignore_system_version` to `true` in your `settings.json`:
 
 ```json
 {
   "lsp": {
     "rust-analyzer": {
       "binary": {
-        "path_lookup": false
+        "ignore_system_version": true
       }
     }
   }

From 1eddd2f38d844f50af4ff0e76ddab63687519d7f Mon Sep 17 00:00:00 2001
From: Richard Feldman <oss@rtfeldman.com>
Date: Wed, 25 Sep 2024 15:21:00 -0400
Subject: [PATCH 331/762] Fix file descriptors leak in evals (#18351)

Fixes an issue where evals were hitting "too many open files" errors
because we were adding (and detaching) new directory watches for each
project. Now we add those watches globally/at the worktree level, and we
store the tasks so they stop watching on drop.

Release Notes:

- N/A

---------

Co-authored-by: Max <max@zed.dev>
Co-authored-by: Piotr <piotr@zed.dev>
Co-authored-by: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
---
 Cargo.lock                                    |  1 +
 .../src/platform/mac/attributed_string.rs     |  4 +-
 crates/project/src/project.rs                 | 10 +---
 crates/snippet_provider/Cargo.toml            |  1 +
 crates/snippet_provider/src/lib.rs            | 55 +++++++++++++++----
 5 files changed, 49 insertions(+), 22 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 41b2d6d452af53..26b979ccf72aa9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10498,6 +10498,7 @@ dependencies = [
  "futures 0.3.30",
  "gpui",
  "parking_lot",
+ "paths",
  "serde",
  "serde_json",
  "snippet",
diff --git a/crates/gpui/src/platform/mac/attributed_string.rs b/crates/gpui/src/platform/mac/attributed_string.rs
index 663ce67d4cd417..3f1185bc145cf3 100644
--- a/crates/gpui/src/platform/mac/attributed_string.rs
+++ b/crates/gpui/src/platform/mac/attributed_string.rs
@@ -70,9 +70,7 @@ mod tests {
 
         unsafe {
             let image: id = msg_send![class!(NSImage), alloc];
-            image.initWithContentsOfFile_(
-                NSString::alloc(nil).init_str("/Users/rtfeldman/Downloads/test.jpeg"),
-            );
+            image.initWithContentsOfFile_(NSString::alloc(nil).init_str("test.jpeg"));
             let _size = image.size();
 
             let string = NSString::alloc(nil).init_str("Test String");
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 8d95c8f2f18238..10fd88f286d994 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -587,10 +587,7 @@ impl Project {
             cx.spawn(move |this, cx| Self::send_buffer_ordered_messages(this, rx, cx))
                 .detach();
             let tasks = Inventory::new(cx);
-            let global_snippets_dir = paths::config_dir().join("snippets");
-            let snippets =
-                SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
-
+            let snippets = SnippetProvider::new(fs.clone(), BTreeSet::from_iter([]), cx);
             let worktree_store = cx.new_model(|_| WorktreeStore::local(false, fs.clone()));
             cx.subscribe(&worktree_store, Self::on_worktree_store_event)
                 .detach();
@@ -875,9 +872,8 @@ impl Project {
         let this = cx.new_model(|cx| {
             let replica_id = response.payload.replica_id as ReplicaId;
             let tasks = Inventory::new(cx);
-            let global_snippets_dir = paths::config_dir().join("snippets");
-            let snippets =
-                SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
+
+            let snippets = SnippetProvider::new(fs.clone(), BTreeSet::from_iter([]), cx);
 
             let mut worktrees = Vec::new();
             for worktree in response.payload.worktrees {
diff --git a/crates/snippet_provider/Cargo.toml b/crates/snippet_provider/Cargo.toml
index 75b7210a7afa54..95ab19ebb6f992 100644
--- a/crates/snippet_provider/Cargo.toml
+++ b/crates/snippet_provider/Cargo.toml
@@ -15,6 +15,7 @@ fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
 parking_lot.workspace = true
+paths.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 snippet.workspace = true
diff --git a/crates/snippet_provider/src/lib.rs b/crates/snippet_provider/src/lib.rs
index 17d615866a4307..a18f9ff1b6f899 100644
--- a/crates/snippet_provider/src/lib.rs
+++ b/crates/snippet_provider/src/lib.rs
@@ -130,8 +130,29 @@ async fn initial_scan(
 pub struct SnippetProvider {
     fs: Arc<dyn Fs>,
     snippets: HashMap<SnippetKind, BTreeMap<PathBuf, Vec<Arc<Snippet>>>>,
+    watch_tasks: Vec<Task<Result<()>>>,
 }
 
+// Watches global snippet directory, is created just once and reused across multiple projects
+struct GlobalSnippetWatcher(Model<SnippetProvider>);
+
+impl GlobalSnippetWatcher {
+    fn new(fs: Arc<dyn Fs>, cx: &mut AppContext) -> Self {
+        let global_snippets_dir = paths::config_dir().join("snippets");
+        let provider = cx.new_model(|_cx| SnippetProvider {
+            fs,
+            snippets: Default::default(),
+            watch_tasks: vec![],
+        });
+        provider.update(cx, |this, cx| {
+            this.watch_directory(&global_snippets_dir, cx)
+        });
+        Self(provider)
+    }
+}
+
+impl gpui::Global for GlobalSnippetWatcher {}
+
 impl SnippetProvider {
     pub fn new(
         fs: Arc<dyn Fs>,
@@ -139,29 +160,29 @@ impl SnippetProvider {
         cx: &mut AppContext,
     ) -> Model<Self> {
         cx.new_model(move |cx| {
+            if !cx.has_global::<GlobalSnippetWatcher>() {
+                let global_watcher = GlobalSnippetWatcher::new(fs.clone(), cx);
+                cx.set_global(global_watcher);
+            }
             let mut this = Self {
                 fs,
+                watch_tasks: Vec::new(),
                 snippets: Default::default(),
             };
 
-            let mut task_handles = vec![];
             for dir in dirs_to_watch {
-                task_handles.push(this.watch_directory(&dir, cx));
+                this.watch_directory(&dir, cx);
             }
-            cx.spawn(|_, _| async move {
-                futures::future::join_all(task_handles).await;
-            })
-            .detach();
 
             this
         })
     }
 
     /// Add directory to be watched for content changes
-    fn watch_directory(&mut self, path: &Path, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
+    fn watch_directory(&mut self, path: &Path, cx: &mut ModelContext<Self>) {
         let path: Arc<Path> = Arc::from(path);
 
-        cx.spawn(|this, mut cx| async move {
+        self.watch_tasks.push(cx.spawn(|this, mut cx| async move {
             let fs = this.update(&mut cx, |this, _| this.fs.clone())?;
             let watched_path = path.clone();
             let watcher = fs.watch(&watched_path, Duration::from_secs(1));
@@ -177,10 +198,10 @@ impl SnippetProvider {
                 .await?;
             }
             Ok(())
-        })
+        }));
     }
 
-    fn lookup_snippets<'a>(
+    fn lookup_snippets<'a, const LOOKUP_GLOBALS: bool>(
         &'a self,
         language: &'a SnippetKind,
         cx: &AppContext,
@@ -193,6 +214,16 @@ impl SnippetProvider {
             .into_iter()
             .flat_map(|(_, snippets)| snippets.into_iter())
             .collect();
+        if LOOKUP_GLOBALS {
+            if let Some(global_watcher) = cx.try_global::<GlobalSnippetWatcher>() {
+                user_snippets.extend(
+                    global_watcher
+                        .0
+                        .read(cx)
+                        .lookup_snippets::<false>(language, cx),
+                );
+            }
+        }
 
         let Some(registry) = SnippetRegistry::try_global(cx) else {
             return user_snippets;
@@ -205,11 +236,11 @@ impl SnippetProvider {
     }
 
     pub fn snippets_for(&self, language: SnippetKind, cx: &AppContext) -> Vec<Arc<Snippet>> {
-        let mut requested_snippets = self.lookup_snippets(&language, cx);
+        let mut requested_snippets = self.lookup_snippets::<true>(&language, cx);
 
         if language.is_some() {
             // Look up global snippets as well.
-            requested_snippets.extend(self.lookup_snippets(&None, cx));
+            requested_snippets.extend(self.lookup_snippets::<true>(&None, cx));
         }
         requested_snippets
     }

From dc7c49bd0b386e6303472542a44aaeba0c2c0526 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 25 Sep 2024 15:25:57 -0400
Subject: [PATCH 332/762] Pin actions/stale action to 28ca103 (#18356)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [actions/stale](https://redirect.github.com/actions/stale) | action |
pinDigest | -> `28ca103` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 .github/workflows/close_stale_issues.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/close_stale_issues.yml
index 2d4085524bb8d0..bbafb6c9851c4a 100644
--- a/.github/workflows/close_stale_issues.yml
+++ b/.github/workflows/close_stale_issues.yml
@@ -8,7 +8,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v9
+      - uses: actions/stale@28ca1036281a5e5922ead5184a1bbf96e5fc984e # v9
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           stale-issue-message: >

From ae6a3d15af5814eaa5602c23314499b73a8329e4 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Wed, 25 Sep 2024 12:45:41 -0700
Subject: [PATCH 333/762] Make python run local worktree LSPs (#18353)

Release Notes:

- Python: made it possible to use locally installed `pyright` if
available

---------

Co-authored-by: conrad <conrad@zed.dev>
---
 crates/language/src/language.rs         |  4 +++
 crates/languages/src/python.rs          | 21 +++++++++++
 crates/node_runtime/src/node_runtime.rs |  3 +-
 crates/project/src/lsp_store.rs         | 46 +++++++++++++++++++++++++
 4 files changed, 73 insertions(+), 1 deletion(-)

diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index 4c75ef4eeb38da..fad799da19898d 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -313,6 +313,10 @@ pub trait LspAdapterDelegate: Send + Sync {
     fn update_status(&self, language: LanguageServerName, status: LanguageServerBinaryStatus);
     async fn language_server_download_dir(&self, name: &LanguageServerName) -> Option<Arc<Path>>;
 
+    async fn npm_package_installed_version(
+        &self,
+        package_name: &str,
+    ) -> Result<Option<(PathBuf, String)>>;
     async fn which(&self, command: &OsStr) -> Option<PathBuf>;
     async fn shell_env(&self) -> HashMap<String, String>;
     async fn read_text_file(&self, path: PathBuf) -> Result<String>;
diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs
index 964abf42b525fa..4b5fe3d277cd39 100644
--- a/crates/languages/src/python.rs
+++ b/crates/languages/src/python.rs
@@ -20,6 +20,7 @@ use task::{TaskTemplate, TaskTemplates, VariableName};
 use util::ResultExt;
 
 const SERVER_PATH: &str = "node_modules/pyright/langserver.index.js";
+const NODE_MODULE_RELATIVE_SERVER_PATH: &str = "pyright/langserver.index.js";
 
 fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
     vec![server_path.into(), "--stdio".into()]
@@ -43,6 +44,26 @@ impl LspAdapter for PythonLspAdapter {
         Self::SERVER_NAME.clone()
     }
 
+    async fn check_if_user_installed(
+        &self,
+        delegate: &dyn LspAdapterDelegate,
+        _: &AsyncAppContext,
+    ) -> Option<LanguageServerBinary> {
+        let node = delegate.which("node".as_ref()).await?;
+        let (node_modules_path, _) = delegate
+            .npm_package_installed_version(Self::SERVER_NAME.as_ref())
+            .await
+            .log_err()??;
+
+        let path = node_modules_path.join(NODE_MODULE_RELATIVE_SERVER_PATH);
+
+        Some(LanguageServerBinary {
+            path: node,
+            env: None,
+            arguments: server_binary_arguments(&path),
+        })
+    }
+
     async fn fetch_latest_server_version(
         &self,
         _: &dyn LspAdapterDelegate,
diff --git a/crates/node_runtime/src/node_runtime.rs b/crates/node_runtime/src/node_runtime.rs
index 9507eb75364859..0f0512c65ee714 100644
--- a/crates/node_runtime/src/node_runtime.rs
+++ b/crates/node_runtime/src/node_runtime.rs
@@ -177,6 +177,7 @@ impl NodeRuntime {
             "5000",
         ]);
 
+        // This is also wrong because the directory is wrong.
         self.run_npm_subcommand(directory, "install", &arguments)
             .await?;
         Ok(())
@@ -576,7 +577,7 @@ impl NodeRuntimeTrait for SystemNodeRuntime {
     }
 }
 
-async fn read_package_installed_version(
+pub async fn read_package_installed_version(
     node_module_directory: PathBuf,
     name: &str,
 ) -> Result<Option<String>> {
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 21d5de53e6be28..bef57bafb48cf9 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -48,6 +48,7 @@ use lsp::{
     LspRequestFuture, MessageActionItem, MessageType, OneOf, ServerHealthStatus, ServerStatus,
     SymbolKind, TextEdit, Url, WorkDoneProgressCancelParams, WorkspaceFolder,
 };
+use node_runtime::read_package_installed_version;
 use parking_lot::{Mutex, RwLock};
 use postage::watch;
 use rand::prelude::*;
@@ -7801,6 +7802,44 @@ impl LspAdapterDelegate for LocalLspAdapterDelegate {
         task.await.unwrap_or_default()
     }
 
+    async fn npm_package_installed_version(
+        &self,
+        package_name: &str,
+    ) -> Result<Option<(PathBuf, String)>> {
+        let local_package_directory = self.worktree_root_path();
+        let node_modules_directory = local_package_directory.join("node_modules");
+
+        if let Some(version) =
+            read_package_installed_version(node_modules_directory.clone(), package_name).await?
+        {
+            return Ok(Some((node_modules_directory, version)));
+        }
+        let Some(npm) = self.which("npm".as_ref()).await else {
+            log::warn!(
+                "Failed to find npm executable for {:?}",
+                local_package_directory
+            );
+            return Ok(None);
+        };
+
+        let env = self.shell_env().await;
+        let output = smol::process::Command::new(&npm)
+            .args(["root", "-g"])
+            .envs(env)
+            .current_dir(local_package_directory)
+            .output()
+            .await?;
+        let global_node_modules =
+            PathBuf::from(String::from_utf8_lossy(&output.stdout).to_string());
+
+        if let Some(version) =
+            read_package_installed_version(global_node_modules.clone(), package_name).await?
+        {
+            return Ok(Some((global_node_modules, version)));
+        }
+        return Ok(None);
+    }
+
     #[cfg(not(target_os = "windows"))]
     async fn which(&self, command: &OsStr) -> Option<PathBuf> {
         let worktree_abs_path = self.worktree.abs_path();
@@ -7883,6 +7922,13 @@ impl LspAdapterDelegate for SshLspAdapterDelegate {
             .ok();
     }
 
+    async fn npm_package_installed_version(
+        &self,
+        _package_name: &str,
+    ) -> Result<Option<(PathBuf, String)>> {
+        Ok(None)
+    }
+
     fn http_client(&self) -> Arc<dyn HttpClient> {
         Arc::new(BlockedHttpClient)
     }

From 21a023980d39b0113d39331942eb05f365af8bc0 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Wed, 25 Sep 2024 12:50:38 -0700
Subject: [PATCH 334/762] Expand git diffs when clicking the gutter strip,
 display their controls in a block above (#18313)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Todo:

* [x] Tooltips for hunk buttons
* [x] Buttons to go to next and previous hunk
* [x] Ellipsis button that opens a context menu with `Revert all`

/cc @iamnbutler @danilo-leal for design 👀

Release Notes:

- Changed the behavior of the git gutter so that diff hunk are expanded
immediately when clicking the gutter, and hunk controls are displayed
above the hunk.

---------

Co-authored-by: Marshall <marshall@zed.dev>
Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 crates/collab/src/tests/editor_tests.rs | 289 +-----------
 crates/editor/src/editor.rs             | 126 ++---
 crates/editor/src/editor_tests.rs       | 211 ++++-----
 crates/editor/src/element.rs            |  95 +---
 crates/editor/src/hunk_diff.rs          | 597 +++++++++++++++---------
 5 files changed, 570 insertions(+), 748 deletions(-)

diff --git a/crates/collab/src/tests/editor_tests.rs b/crates/collab/src/tests/editor_tests.rs
index 121c93656305a6..d2835edc619e20 100644
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -7,18 +7,12 @@ use collections::HashMap;
 use editor::{
     actions::{
         ConfirmCodeAction, ConfirmCompletion, ConfirmRename, ContextMenuFirst, Redo, Rename,
-        RevertSelectedHunks, ToggleCodeActions, Undo,
-    },
-    display_map::DisplayRow,
-    test::{
-        editor_hunks,
-        editor_test_context::{AssertionContextManager, EditorTestContext},
-        expanded_hunks, expanded_hunks_background_highlights,
+        ToggleCodeActions, Undo,
     },
+    test::editor_test_context::{AssertionContextManager, EditorTestContext},
     Editor,
 };
 use futures::StreamExt;
-use git::diff::DiffHunkStatus;
 use gpui::{TestAppContext, UpdateGlobal, VisualContext, VisualTestContext};
 use indoc::indoc;
 use language::{
@@ -1970,285 +1964,6 @@ async fn test_inlay_hint_refresh_is_forwarded(
     });
 }
 
-#[gpui::test]
-async fn test_multiple_hunk_types_revert(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
-    let mut server = TestServer::start(cx_a.executor()).await;
-    let client_a = server.create_client(cx_a, "user_a").await;
-    let client_b = server.create_client(cx_b, "user_b").await;
-    server
-        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
-        .await;
-    let active_call_a = cx_a.read(ActiveCall::global);
-    let active_call_b = cx_b.read(ActiveCall::global);
-
-    cx_a.update(editor::init);
-    cx_b.update(editor::init);
-
-    client_a.language_registry().add(rust_lang());
-    client_b.language_registry().add(rust_lang());
-
-    let base_text = indoc! {r#"struct Row;
-struct Row1;
-struct Row2;
-
-struct Row4;
-struct Row5;
-struct Row6;
-
-struct Row8;
-struct Row9;
-struct Row10;"#};
-
-    client_a
-        .fs()
-        .insert_tree(
-            "/a",
-            json!({
-                "main.rs": base_text,
-            }),
-        )
-        .await;
-    let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
-    active_call_a
-        .update(cx_a, |call, cx| call.set_location(Some(&project_a), cx))
-        .await
-        .unwrap();
-    let project_id = active_call_a
-        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
-        .await
-        .unwrap();
-
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
-    active_call_b
-        .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
-        .await
-        .unwrap();
-
-    let (workspace_a, cx_a) = client_a.build_workspace(&project_a, cx_a);
-    let (workspace_b, cx_b) = client_b.build_workspace(&project_b, cx_b);
-
-    let editor_a = workspace_a
-        .update(cx_a, |workspace, cx| {
-            workspace.open_path((worktree_id, "main.rs"), None, true, cx)
-        })
-        .await
-        .unwrap()
-        .downcast::<Editor>()
-        .unwrap();
-
-    let editor_b = workspace_b
-        .update(cx_b, |workspace, cx| {
-            workspace.open_path((worktree_id, "main.rs"), None, true, cx)
-        })
-        .await
-        .unwrap()
-        .downcast::<Editor>()
-        .unwrap();
-
-    let mut editor_cx_a = EditorTestContext {
-        cx: cx_a.clone(),
-        window: cx_a.handle(),
-        editor: editor_a,
-        assertion_cx: AssertionContextManager::new(),
-    };
-    let mut editor_cx_b = EditorTestContext {
-        cx: cx_b.clone(),
-        window: cx_b.handle(),
-        editor: editor_b,
-        assertion_cx: AssertionContextManager::new(),
-    };
-
-    // host edits the file, that differs from the base text, producing diff hunks
-    editor_cx_a.set_state(indoc! {r#"struct Row;
-        struct Row0.1;
-        struct Row0.2;
-        struct Row1;
-
-        struct Row4;
-        struct Row5444;
-        struct Row6;
-
-        struct Row9;
-        struct Row1220;ˇ"#});
-    editor_cx_a.update_editor(|editor, cx| {
-        editor
-            .buffer()
-            .read(cx)
-            .as_singleton()
-            .unwrap()
-            .update(cx, |buffer, cx| {
-                buffer.set_diff_base(Some(base_text.into()), cx);
-            });
-    });
-    editor_cx_b.update_editor(|editor, cx| {
-        editor
-            .buffer()
-            .read(cx)
-            .as_singleton()
-            .unwrap()
-            .update(cx, |buffer, cx| {
-                buffer.set_diff_base(Some(base_text.into()), cx);
-            });
-    });
-    cx_a.executor().run_until_parked();
-    cx_b.executor().run_until_parked();
-
-    // the client selects a range in the updated buffer, expands it to see the diff for each hunk in the selection
-    // the host does not see the diffs toggled
-    editor_cx_b.set_selections_state(indoc! {r#"«ˇstruct Row;
-        struct Row0.1;
-        struct Row0.2;
-        struct Row1;
-
-        struct Row4;
-        struct Row5444;
-        struct Row6;
-
-        struct R»ow9;
-        struct Row1220;"#});
-    editor_cx_b
-        .update_editor(|editor, cx| editor.toggle_hunk_diff(&editor::actions::ToggleHunkDiff, cx));
-    cx_a.executor().run_until_parked();
-    cx_b.executor().run_until_parked();
-    editor_cx_a.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(expanded_hunks_background_highlights(editor, cx), Vec::new());
-        assert_eq!(
-            all_hunks,
-            vec![
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(1)..DisplayRow(3)
-                ),
-                (
-                    "struct Row2;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(4)..DisplayRow(4)
-                ),
-                (
-                    "struct Row5;\n".to_string(),
-                    DiffHunkStatus::Modified,
-                    DisplayRow(6)..DisplayRow(7)
-                ),
-                (
-                    "struct Row8;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(9)..DisplayRow(9)
-                ),
-                (
-                    "struct Row10;".to_string(),
-                    DiffHunkStatus::Modified,
-                    DisplayRow(10)..DisplayRow(10),
-                ),
-            ]
-        );
-        assert_eq!(all_expanded_hunks, Vec::new());
-    });
-    editor_cx_b.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(1)..=DisplayRow(2), DisplayRow(8)..=DisplayRow(8)],
-        );
-        assert_eq!(
-            all_hunks,
-            vec![
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(1)..DisplayRow(3)
-                ),
-                (
-                    "struct Row2;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(5)..DisplayRow(5)
-                ),
-                (
-                    "struct Row5;\n".to_string(),
-                    DiffHunkStatus::Modified,
-                    DisplayRow(8)..DisplayRow(9)
-                ),
-                (
-                    "struct Row8;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(12)..DisplayRow(12)
-                ),
-                (
-                    "struct Row10;".to_string(),
-                    DiffHunkStatus::Modified,
-                    DisplayRow(13)..DisplayRow(13),
-                ),
-            ]
-        );
-        assert_eq!(all_expanded_hunks, &all_hunks[..all_hunks.len() - 1]);
-    });
-
-    // the client reverts the hunks, removing the expanded diffs too
-    // both host and the client observe the reverted state (with one hunk left, not covered by client's selection)
-    editor_cx_b.update_editor(|editor, cx| {
-        editor.revert_selected_hunks(&RevertSelectedHunks, cx);
-    });
-    cx_a.executor().run_until_parked();
-    cx_b.executor().run_until_parked();
-    editor_cx_a.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(expanded_hunks_background_highlights(editor, cx), Vec::new());
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "struct Row10;".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(10)..DisplayRow(10),
-            )]
-        );
-        assert_eq!(all_expanded_hunks, Vec::new());
-    });
-    editor_cx_b.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(expanded_hunks_background_highlights(editor, cx), Vec::new());
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "struct Row10;".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(10)..DisplayRow(10),
-            )]
-        );
-        assert_eq!(all_expanded_hunks, Vec::new());
-    });
-    editor_cx_a.assert_editor_state(indoc! {r#"struct Row;
-        struct Row1;
-        struct Row2;
-
-        struct Row4;
-        struct Row5;
-        struct Row6;
-
-        struct Row8;
-        struct Row9;
-        struct Row1220;ˇ"#});
-    editor_cx_b.assert_editor_state(indoc! {r#"«ˇstruct Row;
-        struct Row1;
-        struct Row2;
-
-        struct Row4;
-        struct Row5;
-        struct Row6;
-
-        struct Row8;
-        struct R»ow9;
-        struct Row1220;"#});
-}
-
 #[gpui::test(iterations = 10)]
 async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
     let mut server = TestServer::start(cx_a.executor()).await;
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index ad5cd24d73ac46..78c8ba6920337c 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -154,7 +154,7 @@ use theme::{
 };
 use ui::{
     h_flex, prelude::*, ButtonSize, ButtonStyle, Disclosure, IconButton, IconName, IconSize,
-    ListItem, Popover, Tooltip,
+    ListItem, Popover, PopoverMenuHandle, Tooltip,
 };
 use util::{defer, maybe, post_inc, RangeExt, ResultExt, TryFutureExt};
 use workspace::item::{ItemHandle, PreviewTabsSettings};
@@ -562,6 +562,7 @@ pub struct Editor {
     nav_history: Option<ItemNavHistory>,
     context_menu: RwLock<Option<ContextMenu>>,
     mouse_context_menu: Option<MouseContextMenu>,
+    hunk_controls_menu_handle: PopoverMenuHandle<ui::ContextMenu>,
     completion_tasks: Vec<(CompletionId, Task<Option<()>>)>,
     signature_help_state: SignatureHelpState,
     auto_signature_help: Option<bool>,
@@ -1938,6 +1939,7 @@ impl Editor {
             nav_history: None,
             context_menu: RwLock::new(None),
             mouse_context_menu: None,
+            hunk_controls_menu_handle: PopoverMenuHandle::default(),
             completion_tasks: Default::default(),
             signature_help_state: SignatureHelpState::default(),
             auto_signature_help: None,
@@ -5383,23 +5385,6 @@ impl Editor {
             }))
     }
 
-    fn close_hunk_diff_button(
-        &self,
-        hunk: HoveredHunk,
-        row: DisplayRow,
-        cx: &mut ViewContext<Self>,
-    ) -> IconButton {
-        IconButton::new(
-            ("close_hunk_diff_indicator", row.0 as usize),
-            ui::IconName::Close,
-        )
-        .shape(ui::IconButtonShape::Square)
-        .icon_size(IconSize::XSmall)
-        .icon_color(Color::Muted)
-        .tooltip(|cx| Tooltip::for_action("Close hunk diff", &ToggleHunkDiff, cx))
-        .on_click(cx.listener(move |editor, _e, cx| editor.toggle_hovered_hunk(&hunk, cx)))
-    }
-
     pub fn context_menu_visible(&self) -> bool {
         self.context_menu
             .read()
@@ -9335,32 +9320,42 @@ impl Editor {
         }
     }
 
-    fn go_to_hunk(&mut self, _: &GoToHunk, cx: &mut ViewContext<Self>) {
+    fn go_to_next_hunk(&mut self, _: &GoToHunk, cx: &mut ViewContext<Self>) {
         let snapshot = self
             .display_map
             .update(cx, |display_map, cx| display_map.snapshot(cx));
         let selection = self.selections.newest::<Point>(cx);
+        self.go_to_hunk_after_position(&snapshot, selection.head(), cx);
+    }
 
-        if !self.seek_in_direction(
-            &snapshot,
-            selection.head(),
+    fn go_to_hunk_after_position(
+        &mut self,
+        snapshot: &DisplaySnapshot,
+        position: Point,
+        cx: &mut ViewContext<'_, Editor>,
+    ) -> Option<MultiBufferDiffHunk> {
+        if let Some(hunk) = self.go_to_next_hunk_in_direction(
+            snapshot,
+            position,
             false,
-            snapshot.buffer_snapshot.git_diff_hunks_in_range(
-                MultiBufferRow(selection.head().row + 1)..MultiBufferRow::MAX,
-            ),
+            snapshot
+                .buffer_snapshot
+                .git_diff_hunks_in_range(MultiBufferRow(position.row + 1)..MultiBufferRow::MAX),
             cx,
         ) {
-            let wrapped_point = Point::zero();
-            self.seek_in_direction(
-                &snapshot,
-                wrapped_point,
-                true,
-                snapshot.buffer_snapshot.git_diff_hunks_in_range(
-                    MultiBufferRow(wrapped_point.row + 1)..MultiBufferRow::MAX,
-                ),
-                cx,
-            );
+            return Some(hunk);
         }
+
+        let wrapped_point = Point::zero();
+        self.go_to_next_hunk_in_direction(
+            snapshot,
+            wrapped_point,
+            true,
+            snapshot.buffer_snapshot.git_diff_hunks_in_range(
+                MultiBufferRow(wrapped_point.row + 1)..MultiBufferRow::MAX,
+            ),
+            cx,
+        )
     }
 
     fn go_to_prev_hunk(&mut self, _: &GoToPrevHunk, cx: &mut ViewContext<Self>) {
@@ -9369,52 +9364,65 @@ impl Editor {
             .update(cx, |display_map, cx| display_map.snapshot(cx));
         let selection = self.selections.newest::<Point>(cx);
 
-        if !self.seek_in_direction(
-            &snapshot,
-            selection.head(),
+        self.go_to_hunk_before_position(&snapshot, selection.head(), cx);
+    }
+
+    fn go_to_hunk_before_position(
+        &mut self,
+        snapshot: &DisplaySnapshot,
+        position: Point,
+        cx: &mut ViewContext<'_, Editor>,
+    ) -> Option<MultiBufferDiffHunk> {
+        if let Some(hunk) = self.go_to_next_hunk_in_direction(
+            snapshot,
+            position,
             false,
-            snapshot.buffer_snapshot.git_diff_hunks_in_range_rev(
-                MultiBufferRow(0)..MultiBufferRow(selection.head().row),
-            ),
+            snapshot
+                .buffer_snapshot
+                .git_diff_hunks_in_range_rev(MultiBufferRow(0)..MultiBufferRow(position.row)),
             cx,
         ) {
-            let wrapped_point = snapshot.buffer_snapshot.max_point();
-            self.seek_in_direction(
-                &snapshot,
-                wrapped_point,
-                true,
-                snapshot.buffer_snapshot.git_diff_hunks_in_range_rev(
-                    MultiBufferRow(0)..MultiBufferRow(wrapped_point.row),
-                ),
-                cx,
-            );
+            return Some(hunk);
         }
+
+        let wrapped_point = snapshot.buffer_snapshot.max_point();
+        self.go_to_next_hunk_in_direction(
+            snapshot,
+            wrapped_point,
+            true,
+            snapshot
+                .buffer_snapshot
+                .git_diff_hunks_in_range_rev(MultiBufferRow(0)..MultiBufferRow(wrapped_point.row)),
+            cx,
+        )
     }
 
-    fn seek_in_direction(
+    fn go_to_next_hunk_in_direction(
         &mut self,
         snapshot: &DisplaySnapshot,
         initial_point: Point,
         is_wrapped: bool,
         hunks: impl Iterator<Item = MultiBufferDiffHunk>,
         cx: &mut ViewContext<Editor>,
-    ) -> bool {
+    ) -> Option<MultiBufferDiffHunk> {
         let display_point = initial_point.to_display_point(snapshot);
         let mut hunks = hunks
-            .map(|hunk| diff_hunk_to_display(&hunk, snapshot))
-            .filter(|hunk| is_wrapped || !hunk.contains_display_row(display_point.row()))
+            .map(|hunk| (diff_hunk_to_display(&hunk, snapshot), hunk))
+            .filter(|(display_hunk, _)| {
+                is_wrapped || !display_hunk.contains_display_row(display_point.row())
+            })
             .dedup();
 
-        if let Some(hunk) = hunks.next() {
+        if let Some((display_hunk, hunk)) = hunks.next() {
             self.change_selections(Some(Autoscroll::fit()), cx, |s| {
-                let row = hunk.start_display_row();
+                let row = display_hunk.start_display_row();
                 let point = DisplayPoint::new(row, 0);
                 s.select_display_ranges([point..point]);
             });
 
-            true
+            Some(hunk)
         } else {
-            false
+            None
         }
     }
 
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 5927c22cb08439..de1b12abe00778 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -9623,7 +9623,7 @@ async fn go_to_hunk(executor: BackgroundExecutor, cx: &mut gpui::TestAppContext)
     cx.update_editor(|editor, cx| {
         //Wrap around the bottom of the buffer
         for _ in 0..3 {
-            editor.go_to_hunk(&GoToHunk, cx);
+            editor.go_to_next_hunk(&GoToHunk, cx);
         }
     });
 
@@ -9709,7 +9709,7 @@ async fn go_to_hunk(executor: BackgroundExecutor, cx: &mut gpui::TestAppContext)
 
         //Make sure that the fold only gets one hunk
         for _ in 0..4 {
-            editor.go_to_hunk(&GoToHunk, cx);
+            editor.go_to_next_hunk(&GoToHunk, cx);
         }
     });
 
@@ -11226,7 +11226,7 @@ async fn test_toggle_hunk_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
 
     cx.update_editor(|editor, cx| {
         for _ in 0..4 {
-            editor.go_to_hunk(&GoToHunk, cx);
+            editor.go_to_next_hunk(&GoToHunk, cx);
             editor.toggle_hunk_diff(&ToggleHunkDiff, cx);
         }
     });
@@ -11249,18 +11249,13 @@ async fn test_toggle_hunk_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
         let snapshot = editor.snapshot(cx);
         let all_hunks = editor_hunks(editor, &snapshot, cx);
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(1)..=DisplayRow(1), DisplayRow(7)..=DisplayRow(7), DisplayRow(9)..=DisplayRow(9)],
-            "After expanding, all git additions should be highlighted for Modified (split into added and removed) and Added hunks"
-        );
         assert_eq!(
             all_hunks,
             vec![
-                ("use some::mod;\n".to_string(), DiffHunkStatus::Modified, DisplayRow(1)..DisplayRow(2)),
-                ("const A: u32 = 42;\n".to_string(), DiffHunkStatus::Removed, DisplayRow(4)..DisplayRow(4)),
-                ("    println!(\"hello\");\n".to_string(), DiffHunkStatus::Modified, DisplayRow(7)..DisplayRow(8)),
-                ("".to_string(), DiffHunkStatus::Added, DisplayRow(9)..DisplayRow(10)),
+                ("use some::mod;\n".to_string(), DiffHunkStatus::Modified, DisplayRow(2)..DisplayRow(3)),
+                ("const A: u32 = 42;\n".to_string(), DiffHunkStatus::Removed, DisplayRow(6)..DisplayRow(6)),
+                ("    println!(\"hello\");\n".to_string(), DiffHunkStatus::Modified, DisplayRow(10)..DisplayRow(11)),
+                ("".to_string(), DiffHunkStatus::Added, DisplayRow(13)..DisplayRow(14)),
             ],
             "After expanding, all hunks' display rows should have shifted by the amount of deleted lines added \
             (from modified and removed hunks)"
@@ -11269,6 +11264,11 @@ async fn test_toggle_hunk_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
             all_hunks, all_expanded_hunks,
             "Editor hunks should not change and all be expanded"
         );
+        assert_eq!(
+            expanded_hunks_background_highlights(editor, cx),
+            vec![DisplayRow(2)..=DisplayRow(2), DisplayRow(10)..=DisplayRow(10), DisplayRow(13)..=DisplayRow(13)],
+            "After expanding, all git additions should be highlighted for Modified (split into added and removed) and Added hunks"
+        );
     });
 
     cx.update_editor(|editor, cx| {
@@ -11311,7 +11311,7 @@ async fn test_toggled_diff_base_change(
         const B: u32 = 42;
         const C: u32 = 42;
 
-        fn main(ˇ) {
+        fn main() {
             println!("hello");
 
             println!("world");
@@ -11356,9 +11356,9 @@ async fn test_toggled_diff_base_change(
                     DisplayRow(3)..DisplayRow(3)
                 ),
                 (
-                    "fn main(ˇ) {\n    println!(\"hello\");\n".to_string(),
+                    "    println!(\"hello\");\n".to_string(),
                     DiffHunkStatus::Modified,
-                    DisplayRow(5)..DisplayRow(7)
+                    DisplayRow(6)..DisplayRow(7)
                 ),
                 (
                     "".to_string(),
@@ -11390,22 +11390,18 @@ async fn test_toggled_diff_base_change(
         "#
         .unindent(),
     );
+
     cx.update_editor(|editor, cx| {
         let snapshot = editor.snapshot(cx);
         let all_hunks = editor_hunks(editor, &snapshot, cx);
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(9)..=DisplayRow(10), DisplayRow(13)..=DisplayRow(14)],
-            "After expanding, all git additions should be highlighted for Modified (split into added and removed) and Added hunks"
-        );
         assert_eq!(
             all_hunks,
             vec![
-                ("use some::mod1;\n".to_string(), DiffHunkStatus::Removed, DisplayRow(1)..DisplayRow(1)),
-                ("const B: u32 = 42;\n".to_string(), DiffHunkStatus::Removed, DisplayRow(5)..DisplayRow(5)),
-                ("fn main(ˇ) {\n    println!(\"hello\");\n".to_string(), DiffHunkStatus::Modified, DisplayRow(9)..DisplayRow(11)),
-                ("".to_string(), DiffHunkStatus::Added, DisplayRow(13)..DisplayRow(15)),
+                ("use some::mod1;\n".to_string(), DiffHunkStatus::Removed, DisplayRow(2)..DisplayRow(2)),
+                ("const B: u32 = 42;\n".to_string(), DiffHunkStatus::Removed, DisplayRow(7)..DisplayRow(7)),
+                ("    println!(\"hello\");\n".to_string(), DiffHunkStatus::Modified, DisplayRow(12)..DisplayRow(13)),
+                ("".to_string(), DiffHunkStatus::Added, DisplayRow(16)..DisplayRow(18)),
             ],
             "After expanding, all hunks' display rows should have shifted by the amount of deleted lines added \
             (from modified and removed hunks)"
@@ -11414,6 +11410,11 @@ async fn test_toggled_diff_base_change(
             all_hunks, all_expanded_hunks,
             "Editor hunks should not change and all be expanded"
         );
+        assert_eq!(
+            expanded_hunks_background_highlights(editor, cx),
+            vec![DisplayRow(12)..=DisplayRow(12), DisplayRow(16)..=DisplayRow(17)],
+            "After expanding, all git additions should be highlighted for Modified (split into added and removed) and Added hunks"
+        );
     });
 
     cx.set_diff_base(Some("new diff base!"));
@@ -11459,7 +11460,7 @@ async fn test_fold_unfold_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
         const B: u32 = 42;
         const C: u32 = 42;
 
-        fn main(ˇ) {
+        fn main() {
             println!("hello");
 
             println!("world");
@@ -11520,9 +11521,9 @@ async fn test_fold_unfold_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
                     DisplayRow(3)..DisplayRow(3)
                 ),
                 (
-                    "fn main(ˇ) {\n    println!(\"hello\");\n".to_string(),
+                    "    println!(\"hello\");\n".to_string(),
                     DiffHunkStatus::Modified,
-                    DisplayRow(5)..DisplayRow(7)
+                    DisplayRow(6)..DisplayRow(7)
                 ),
                 (
                     "".to_string(),
@@ -11576,50 +11577,50 @@ async fn test_fold_unfold_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
         let snapshot = editor.snapshot(cx);
         let all_hunks = editor_hunks(editor, &snapshot, cx);
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![
-                DisplayRow(9)..=DisplayRow(10),
-                DisplayRow(13)..=DisplayRow(14),
-                DisplayRow(19)..=DisplayRow(19)
-            ]
-        );
         assert_eq!(
             all_hunks,
             vec![
                 (
                     "use some::mod1;\n".to_string(),
                     DiffHunkStatus::Removed,
-                    DisplayRow(1)..DisplayRow(1)
+                    DisplayRow(2)..DisplayRow(2)
                 ),
                 (
                     "const B: u32 = 42;\n".to_string(),
                     DiffHunkStatus::Removed,
-                    DisplayRow(5)..DisplayRow(5)
+                    DisplayRow(7)..DisplayRow(7)
                 ),
                 (
-                    "fn main(ˇ) {\n    println!(\"hello\");\n".to_string(),
+                    "    println!(\"hello\");\n".to_string(),
                     DiffHunkStatus::Modified,
-                    DisplayRow(9)..DisplayRow(11)
+                    DisplayRow(12)..DisplayRow(13)
                 ),
                 (
                     "".to_string(),
                     DiffHunkStatus::Added,
-                    DisplayRow(13)..DisplayRow(15)
+                    DisplayRow(16)..DisplayRow(18)
                 ),
                 (
                     "".to_string(),
                     DiffHunkStatus::Added,
-                    DisplayRow(19)..DisplayRow(20)
+                    DisplayRow(23)..DisplayRow(24)
                 ),
                 (
                     "fn another2() {\n".to_string(),
                     DiffHunkStatus::Removed,
-                    DisplayRow(23)..DisplayRow(23)
+                    DisplayRow(28)..DisplayRow(28)
                 ),
             ],
         );
         assert_eq!(all_hunks, all_expanded_hunks);
+        assert_eq!(
+            expanded_hunks_background_highlights(editor, cx),
+            vec![
+                DisplayRow(12)..=DisplayRow(12),
+                DisplayRow(16)..=DisplayRow(17),
+                DisplayRow(23)..=DisplayRow(23)
+            ]
+        );
     });
 
     cx.update_editor(|editor, cx| editor.fold_selected_ranges(&FoldSelectedRanges, cx));
@@ -11653,11 +11654,6 @@ async fn test_fold_unfold_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
         let snapshot = editor.snapshot(cx);
         let all_hunks = editor_hunks(editor, &snapshot, cx);
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(0)..=DisplayRow(0), DisplayRow(5)..=DisplayRow(5)],
-            "Only one hunk is left not folded, its highlight should be visible"
-        );
         assert_eq!(
             all_hunks,
             vec![
@@ -11672,7 +11668,7 @@ async fn test_fold_unfold_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
                     DisplayRow(0)..DisplayRow(0)
                 ),
                 (
-                    "fn main(ˇ) {\n    println!(\"hello\");\n".to_string(),
+                    "    println!(\"hello\");\n".to_string(),
                     DiffHunkStatus::Modified,
                     DisplayRow(0)..DisplayRow(0)
                 ),
@@ -11684,12 +11680,12 @@ async fn test_fold_unfold_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
                 (
                     "".to_string(),
                     DiffHunkStatus::Added,
-                    DisplayRow(5)..DisplayRow(6)
+                    DisplayRow(6)..DisplayRow(7)
                 ),
                 (
                     "fn another2() {\n".to_string(),
                     DiffHunkStatus::Removed,
-                    DisplayRow(9)..DisplayRow(9)
+                    DisplayRow(11)..DisplayRow(11)
                 ),
             ],
             "Hunk list should still return shifted folded hunks"
@@ -11700,16 +11696,21 @@ async fn test_fold_unfold_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
                 (
                     "".to_string(),
                     DiffHunkStatus::Added,
-                    DisplayRow(5)..DisplayRow(6)
+                    DisplayRow(6)..DisplayRow(7)
                 ),
                 (
                     "fn another2() {\n".to_string(),
                     DiffHunkStatus::Removed,
-                    DisplayRow(9)..DisplayRow(9)
+                    DisplayRow(11)..DisplayRow(11)
                 ),
             ],
             "Only non-folded hunks should be left expanded"
         );
+        assert_eq!(
+            expanded_hunks_background_highlights(editor, cx),
+            vec![DisplayRow(0)..=DisplayRow(0), DisplayRow(6)..=DisplayRow(6)],
+            "Only one hunk is left not folded, its highlight should be visible"
+        );
     });
 
     cx.update_editor(|editor, cx| {
@@ -11746,51 +11747,51 @@ async fn test_fold_unfold_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
         let snapshot = editor.snapshot(cx);
         let all_hunks = editor_hunks(editor, &snapshot, cx);
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![
-                DisplayRow(9)..=DisplayRow(10),
-                DisplayRow(13)..=DisplayRow(14),
-                DisplayRow(19)..=DisplayRow(19)
-            ],
-            "After unfolding, all hunk diffs should be visible again"
-        );
         assert_eq!(
             all_hunks,
             vec![
                 (
                     "use some::mod1;\n".to_string(),
                     DiffHunkStatus::Removed,
-                    DisplayRow(1)..DisplayRow(1)
+                    DisplayRow(2)..DisplayRow(2)
                 ),
                 (
                     "const B: u32 = 42;\n".to_string(),
                     DiffHunkStatus::Removed,
-                    DisplayRow(5)..DisplayRow(5)
+                    DisplayRow(7)..DisplayRow(7)
                 ),
                 (
-                    "fn main(ˇ) {\n    println!(\"hello\");\n".to_string(),
+                    "    println!(\"hello\");\n".to_string(),
                     DiffHunkStatus::Modified,
-                    DisplayRow(9)..DisplayRow(11)
+                    DisplayRow(12)..DisplayRow(13)
                 ),
                 (
                     "".to_string(),
                     DiffHunkStatus::Added,
-                    DisplayRow(13)..DisplayRow(15)
+                    DisplayRow(16)..DisplayRow(18)
                 ),
                 (
                     "".to_string(),
                     DiffHunkStatus::Added,
-                    DisplayRow(19)..DisplayRow(20)
+                    DisplayRow(23)..DisplayRow(24)
                 ),
                 (
                     "fn another2() {\n".to_string(),
                     DiffHunkStatus::Removed,
-                    DisplayRow(23)..DisplayRow(23)
+                    DisplayRow(28)..DisplayRow(28)
                 ),
             ],
         );
         assert_eq!(all_hunks, all_expanded_hunks);
+        assert_eq!(
+            expanded_hunks_background_highlights(editor, cx),
+            vec![
+                DisplayRow(12)..=DisplayRow(12),
+                DisplayRow(16)..=DisplayRow(17),
+                DisplayRow(23)..=DisplayRow(23)
+            ],
+            "After unfolding, all hunk diffs should be visible again"
+        );
     });
 }
 
@@ -11940,17 +11941,17 @@ async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut gpui::TestAppContext)
         (
             "bbbb\n".to_string(),
             DiffHunkStatus::Removed,
-            DisplayRow(5)..DisplayRow(5),
+            DisplayRow(6)..DisplayRow(6),
         ),
         (
             "nnnn\n".to_string(),
             DiffHunkStatus::Modified,
-            DisplayRow(23)..DisplayRow(24),
+            DisplayRow(25)..DisplayRow(26),
         ),
         (
             "".to_string(),
             DiffHunkStatus::Added,
-            DisplayRow(43)..DisplayRow(44),
+            DisplayRow(46)..DisplayRow(47),
         ),
     ];
 
@@ -11975,8 +11976,8 @@ async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut gpui::TestAppContext)
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
             vec![
-                DisplayRow(23)..=DisplayRow(23),
-                DisplayRow(43)..=DisplayRow(43)
+                DisplayRow(25)..=DisplayRow(25),
+                DisplayRow(46)..=DisplayRow(46)
             ],
         );
         assert_eq!(all_hunks, expected_all_hunks_shifted);
@@ -12007,8 +12008,8 @@ async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut gpui::TestAppContext)
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
             vec![
-                DisplayRow(23)..=DisplayRow(23),
-                DisplayRow(43)..=DisplayRow(43)
+                DisplayRow(25)..=DisplayRow(25),
+                DisplayRow(46)..=DisplayRow(46)
             ],
         );
         assert_eq!(all_hunks, expected_all_hunks_shifted);
@@ -12116,12 +12117,12 @@ async fn test_edits_around_toggled_additions(
             vec![(
                 "".to_string(),
                 DiffHunkStatus::Added,
-                DisplayRow(4)..DisplayRow(7)
+                DisplayRow(5)..DisplayRow(8)
             )]
         );
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(4)..=DisplayRow(6)]
+            vec![DisplayRow(5)..=DisplayRow(7)]
         );
         assert_eq!(all_hunks, all_expanded_hunks);
     });
@@ -12156,12 +12157,12 @@ async fn test_edits_around_toggled_additions(
             vec![(
                 "".to_string(),
                 DiffHunkStatus::Added,
-                DisplayRow(4)..DisplayRow(8)
+                DisplayRow(5)..DisplayRow(9)
             )]
         );
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(4)..=DisplayRow(6)],
+            vec![DisplayRow(5)..=DisplayRow(7)],
             "Edited hunk should have one more line added"
         );
         assert_eq!(
@@ -12201,12 +12202,12 @@ async fn test_edits_around_toggled_additions(
             vec![(
                 "".to_string(),
                 DiffHunkStatus::Added,
-                DisplayRow(4)..DisplayRow(9)
+                DisplayRow(5)..DisplayRow(10)
             )]
         );
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(4)..=DisplayRow(6)],
+            vec![DisplayRow(5)..=DisplayRow(7)],
             "Edited hunk should have one more line added"
         );
         assert_eq!(all_hunks, all_expanded_hunks);
@@ -12245,12 +12246,12 @@ async fn test_edits_around_toggled_additions(
             vec![(
                 "".to_string(),
                 DiffHunkStatus::Added,
-                DisplayRow(4)..DisplayRow(8)
+                DisplayRow(5)..DisplayRow(9)
             )]
         );
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(4)..=DisplayRow(6)],
+            vec![DisplayRow(5)..=DisplayRow(7)],
             "Deleting a line should shrint the hunk"
         );
         assert_eq!(
@@ -12293,12 +12294,12 @@ async fn test_edits_around_toggled_additions(
             vec![(
                 "".to_string(),
                 DiffHunkStatus::Added,
-                DisplayRow(5)..DisplayRow(6)
+                DisplayRow(6)..DisplayRow(7)
             )]
         );
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(5)..=DisplayRow(5)]
+            vec![DisplayRow(6)..=DisplayRow(6)]
         );
         assert_eq!(all_hunks, all_expanded_hunks);
     });
@@ -12335,7 +12336,7 @@ async fn test_edits_around_toggled_additions(
                 (
                     "const A: u32 = 42;\n".to_string(),
                     DiffHunkStatus::Removed,
-                    DisplayRow(2)..DisplayRow(2)
+                    DisplayRow(3)..DisplayRow(3)
                 )
             ]
         );
@@ -12349,7 +12350,7 @@ async fn test_edits_around_toggled_additions(
             vec![(
                 "const A: u32 = 42;\n".to_string(),
                 DiffHunkStatus::Removed,
-                DisplayRow(2)..DisplayRow(2)
+                DisplayRow(3)..DisplayRow(3)
             )],
             "Should open hunks that were adjacent to the stale addition one"
         );
@@ -12445,7 +12446,7 @@ async fn test_edits_around_toggled_deletions(
             vec![(
                 "const A: u32 = 42;\n".to_string(),
                 DiffHunkStatus::Removed,
-                DisplayRow(4)..DisplayRow(4)
+                DisplayRow(5)..DisplayRow(5)
             )]
         );
         assert_eq!(all_hunks, all_expanded_hunks);
@@ -12485,7 +12486,7 @@ async fn test_edits_around_toggled_deletions(
             vec![(
                 "const A: u32 = 42;\nconst B: u32 = 42;\n".to_string(),
                 DiffHunkStatus::Removed,
-                DisplayRow(5)..DisplayRow(5)
+                DisplayRow(6)..DisplayRow(6)
             )]
         );
         assert_eq!(all_hunks, all_expanded_hunks);
@@ -12520,7 +12521,7 @@ async fn test_edits_around_toggled_deletions(
             vec![(
                 "const A: u32 = 42;\nconst B: u32 = 42;\nconst C: u32 = 42;\n".to_string(),
                 DiffHunkStatus::Removed,
-                DisplayRow(6)..DisplayRow(6)
+                DisplayRow(7)..DisplayRow(7)
             )]
         );
         assert_eq!(all_hunks, all_expanded_hunks);
@@ -12554,12 +12555,12 @@ async fn test_edits_around_toggled_deletions(
             vec![(
                 "const A: u32 = 42;\nconst B: u32 = 42;\nconst C: u32 = 42;\n\n".to_string(),
                 DiffHunkStatus::Modified,
-                DisplayRow(7)..DisplayRow(8)
+                DisplayRow(8)..DisplayRow(9)
             )]
         );
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(7)..=DisplayRow(7)],
+            vec![DisplayRow(8)..=DisplayRow(8)],
             "Modified expanded hunks should display additions and highlight their background"
         );
         assert_eq!(all_hunks, all_expanded_hunks);
@@ -12653,14 +12654,14 @@ async fn test_edits_around_toggled_modifications(
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(6)..=DisplayRow(6)],
+            vec![DisplayRow(7)..=DisplayRow(7)],
         );
         assert_eq!(
             all_hunks,
             vec![(
                 "const C: u32 = 42;\n".to_string(),
                 DiffHunkStatus::Modified,
-                DisplayRow(6)..DisplayRow(7)
+                DisplayRow(7)..DisplayRow(8)
             )]
         );
         assert_eq!(all_hunks, all_expanded_hunks);
@@ -12696,7 +12697,7 @@ async fn test_edits_around_toggled_modifications(
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(6)..=DisplayRow(6)],
+            vec![DisplayRow(7)..=DisplayRow(7)],
             "Modified hunk should grow highlighted lines on more text additions"
         );
         assert_eq!(
@@ -12704,7 +12705,7 @@ async fn test_edits_around_toggled_modifications(
             vec![(
                 "const C: u32 = 42;\n".to_string(),
                 DiffHunkStatus::Modified,
-                DisplayRow(6)..DisplayRow(9)
+                DisplayRow(7)..DisplayRow(10)
             )]
         );
         assert_eq!(all_hunks, all_expanded_hunks);
@@ -12742,14 +12743,14 @@ async fn test_edits_around_toggled_modifications(
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(6)..=DisplayRow(8)],
+            vec![DisplayRow(7)..=DisplayRow(9)],
         );
         assert_eq!(
             all_hunks,
             vec![(
                 "const B: u32 = 42;\nconst C: u32 = 42;\n".to_string(),
                 DiffHunkStatus::Modified,
-                DisplayRow(6)..DisplayRow(9)
+                DisplayRow(7)..DisplayRow(10)
             )],
             "Modified hunk should grow deleted lines on text deletions above"
         );
@@ -12786,7 +12787,7 @@ async fn test_edits_around_toggled_modifications(
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(6)..=DisplayRow(9)],
+            vec![DisplayRow(7)..=DisplayRow(10)],
             "Modified hunk should grow deleted lines on text modifications above"
         );
         assert_eq!(
@@ -12794,7 +12795,7 @@ async fn test_edits_around_toggled_modifications(
             vec![(
                 "const A: u32 = 42;\nconst B: u32 = 42;\nconst C: u32 = 42;\n".to_string(),
                 DiffHunkStatus::Modified,
-                DisplayRow(6)..DisplayRow(10)
+                DisplayRow(7)..DisplayRow(11)
             )]
         );
         assert_eq!(all_hunks, all_expanded_hunks);
@@ -12830,7 +12831,7 @@ async fn test_edits_around_toggled_modifications(
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(6)..=DisplayRow(8)],
+            vec![DisplayRow(7)..=DisplayRow(9)],
             "Modified hunk should grow shrink lines on modification lines removal"
         );
         assert_eq!(
@@ -12838,7 +12839,7 @@ async fn test_edits_around_toggled_modifications(
             vec![(
                 "const A: u32 = 42;\nconst B: u32 = 42;\nconst C: u32 = 42;\n".to_string(),
                 DiffHunkStatus::Modified,
-                DisplayRow(6)..DisplayRow(9)
+                DisplayRow(7)..DisplayRow(10)
             )]
         );
         assert_eq!(all_hunks, all_expanded_hunks);
@@ -12880,7 +12881,7 @@ async fn test_edits_around_toggled_modifications(
                 "const A: u32 = 42;\nconst B: u32 = 42;\nconst C: u32 = 42;\nconst D: u32 = 42;\n"
                     .to_string(),
                 DiffHunkStatus::Removed,
-                DisplayRow(7)..DisplayRow(7)
+                DisplayRow(8)..DisplayRow(8)
             )]
         );
         assert_eq!(all_hunks, all_expanded_hunks);
@@ -12974,14 +12975,14 @@ async fn test_multiple_expanded_hunks_merge(
         let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
         assert_eq!(
             expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(6)..=DisplayRow(6)],
+            vec![DisplayRow(7)..=DisplayRow(7)],
         );
         assert_eq!(
             all_hunks,
             vec![(
                 "const C: u32 = 42;\n".to_string(),
                 DiffHunkStatus::Modified,
-                DisplayRow(6)..DisplayRow(7)
+                DisplayRow(7)..DisplayRow(8)
             )]
         );
         assert_eq!(all_hunks, all_expanded_hunks);
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index cf8edb67dccbc6..9fe05bc4f26063 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -11,7 +11,7 @@ use crate::{
     hover_popover::{
         self, hover_at, HOVER_POPOVER_GAP, MIN_POPOVER_CHARACTER_WIDTH, MIN_POPOVER_LINE_HEIGHT,
     },
-    hunk_diff::{diff_hunk_to_display, DisplayDiffHunk, ExpandedHunk},
+    hunk_diff::{diff_hunk_to_display, DisplayDiffHunk},
     hunk_status,
     items::BufferSearchHighlights,
     mouse_context_menu::{self, MenuPosition, MouseContextMenu},
@@ -20,8 +20,8 @@ use crate::{
     DocumentHighlightRead, DocumentHighlightWrite, Editor, EditorMode, EditorSettings,
     EditorSnapshot, EditorStyle, ExpandExcerpts, FocusedBlock, GutterDimensions, HalfPageDown,
     HalfPageUp, HandleInput, HoveredCursor, HoveredHunk, LineDown, LineUp, OpenExcerpts, PageDown,
-    PageUp, Point, RangeToAnchorExt, RowExt, RowRangeExt, SelectPhase, Selection, SoftWrap,
-    ToPoint, CURSORS_VISIBLE_FOR, MAX_LINE_LEN,
+    PageUp, Point, RowExt, RowRangeExt, SelectPhase, Selection, SoftWrap, ToPoint,
+    CURSORS_VISIBLE_FOR, MAX_LINE_LEN,
 };
 use client::ParticipantIndex;
 use collections::{BTreeMap, HashMap};
@@ -302,7 +302,7 @@ impl EditorElement {
         }
         register_action(view, cx, Editor::go_to_diagnostic);
         register_action(view, cx, Editor::go_to_prev_diagnostic);
-        register_action(view, cx, Editor::go_to_hunk);
+        register_action(view, cx, Editor::go_to_next_hunk);
         register_action(view, cx, Editor::go_to_prev_hunk);
         register_action(view, cx, |editor, a, cx| {
             editor.go_to_definition(a, cx).detach_and_log_err(cx);
@@ -489,28 +489,7 @@ impl EditorElement {
         let mut modifiers = event.modifiers;
 
         if let Some(hovered_hunk) = hovered_hunk {
-            if modifiers.control || modifiers.platform {
-                editor.toggle_hovered_hunk(&hovered_hunk, cx);
-            } else {
-                let display_range = hovered_hunk
-                    .multi_buffer_range
-                    .clone()
-                    .to_display_points(&position_map.snapshot);
-                let hunk_bounds = Self::diff_hunk_bounds(
-                    &position_map.snapshot,
-                    position_map.line_height,
-                    gutter_hitbox.bounds,
-                    &DisplayDiffHunk::Unfolded {
-                        diff_base_byte_range: hovered_hunk.diff_base_byte_range.clone(),
-                        display_row_range: display_range.start.row()..display_range.end.row(),
-                        multi_buffer_range: hovered_hunk.multi_buffer_range.clone(),
-                        status: hovered_hunk.status,
-                    },
-                );
-                if hunk_bounds.contains(&event.position) {
-                    editor.open_hunk_context_menu(hovered_hunk, event.position, cx);
-                }
-            }
+            editor.toggle_hovered_hunk(&hovered_hunk, cx);
             cx.notify();
             return;
         } else if gutter_hitbox.is_hovered(cx) {
@@ -1303,13 +1282,13 @@ impl EditorElement {
             let display_hunks = buffer_snapshot
                 .git_diff_hunks_in_range(buffer_start_row..buffer_end_row)
                 .filter_map(|hunk| {
-                    let mut display_hunk = diff_hunk_to_display(&hunk, snapshot);
+                    let display_hunk = diff_hunk_to_display(&hunk, snapshot);
 
                     if let DisplayDiffHunk::Unfolded {
                         multi_buffer_range,
                         status,
                         ..
-                    } = &mut display_hunk
+                    } = &display_hunk
                     {
                         let mut is_expanded = false;
                         while let Some(expanded_hunk) = expanded_hunks.peek() {
@@ -1332,11 +1311,7 @@ impl EditorElement {
                         }
                         match status {
                             DiffHunkStatus::Added => {}
-                            DiffHunkStatus::Modified => {
-                                if is_expanded {
-                                    *status = DiffHunkStatus::Added;
-                                }
-                            }
+                            DiffHunkStatus::Modified => {}
                             DiffHunkStatus::Removed => {
                                 if is_expanded {
                                     return None;
@@ -3371,9 +3346,6 @@ impl EditorElement {
             for test_indicator in layout.test_indicators.iter_mut() {
                 test_indicator.paint(cx);
             }
-            for close_indicator in layout.close_indicators.iter_mut() {
-                close_indicator.paint(cx);
-            }
 
             if let Some(indicator) = layout.code_actions_indicator.as_mut() {
                 indicator.paint(cx);
@@ -4159,46 +4131,6 @@ impl EditorElement {
             + 1;
         self.column_pixels(digit_count, cx)
     }
-
-    #[allow(clippy::too_many_arguments)]
-    fn layout_hunk_diff_close_indicators(
-        &self,
-        line_height: Pixels,
-        scroll_pixel_position: gpui::Point<Pixels>,
-        gutter_dimensions: &GutterDimensions,
-        gutter_hitbox: &Hitbox,
-        rows_with_hunk_bounds: &HashMap<DisplayRow, Bounds<Pixels>>,
-        expanded_hunks_by_rows: HashMap<DisplayRow, ExpandedHunk>,
-        cx: &mut WindowContext,
-    ) -> Vec<AnyElement> {
-        self.editor.update(cx, |editor, cx| {
-            expanded_hunks_by_rows
-                .into_iter()
-                .map(|(display_row, hunk)| {
-                    let button = editor.close_hunk_diff_button(
-                        HoveredHunk {
-                            multi_buffer_range: hunk.hunk_range,
-                            status: hunk.status,
-                            diff_base_byte_range: hunk.diff_base_byte_range,
-                        },
-                        display_row,
-                        cx,
-                    );
-
-                    prepaint_gutter_button(
-                        button,
-                        display_row,
-                        line_height,
-                        gutter_dimensions,
-                        scroll_pixel_position,
-                        gutter_hitbox,
-                        rows_with_hunk_bounds,
-                        cx,
-                    )
-                })
-                .collect()
-        })
-    }
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -5549,15 +5481,6 @@ impl Element for EditorElement {
                     } else {
                         Vec::new()
                     };
-                    let close_indicators = self.layout_hunk_diff_close_indicators(
-                        line_height,
-                        scroll_pixel_position,
-                        &gutter_dimensions,
-                        &gutter_hitbox,
-                        &rows_with_hunk_bounds,
-                        expanded_add_hunks_by_rows,
-                        cx,
-                    );
 
                     self.layout_signature_help(
                         &hitbox,
@@ -5670,7 +5593,6 @@ impl Element for EditorElement {
                         selections,
                         mouse_context_menu,
                         test_indicators,
-                        close_indicators,
                         code_actions_indicator,
                         gutter_fold_toggles,
                         crease_trailers,
@@ -5812,7 +5734,6 @@ pub struct EditorLayout {
     selections: Vec<(PlayerColor, Vec<SelectionLayout>)>,
     code_actions_indicator: Option<AnyElement>,
     test_indicators: Vec<AnyElement>,
-    close_indicators: Vec<AnyElement>,
     gutter_fold_toggles: Vec<Option<AnyElement>>,
     crease_trailers: Vec<Option<CreaseTrailerLayout>>,
     mouse_context_menu: Option<AnyElement>,
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index 67e8a25df58c56..4fa1f10a8a17c9 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -1,28 +1,26 @@
 use collections::{hash_map, HashMap, HashSet};
 use git::diff::DiffHunkStatus;
-use gpui::{Action, AppContext, CursorStyle, Hsla, Model, MouseButton, Subscription, Task, View};
+use gpui::{Action, AnchorCorner, AppContext, CursorStyle, Hsla, Model, MouseButton, Task, View};
 use language::{Buffer, BufferId, Point};
 use multi_buffer::{
     Anchor, AnchorRangeExt, ExcerptRange, MultiBuffer, MultiBufferDiffHunk, MultiBufferRow,
     MultiBufferSnapshot, ToPoint,
 };
-use settings::SettingsStore;
 use std::{
     ops::{Range, RangeInclusive},
     sync::Arc,
 };
 use ui::{
-    prelude::*, ActiveTheme, ContextMenu, InteractiveElement, IntoElement, ParentElement, Pixels,
-    Styled, ViewContext, VisualContext,
+    prelude::*, ActiveTheme, ContextMenu, IconButtonShape, InteractiveElement, IntoElement,
+    ParentElement, PopoverMenu, Styled, Tooltip, ViewContext, VisualContext,
 };
-use util::{debug_panic, RangeExt};
+use util::RangeExt;
 
 use crate::{
-    editor_settings::CurrentLineHighlight, hunk_status, hunks_for_selections,
-    mouse_context_menu::MouseContextMenu, BlockDisposition, BlockProperties, BlockStyle,
-    CustomBlockId, DiffRowHighlight, DisplayRow, DisplaySnapshot, Editor, EditorElement,
-    EditorSnapshot, ExpandAllHunkDiffs, RangeToAnchorExt, RevertFile, RevertSelectedHunks,
-    ToDisplayPoint, ToggleHunkDiff,
+    editor_settings::CurrentLineHighlight, hunk_status, hunks_for_selections, BlockDisposition,
+    BlockProperties, BlockStyle, CustomBlockId, DiffRowHighlight, DisplayRow, DisplaySnapshot,
+    Editor, EditorElement, EditorSnapshot, ExpandAllHunkDiffs, GoToHunk, GoToPrevHunk,
+    RangeToAnchorExt, RevertFile, RevertSelectedHunks, ToDisplayPoint, ToggleHunkDiff,
 };
 
 #[derive(Debug, Clone)]
@@ -41,7 +39,7 @@ pub(super) struct ExpandedHunks {
 
 #[derive(Debug, Clone)]
 pub(super) struct ExpandedHunk {
-    pub block: Option<CustomBlockId>,
+    pub blocks: Vec<CustomBlockId>,
     pub hunk_range: Range<Anchor>,
     pub diff_base_byte_range: Range<usize>,
     pub status: DiffHunkStatus,
@@ -77,85 +75,6 @@ impl ExpandedHunks {
 }
 
 impl Editor {
-    pub(super) fn open_hunk_context_menu(
-        &mut self,
-        hovered_hunk: HoveredHunk,
-        clicked_point: gpui::Point<Pixels>,
-        cx: &mut ViewContext<Editor>,
-    ) {
-        let focus_handle = self.focus_handle.clone();
-        let expanded = self
-            .expanded_hunks
-            .hunks(false)
-            .any(|expanded_hunk| expanded_hunk.hunk_range == hovered_hunk.multi_buffer_range);
-        let editor_handle = cx.view().clone();
-        let editor_snapshot = self.snapshot(cx);
-        let start_point = self
-            .to_pixel_point(hovered_hunk.multi_buffer_range.start, &editor_snapshot, cx)
-            .unwrap_or(clicked_point);
-        let end_point = self
-            .to_pixel_point(hovered_hunk.multi_buffer_range.start, &editor_snapshot, cx)
-            .unwrap_or(clicked_point);
-        let norm =
-            |a: gpui::Point<Pixels>, b: gpui::Point<Pixels>| (a.x - b.x).abs() + (a.y - b.y).abs();
-        let closest_source = if norm(start_point, clicked_point) < norm(end_point, clicked_point) {
-            hovered_hunk.multi_buffer_range.start
-        } else {
-            hovered_hunk.multi_buffer_range.end
-        };
-
-        self.mouse_context_menu = MouseContextMenu::pinned_to_editor(
-            self,
-            closest_source,
-            clicked_point,
-            ContextMenu::build(cx, move |menu, _| {
-                menu.on_blur_subscription(Subscription::new(|| {}))
-                    .context(focus_handle)
-                    .entry(
-                        if expanded {
-                            "Collapse Hunk"
-                        } else {
-                            "Expand Hunk"
-                        },
-                        Some(ToggleHunkDiff.boxed_clone()),
-                        {
-                            let editor = editor_handle.clone();
-                            let hunk = hovered_hunk.clone();
-                            move |cx| {
-                                editor.update(cx, |editor, cx| {
-                                    editor.toggle_hovered_hunk(&hunk, cx);
-                                });
-                            }
-                        },
-                    )
-                    .entry("Revert Hunk", Some(RevertSelectedHunks.boxed_clone()), {
-                        let editor = editor_handle.clone();
-                        let hunk = hovered_hunk.clone();
-                        move |cx| {
-                            let multi_buffer = editor.read(cx).buffer().clone();
-                            let multi_buffer_snapshot = multi_buffer.read(cx).snapshot(cx);
-                            let mut revert_changes = HashMap::default();
-                            if let Some(hunk) =
-                                crate::hunk_diff::to_diff_hunk(&hunk, &multi_buffer_snapshot)
-                            {
-                                Editor::prepare_revert_change(
-                                    &mut revert_changes,
-                                    &multi_buffer,
-                                    &hunk,
-                                    cx,
-                                );
-                            }
-                            if !revert_changes.is_empty() {
-                                editor.update(cx, |editor, cx| editor.revert(revert_changes, cx));
-                            }
-                        }
-                    })
-                    .action("Revert File", RevertFile.boxed_clone())
-            }),
-            cx,
-        )
-    }
-
     pub(super) fn toggle_hovered_hunk(
         &mut self,
         hovered_hunk: &HoveredHunk,
@@ -264,7 +183,8 @@ impl Editor {
                                         break;
                                     } else if expanded_hunk_row_range == hunk_to_toggle_row_range {
                                         highlights_to_remove.push(expanded_hunk.hunk_range.clone());
-                                        blocks_to_remove.extend(expanded_hunk.block);
+                                        blocks_to_remove
+                                            .extend(expanded_hunk.blocks.iter().copied());
                                         hunks_to_toggle.next();
                                         retain = false;
                                         break;
@@ -371,9 +291,17 @@ impl Editor {
             Err(ix) => ix,
         };
 
-        let block = match hunk.status {
+        let blocks;
+        match hunk.status {
             DiffHunkStatus::Removed => {
-                self.insert_deleted_text_block(diff_base_buffer, deleted_text_lines, hunk, cx)
+                blocks = self.insert_blocks(
+                    [
+                        self.hunk_header_block(&hunk, cx),
+                        Self::deleted_text_block(hunk, diff_base_buffer, deleted_text_lines, cx),
+                    ],
+                    None,
+                    cx,
+                );
             }
             DiffHunkStatus::Added => {
                 self.highlight_rows::<DiffRowHighlight>(
@@ -382,7 +310,7 @@ impl Editor {
                     false,
                     cx,
                 );
-                None
+                blocks = self.insert_blocks([self.hunk_header_block(&hunk, cx)], None, cx);
             }
             DiffHunkStatus::Modified => {
                 self.highlight_rows::<DiffRowHighlight>(
@@ -391,13 +319,20 @@ impl Editor {
                     false,
                     cx,
                 );
-                self.insert_deleted_text_block(diff_base_buffer, deleted_text_lines, hunk, cx)
+                blocks = self.insert_blocks(
+                    [
+                        self.hunk_header_block(&hunk, cx),
+                        Self::deleted_text_block(hunk, diff_base_buffer, deleted_text_lines, cx),
+                    ],
+                    None,
+                    cx,
+                );
             }
         };
         self.expanded_hunks.hunks.insert(
             block_insert_index,
             ExpandedHunk {
-                block,
+                blocks,
                 hunk_range: hunk_start..hunk_end,
                 status: hunk.status,
                 folded: false,
@@ -408,109 +343,368 @@ impl Editor {
         Some(())
     }
 
-    fn insert_deleted_text_block(
-        &mut self,
-        diff_base_buffer: Model<Buffer>,
-        deleted_text_height: u32,
+    fn hunk_header_block(
+        &self,
         hunk: &HoveredHunk,
-        cx: &mut ViewContext<'_, Self>,
-    ) -> Option<CustomBlockId> {
-        let deleted_hunk_color = deleted_hunk_color(cx);
-        let (editor_height, editor_with_deleted_text) =
-            editor_with_deleted_text(diff_base_buffer, deleted_hunk_color, hunk, cx);
-        let editor = cx.view().clone();
-        let hunk = hunk.clone();
-        let height = editor_height.max(deleted_text_height);
-        let mut new_block_ids = self.insert_blocks(
-            Some(BlockProperties {
-                position: hunk.multi_buffer_range.start,
-                height,
-                style: BlockStyle::Flex,
-                disposition: BlockDisposition::Above,
-                render: Box::new(move |cx| {
-                    let width = EditorElement::diff_hunk_strip_width(cx.line_height());
-                    let gutter_dimensions = editor.read(cx.context).gutter_dimensions;
-
-                    let close_button = editor.update(cx.context, |editor, cx| {
-                        let editor_snapshot = editor.snapshot(cx);
-                        let hunk_display_range = hunk
-                            .multi_buffer_range
-                            .clone()
-                            .to_display_points(&editor_snapshot);
-                        editor.close_hunk_diff_button(
-                            hunk.clone(),
-                            hunk_display_range.start.row(),
-                            cx,
-                        )
-                    });
+        cx: &mut ViewContext<'_, Editor>,
+    ) -> BlockProperties<Anchor> {
+        let border_color = cx.theme().colors().border_disabled;
+        let gutter_color = match hunk.status {
+            DiffHunkStatus::Added => cx.theme().status().created,
+            DiffHunkStatus::Modified => cx.theme().status().modified,
+            DiffHunkStatus::Removed => cx.theme().status().deleted,
+        };
+
+        BlockProperties {
+            position: hunk.multi_buffer_range.start,
+            height: 1,
+            style: BlockStyle::Sticky,
+            disposition: BlockDisposition::Above,
+            priority: 0,
+            render: Box::new({
+                let editor = cx.view().clone();
+                let hunk = hunk.clone();
+                move |cx| {
+                    let hunk_controls_menu_handle =
+                        editor.read(cx).hunk_controls_menu_handle.clone();
 
                     h_flex()
-                        .id("gutter with editor")
-                        .bg(deleted_hunk_color)
-                        .h(height as f32 * cx.line_height())
+                        .id(cx.block_id)
                         .w_full()
+                        .h(cx.line_height())
+                        .child(
+                            div()
+                                .id("gutter-strip")
+                                .w(EditorElement::diff_hunk_strip_width(cx.line_height()))
+                                .h_full()
+                                .bg(gutter_color)
+                                .cursor(CursorStyle::PointingHand)
+                                .on_click({
+                                    let editor = editor.clone();
+                                    let hunk = hunk.clone();
+                                    move |_event, cx| {
+                                        editor.update(cx, |editor, cx| {
+                                            editor.toggle_hovered_hunk(&hunk, cx);
+                                        });
+                                    }
+                                }),
+                        )
                         .child(
                             h_flex()
-                                .id("gutter")
-                                .max_w(gutter_dimensions.full_width())
-                                .min_w(gutter_dimensions.full_width())
                                 .size_full()
+                                .justify_between()
+                                .border_t_1()
+                                .border_color(border_color)
                                 .child(
                                     h_flex()
-                                        .id("gutter hunk")
-                                        .bg(cx.theme().status().deleted)
-                                        .pl(gutter_dimensions.margin
-                                            + gutter_dimensions
-                                                .git_blame_entries_width
-                                                .unwrap_or_default())
-                                        .max_w(width)
-                                        .min_w(width)
-                                        .size_full()
-                                        .cursor(CursorStyle::PointingHand)
-                                        .on_mouse_down(MouseButton::Left, {
-                                            let editor = editor.clone();
-                                            let hunk = hunk.clone();
-                                            move |event, cx| {
-                                                let modifiers = event.modifiers;
-                                                if modifiers.control || modifiers.platform {
-                                                    editor.update(cx, |editor, cx| {
-                                                        editor.toggle_hovered_hunk(&hunk, cx);
-                                                    });
-                                                } else {
-                                                    editor.update(cx, |editor, cx| {
-                                                        editor.open_hunk_context_menu(
-                                                            hunk.clone(),
-                                                            event.position,
+                                        .gap_2()
+                                        .pl_6()
+                                        .child(
+                                            IconButton::new("next-hunk", IconName::ArrowDown)
+                                                .shape(IconButtonShape::Square)
+                                                .icon_size(IconSize::Small)
+                                                .tooltip({
+                                                    let focus_handle = editor.focus_handle(cx);
+                                                    move |cx| {
+                                                        Tooltip::for_action_in(
+                                                            "Next Hunk",
+                                                            &GoToHunk,
+                                                            &focus_handle,
                                                             cx,
-                                                        );
-                                                    });
-                                                }
-                                            }
-                                        }),
+                                                        )
+                                                    }
+                                                })
+                                                .on_click({
+                                                    let editor = editor.clone();
+                                                    let hunk = hunk.clone();
+                                                    move |_event, cx| {
+                                                        editor.update(cx, |editor, cx| {
+                                                            let snapshot = editor.snapshot(cx);
+                                                            let position = hunk
+                                                                .multi_buffer_range
+                                                                .end
+                                                                .to_point(
+                                                                    &snapshot.buffer_snapshot,
+                                                                );
+                                                            if let Some(hunk) = editor
+                                                                .go_to_hunk_after_position(
+                                                                    &snapshot, position, cx,
+                                                                )
+                                                            {
+                                                                let multi_buffer_start = snapshot
+                                                                    .buffer_snapshot
+                                                                    .anchor_before(Point::new(
+                                                                        hunk.row_range.start.0,
+                                                                        0,
+                                                                    ));
+                                                                let multi_buffer_end = snapshot
+                                                                    .buffer_snapshot
+                                                                    .anchor_after(Point::new(
+                                                                        hunk.row_range.end.0,
+                                                                        0,
+                                                                    ));
+                                                                editor.expand_diff_hunk(
+                                                                    None,
+                                                                    &HoveredHunk {
+                                                                        multi_buffer_range:
+                                                                            multi_buffer_start
+                                                                                ..multi_buffer_end,
+                                                                        status: hunk_status(&hunk),
+                                                                        diff_base_byte_range: hunk
+                                                                            .diff_base_byte_range,
+                                                                    },
+                                                                    cx,
+                                                                );
+                                                            }
+                                                        });
+                                                    }
+                                                }),
+                                        )
+                                        .child(
+                                            IconButton::new("prev-hunk", IconName::ArrowUp)
+                                                .shape(IconButtonShape::Square)
+                                                .icon_size(IconSize::Small)
+                                                .tooltip({
+                                                    let focus_handle = editor.focus_handle(cx);
+                                                    move |cx| {
+                                                        Tooltip::for_action_in(
+                                                            "Previous Hunk",
+                                                            &GoToPrevHunk,
+                                                            &focus_handle,
+                                                            cx,
+                                                        )
+                                                    }
+                                                })
+                                                .on_click({
+                                                    let editor = editor.clone();
+                                                    let hunk = hunk.clone();
+                                                    move |_event, cx| {
+                                                        editor.update(cx, |editor, cx| {
+                                                            let snapshot = editor.snapshot(cx);
+                                                            let position = hunk
+                                                                .multi_buffer_range
+                                                                .start
+                                                                .to_point(
+                                                                    &snapshot.buffer_snapshot,
+                                                                );
+                                                            let hunk = editor
+                                                                .go_to_hunk_before_position(
+                                                                    &snapshot, position, cx,
+                                                                );
+                                                            if let Some(hunk) = hunk {
+                                                                let multi_buffer_start = snapshot
+                                                                    .buffer_snapshot
+                                                                    .anchor_before(Point::new(
+                                                                        hunk.row_range.start.0,
+                                                                        0,
+                                                                    ));
+                                                                let multi_buffer_end = snapshot
+                                                                    .buffer_snapshot
+                                                                    .anchor_after(Point::new(
+                                                                        hunk.row_range.end.0,
+                                                                        0,
+                                                                    ));
+                                                                editor.expand_diff_hunk(
+                                                                    None,
+                                                                    &HoveredHunk {
+                                                                        multi_buffer_range:
+                                                                            multi_buffer_start
+                                                                                ..multi_buffer_end,
+                                                                        status: hunk_status(&hunk),
+                                                                        diff_base_byte_range: hunk
+                                                                            .diff_base_byte_range,
+                                                                    },
+                                                                    cx,
+                                                                );
+                                                            }
+                                                        });
+                                                    }
+                                                }),
+                                        ),
                                 )
                                 .child(
-                                    v_flex()
-                                        .size_full()
-                                        .pt(rems(0.25))
-                                        .justify_start()
-                                        .child(close_button),
+                                    h_flex()
+                                        .gap_2()
+                                        .pr_6()
+                                        .child({
+                                            let focus = editor.focus_handle(cx);
+                                            PopoverMenu::new("hunk-controls-dropdown")
+                                                .trigger(
+                                                    IconButton::new(
+                                                        "toggle_editor_selections_icon",
+                                                        IconName::EllipsisVertical,
+                                                    )
+                                                    .shape(IconButtonShape::Square)
+                                                    .icon_size(IconSize::Small)
+                                                    .style(ButtonStyle::Subtle)
+                                                    .selected(
+                                                        hunk_controls_menu_handle.is_deployed(),
+                                                    )
+                                                    .when(
+                                                        !hunk_controls_menu_handle.is_deployed(),
+                                                        |this| {
+                                                            this.tooltip(|cx| {
+                                                                Tooltip::text("Hunk Controls", cx)
+                                                            })
+                                                        },
+                                                    ),
+                                                )
+                                                .anchor(AnchorCorner::TopRight)
+                                                .with_handle(hunk_controls_menu_handle)
+                                                .menu(move |cx| {
+                                                    let focus = focus.clone();
+                                                    let menu =
+                                                        ContextMenu::build(cx, move |menu, _| {
+                                                            menu.context(focus.clone()).action(
+                                                                "Discard All",
+                                                                RevertFile.boxed_clone(),
+                                                            )
+                                                        });
+                                                    Some(menu)
+                                                })
+                                        })
+                                        .child(
+                                            IconButton::new("discard", IconName::RotateCcw)
+                                                .shape(IconButtonShape::Square)
+                                                .icon_size(IconSize::Small)
+                                                .tooltip({
+                                                    let focus_handle = editor.focus_handle(cx);
+                                                    move |cx| {
+                                                        Tooltip::for_action_in(
+                                                            "Discard Hunk",
+                                                            &RevertSelectedHunks,
+                                                            &focus_handle,
+                                                            cx,
+                                                        )
+                                                    }
+                                                })
+                                                .on_click({
+                                                    let editor = editor.clone();
+                                                    let hunk = hunk.clone();
+                                                    move |_event, cx| {
+                                                        let multi_buffer =
+                                                            editor.read(cx).buffer().clone();
+                                                        let multi_buffer_snapshot =
+                                                            multi_buffer.read(cx).snapshot(cx);
+                                                        let mut revert_changes = HashMap::default();
+                                                        if let Some(hunk) =
+                                                            crate::hunk_diff::to_diff_hunk(
+                                                                &hunk,
+                                                                &multi_buffer_snapshot,
+                                                            )
+                                                        {
+                                                            Editor::prepare_revert_change(
+                                                                &mut revert_changes,
+                                                                &multi_buffer,
+                                                                &hunk,
+                                                                cx,
+                                                            );
+                                                        }
+                                                        if !revert_changes.is_empty() {
+                                                            editor.update(cx, |editor, cx| {
+                                                                editor.revert(revert_changes, cx)
+                                                            });
+                                                        }
+                                                    }
+                                                }),
+                                        )
+                                        .child(
+                                            IconButton::new("collapse", IconName::Close)
+                                                .shape(IconButtonShape::Square)
+                                                .icon_size(IconSize::Small)
+                                                .tooltip({
+                                                    let focus_handle = editor.focus_handle(cx);
+                                                    move |cx| {
+                                                        Tooltip::for_action_in(
+                                                            "Collapse Hunk",
+                                                            &ToggleHunkDiff,
+                                                            &focus_handle,
+                                                            cx,
+                                                        )
+                                                    }
+                                                })
+                                                .on_click({
+                                                    let editor = editor.clone();
+                                                    let hunk = hunk.clone();
+                                                    move |_event, cx| {
+                                                        editor.update(cx, |editor, cx| {
+                                                            editor.toggle_hovered_hunk(&hunk, cx);
+                                                        });
+                                                    }
+                                                }),
+                                        ),
                                 ),
                         )
-                        .child(editor_with_deleted_text.clone())
                         .into_any_element()
-                }),
-                priority: 0,
+                }
+            }),
+        }
+    }
+
+    fn deleted_text_block(
+        hunk: &HoveredHunk,
+        diff_base_buffer: Model<Buffer>,
+        deleted_text_height: u32,
+        cx: &mut ViewContext<'_, Editor>,
+    ) -> BlockProperties<Anchor> {
+        let gutter_color = match hunk.status {
+            DiffHunkStatus::Added => unreachable!(),
+            DiffHunkStatus::Modified => cx.theme().status().modified,
+            DiffHunkStatus::Removed => cx.theme().status().deleted,
+        };
+        let deleted_hunk_color = deleted_hunk_color(cx);
+        let (editor_height, editor_with_deleted_text) =
+            editor_with_deleted_text(diff_base_buffer, deleted_hunk_color, hunk, cx);
+        let editor = cx.view().clone();
+        let hunk = hunk.clone();
+        let height = editor_height.max(deleted_text_height);
+        BlockProperties {
+            position: hunk.multi_buffer_range.start,
+            height,
+            style: BlockStyle::Flex,
+            disposition: BlockDisposition::Above,
+            priority: 0,
+            render: Box::new(move |cx| {
+                let width = EditorElement::diff_hunk_strip_width(cx.line_height());
+                let gutter_dimensions = editor.read(cx.context).gutter_dimensions;
+
+                h_flex()
+                    .id(cx.block_id)
+                    .bg(deleted_hunk_color)
+                    .h(height as f32 * cx.line_height())
+                    .w_full()
+                    .child(
+                        h_flex()
+                            .id("gutter")
+                            .max_w(gutter_dimensions.full_width())
+                            .min_w(gutter_dimensions.full_width())
+                            .size_full()
+                            .child(
+                                h_flex()
+                                    .id("gutter hunk")
+                                    .bg(gutter_color)
+                                    .pl(gutter_dimensions.margin
+                                        + gutter_dimensions
+                                            .git_blame_entries_width
+                                            .unwrap_or_default())
+                                    .max_w(width)
+                                    .min_w(width)
+                                    .size_full()
+                                    .cursor(CursorStyle::PointingHand)
+                                    .on_mouse_down(MouseButton::Left, {
+                                        let editor = editor.clone();
+                                        let hunk = hunk.clone();
+                                        move |_event, cx| {
+                                            editor.update(cx, |editor, cx| {
+                                                editor.toggle_hovered_hunk(&hunk, cx);
+                                            });
+                                        }
+                                    }),
+                            ),
+                    )
+                    .child(editor_with_deleted_text.clone())
+                    .into_any_element()
             }),
-            None,
-            cx,
-        );
-        if new_block_ids.len() == 1 {
-            new_block_ids.pop()
-        } else {
-            debug_panic!(
-                "Inserted one editor block but did not receive exactly one block id: {new_block_ids:?}"
-            );
-            None
         }
     }
 
@@ -521,7 +715,7 @@ impl Editor {
             .expanded_hunks
             .hunks
             .drain(..)
-            .filter_map(|expanded_hunk| expanded_hunk.block)
+            .flat_map(|expanded_hunk| expanded_hunk.blocks.into_iter())
             .collect::<HashSet<_>>();
         if to_remove.is_empty() {
             false
@@ -603,7 +797,7 @@ impl Editor {
                                             expanded_hunk.folded = true;
                                             highlights_to_remove
                                                 .push(expanded_hunk.hunk_range.clone());
-                                            if let Some(block) = expanded_hunk.block.take() {
+                                            for block in expanded_hunk.blocks.drain(..) {
                                                 blocks_to_remove.insert(block);
                                             }
                                             break;
@@ -650,7 +844,7 @@ impl Editor {
                             }
                         }
                         if !retain {
-                            blocks_to_remove.extend(expanded_hunk.block);
+                            blocks_to_remove.extend(expanded_hunk.blocks.drain(..));
                             highlights_to_remove.push(expanded_hunk.hunk_range.clone());
                         }
                         retain
@@ -749,7 +943,7 @@ fn added_hunk_color(cx: &AppContext) -> Hsla {
 }
 
 fn deleted_hunk_color(cx: &AppContext) -> Hsla {
-    let mut deleted_color = cx.theme().status().git().deleted;
+    let mut deleted_color = cx.theme().status().deleted;
     deleted_color.fade_out(0.7);
     deleted_color
 }
@@ -788,32 +982,15 @@ fn editor_with_deleted_text(
             false,
             cx,
         );
-
-        let subscription_editor = parent_editor.clone();
-        editor._subscriptions.extend([
-            cx.on_blur(&editor.focus_handle, |editor, cx| {
-                editor.set_current_line_highlight(Some(CurrentLineHighlight::None));
+        editor.set_current_line_highlight(Some(CurrentLineHighlight::None));
+        editor
+            ._subscriptions
+            .extend([cx.on_blur(&editor.focus_handle, |editor, cx| {
                 editor.change_selections(None, cx, |s| {
                     s.try_cancel();
                 });
-                cx.notify();
-            }),
-            cx.on_focus(&editor.focus_handle, move |editor, cx| {
-                let restored_highlight = if let Some(parent_editor) = subscription_editor.upgrade()
-                {
-                    parent_editor.read(cx).current_line_highlight
-                } else {
-                    None
-                };
-                editor.set_current_line_highlight(restored_highlight);
-                cx.notify();
-            }),
-            cx.observe_global::<SettingsStore>(|editor, cx| {
-                if !editor.is_focused(cx) {
-                    editor.set_current_line_highlight(Some(CurrentLineHighlight::None));
-                }
-            }),
-        ]);
+            })]);
+
         let parent_editor_for_reverts = parent_editor.clone();
         let original_multi_buffer_range = hunk.multi_buffer_range.clone();
         let diff_base_range = hunk.diff_base_byte_range.clone();

From 4b4565fb7afaa7ab2c8d2058c924120fda911311 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Wed, 25 Sep 2024 22:55:36 +0200
Subject: [PATCH 335/762] assistant: Enable assistant panel/inline assists in
 ssh remote projects (#18367)

Release Notes:

- ssh remoting: Enable assistant panel and inline assists (running on
client)
---
 crates/assistant/src/assistant_panel.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 22237eeb079270..c7a06b428b9f1a 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -960,7 +960,8 @@ impl AssistantPanel {
     }
 
     fn new_context(&mut self, cx: &mut ViewContext<Self>) -> Option<View<ContextEditor>> {
-        if self.project.read(cx).is_via_collab() {
+        let project = self.project.read(cx);
+        if project.is_via_collab() && project.dev_server_project_id().is_none() {
             let task = self
                 .context_store
                 .update(cx, |store, cx| store.create_remote_context(cx));

From 7398f795e3fde21b8c1a6a40cd67c0b1854ed60c Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 25 Sep 2024 22:01:12 +0000
Subject: [PATCH 336/762] Ollama llama3.2 default context size (#18366)

Release Notes:

- Ollama: Added llama3.2 support
---
 crates/ollama/src/ollama.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/ollama/src/ollama.rs b/crates/ollama/src/ollama.rs
index e592bfa17717d3..84404afce13b10 100644
--- a/crates/ollama/src/ollama.rs
+++ b/crates/ollama/src/ollama.rs
@@ -83,7 +83,7 @@ fn get_max_tokens(name: &str) -> usize {
         "codellama" | "starcoder2" => 16384,
         "mistral" | "codestral" | "mixstral" | "llava" | "qwen2" | "dolphin-mixtral" => 32768,
         "llama3.1" | "phi3" | "phi3.5" | "command-r" | "deepseek-coder-v2" | "yi-coder"
-        | "qwen2.5-coder" => 128000,
+        | "llama3.2" | "qwen2.5-coder" => 128000,
         _ => DEFAULT_TOKENS,
     }
     .clamp(1, MAXIMUM_TOKENS)

From 40408e731e859ecaf03919aaa32f22ff41869522 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 25 Sep 2024 22:01:33 +0000
Subject: [PATCH 337/762] Fix sending alt-enter in terminal (#18363)

---
 crates/terminal/src/mappings/keys.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/terminal/src/mappings/keys.rs b/crates/terminal/src/mappings/keys.rs
index e760db3616fea3..2d4fe4c62e97be 100644
--- a/crates/terminal/src/mappings/keys.rs
+++ b/crates/terminal/src/mappings/keys.rs
@@ -51,6 +51,7 @@ pub fn to_esc_str(keystroke: &Keystroke, mode: &TermMode, alt_is_meta: bool) ->
         ("escape", AlacModifiers::None) => Some("\x1b".to_string()),
         ("enter", AlacModifiers::None) => Some("\x0d".to_string()),
         ("enter", AlacModifiers::Shift) => Some("\x0d".to_string()),
+        ("enter", AlacModifiers::Alt) => Some("\x1b\x0d".to_string()),
         ("backspace", AlacModifiers::None) => Some("\x7f".to_string()),
         //Interesting escape codes
         ("tab", AlacModifiers::Shift) => Some("\x1b[Z".to_string()),

From 64532e94e456dd4595897c96a0d06a7e22379add Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 25 Sep 2024 16:29:04 -0600
Subject: [PATCH 338/762] Move adapters to remote (#18359)

Release Notes:

- ssh remoting: run LSP Adapters on host

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 Cargo.lock                                   |   1 +
 crates/languages/Cargo.toml                  |  54 ++-
 crates/languages/src/lib.rs                  |  17 +-
 crates/project/src/lsp_store.rs              | 442 +------------------
 crates/project/src/project.rs                |   3 +-
 crates/proto/proto/zed.proto                 |  74 +---
 crates/proto/src/proto.rs                    |  18 -
 crates/remote_server/Cargo.toml              |   1 +
 crates/remote_server/src/headless_project.rs |  12 +-
 crates/zed/Cargo.toml                        |   2 +-
 10 files changed, 76 insertions(+), 548 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 26b979ccf72aa9..0b3ee53e9aa852 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9122,6 +9122,7 @@ dependencies = [
  "gpui",
  "http_client",
  "language",
+ "languages",
  "log",
  "lsp",
  "node_runtime",
diff --git a/crates/languages/Cargo.toml b/crates/languages/Cargo.toml
index 33be1a9809601a..5cb5455dd168d6 100644
--- a/crates/languages/Cargo.toml
+++ b/crates/languages/Cargo.toml
@@ -10,6 +10,25 @@ workspace = true
 
 [features]
 test-support = []
+load-grammars = [
+    "tree-sitter-bash",
+    "tree-sitter-c",
+    "tree-sitter-cpp",
+    "tree-sitter-css",
+    "tree-sitter-go",
+    "tree-sitter-go-mod",
+    "tree-sitter-gowork",
+    "tree-sitter-jsdoc",
+    "tree-sitter-json",
+    "tree-sitter-md",
+    "protols-tree-sitter-proto",
+    "tree-sitter-python",
+    "tree-sitter-regex",
+    "tree-sitter-rust",
+    "tree-sitter-typescript",
+    "tree-sitter-yaml",
+    "tree-sitter"
+]
 
 [dependencies]
 anyhow.workspace = true
@@ -36,25 +55,26 @@ settings.workspace = true
 smol.workspace = true
 task.workspace = true
 toml.workspace = true
-tree-sitter-bash.workspace = true
-tree-sitter-c.workspace = true
-tree-sitter-cpp.workspace = true
-tree-sitter-css.workspace = true
-tree-sitter-go.workspace = true
-tree-sitter-go-mod.workspace = true
-tree-sitter-gowork.workspace = true
-tree-sitter-jsdoc.workspace = true
-tree-sitter-json.workspace = true
-tree-sitter-md.workspace = true
-protols-tree-sitter-proto.workspace = true
-tree-sitter-python.workspace = true
-tree-sitter-regex.workspace = true
-tree-sitter-rust.workspace = true
-tree-sitter-typescript.workspace = true
-tree-sitter-yaml.workspace = true
-tree-sitter.workspace = true
 util.workspace = true
 
+tree-sitter-bash = {workspace = true, optional = true}
+tree-sitter-c = {workspace = true, optional = true}
+tree-sitter-cpp = {workspace = true, optional = true}
+tree-sitter-css = {workspace = true, optional = true}
+tree-sitter-go = {workspace = true, optional = true}
+tree-sitter-go-mod = {workspace = true, optional = true}
+tree-sitter-gowork = {workspace = true, optional = true}
+tree-sitter-jsdoc = {workspace = true, optional = true}
+tree-sitter-json = {workspace = true, optional = true}
+tree-sitter-md = {workspace = true, optional = true}
+protols-tree-sitter-proto = {workspace = true, optional = true}
+tree-sitter-python = {workspace = true, optional = true}
+tree-sitter-regex = {workspace = true, optional = true}
+tree-sitter-rust = {workspace = true, optional = true}
+tree-sitter-typescript = {workspace = true, optional = true}
+tree-sitter-yaml = {workspace = true, optional = true}
+tree-sitter = {workspace = true, optional = true}
+
 [dev-dependencies]
 text.workspace = true
 theme = { workspace = true, features = ["test-support"] }
diff --git a/crates/languages/src/lib.rs b/crates/languages/src/lib.rs
index 7435ddb13196dd..295df6e419b7ec 100644
--- a/crates/languages/src/lib.rs
+++ b/crates/languages/src/lib.rs
@@ -31,6 +31,7 @@ mod yaml;
 struct LanguageDir;
 
 pub fn init(languages: Arc<LanguageRegistry>, node_runtime: NodeRuntime, cx: &mut AppContext) {
+    #[cfg(feature = "load-grammars")]
     languages.register_native_grammars([
         ("bash", tree_sitter_bash::LANGUAGE),
         ("c", tree_sitter_c::LANGUAGE),
@@ -282,9 +283,21 @@ fn load_config(name: &str) -> LanguageConfig {
     )
     .unwrap();
 
-    ::toml::from_str(&config_toml)
+    #[allow(unused_mut)]
+    let mut config: LanguageConfig = ::toml::from_str(&config_toml)
         .with_context(|| format!("failed to load config.toml for language {name:?}"))
-        .unwrap()
+        .unwrap();
+
+    #[cfg(not(feature = "load-grammars"))]
+    {
+        config = LanguageConfig {
+            name: config.name,
+            matcher: config.matcher,
+            ..Default::default()
+        }
+    }
+
+    config
 }
 
 fn load_queries(name: &str) -> LanguageQueries {
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index bef57bafb48cf9..a4a13b296ed5c1 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -36,10 +36,10 @@ use language::{
     markdown, point_to_lsp, prepare_completion_documentation,
     proto::{deserialize_anchor, deserialize_version, serialize_anchor, serialize_version},
     range_from_lsp, Bias, Buffer, BufferSnapshot, CachedLspAdapter, CodeLabel, Diagnostic,
-    DiagnosticEntry, DiagnosticSet, Diff, Documentation, File as _, Language, LanguageConfig,
-    LanguageMatcher, LanguageName, LanguageRegistry, LanguageServerBinaryStatus,
-    LanguageServerName, LocalFile, LspAdapter, LspAdapterDelegate, Patch, PointUtf16,
-    TextBufferSnapshot, ToOffset, ToPointUtf16, Transaction, Unclipped,
+    DiagnosticEntry, DiagnosticSet, Diff, Documentation, File as _, Language, LanguageName,
+    LanguageRegistry, LanguageServerBinaryStatus, LanguageServerName, LocalFile, LspAdapter,
+    LspAdapterDelegate, Patch, PointUtf16, TextBufferSnapshot, ToOffset, ToPointUtf16, Transaction,
+    Unclipped,
 };
 use lsp::{
     CodeActionKind, CompletionContext, DiagnosticSeverity, DiagnosticTag,
@@ -53,7 +53,7 @@ use parking_lot::{Mutex, RwLock};
 use postage::watch;
 use rand::prelude::*;
 
-use rpc::{proto::SSH_PROJECT_ID, AnyProtoClient};
+use rpc::AnyProtoClient;
 use serde::Serialize;
 use settings::{Settings, SettingsLocation, SettingsStore};
 use sha2::{Digest, Sha256};
@@ -644,16 +644,15 @@ pub struct RemoteLspStore {
 
 impl RemoteLspStore {}
 
-pub struct SshLspStore {
-    upstream_client: AnyProtoClient,
-    current_lsp_settings: HashMap<LanguageServerName, LspSettings>,
-}
+// pub struct SshLspStore {
+//     upstream_client: AnyProtoClient,
+//     current_lsp_settings: HashMap<LanguageServerName, LspSettings>,
+// }
 
 #[allow(clippy::large_enum_variant)]
 pub enum LspStoreMode {
     Local(LocalLspStore),   // ssh host and collab host
     Remote(RemoteLspStore), // collab guest
-    Ssh(SshLspStore),       // ssh client
 }
 
 impl LspStoreMode {
@@ -661,10 +660,6 @@ impl LspStoreMode {
         matches!(self, LspStoreMode::Local(_))
     }
 
-    fn is_ssh(&self) -> bool {
-        matches!(self, LspStoreMode::Ssh(_))
-    }
-
     fn is_remote(&self) -> bool {
         matches!(self, LspStoreMode::Remote(_))
     }
@@ -787,13 +782,6 @@ impl LspStore {
         }
     }
 
-    pub fn as_ssh(&self) -> Option<&SshLspStore> {
-        match &self.mode {
-            LspStoreMode::Ssh(ssh_lsp_store) => Some(ssh_lsp_store),
-            _ => None,
-        }
-    }
-
     pub fn as_local(&self) -> Option<&LocalLspStore> {
         match &self.mode {
             LspStoreMode::Local(local_lsp_store) => Some(local_lsp_store),
@@ -810,9 +798,6 @@ impl LspStore {
 
     pub fn upstream_client(&self) -> Option<(AnyProtoClient, u64)> {
         match &self.mode {
-            LspStoreMode::Ssh(SshLspStore {
-                upstream_client, ..
-            }) => Some((upstream_client.clone(), SSH_PROJECT_ID)),
             LspStoreMode::Remote(RemoteLspStore {
                 upstream_client,
                 upstream_project_id,
@@ -827,11 +812,7 @@ impl LspStore {
         new_settings: HashMap<LanguageServerName, LspSettings>,
     ) -> Option<HashMap<LanguageServerName, LspSettings>> {
         match &mut self.mode {
-            LspStoreMode::Ssh(SshLspStore {
-                current_lsp_settings,
-                ..
-            })
-            | LspStoreMode::Local(LocalLspStore {
+            LspStoreMode::Local(LocalLspStore {
                 current_lsp_settings,
                 ..
             }) => {
@@ -919,43 +900,6 @@ impl LspStore {
         })
     }
 
-    pub fn new_ssh(
-        buffer_store: Model<BufferStore>,
-        worktree_store: Model<WorktreeStore>,
-        languages: Arc<LanguageRegistry>,
-        upstream_client: AnyProtoClient,
-        cx: &mut ModelContext<Self>,
-    ) -> Self {
-        cx.subscribe(&buffer_store, Self::on_buffer_store_event)
-            .detach();
-        cx.subscribe(&worktree_store, Self::on_worktree_store_event)
-            .detach();
-        cx.observe_global::<SettingsStore>(Self::on_settings_changed)
-            .detach();
-
-        Self {
-            mode: LspStoreMode::Ssh(SshLspStore {
-                upstream_client,
-                current_lsp_settings: Default::default(),
-            }),
-            downstream_client: None,
-            buffer_store,
-            worktree_store,
-            languages: languages.clone(),
-            language_server_ids: Default::default(),
-            language_server_statuses: Default::default(),
-            nonce: StdRng::from_entropy().gen(),
-            buffer_snapshots: Default::default(),
-            next_diagnostic_group_id: Default::default(),
-            diagnostic_summaries: Default::default(),
-
-            diagnostics: Default::default(),
-            active_entry: None,
-            _maintain_workspace_config: Self::maintain_workspace_config(cx),
-            _maintain_buffer_languages: Self::maintain_buffer_languages(languages.clone(), cx),
-        }
-    }
-
     pub fn new_remote(
         buffer_store: Model<BufferStore>,
         worktree_store: Model<WorktreeStore>,
@@ -3697,11 +3641,11 @@ impl LspStore {
         mut cx: AsyncAppContext,
     ) -> Result<proto::MultiLspQueryResponse> {
         let response_from_ssh = this.update(&mut cx, |this, _| {
-            let ssh = this.as_ssh()?;
+            let (upstream_client, project_id) = this.upstream_client()?;
             let mut payload = envelope.payload.clone();
-            payload.project_id = SSH_PROJECT_ID;
+            payload.project_id = project_id;
 
-            Some(ssh.upstream_client.request(payload))
+            Some(upstream_client.request(payload))
         })?;
         if let Some(response_from_ssh) = response_from_ssh {
             return response_from_ssh.await;
@@ -5009,165 +4953,6 @@ impl LspStore {
         Ok(proto::Ack {})
     }
 
-    pub async fn handle_create_language_server(
-        this: Model<Self>,
-        envelope: TypedEnvelope<proto::CreateLanguageServer>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::Ack> {
-        let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
-        let server_name = LanguageServerName::from_proto(envelope.payload.name);
-
-        let binary = envelope
-            .payload
-            .binary
-            .ok_or_else(|| anyhow!("missing binary"))?;
-        let binary = LanguageServerBinary {
-            path: PathBuf::from(binary.path),
-            env: None,
-            arguments: binary.arguments.into_iter().map(Into::into).collect(),
-        };
-        let language = envelope
-            .payload
-            .language
-            .ok_or_else(|| anyhow!("missing language"))?;
-        let language_name = LanguageName::from_proto(language.name);
-        let matcher: LanguageMatcher = serde_json::from_str(&language.matcher)?;
-
-        this.update(&mut cx, |this, cx| {
-            let Some(worktree) = this
-                .worktree_store
-                .read(cx)
-                .worktree_for_id(worktree_id, cx)
-            else {
-                return Err(anyhow!("worktree not found"));
-            };
-
-            this.languages
-                .register_language(language_name.clone(), None, matcher.clone(), {
-                    let language_name = language_name.clone();
-                    move || {
-                        Ok((
-                            LanguageConfig {
-                                name: language_name.clone(),
-                                matcher: matcher.clone(),
-                                ..Default::default()
-                            },
-                            Default::default(),
-                            Default::default(),
-                        ))
-                    }
-                });
-            cx.background_executor()
-                .spawn(this.languages.language_for_name(language_name.0.as_ref()))
-                .detach();
-
-            // host
-            let adapter = this.languages.get_or_register_lsp_adapter(
-                language_name.clone(),
-                server_name.clone(),
-                || {
-                    Arc::new(SshLspAdapter::new(
-                        server_name,
-                        binary,
-                        envelope.payload.initialization_options,
-                        envelope.payload.code_action_kinds,
-                    ))
-                },
-            );
-
-            this.start_language_server(&worktree, adapter, language_name, cx);
-            Ok(())
-        })??;
-        Ok(proto::Ack {})
-    }
-
-    pub async fn handle_which_command(
-        this: Model<Self>,
-        envelope: TypedEnvelope<proto::WhichCommand>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::WhichCommandResponse> {
-        let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
-        let command = PathBuf::from(envelope.payload.command);
-        let response = this
-            .update(&mut cx, |this, cx| {
-                let worktree = this.worktree_for_id(worktree_id, cx)?;
-                let delegate = LocalLspAdapterDelegate::for_local(this, &worktree, cx);
-                anyhow::Ok(
-                    cx.spawn(|_, _| async move { delegate.which(command.as_os_str()).await }),
-                )
-            })??
-            .await;
-
-        Ok(proto::WhichCommandResponse {
-            path: response.map(|path| path.to_string_lossy().to_string()),
-        })
-    }
-
-    pub async fn handle_shell_env(
-        this: Model<Self>,
-        envelope: TypedEnvelope<proto::ShellEnv>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::ShellEnvResponse> {
-        let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
-        let response = this
-            .update(&mut cx, |this, cx| {
-                let worktree = this.worktree_for_id(worktree_id, cx)?;
-                let delegate = LocalLspAdapterDelegate::for_local(this, &worktree, cx);
-                anyhow::Ok(cx.spawn(|_, _| async move { delegate.shell_env().await }))
-            })??
-            .await;
-
-        Ok(proto::ShellEnvResponse {
-            env: response.into_iter().collect(),
-        })
-    }
-    pub async fn handle_try_exec(
-        this: Model<Self>,
-        envelope: TypedEnvelope<proto::TryExec>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::Ack> {
-        let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
-        let binary = envelope
-            .payload
-            .binary
-            .ok_or_else(|| anyhow!("missing binary"))?;
-        let binary = LanguageServerBinary {
-            path: PathBuf::from(binary.path),
-            env: None,
-            arguments: binary.arguments.into_iter().map(Into::into).collect(),
-        };
-        this.update(&mut cx, |this, cx| {
-            let worktree = this.worktree_for_id(worktree_id, cx)?;
-            let delegate = LocalLspAdapterDelegate::for_local(this, &worktree, cx);
-            anyhow::Ok(cx.spawn(|_, _| async move { delegate.try_exec(binary).await }))
-        })??
-        .await?;
-
-        Ok(proto::Ack {})
-    }
-
-    pub async fn handle_read_text_file(
-        this: Model<Self>,
-        envelope: TypedEnvelope<proto::ReadTextFile>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::ReadTextFileResponse> {
-        let path = envelope
-            .payload
-            .path
-            .ok_or_else(|| anyhow!("missing path"))?;
-        let worktree_id = WorktreeId::from_proto(path.worktree_id);
-        let path = PathBuf::from(path.path);
-        let response = this
-            .update(&mut cx, |this, cx| {
-                let worktree = this.worktree_for_id(worktree_id, cx)?;
-                let delegate = LocalLspAdapterDelegate::for_local(this, &worktree, cx);
-                anyhow::Ok(cx.spawn(|_, _| async move { delegate.read_text_file(path).await }))
-            })??
-            .await?;
-
-        Ok(proto::ReadTextFileResponse { text: response })
-    }
-
     async fn handle_apply_additional_edits_for_completion(
         this: Model<Self>,
         envelope: TypedEnvelope<proto::ApplyCompletionAdditionalEdits>,
@@ -5388,89 +5173,6 @@ impl LspStore {
             .reorder_language_servers(&language, enabled_lsp_adapters);
     }
 
-    fn start_language_server_on_ssh_host(
-        &mut self,
-        worktree: &Model<Worktree>,
-        adapter: Arc<CachedLspAdapter>,
-        language: LanguageName,
-        cx: &mut ModelContext<Self>,
-    ) {
-        let ssh = self.as_ssh().unwrap();
-
-        let delegate = Arc::new(SshLspAdapterDelegate {
-            lsp_store: cx.handle().downgrade(),
-            worktree: worktree.read(cx).snapshot(),
-            upstream_client: ssh.upstream_client.clone(),
-            language_registry: self.languages.clone(),
-        }) as Arc<dyn LspAdapterDelegate>;
-
-        let Some((upstream_client, project_id)) = self.upstream_client() else {
-            return;
-        };
-        let worktree_id = worktree.read(cx).id().to_proto();
-        let name = adapter.name().to_string();
-
-        let Some(available_language) = self.languages.available_language_for_name(&language) else {
-            log::error!("failed to find available language {language}");
-            return;
-        };
-
-        let user_binary_task =
-            self.get_language_server_binary(adapter.clone(), delegate.clone(), false, cx);
-
-        let task = cx.spawn(|_, _| async move {
-            let binary = user_binary_task.await?;
-            let name = adapter.name();
-            let code_action_kinds = adapter
-                .adapter
-                .code_action_kinds()
-                .map(|kinds| serde_json::to_string(&kinds))
-                .transpose()?;
-            let get_options = adapter.adapter.clone().initialization_options(&delegate);
-            let initialization_options = get_options
-                .await?
-                .map(|options| serde_json::to_string(&options))
-                .transpose()?;
-
-            let language_server_command = proto::LanguageServerCommand {
-                path: binary.path.to_string_lossy().to_string(),
-                arguments: binary
-                    .arguments
-                    .iter()
-                    .map(|args| args.to_string_lossy().to_string())
-                    .collect(),
-                env: binary.env.unwrap_or_default().into_iter().collect(),
-            };
-
-            upstream_client
-                .request(proto::CreateLanguageServer {
-                    project_id,
-                    worktree_id,
-                    name: name.0.to_string(),
-                    binary: Some(language_server_command),
-                    initialization_options,
-                    code_action_kinds,
-                    language: Some(proto::AvailableLanguage {
-                        name: language.to_proto(),
-                        matcher: serde_json::to_string(&available_language.matcher())?,
-                    }),
-                })
-                .await
-        });
-        cx.spawn(|this, mut cx| async move {
-            if let Err(e) = task.await {
-                this.update(&mut cx, |_this, cx| {
-                    cx.emit(LspStoreEvent::Notification(format!(
-                        "failed to start {}: {}",
-                        name, e
-                    )))
-                })
-                .ok();
-            }
-        })
-        .detach();
-    }
-
     fn get_language_server_binary(
         &self,
         adapter: Arc<CachedLspAdapter>,
@@ -5558,11 +5260,6 @@ impl LspStore {
             return;
         }
 
-        if self.mode.is_ssh() {
-            self.start_language_server_on_ssh_host(worktree_handle, adapter, language, cx);
-            return;
-        }
-
         let project_settings = ProjectSettings::get(
             Some(SettingsLocation {
                 worktree_id,
@@ -5852,9 +5549,6 @@ impl LspStore {
             } else {
                 Task::ready(Vec::new())
             }
-        } else if self.mode.is_ssh() {
-            // TODO ssh
-            Task::ready(Vec::new())
         } else {
             Task::ready(Vec::new())
         }
@@ -7905,116 +7599,6 @@ impl LspAdapterDelegate for LocalLspAdapterDelegate {
     }
 }
 
-struct SshLspAdapterDelegate {
-    lsp_store: WeakModel<LspStore>,
-    worktree: worktree::Snapshot,
-    upstream_client: AnyProtoClient,
-    language_registry: Arc<LanguageRegistry>,
-}
-
-#[async_trait]
-impl LspAdapterDelegate for SshLspAdapterDelegate {
-    fn show_notification(&self, message: &str, cx: &mut AppContext) {
-        self.lsp_store
-            .update(cx, |_, cx| {
-                cx.emit(LspStoreEvent::Notification(message.to_owned()))
-            })
-            .ok();
-    }
-
-    async fn npm_package_installed_version(
-        &self,
-        _package_name: &str,
-    ) -> Result<Option<(PathBuf, String)>> {
-        Ok(None)
-    }
-
-    fn http_client(&self) -> Arc<dyn HttpClient> {
-        Arc::new(BlockedHttpClient)
-    }
-
-    fn worktree_id(&self) -> WorktreeId {
-        self.worktree.id()
-    }
-
-    fn worktree_root_path(&self) -> &Path {
-        self.worktree.abs_path().as_ref()
-    }
-
-    async fn shell_env(&self) -> HashMap<String, String> {
-        use rpc::proto::SSH_PROJECT_ID;
-
-        self.upstream_client
-            .request(proto::ShellEnv {
-                project_id: SSH_PROJECT_ID,
-                worktree_id: self.worktree_id().to_proto(),
-            })
-            .await
-            .map(|response| response.env.into_iter().collect())
-            .unwrap_or_default()
-    }
-
-    async fn which(&self, command: &OsStr) -> Option<PathBuf> {
-        use rpc::proto::SSH_PROJECT_ID;
-
-        self.upstream_client
-            .request(proto::WhichCommand {
-                project_id: SSH_PROJECT_ID,
-                worktree_id: self.worktree_id().to_proto(),
-                command: command.to_string_lossy().to_string(),
-            })
-            .await
-            .log_err()
-            .and_then(|response| response.path)
-            .map(PathBuf::from)
-    }
-
-    async fn try_exec(&self, command: LanguageServerBinary) -> Result<()> {
-        self.upstream_client
-            .request(proto::TryExec {
-                project_id: rpc::proto::SSH_PROJECT_ID,
-                worktree_id: self.worktree.id().to_proto(),
-                binary: Some(proto::LanguageServerCommand {
-                    path: command.path.to_string_lossy().to_string(),
-                    arguments: command
-                        .arguments
-                        .into_iter()
-                        .map(|s| s.to_string_lossy().to_string())
-                        .collect(),
-                    env: command.env.unwrap_or_default().into_iter().collect(),
-                }),
-            })
-            .await?;
-        Ok(())
-    }
-
-    async fn language_server_download_dir(&self, _: &LanguageServerName) -> Option<Arc<Path>> {
-        None
-    }
-
-    fn update_status(
-        &self,
-        server_name: LanguageServerName,
-        status: language::LanguageServerBinaryStatus,
-    ) {
-        self.language_registry
-            .update_lsp_status(server_name, status);
-    }
-
-    async fn read_text_file(&self, path: PathBuf) -> Result<String> {
-        self.upstream_client
-            .request(proto::ReadTextFile {
-                project_id: rpc::proto::SSH_PROJECT_ID,
-                path: Some(proto::ProjectPath {
-                    worktree_id: self.worktree.id().to_proto(),
-                    path: path.to_string_lossy().to_string(),
-                }),
-            })
-            .await
-            .map(|r| r.text)
-    }
-}
-
 async fn populate_labels_for_symbols(
     symbols: Vec<CoreSymbol>,
     language_registry: &Arc<LanguageRegistry>,
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 10fd88f286d994..c3b3c383c11ffd 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -706,11 +706,12 @@ impl Project {
 
             let environment = ProjectEnvironment::new(&worktree_store, None, cx);
             let lsp_store = cx.new_model(|cx| {
-                LspStore::new_ssh(
+                LspStore::new_remote(
                     buffer_store.clone(),
                     worktree_store.clone(),
                     languages.clone(),
                     ssh.clone().into(),
+                    SSH_PROJECT_ID,
                     cx,
                 )
             });
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index 475ed139edfb87..d81ef35f6bffbd 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -283,18 +283,6 @@ message Envelope {
         CloseBuffer close_buffer = 245;
         UpdateUserSettings update_user_settings = 246;
 
-        CreateLanguageServer create_language_server = 247;
-
-        WhichCommand which_command = 248;
-        WhichCommandResponse which_command_response = 249;
-
-        ShellEnv shell_env = 250;
-        ShellEnvResponse shell_env_response = 251;
-
-        TryExec try_exec = 252;
-        ReadTextFile read_text_file = 253;
-        ReadTextFileResponse read_text_file_response = 254;
-
         CheckFileExists check_file_exists = 255;
         CheckFileExistsResponse check_file_exists_response = 256; // current max
     }
@@ -302,6 +290,7 @@ message Envelope {
     reserved 158 to 161;
     reserved 166 to 169;
     reserved 224 to 229;
+    reserved 247 to 254;
 }
 
 // Messages
@@ -2517,67 +2506,6 @@ message UpdateUserSettings {
     string content = 2;
 }
 
-message LanguageServerCommand {
-   string path = 1;
-   repeated string arguments = 2;
-   map<string, string> env = 3;
-}
-
-message AvailableLanguage {
-    string name = 7;
-    string matcher = 8;
-}
-
-message CreateLanguageServer {
-    uint64 project_id = 1;
-    uint64 worktree_id = 2;
-    string name = 3;
-
-    LanguageServerCommand binary = 4;
-    optional string initialization_options = 5;
-    optional string code_action_kinds = 6;
-
-    AvailableLanguage language = 7;
-}
-
-message WhichCommand {
-    uint64 project_id = 1;
-    uint64 worktree_id = 2;
-    string command = 3;
-}
-
-message WhichCommandResponse {
-    optional string path = 1;
-}
-
-message ShellEnv {
-    uint64 project_id = 1;
-    uint64 worktree_id = 2;
-}
-
-message ShellEnvResponse {
-    map<string, string> env = 1;
-}
-
-message ReadTextFile {
-    uint64 project_id = 1;
-    ProjectPath path = 2;
-}
-
-message ReadTextFileResponse {
-    string text = 1;
-}
-
-message TryExec {
-    uint64 project_id = 1;
-    uint64 worktree_id = 2;
-    LanguageServerCommand binary = 3;
-}
-
-message TryExecResponse {
-    string text = 1;
-}
-
 message CheckFileExists {
     uint64 project_id = 1;
     string path = 2;
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 4146a47409ad71..799d51defec718 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -365,14 +365,6 @@ messages!(
     (FindSearchCandidatesResponse, Background),
     (CloseBuffer, Foreground),
     (UpdateUserSettings, Foreground),
-    (CreateLanguageServer, Foreground),
-    (WhichCommand, Foreground),
-    (WhichCommandResponse, Foreground),
-    (ShellEnv, Foreground),
-    (ShellEnvResponse, Foreground),
-    (TryExec, Foreground),
-    (ReadTextFile, Foreground),
-    (ReadTextFileResponse, Foreground),
     (CheckFileExists, Background),
     (CheckFileExistsResponse, Background)
 );
@@ -498,11 +490,6 @@ request_messages!(
     (SynchronizeContexts, SynchronizeContextsResponse),
     (LspExtSwitchSourceHeader, LspExtSwitchSourceHeaderResponse),
     (AddWorktree, AddWorktreeResponse),
-    (CreateLanguageServer, Ack),
-    (WhichCommand, WhichCommandResponse),
-    (ShellEnv, ShellEnvResponse),
-    (ReadTextFile, ReadTextFileResponse),
-    (TryExec, Ack),
     (CheckFileExists, CheckFileExistsResponse)
 );
 
@@ -577,11 +564,6 @@ entity_messages!(
     SynchronizeContexts,
     LspExtSwitchSourceHeader,
     UpdateUserSettings,
-    CreateLanguageServer,
-    WhichCommand,
-    ShellEnv,
-    TryExec,
-    ReadTextFile,
     CheckFileExists,
 );
 
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index 64db2616e9b2f8..b15970042d0f7f 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -39,6 +39,7 @@ shellexpand.workspace = true
 smol.workspace = true
 worktree.workspace = true
 language.workspace = true
+languages.workspace = true
 util.workspace = true
 
 [dev-dependencies]
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 84fb22b282d37d..4b13938d8ca2f5 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -44,6 +44,10 @@ impl HeadlessProject {
     pub fn new(session: Arc<SshSession>, fs: Arc<dyn Fs>, cx: &mut ModelContext<Self>) -> Self {
         let languages = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
 
+        let node_runtime = NodeRuntime::unavailable();
+
+        languages::init(languages.clone(), node_runtime.clone(), cx);
+
         let worktree_store = cx.new_model(|cx| {
             let mut store = WorktreeStore::local(true, fs.clone());
             store.shared(SSH_PROJECT_ID, session.clone().into(), cx);
@@ -56,7 +60,7 @@ impl HeadlessProject {
         });
         let prettier_store = cx.new_model(|cx| {
             PrettierStore::new(
-                NodeRuntime::unavailable(),
+                node_runtime,
                 fs.clone(),
                 languages.clone(),
                 worktree_store.clone(),
@@ -116,12 +120,6 @@ impl HeadlessProject {
         client.add_model_request_handler(BufferStore::handle_update_buffer);
         client.add_model_message_handler(BufferStore::handle_close_buffer);
 
-        client.add_model_request_handler(LspStore::handle_create_language_server);
-        client.add_model_request_handler(LspStore::handle_which_command);
-        client.add_model_request_handler(LspStore::handle_shell_env);
-        client.add_model_request_handler(LspStore::handle_try_exec);
-        client.add_model_request_handler(LspStore::handle_read_text_file);
-
         BufferStore::init(&client);
         WorktreeStore::init(&client);
         SettingsObserver::init(&client);
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index eb8f45d92e476d..897e0e9a28bca8 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -64,7 +64,7 @@ language.workspace = true
 language_model.workspace = true
 language_selector.workspace = true
 language_tools.workspace = true
-languages.workspace = true
+languages = {workspace = true, features = ["load-grammars"] }
 libc.workspace = true
 log.workspace = true
 markdown_preview.workspace = true

From 3161aedcb02e5e18bc802ffa38504909490938c6 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Wed, 25 Sep 2024 16:03:08 -0700
Subject: [PATCH 339/762] Fix broken collaboration UI from #18308 (#18372)

Fixes a bug introduced by #18308, that caused the call controls to
render incorrectly.

Release Notes:

- N/A
---
 crates/title_bar/src/collab.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/title_bar/src/collab.rs b/crates/title_bar/src/collab.rs
index e9f89643d5729f..2f534589050358 100644
--- a/crates/title_bar/src/collab.rs
+++ b/crates/title_bar/src/collab.rs
@@ -284,14 +284,14 @@ impl TitleBar {
 
         let room = room.read(cx);
         let project = self.project.read(cx);
+        let is_local = project.is_local() || project.is_via_ssh();
         let is_dev_server_project = project.dev_server_project_id().is_some();
-        let is_shared = project.is_shared();
+        let is_shared = (is_local || is_dev_server_project) && project.is_shared();
         let is_muted = room.is_muted();
         let is_deafened = room.is_deafened().unwrap_or(false);
         let is_screen_sharing = room.is_screen_sharing();
         let can_use_microphone = room.can_use_microphone();
-        let can_share_projects = room.can_share_projects()
-            && (is_dev_server_project || project.is_local() || project.is_via_ssh());
+        let can_share_projects = room.can_share_projects();
         let platform_supported = match self.platform_style {
             PlatformStyle::Mac => true,
             PlatformStyle::Linux | PlatformStyle::Windows => false,
@@ -299,7 +299,7 @@ impl TitleBar {
 
         let mut children = Vec::new();
 
-        if can_share_projects {
+        if (is_local || is_dev_server_project) && can_share_projects {
             children.push(
                 Button::new(
                     "toggle_sharing",

From 6167688a63eed63791814e39b3b8fd1a10da0e9b Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Wed, 25 Sep 2024 16:33:00 -0700
Subject: [PATCH 340/762] Proposed changes editor features (#18373)

This PR adds some more functionality to the Proposed Changes Editor
view, which we'll be using in
https://github.com/zed-industries/zed/pull/18240 for allowing the
assistant to propose changes to a set of buffers.

* Add an `Apply All` button, and fully implement applying of changes to
the base buffer
* Make the proposed changes editor searchable
* Fix a bug in branch buffers' diff state management

Release Notes:

- N/A
---
 crates/editor/src/editor.rs                  |   4 +-
 crates/editor/src/proposed_changes_editor.rs |  84 +++++++++++-
 crates/language/src/buffer.rs                | 130 ++++++++++++++-----
 crates/language/src/buffer_tests.rs          |  96 ++++++++------
 crates/zed/src/zed.rs                        |   3 +
 5 files changed, 241 insertions(+), 76 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 78c8ba6920337c..23448b43a7cc72 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -98,7 +98,9 @@ use language::{
 };
 use language::{point_to_lsp, BufferRow, CharClassifier, Runnable, RunnableRange};
 use linked_editing_ranges::refresh_linked_ranges;
-use proposed_changes_editor::{ProposedChangesBuffer, ProposedChangesEditor};
+pub use proposed_changes_editor::{
+    ProposedChangesBuffer, ProposedChangesEditor, ProposedChangesEditorToolbar,
+};
 use similar::{ChangeTag, TextDiff};
 use task::{ResolvedTask, TaskTemplate, TaskVariables};
 
diff --git a/crates/editor/src/proposed_changes_editor.rs b/crates/editor/src/proposed_changes_editor.rs
index 3979e558a42364..ec0c05d88382c0 100644
--- a/crates/editor/src/proposed_changes_editor.rs
+++ b/crates/editor/src/proposed_changes_editor.rs
@@ -6,10 +6,13 @@ use language::{Buffer, BufferEvent, Capability};
 use multi_buffer::{ExcerptRange, MultiBuffer};
 use project::Project;
 use smol::stream::StreamExt;
-use std::{ops::Range, time::Duration};
+use std::{any::TypeId, ops::Range, time::Duration};
 use text::ToOffset;
 use ui::prelude::*;
-use workspace::Item;
+use workspace::{
+    searchable::SearchableItemHandle, Item, ItemHandle as _, ToolbarItemEvent, ToolbarItemLocation,
+    ToolbarItemView,
+};
 
 pub struct ProposedChangesEditor {
     editor: View<Editor>,
@@ -23,6 +26,10 @@ pub struct ProposedChangesBuffer<T> {
     pub ranges: Vec<Range<T>>,
 }
 
+pub struct ProposedChangesEditorToolbar {
+    current_editor: Option<View<ProposedChangesEditor>>,
+}
+
 impl ProposedChangesEditor {
     pub fn new<T: ToOffset>(
         buffers: Vec<ProposedChangesBuffer<T>>,
@@ -96,6 +103,17 @@ impl ProposedChangesEditor {
             self.recalculate_diffs_tx.unbounded_send(buffer).ok();
         }
     }
+
+    fn apply_all_changes(&self, cx: &mut ViewContext<Self>) {
+        let buffers = self.editor.read(cx).buffer.read(cx).all_buffers();
+        for branch_buffer in buffers {
+            if let Some(base_buffer) = branch_buffer.read(cx).diff_base_buffer() {
+                base_buffer.update(cx, |base_buffer, cx| {
+                    base_buffer.merge(&branch_buffer, None, cx)
+                });
+            }
+        }
+    }
 }
 
 impl Render for ProposedChangesEditor {
@@ -122,4 +140,66 @@ impl Item for ProposedChangesEditor {
     fn tab_content_text(&self, _cx: &WindowContext) -> Option<SharedString> {
         Some("Proposed changes".into())
     }
+
+    fn as_searchable(&self, _: &View<Self>) -> Option<Box<dyn SearchableItemHandle>> {
+        Some(Box::new(self.editor.clone()))
+    }
+
+    fn act_as_type<'a>(
+        &'a self,
+        type_id: TypeId,
+        self_handle: &'a View<Self>,
+        _: &'a AppContext,
+    ) -> Option<gpui::AnyView> {
+        if type_id == TypeId::of::<Self>() {
+            Some(self_handle.to_any())
+        } else if type_id == TypeId::of::<Editor>() {
+            Some(self.editor.to_any())
+        } else {
+            None
+        }
+    }
+}
+
+impl ProposedChangesEditorToolbar {
+    pub fn new() -> Self {
+        Self {
+            current_editor: None,
+        }
+    }
+
+    fn get_toolbar_item_location(&self) -> ToolbarItemLocation {
+        if self.current_editor.is_some() {
+            ToolbarItemLocation::PrimaryRight
+        } else {
+            ToolbarItemLocation::Hidden
+        }
+    }
+}
+
+impl Render for ProposedChangesEditorToolbar {
+    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let editor = self.current_editor.clone();
+        Button::new("apply-changes", "Apply All").on_click(move |_, cx| {
+            if let Some(editor) = &editor {
+                editor.update(cx, |editor, cx| {
+                    editor.apply_all_changes(cx);
+                });
+            }
+        })
+    }
+}
+
+impl EventEmitter<ToolbarItemEvent> for ProposedChangesEditorToolbar {}
+
+impl ToolbarItemView for ProposedChangesEditorToolbar {
+    fn set_active_pane_item(
+        &mut self,
+        active_pane_item: Option<&dyn workspace::ItemHandle>,
+        _cx: &mut ViewContext<Self>,
+    ) -> workspace::ToolbarItemLocation {
+        self.current_editor =
+            active_pane_item.and_then(|item| item.downcast::<ProposedChangesEditor>());
+        self.get_toolbar_item_location()
+    }
 }
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 5735ee961651ab..7abc9b8dba146a 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -87,7 +87,11 @@ pub type BufferRow = u32;
 #[derive(Clone)]
 enum BufferDiffBase {
     Git(Rope),
-    PastBufferVersion(Model<Buffer>, BufferSnapshot),
+    PastBufferVersion {
+        buffer: Model<Buffer>,
+        rope: Rope,
+        operations_to_ignore: Vec<clock::Lamport>,
+    },
 }
 
 /// An in-memory representation of a source code file, including its text,
@@ -795,19 +799,15 @@ impl Buffer {
         let this = cx.handle();
         cx.new_model(|cx| {
             let mut branch = Self {
-                diff_base: Some(BufferDiffBase::PastBufferVersion(
-                    this.clone(),
-                    self.snapshot(),
-                )),
+                diff_base: Some(BufferDiffBase::PastBufferVersion {
+                    buffer: this.clone(),
+                    rope: self.as_rope().clone(),
+                    operations_to_ignore: Vec::new(),
+                }),
                 language: self.language.clone(),
                 has_conflict: self.has_conflict,
                 has_unsaved_edits: Cell::new(self.has_unsaved_edits.get_mut().clone()),
-                _subscriptions: vec![cx.subscribe(&this, |branch: &mut Self, _, event, cx| {
-                    if let BufferEvent::Operation { operation, .. } = event {
-                        branch.apply_ops([operation.clone()], cx);
-                        branch.diff_base_version += 1;
-                    }
-                })],
+                _subscriptions: vec![cx.subscribe(&this, Self::on_base_buffer_event)],
                 ..Self::build(
                     self.text.branch(),
                     None,
@@ -823,18 +823,74 @@ impl Buffer {
         })
     }
 
-    pub fn merge(&mut self, branch: &Model<Self>, cx: &mut ModelContext<Self>) {
-        let branch = branch.read(cx);
-        let edits = branch
-            .edits_since::<usize>(&self.version)
-            .map(|edit| {
-                (
-                    edit.old,
-                    branch.text_for_range(edit.new).collect::<String>(),
+    /// Applies all of the changes in `branch` buffer that intersect the given `range`
+    /// to this buffer.
+    pub fn merge(
+        &mut self,
+        branch: &Model<Self>,
+        range: Option<Range<Anchor>>,
+        cx: &mut ModelContext<Self>,
+    ) {
+        let edits = branch.read_with(cx, |branch, _| {
+            branch
+                .edits_since_in_range::<usize>(
+                    &self.version,
+                    range.unwrap_or(Anchor::MIN..Anchor::MAX),
                 )
-            })
-            .collect::<Vec<_>>();
-        self.edit(edits, None, cx);
+                .map(|edit| {
+                    (
+                        edit.old,
+                        branch.text_for_range(edit.new).collect::<String>(),
+                    )
+                })
+                .collect::<Vec<_>>()
+        });
+        let operation = self.edit(edits, None, cx);
+
+        // Prevent this operation from being reapplied to the branch.
+        branch.update(cx, |branch, cx| {
+            if let Some(BufferDiffBase::PastBufferVersion {
+                operations_to_ignore,
+                ..
+            }) = &mut branch.diff_base
+            {
+                operations_to_ignore.extend(operation);
+            }
+            cx.emit(BufferEvent::Edited)
+        });
+    }
+
+    fn on_base_buffer_event(
+        &mut self,
+        _: Model<Buffer>,
+        event: &BufferEvent,
+        cx: &mut ModelContext<Self>,
+    ) {
+        if let BufferEvent::Operation { operation, .. } = event {
+            if let Some(BufferDiffBase::PastBufferVersion {
+                operations_to_ignore,
+                ..
+            }) = &mut self.diff_base
+            {
+                let mut is_ignored = false;
+                if let Operation::Buffer(text::Operation::Edit(buffer_operation)) = &operation {
+                    operations_to_ignore.retain(|operation_to_ignore| {
+                        match buffer_operation.timestamp.cmp(&operation_to_ignore) {
+                            Ordering::Less => true,
+                            Ordering::Equal => {
+                                is_ignored = true;
+                                false
+                            }
+                            Ordering::Greater => false,
+                        }
+                    });
+                }
+                if !is_ignored {
+                    self.apply_ops([operation.clone()], cx);
+                    self.diff_base_version += 1;
+                }
+            }
+        }
     }
 
     #[cfg(test)]
@@ -1017,9 +1073,8 @@ impl Buffer {
     /// Returns the current diff base, see [Buffer::set_diff_base].
     pub fn diff_base(&self) -> Option<&Rope> {
         match self.diff_base.as_ref()? {
-            BufferDiffBase::Git(rope) => Some(rope),
-            BufferDiffBase::PastBufferVersion(_, buffer_snapshot) => {
-                Some(buffer_snapshot.as_rope())
+            BufferDiffBase::Git(rope) | BufferDiffBase::PastBufferVersion { rope, .. } => {
+                Some(rope)
             }
         }
     }
@@ -1050,29 +1105,36 @@ impl Buffer {
         self.diff_base_version
     }
 
+    pub fn diff_base_buffer(&self) -> Option<Model<Self>> {
+        match self.diff_base.as_ref()? {
+            BufferDiffBase::Git(_) => None,
+            BufferDiffBase::PastBufferVersion { buffer, .. } => Some(buffer.clone()),
+        }
+    }
+
     /// Recomputes the diff.
     pub fn recalculate_diff(&mut self, cx: &mut ModelContext<Self>) -> Option<Task<()>> {
-        let diff_base_rope = match self.diff_base.as_mut()? {
+        let diff_base_rope = match self.diff_base.as_ref()? {
             BufferDiffBase::Git(rope) => rope.clone(),
-            BufferDiffBase::PastBufferVersion(base_buffer, base_buffer_snapshot) => {
-                let new_base_snapshot = base_buffer.read(cx).snapshot();
-                *base_buffer_snapshot = new_base_snapshot;
-                base_buffer_snapshot.as_rope().clone()
-            }
+            BufferDiffBase::PastBufferVersion { buffer, .. } => buffer.read(cx).as_rope().clone(),
         };
-        let snapshot = self.snapshot();
 
+        let snapshot = self.snapshot();
         let mut diff = self.git_diff.clone();
         let diff = cx.background_executor().spawn(async move {
             diff.update(&diff_base_rope, &snapshot).await;
-            diff
+            (diff, diff_base_rope)
         });
 
         Some(cx.spawn(|this, mut cx| async move {
-            let buffer_diff = diff.await;
+            let (buffer_diff, diff_base_rope) = diff.await;
             this.update(&mut cx, |this, cx| {
                 this.git_diff = buffer_diff;
                 this.non_text_state_update_count += 1;
+                if let Some(BufferDiffBase::PastBufferVersion { rope, .. }) = &mut this.diff_base {
+                    *rope = diff_base_rope;
+                    cx.emit(BufferEvent::DiffBaseChanged);
+                }
                 cx.emit(BufferEvent::DiffUpdated);
             })
             .ok();
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index 1335a94dd0313f..49cc31067b93ae 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -2413,80 +2413,98 @@ fn test_branch_and_merge(cx: &mut TestAppContext) {
     });
 
     // Edits to the branch are not applied to the base.
-    branch_buffer.update(cx, |buffer, cx| {
-        buffer.edit(
-            [(Point::new(1, 0)..Point::new(1, 0), "ONE_POINT_FIVE\n")],
+    branch_buffer.update(cx, |branch_buffer, cx| {
+        branch_buffer.edit(
+            [
+                (Point::new(1, 0)..Point::new(1, 0), "1.5\n"),
+                (Point::new(2, 0)..Point::new(2, 5), "THREE"),
+            ],
             None,
             cx,
         )
     });
     branch_buffer.read_with(cx, |branch_buffer, cx| {
         assert_eq!(base_buffer.read(cx).text(), "one\ntwo\nthree\n");
-        assert_eq!(branch_buffer.text(), "one\nONE_POINT_FIVE\ntwo\nthree\n");
+        assert_eq!(branch_buffer.text(), "one\n1.5\ntwo\nTHREE\n");
     });
 
+    // The branch buffer maintains a diff with respect to its base buffer.
+    start_recalculating_diff(&branch_buffer, cx);
+    cx.run_until_parked();
+    assert_diff_hunks(
+        &branch_buffer,
+        cx,
+        &[(1..2, "", "1.5\n"), (3..4, "three\n", "THREE\n")],
+    );
+
     // Edits to the base are applied to the branch.
     base_buffer.update(cx, |buffer, cx| {
         buffer.edit([(Point::new(0, 0)..Point::new(0, 0), "ZERO\n")], None, cx)
     });
     branch_buffer.read_with(cx, |branch_buffer, cx| {
         assert_eq!(base_buffer.read(cx).text(), "ZERO\none\ntwo\nthree\n");
-        assert_eq!(
-            branch_buffer.text(),
-            "ZERO\none\nONE_POINT_FIVE\ntwo\nthree\n"
-        );
+        assert_eq!(branch_buffer.text(), "ZERO\none\n1.5\ntwo\nTHREE\n");
     });
 
-    assert_diff_hunks(&branch_buffer, cx, &[(2..3, "", "ONE_POINT_FIVE\n")]);
+    // Until the git diff recalculation is complete, the git diff references
+    // the previous content of the base buffer, so that it stays in sync.
+    start_recalculating_diff(&branch_buffer, cx);
+    assert_diff_hunks(
+        &branch_buffer,
+        cx,
+        &[(2..3, "", "1.5\n"), (4..5, "three\n", "THREE\n")],
+    );
+    cx.run_until_parked();
+    assert_diff_hunks(
+        &branch_buffer,
+        cx,
+        &[(2..3, "", "1.5\n"), (4..5, "three\n", "THREE\n")],
+    );
 
     // Edits to any replica of the base are applied to the branch.
     base_buffer_replica.update(cx, |buffer, cx| {
-        buffer.edit(
-            [(Point::new(2, 0)..Point::new(2, 0), "TWO_POINT_FIVE\n")],
-            None,
-            cx,
-        )
+        buffer.edit([(Point::new(2, 0)..Point::new(2, 0), "2.5\n")], None, cx)
     });
     branch_buffer.read_with(cx, |branch_buffer, cx| {
-        assert_eq!(
-            base_buffer.read(cx).text(),
-            "ZERO\none\ntwo\nTWO_POINT_FIVE\nthree\n"
-        );
-        assert_eq!(
-            branch_buffer.text(),
-            "ZERO\none\nONE_POINT_FIVE\ntwo\nTWO_POINT_FIVE\nthree\n"
-        );
+        assert_eq!(base_buffer.read(cx).text(), "ZERO\none\ntwo\n2.5\nthree\n");
+        assert_eq!(branch_buffer.text(), "ZERO\none\n1.5\ntwo\n2.5\nTHREE\n");
     });
 
     // Merging the branch applies all of its changes to the base.
     base_buffer.update(cx, |base_buffer, cx| {
-        base_buffer.merge(&branch_buffer, cx);
+        base_buffer.merge(&branch_buffer, None, cx);
+    });
+
+    branch_buffer.update(cx, |branch_buffer, cx| {
         assert_eq!(
-            base_buffer.text(),
-            "ZERO\none\nONE_POINT_FIVE\ntwo\nTWO_POINT_FIVE\nthree\n"
+            base_buffer.read(cx).text(),
+            "ZERO\none\n1.5\ntwo\n2.5\nTHREE\n"
         );
+        assert_eq!(branch_buffer.text(), "ZERO\none\n1.5\ntwo\n2.5\nTHREE\n");
     });
 }
 
+fn start_recalculating_diff(buffer: &Model<Buffer>, cx: &mut TestAppContext) {
+    buffer
+        .update(cx, |buffer, cx| buffer.recalculate_diff(cx).unwrap())
+        .detach();
+}
+
+#[track_caller]
 fn assert_diff_hunks(
     buffer: &Model<Buffer>,
     cx: &mut TestAppContext,
     expected_hunks: &[(Range<u32>, &str, &str)],
 ) {
-    buffer
-        .update(cx, |buffer, cx| buffer.recalculate_diff(cx).unwrap())
-        .detach();
-    cx.executor().run_until_parked();
-
-    buffer.read_with(cx, |buffer, _| {
-        let snapshot = buffer.snapshot();
-        assert_hunks(
-            snapshot.git_diff_hunks_intersecting_range(Anchor::MIN..Anchor::MAX),
-            &snapshot,
-            &buffer.diff_base().unwrap().to_string(),
-            expected_hunks,
-        );
-    });
+    let (snapshot, diff_base) = buffer.read_with(cx, |buffer, _| {
+        (buffer.snapshot(), buffer.diff_base().unwrap().to_string())
+    });
+    assert_hunks(
+        snapshot.git_diff_hunks_intersecting_range(Anchor::MIN..Anchor::MAX),
+        &snapshot,
+        &diff_base,
+        expected_hunks,
+    );
 }
 
 #[gpui::test(iterations = 100)]
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index c631c01f99a1a6..4dc378a755bdae 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -14,6 +14,7 @@ use breadcrumbs::Breadcrumbs;
 use client::ZED_URL_SCHEME;
 use collections::VecDeque;
 use command_palette_hooks::CommandPaletteFilter;
+use editor::ProposedChangesEditorToolbar;
 use editor::{scroll::Autoscroll, Editor, MultiBuffer};
 use feature_flags::FeatureFlagAppExt;
 use gpui::{
@@ -582,6 +583,8 @@ fn initialize_pane(workspace: &mut Workspace, pane: &View<Pane>, cx: &mut ViewCo
             let buffer_search_bar = cx.new_view(search::BufferSearchBar::new);
             toolbar.add_item(buffer_search_bar.clone(), cx);
 
+            let proposed_change_bar = cx.new_view(|_| ProposedChangesEditorToolbar::new());
+            toolbar.add_item(proposed_change_bar, cx);
             let quick_action_bar =
                 cx.new_view(|cx| QuickActionBar::new(buffer_search_bar, workspace, cx));
             toolbar.add_item(quick_action_bar, cx);

From b701eab44f0728d90d2d65b3bba20263e16897ad Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 26 Sep 2024 01:31:17 -0600
Subject: [PATCH 341/762] Avoid unwrap in file finder (#18374)

Release Notes:

- Fixed a (rare) panic in file finder

---------

Co-authored-by: Kirill Bulatov <kirill@zed.dev>
---
 crates/file_finder/src/file_finder.rs | 28 +++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/crates/file_finder/src/file_finder.rs b/crates/file_finder/src/file_finder.rs
index 1a65bd352d61d7..f63c499ee84c72 100644
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -394,7 +394,7 @@ fn matching_history_items<'a>(
                         .chars(),
                 ),
             };
-            candidates_paths.insert(Arc::clone(&found_path.project.path), found_path);
+            candidates_paths.insert(&found_path.project, found_path);
             Some((found_path.project.worktree_id, candidate))
         })
         .fold(
@@ -419,17 +419,21 @@ fn matching_history_items<'a>(
                 max_results,
             )
             .into_iter()
-            .map(|path_match| {
-                let (_, found_path) = candidates_paths
-                    .remove_entry(&path_match.path)
-                    .expect("candidate info not found");
-                (
-                    Arc::clone(&path_match.path),
-                    Match::History {
-                        path: found_path.clone(),
-                        panel_match: Some(ProjectPanelOrdMatch(path_match)),
-                    },
-                )
+            .filter_map(|path_match| {
+                candidates_paths
+                    .remove_entry(&ProjectPath {
+                        worktree_id: WorktreeId::from_usize(path_match.worktree_id),
+                        path: Arc::clone(&path_match.path),
+                    })
+                    .map(|(_, found_path)| {
+                        (
+                            Arc::clone(&path_match.path),
+                            Match::History {
+                                path: found_path.clone(),
+                                panel_match: Some(ProjectPanelOrdMatch(path_match)),
+                            },
+                        )
+                    })
             }),
         );
     }

From 2d2e20f9d426709f8cebfc7321866880834db4a3 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 26 Sep 2024 11:07:07 +0200
Subject: [PATCH 342/762] editor: Fix cursor shape not restoring when setting
 removed (#18379)

Closes #18119

Release Notes:

- Fixed the cursor shape in the editor not changing back to default when
`{"cursor_shape": "..."}` setting is removed. (Does not apply to Vim
mode.)
---
 crates/editor/src/editor.rs | 18 +++++++++++++-----
 crates/vim/src/vim.rs       |  7 +++++++
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 23448b43a7cc72..6e5543132c8e78 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -11925,12 +11925,19 @@ impl Editor {
             )),
             cx,
         );
-        let editor_settings = EditorSettings::get_global(cx);
-        if let Some(cursor_shape) = editor_settings.cursor_shape {
-            self.cursor_shape = cursor_shape;
+
+        let old_cursor_shape = self.cursor_shape;
+
+        {
+            let editor_settings = EditorSettings::get_global(cx);
+            self.scroll_manager.vertical_scroll_margin = editor_settings.vertical_scroll_margin;
+            self.show_breadcrumbs = editor_settings.toolbar.breadcrumbs;
+            self.cursor_shape = editor_settings.cursor_shape.unwrap_or_default();
+        }
+
+        if old_cursor_shape != self.cursor_shape {
+            cx.emit(EditorEvent::CursorShapeChanged);
         }
-        self.scroll_manager.vertical_scroll_margin = editor_settings.vertical_scroll_margin;
-        self.show_breadcrumbs = editor_settings.toolbar.breadcrumbs;
 
         let project_settings = ProjectSettings::get_global(cx);
         self.serialize_dirty_buffers = project_settings.session.restore_unsaved_buffers;
@@ -13127,6 +13134,7 @@ pub enum EditorEvent {
     TransactionBegun {
         transaction_id: clock::Lamport,
     },
+    CursorShapeChanged,
 }
 
 impl EventEmitter<EditorEvent> for Editor {}
diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs
index 701972c19bb614..06116bff99de48 100644
--- a/crates/vim/src/vim.rs
+++ b/crates/vim/src/vim.rs
@@ -389,6 +389,7 @@ impl Vim {
             }
             EditorEvent::Edited { .. } => self.push_to_change_list(cx),
             EditorEvent::FocusedIn => self.sync_vim_settings(cx),
+            EditorEvent::CursorShapeChanged => self.cursor_shape_changed(cx),
             _ => {}
         }
     }
@@ -679,6 +680,12 @@ impl Vim {
         });
     }
 
+    fn cursor_shape_changed(&mut self, cx: &mut ViewContext<Self>) {
+        self.update_editor(cx, |vim, editor, cx| {
+            editor.set_cursor_shape(vim.cursor_shape(), cx);
+        });
+    }
+
     fn update_editor<S>(
         &mut self,
         cx: &mut ViewContext<Self>,

From b9b689d3221b6bcbea349b98a480d8e8f87fa802 Mon Sep 17 00:00:00 2001
From: "Hyunmin Woo (Hanul)" <woohm404@gmail.com>
Date: Thu, 26 Sep 2024 19:24:29 +0900
Subject: [PATCH 343/762] Fix Typo in rust language guide (#18383)

Release Notes:

- N/A
---
 docs/src/languages/rust.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/src/languages/rust.md b/docs/src/languages/rust.md
index 02e90d60a403b3..330b5fa9d0151d 100644
--- a/docs/src/languages/rust.md
+++ b/docs/src/languages/rust.md
@@ -23,8 +23,8 @@ The following configuration can be used to change the inlay hint settings for `r
         "inlayHints": {
           "maxLength": null,
           "lifetimeElisionHints": {
-            "enable": "skip_trivial"
-            "useParameterNames": true,
+            "enable": "skip_trivial",
+            "useParameterNames": true
           },
           "closureReturnTypeHints": {
             "enable": "always"

From 140d70289e54328509f59d9de2fefd8e8b35bec0 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 26 Sep 2024 12:26:58 +0200
Subject: [PATCH 344/762] Avoid panic by only restoring workspace if UI has
 launched (#18386)

This should fix the `unregistered setting type
workspace::workspace_settings::WorkspaceSettings` panic that came from
inside `restorable_workspace_locations`.

We tracked it down to a possible scenario (we can't recreate it though)
in which `app.on_reopen` is called before the app has finished
launching.

In any case, this check makes sense, because we only want to restore a
workspace in case the whole app has launched with a UI.

Release Notes:

- N/A

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/zed/src/main.rs | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 0f37e06f438f92..186805d12cd01d 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -425,15 +425,22 @@ fn main() {
     app.on_reopen(move |cx| {
         if let Some(app_state) = AppState::try_global(cx).and_then(|app_state| app_state.upgrade())
         {
-            cx.spawn({
-                let app_state = app_state.clone();
-                |mut cx| async move {
-                    if let Err(e) = restore_or_create_workspace(app_state, &mut cx).await {
-                        fail_to_open_window_async(e, &mut cx)
+            let ui_has_launched = cx
+                .try_global::<AppMode>()
+                .map(|mode| matches!(mode, AppMode::Ui))
+                .unwrap_or(false);
+
+            if ui_has_launched {
+                cx.spawn({
+                    let app_state = app_state.clone();
+                    |mut cx| async move {
+                        if let Err(e) = restore_or_create_workspace(app_state, &mut cx).await {
+                            fail_to_open_window_async(e, &mut cx)
+                        }
                     }
-                }
-            })
-            .detach();
+                })
+                .detach();
+            }
         }
     });
 

From 3f415f3587b12cc4745300e4c129f252649356e2 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 26 Sep 2024 12:27:08 +0200
Subject: [PATCH 345/762] Fix `use_on_type_format` setting being unused per
 language (#18387)

Before this change, `use_on_type_format` would only have an effect when
defined on a global level in our settings.

But our default.json settings would also document that it's used in
language settings, i.e.:

```json
{
  "languages": {
    "C": {
      "use_on_type_format": false
    },
    "C++": {
      "use_on_type_format": false
    }
  }
}
```

But this did **not** work.

With the change, it now works globally and per-language.

Release Notes:

- Fixed `use_on_type_format` setting not working when defined inside
`"languages"` in the settings. This change will now change the default
behavior for C, C++, and Markdown, by turning language server's
`OnTypeFormatting` completions off by default.

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/editor/src/editor.rs              | 11 ++++++++++-
 crates/editor/src/editor_settings.rs     |  6 ------
 crates/language/src/language_settings.rs |  9 +++++++++
 3 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 6e5543132c8e78..730482b123bf77 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -3442,7 +3442,7 @@ impl Editor {
                 s.select(new_selections)
             });
 
-            if !bracket_inserted && EditorSettings::get_global(cx).use_on_type_format {
+            if !bracket_inserted {
                 if let Some(on_type_format_task) =
                     this.trigger_on_type_formatting(text.to_string(), cx)
                 {
@@ -4191,6 +4191,15 @@ impl Editor {
             .read(cx)
             .text_anchor_for_position(position, cx)?;
 
+        let settings = language_settings::language_settings(
+            buffer.read(cx).language_at(buffer_position).as_ref(),
+            buffer.read(cx).file(),
+            cx,
+        );
+        if !settings.use_on_type_format {
+            return None;
+        }
+
         // OnTypeFormatting returns a list of edits, no need to pass them between Zed instances,
         // hence we do LSP request & edit on host side only — add formats to host's history.
         let push_to_lsp_host_history = true;
diff --git a/crates/editor/src/editor_settings.rs b/crates/editor/src/editor_settings.rs
index d651e76c2c2e7d..9137629241468c 100644
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -13,7 +13,6 @@ pub struct EditorSettings {
     pub show_completions_on_input: bool,
     pub show_completion_documentation: bool,
     pub completion_documentation_secondary_query_debounce: u64,
-    pub use_on_type_format: bool,
     pub toolbar: Toolbar,
     pub scrollbar: Scrollbar,
     pub gutter: Gutter,
@@ -209,11 +208,6 @@ pub struct EditorSettingsContent {
     ///
     /// Default: 300 ms
     pub completion_documentation_secondary_query_debounce: Option<u64>,
-    /// Whether to use additional LSP queries to format (and amend) the code after
-    /// every "trigger" symbol input, defined by LSP server capabilities.
-    ///
-    /// Default: true
-    pub use_on_type_format: Option<bool>,
     /// Toolbar related settings
     pub toolbar: Option<ToolbarContent>,
     /// Scrollbar related settings
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index 735a9a60f87fa6..f830c5f25c308c 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -113,6 +113,9 @@ pub struct LanguageSettings {
     pub use_autoclose: bool,
     /// Whether to automatically surround text with brackets.
     pub use_auto_surround: bool,
+    /// Whether to use additional LSP queries to format (and amend) the code after
+    /// every "trigger" symbol input, defined by LSP server capabilities.
+    pub use_on_type_format: bool,
     // Controls how the editor handles the autoclosed characters.
     pub always_treat_brackets_as_autoclosed: bool,
     /// Which code actions to run on save
@@ -333,6 +336,11 @@ pub struct LanguageSettingsContent {
     ///
     /// Default: false
     pub always_treat_brackets_as_autoclosed: Option<bool>,
+    /// Whether to use additional LSP queries to format (and amend) the code after
+    /// every "trigger" symbol input, defined by LSP server capabilities.
+    ///
+    /// Default: true
+    pub use_on_type_format: Option<bool>,
     /// Which code actions to run on save after the formatter.
     /// These are not run if formatting is off.
     ///
@@ -1045,6 +1053,7 @@ fn merge_settings(settings: &mut LanguageSettings, src: &LanguageSettingsContent
     merge(&mut settings.soft_wrap, src.soft_wrap);
     merge(&mut settings.use_autoclose, src.use_autoclose);
     merge(&mut settings.use_auto_surround, src.use_auto_surround);
+    merge(&mut settings.use_on_type_format, src.use_on_type_format);
     merge(
         &mut settings.always_treat_brackets_as_autoclosed,
         src.always_treat_brackets_as_autoclosed,

From 31902a1b73ce99934b8580cdacc2dd51eb87a046 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Thu, 26 Sep 2024 12:52:56 +0200
Subject: [PATCH 346/762] Remove leftover println statements (#18389)

Remove some leftover println statements from #17644

Release Notes:

- N/A
---
 crates/vim/src/normal/increment.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/crates/vim/src/normal/increment.rs b/crates/vim/src/normal/increment.rs
index 6d66e380c30b80..b0501eeef7da3c 100644
--- a/crates/vim/src/normal/increment.rs
+++ b/crates/vim/src/normal/increment.rs
@@ -213,8 +213,6 @@ fn find_number(
                 begin = Some(offset);
             }
             num.push(ch);
-            println!("pushing {}", ch);
-            println!();
         } else if begin.is_some() {
             end = Some(offset);
             break;

From db92a31067c8a6e6d889a63326decdd42f9de6c2 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Thu, 26 Sep 2024 13:18:50 +0200
Subject: [PATCH 347/762] lsp: Do not notify all language servers on file save
 (#17756)

This is not an ideal solution to
https://github.com/fasterthanlime/zed-diags-readme, but current status
quo is not great either; we were just going through all of the language
servers and notifying them, whereas we should ideally do it based on a
glob.
/cc @fasterthanlime

Release Notes:

- N/A
---
 crates/project/src/lsp_store.rs     | 16 +++++++++
 crates/project/src/project_tests.rs | 55 ++++++++++++++++++++++++-----
 2 files changed, 63 insertions(+), 8 deletions(-)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index a4a13b296ed5c1..37922b7c2ee03b 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -2892,11 +2892,27 @@ impl LspStore {
         let file = File::from_dyn(buffer.read(cx).file())?;
         let worktree_id = file.worktree_id(cx);
         let abs_path = file.as_local()?.abs_path(cx);
+        let worktree_path = file.as_local()?.path();
         let text_document = lsp::TextDocumentIdentifier {
             uri: lsp::Url::from_file_path(abs_path).log_err()?,
         };
 
+        let watched_paths_for_server = &self.as_local()?.language_server_watched_paths;
         for server in self.language_servers_for_worktree(worktree_id) {
+            let should_notify = maybe!({
+                Some(
+                    watched_paths_for_server
+                        .get(&server.server_id())?
+                        .read(cx)
+                        .worktree_paths
+                        .get(&worktree_id)?
+                        .is_match(worktree_path),
+                )
+            })
+            .unwrap_or_default();
+            if !should_notify {
+                continue;
+            }
             if let Some(include_text) = include_text(server.as_ref()) {
                 let text = if include_text {
                     Some(buffer.read(cx).text())
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index 9e58caa2442439..dd14ccd60f4e98 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -386,6 +386,34 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {
 
     // A server is started up, and it is notified about Rust files.
     let mut fake_rust_server = fake_rust_servers.next().await.unwrap();
+    fake_rust_server
+        .request::<lsp::request::RegisterCapability>(lsp::RegistrationParams {
+            registrations: vec![lsp::Registration {
+                id: Default::default(),
+                method: "workspace/didChangeWatchedFiles".to_string(),
+                register_options: serde_json::to_value(
+                    lsp::DidChangeWatchedFilesRegistrationOptions {
+                        watchers: vec![
+                            lsp::FileSystemWatcher {
+                                glob_pattern: lsp::GlobPattern::String(
+                                    "/the-root/Cargo.toml".to_string(),
+                                ),
+                                kind: None,
+                            },
+                            lsp::FileSystemWatcher {
+                                glob_pattern: lsp::GlobPattern::String(
+                                    "/the-root/*.rs".to_string(),
+                                ),
+                                kind: None,
+                            },
+                        ],
+                    },
+                )
+                .ok(),
+            }],
+        })
+        .await
+        .unwrap();
     assert_eq!(
         fake_rust_server
             .receive_notification::<lsp::notification::DidOpenTextDocument>()
@@ -433,6 +461,24 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {
 
     // A json language server is started up and is only notified about the json buffer.
     let mut fake_json_server = fake_json_servers.next().await.unwrap();
+    fake_json_server
+        .request::<lsp::request::RegisterCapability>(lsp::RegistrationParams {
+            registrations: vec![lsp::Registration {
+                id: Default::default(),
+                method: "workspace/didChangeWatchedFiles".to_string(),
+                register_options: serde_json::to_value(
+                    lsp::DidChangeWatchedFilesRegistrationOptions {
+                        watchers: vec![lsp::FileSystemWatcher {
+                            glob_pattern: lsp::GlobPattern::String("/the-root/*.json".to_string()),
+                            kind: None,
+                        }],
+                    },
+                )
+                .ok(),
+            }],
+        })
+        .await
+        .unwrap();
     assert_eq!(
         fake_json_server
             .receive_notification::<lsp::notification::DidOpenTextDocument>()
@@ -483,7 +529,7 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {
         )
     );
 
-    // Save notifications are reported to all servers.
+    // Save notifications are reported only to servers that signed up for a given extension.
     project
         .update(cx, |project, cx| project.save_buffer(toml_buffer, cx))
         .await
@@ -495,13 +541,6 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {
             .text_document,
         lsp::TextDocumentIdentifier::new(lsp::Url::from_file_path("/the-root/Cargo.toml").unwrap())
     );
-    assert_eq!(
-        fake_json_server
-            .receive_notification::<lsp::notification::DidSaveTextDocument>()
-            .await
-            .text_document,
-        lsp::TextDocumentIdentifier::new(lsp::Url::from_file_path("/the-root/Cargo.toml").unwrap())
-    );
 
     // Renames are reported only to servers matching the buffer's language.
     fs.rename(

From 1deed247eb37080b6db5d84ed5054214691554e9 Mon Sep 17 00:00:00 2001
From: Taras Martyniuk <tarabopm@gmail.com>
Date: Thu, 26 Sep 2024 15:36:58 +0300
Subject: [PATCH 348/762] terraform: Bump to v0.1.1 (#18382)

This PR bumps the Terraform extension to v0.1.1

- https://github.com/zed-industries/zed/pull/17200

Release Notes:

- N/A
---
 Cargo.lock                          | 2 +-
 extensions/terraform/Cargo.toml     | 2 +-
 extensions/terraform/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0b3ee53e9aa852..5138d59e277280 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14687,7 +14687,7 @@ dependencies = [
 
 [[package]]
 name = "zed_terraform"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/terraform/Cargo.toml b/extensions/terraform/Cargo.toml
index 7892b68466cc6e..56ae621e167efc 100644
--- a/extensions/terraform/Cargo.toml
+++ b/extensions/terraform/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_terraform"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/terraform/extension.toml b/extensions/terraform/extension.toml
index 80fe03fc04431e..fc96f773e9b238 100644
--- a/extensions/terraform/extension.toml
+++ b/extensions/terraform/extension.toml
@@ -1,7 +1,7 @@
 id = "terraform"
 name = "Terraform"
 description = "Terraform support."
-version = "0.1.0"
+version = "0.1.1"
 schema_version = 1
 authors = ["Caius Durling <dev@caius.name>", "Daniel Banck <dbanck@users.noreply.github.com>"]
 repository = "https://github.com/zed-industries/zed"

From 1a4f9b289130593d77db0759be738624203731e1 Mon Sep 17 00:00:00 2001
From: Galen Elias <gelias@gmail.com>
Date: Thu, 26 Sep 2024 06:30:06 -0700
Subject: [PATCH 349/762] Fix minimum gutter line number spacing (#18021)

I was inspecting how Zed did the layout in the editor, specifically for
the gutter, and noticed that `em_width * X` is being used as the 'width
of X consecutive characters'. Howevever, that math didn't work for me,
because em_width doesn't account for the space between characters, so
you can't just multiply it by a character count.

One place this is actually noticeable is in the logic for
`min_width_for_number_on_gutter`, where we try to reserve 4 characters
of line number space. However, once you actually hit 4 characters, the
actual width is bigger, causing things to resize. This seems clearly
counter to the intent of the code.

It seems the more correct logic is to use `em_advance` which accounts
for the space between the characters. I am leaving the rest of the uses
of `em_width` for generic padding. It is also possible that
`column_pixels()` would be the more correct fix here, but it wasn't
straightforward to use that due to it residing EditorElement source
file.

On my MacBook this increases the width of the gutter by 6 pixels when
there are <999 lines in the file, otherwise it's identical.

It might be worth doing some more general audit of some of the other
uses of em_width as a concept. (e.g. `git_blame_entries_width`)


https://github.com/user-attachments/assets/f2a28cd5-9bb6-4109-bf41-1838e56a75f9

Release Notes:

- Fix a slight gutter flicker when going over 999 lines
---
 crates/editor/src/editor.rs  |  3 ++-
 crates/editor/src/element.rs | 16 ++++++++++++++--
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 730482b123bf77..102e94f1abb41e 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -12956,6 +12956,7 @@ impl EditorSnapshot {
         font_id: FontId,
         font_size: Pixels,
         em_width: Pixels,
+        em_advance: Pixels,
         max_line_number_width: Pixels,
         cx: &AppContext,
     ) -> GutterDimensions {
@@ -12976,7 +12977,7 @@ impl EditorSnapshot {
             .unwrap_or(gutter_settings.line_numbers);
         let line_gutter_width = if show_line_numbers {
             // Avoid flicker-like gutter resizes when the line number gains another digit and only resize the gutter on files with N*10^5 lines.
-            let min_width_for_number_on_gutter = em_width * 4.0;
+            let min_width_for_number_on_gutter = em_advance * 4.0;
             max_line_number_width.max(min_width_for_number_on_gutter)
         } else {
             0.0.into()
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 9fe05bc4f26063..f5db7b94ba8ad5 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -4970,6 +4970,7 @@ impl Element for EditorElement {
                         font_id,
                         font_size,
                         em_width,
+                        em_advance,
                         self.max_line_number_width(&snapshot, cx),
                         cx,
                     );
@@ -6283,10 +6284,21 @@ fn compute_auto_height_layout(
         .unwrap()
         .size
         .width;
+    let em_advance = cx
+        .text_system()
+        .advance(font_id, font_size, 'm')
+        .unwrap()
+        .width;
 
     let mut snapshot = editor.snapshot(cx);
-    let gutter_dimensions =
-        snapshot.gutter_dimensions(font_id, font_size, em_width, max_line_number_width, cx);
+    let gutter_dimensions = snapshot.gutter_dimensions(
+        font_id,
+        font_size,
+        em_width,
+        em_advance,
+        max_line_number_width,
+        cx,
+    );
 
     editor.gutter_dimensions = gutter_dimensions;
     let text_width = width - gutter_dimensions.width;

From 7eea1a6f51b11bd56150203809f21da7e8b5530d Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 26 Sep 2024 15:47:14 +0200
Subject: [PATCH 350/762] git blame gutter: Use smallest possible space
 (#18145)

Before:
![screenshot-2024-09-26-15 00
20@2x](https://github.com/user-attachments/assets/f6706325-5bef-404e-a0b4-63a5121969fa)

After:

![screenshot-2024-09-26-15 02
24@2x](https://github.com/user-attachments/assets/739d0831-0b4a-457f-917e-10f3a662e74d)


Release Notes:

- Improved the git blame gutter to take up only the space required to
display the longest git author name in the current file.

---------

Co-authored-by: Bennet Bo Fenner <bennet@zed.dev>
---
 crates/editor/src/editor.rs    | 35 ++++++++++++++++++++++++++++------
 crates/editor/src/element.rs   | 31 +++++++++++++++---------------
 crates/editor/src/git/blame.rs | 21 ++++++++++++++++++++
 3 files changed, 65 insertions(+), 22 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 102e94f1abb41e..54d23a8219d4f4 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -663,7 +663,7 @@ pub struct EditorSnapshot {
     show_git_diff_gutter: Option<bool>,
     show_code_actions: Option<bool>,
     show_runnables: Option<bool>,
-    render_git_blame_gutter: bool,
+    git_blame_gutter_max_author_length: Option<usize>,
     pub display_snapshot: DisplaySnapshot,
     pub placeholder_text: Option<Arc<str>>,
     is_focused: bool,
@@ -673,7 +673,7 @@ pub struct EditorSnapshot {
     gutter_hovered: bool,
 }
 
-const GIT_BLAME_GUTTER_WIDTH_CHARS: f32 = 53.;
+const GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED: usize = 20;
 
 #[derive(Default, Debug, Clone, Copy)]
 pub struct GutterDimensions {
@@ -2211,6 +2211,19 @@ impl Editor {
     }
 
     pub fn snapshot(&mut self, cx: &mut WindowContext) -> EditorSnapshot {
+        let git_blame_gutter_max_author_length = self
+            .render_git_blame_gutter(cx)
+            .then(|| {
+                if let Some(blame) = self.blame.as_ref() {
+                    let max_author_length =
+                        blame.update(cx, |blame, cx| blame.max_author_length(cx));
+                    Some(max_author_length)
+                } else {
+                    None
+                }
+            })
+            .flatten();
+
         EditorSnapshot {
             mode: self.mode,
             show_gutter: self.show_gutter,
@@ -2218,7 +2231,7 @@ impl Editor {
             show_git_diff_gutter: self.show_git_diff_gutter,
             show_code_actions: self.show_code_actions,
             show_runnables: self.show_runnables,
-            render_git_blame_gutter: self.render_git_blame_gutter(cx),
+            git_blame_gutter_max_author_length,
             display_snapshot: self.display_map.update(cx, |map, cx| map.snapshot(cx)),
             scroll_anchor: self.scroll_manager.anchor(),
             ongoing_scroll: self.scroll_manager.ongoing_scroll(),
@@ -12989,9 +13002,19 @@ impl EditorSnapshot {
 
         let show_runnables = self.show_runnables.unwrap_or(gutter_settings.runnables);
 
-        let git_blame_entries_width = self
-            .render_git_blame_gutter
-            .then_some(em_width * GIT_BLAME_GUTTER_WIDTH_CHARS);
+        let git_blame_entries_width =
+            self.git_blame_gutter_max_author_length
+                .map(|max_author_length| {
+                    // Length of the author name, but also space for the commit hash,
+                    // the spacing and the timestamp.
+                    let max_char_count = max_author_length
+                        .min(GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED)
+                        + 7 // length of commit sha
+                        + 14 // length of max relative timestamp ("60 minutes ago")
+                        + 4; // gaps and margins
+
+                    em_advance * max_char_count
+                });
 
         let mut left_padding = git_blame_entries_width.unwrap_or(Pixels::ZERO);
         left_padding += if show_code_actions || show_runnables {
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index f5db7b94ba8ad5..6f30062d47ec77 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -21,7 +21,7 @@ use crate::{
     EditorSnapshot, EditorStyle, ExpandExcerpts, FocusedBlock, GutterDimensions, HalfPageDown,
     HalfPageUp, HandleInput, HoveredCursor, HoveredHunk, LineDown, LineUp, OpenExcerpts, PageDown,
     PageUp, Point, RowExt, RowRangeExt, SelectPhase, Selection, SoftWrap, ToPoint,
-    CURSORS_VISIBLE_FOR, MAX_LINE_LEN,
+    CURSORS_VISIBLE_FOR, GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED, MAX_LINE_LEN,
 };
 use client::ParticipantIndex;
 use collections::{BTreeMap, HashMap};
@@ -1445,7 +1445,7 @@ impl EditorElement {
             AvailableSpace::MaxContent
         };
         let scroll_top = scroll_position.y * line_height;
-        let start_x = em_width * 1;
+        let start_x = em_width;
 
         let mut last_used_color: Option<(PlayerColor, Oid)> = None;
 
@@ -4228,7 +4228,7 @@ fn render_blame_entry(
     let short_commit_id = blame_entry.sha.display_short();
 
     let author_name = blame_entry.author.as_deref().unwrap_or("<no name>");
-    let name = util::truncate_and_trailoff(author_name, 20);
+    let name = util::truncate_and_trailoff(author_name, GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED);
 
     let details = blame.read(cx).details_for_entry(&blame_entry);
 
@@ -4240,22 +4240,21 @@ fn render_blame_entry(
 
     h_flex()
         .w_full()
+        .justify_between()
         .font_family(style.text.font().family)
         .line_height(style.text.line_height)
         .id(("blame", ix))
-        .children([
-            div()
-                .text_color(sha_color.cursor)
-                .child(short_commit_id)
-                .mr_2(),
-            div()
-                .w_full()
-                .h_flex()
-                .justify_between()
-                .text_color(cx.theme().status().hint)
-                .child(name)
-                .child(relative_timestamp),
-        ])
+        .text_color(cx.theme().status().hint)
+        .pr_2()
+        .gap_2()
+        .child(
+            h_flex()
+                .items_center()
+                .gap_2()
+                .child(div().text_color(sha_color.cursor).child(short_commit_id))
+                .child(name),
+        )
+        .child(relative_timestamp)
         .on_mouse_down(MouseButton::Right, {
             let blame_entry = blame_entry.clone();
             let details = details.clone();
diff --git a/crates/editor/src/git/blame.rs b/crates/editor/src/git/blame.rs
index 775cbcc379e128..733d42d0c57dda 100644
--- a/crates/editor/src/git/blame.rs
+++ b/crates/editor/src/git/blame.rs
@@ -207,6 +207,27 @@ impl GitBlame {
         })
     }
 
+    pub fn max_author_length(&mut self, cx: &mut ModelContext<Self>) -> usize {
+        self.sync(cx);
+
+        let mut max_author_length = 0;
+
+        for entry in self.entries.iter() {
+            let author_len = entry
+                .blame
+                .as_ref()
+                .and_then(|entry| entry.author.as_ref())
+                .map(|author| author.len());
+            if let Some(author_len) = author_len {
+                if author_len > max_author_length {
+                    max_author_length = author_len;
+                }
+            }
+        }
+
+        max_author_length
+    }
+
     pub fn blur(&mut self, _: &mut ModelContext<Self>) {
         self.focused = false;
     }

From f143396825c89b96076087ff80630d0b50eeb6cb Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Thu, 26 Sep 2024 16:24:11 +0200
Subject: [PATCH 351/762] ssh: Do not require user to be signed in to use ssh
 remoting (#18396)

Fixes #18392

Closes #18392

Release Notes:

- N/A
---
 crates/recent_projects/src/dev_servers.rs | 127 +++++++++-------------
 1 file changed, 51 insertions(+), 76 deletions(-)

diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index af5f51f14fca2c..2038d069b4c68a 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -40,7 +40,6 @@ use ui::{
 };
 use ui_input::{FieldLabelLayout, TextField};
 use util::ResultExt;
-use workspace::notifications::NotifyResultExt;
 use workspace::OpenOptions;
 use workspace::{notifications::DetachAndPromptErr, AppState, ModalView, Workspace, WORKSPACE_DB};
 
@@ -1133,7 +1132,8 @@ impl DevServerProjects {
         let dev_server_id = state.dev_server_id;
         let access_token = state.access_token.clone();
         let ssh_prompt = state.ssh_prompt.clone();
-        let use_direct_ssh = SshSettings::get_global(cx).use_direct_ssh();
+        let use_direct_ssh = SshSettings::get_global(cx).use_direct_ssh()
+            || Client::global(cx).status().borrow().is_signed_out();
 
         let mut kind = state.kind;
         if use_direct_ssh && kind == NewServerKind::LegacySSH {
@@ -1407,7 +1407,6 @@ impl DevServerProjects {
             is_creating = Some(*creating);
             creating_dev_server = Some(*dev_server_id);
         };
-        let is_signed_out = Client::global(cx).status().borrow().is_signed_out();
 
         Modal::new("remote-projects", Some(self.scroll_handle.clone()))
             .header(
@@ -1415,82 +1414,58 @@ impl DevServerProjects {
                     .show_dismiss_button(true)
                     .child(Headline::new("Remote Projects (alpha)").size(HeadlineSize::Small)),
             )
-            .when(is_signed_out, |modal| {
-                modal
-                    .section(Section::new().child(div().child(Label::new(
-                        "To continue with the remote development features, you need to sign in to Zed.",
-                    ))))
-                    .footer(
-                        ModalFooter::new().end_slot(
-                            Button::new("sign_in", "Sign in with GitHub")
-                                .icon(IconName::Github)
-                                .icon_position(IconPosition::Start)
-                                .full_width()
-                                .on_click(cx.listener(|_, _, cx| {
-                                    let client = Client::global(cx).clone();
-                                    cx.spawn(|_, mut cx| async move {
-                                        client
-                                            .authenticate_and_connect(true, &cx)
-                                            .await
-                                            .notify_async_err(&mut cx);
-                                    })
-                                    .detach();
-                                    cx.emit(gpui::DismissEvent);
-                                })),
-                        ),
-                    )
-            })
-            .when(!is_signed_out, |modal| {
-                modal.section(
-                    Section::new().child(
-                        div().child(
-                            List::new()
-                                .empty_message("No dev servers registered yet.")
-                                .header(Some(
-                                    ListHeader::new("Connections").end_slot(
-                                        Button::new("register-dev-server-button", "Connect New Server")
-                                            .icon(IconName::Plus)
-                                            .icon_position(IconPosition::Start)
-                                            .icon_color(Color::Muted)
-                                            .on_click(cx.listener(|this, _, cx| {
-                                                this.mode = Mode::CreateDevServer(
-                                                    CreateDevServer {
-                                                        kind: if SshSettings::get_global(cx).use_direct_ssh() { NewServerKind::DirectSSH } else { NewServerKind::LegacySSH },
-                                                        ..Default::default()
-                                                    }
-                                                );
-                                                this.dev_server_name_input.update(
-                                                    cx,
-                                                    |text_field, cx| {
-                                                        text_field.editor().update(
-                                                            cx,
-                                                            |editor, cx| {
-                                                                editor.set_text("", cx);
-                                                            },
-                                                        );
-                                                    },
-                                                );
-                                                cx.notify();
-                                            })),
-                                    ),
-                                ))
-                                .children(ssh_connections.iter().cloned().enumerate().map(|(ix, connection)| {
+            .section(
+                Section::new().child(
+                    div().child(
+                        List::new()
+                            .empty_message("No dev servers registered yet.")
+                            .header(Some(
+                                ListHeader::new("Connections").end_slot(
+                                    Button::new("register-dev-server-button", "Connect New Server")
+                                        .icon(IconName::Plus)
+                                        .icon_position(IconPosition::Start)
+                                        .icon_color(Color::Muted)
+                                        .on_click(cx.listener(|this, _, cx| {
+                                            this.mode = Mode::CreateDevServer(CreateDevServer {
+                                                kind: if SshSettings::get_global(cx)
+                                                    .use_direct_ssh()
+                                                {
+                                                    NewServerKind::DirectSSH
+                                                } else {
+                                                    NewServerKind::LegacySSH
+                                                },
+                                                ..Default::default()
+                                            });
+                                            this.dev_server_name_input.update(
+                                                cx,
+                                                |text_field, cx| {
+                                                    text_field.editor().update(cx, |editor, cx| {
+                                                        editor.set_text("", cx);
+                                                    });
+                                                },
+                                            );
+                                            cx.notify();
+                                        })),
+                                ),
+                            ))
+                            .children(ssh_connections.iter().cloned().enumerate().map(
+                                |(ix, connection)| {
                                     self.render_ssh_connection(ix, connection, cx)
                                         .into_any_element()
-                                }))
-                                .children(dev_servers.iter().map(|dev_server| {
-                                    let creating = if creating_dev_server == Some(dev_server.id) {
-                                        is_creating
-                                    } else {
-                                        None
-                                    };
-                                    self.render_dev_server(dev_server, creating, cx)
-                                        .into_any_element()
-                                })),
-                        ),
+                                },
+                            ))
+                            .children(dev_servers.iter().map(|dev_server| {
+                                let creating = if creating_dev_server == Some(dev_server.id) {
+                                    is_creating
+                                } else {
+                                    None
+                                };
+                                self.render_dev_server(dev_server, creating, cx)
+                                    .into_any_element()
+                            })),
                     ),
-                )
-            })
+                ),
+            )
     }
 }
 

From de1889d6a864a1add60d63d08dd5d293f74a340d Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 26 Sep 2024 08:49:50 -0600
Subject: [PATCH 352/762] Update Rust crate async-trait to v0.1.83 (#18364)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [async-trait](https://redirect.github.com/dtolnay/async-trait) |
workspace.dependencies | patch | `0.1.82` -> `0.1.83` |

---

### Release Notes

<details>
<summary>dtolnay/async-trait (async-trait)</summary>

###
[`v0.1.83`](https://redirect.github.com/dtolnay/async-trait/releases/tag/0.1.83)

[Compare
Source](https://redirect.github.com/dtolnay/async-trait/compare/0.1.82...0.1.83)

- Prevent needless_arbitrary_self_type lint being produced in generated
code
([#&#8203;278](https://redirect.github.com/dtolnay/async-trait/issues/278))

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5138d59e277280..4826b312f103eb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -895,9 +895,9 @@ dependencies = [
 
 [[package]]
 name = "async-trait"
-version = "0.1.82"
+version = "0.1.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a27b8a3a6e1a44fa4c8baf1f653e4172e81486d4941f2237e20dc2d0cf4ddff1"
+checksum = "721cae7de5c34fbb2acd27e21e6d2cf7b886dce0c27388d46c4e6c47ea4318dd"
 dependencies = [
  "proc-macro2",
  "quote",

From 82eb753b31426da8d5b9aacdadf0512678f7b1d5 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 26 Sep 2024 11:24:01 -0400
Subject: [PATCH 353/762] Update actions/setup-node digest to 0a44ba7 (#18357)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [actions/setup-node](https://redirect.github.com/actions/setup-node) |
action | digest | `1e60f62` -> `0a44ba7` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 .github/actions/run_tests/action.yml   | 2 +-
 .github/workflows/ci.yml               | 2 +-
 .github/workflows/danger.yml           | 2 +-
 .github/workflows/randomized_tests.yml | 2 +-
 .github/workflows/release_nightly.yml  | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/actions/run_tests/action.yml b/.github/actions/run_tests/action.yml
index 815953398ba5b5..07284e2f5854ac 100644
--- a/.github/actions/run_tests/action.yml
+++ b/.github/actions/run_tests/action.yml
@@ -10,7 +10,7 @@ runs:
         cargo install cargo-nextest
 
     - name: Install Node
-      uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b # v4
+      uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
       with:
         node-version: "18"
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f059b470040129..07e5499d5eb76c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -172,7 +172,7 @@ jobs:
       DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
     steps:
       - name: Install Node
-        uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
         with:
           node-version: "18"
 
diff --git a/.github/workflows/danger.yml b/.github/workflows/danger.yml
index 8ff35b9e26da59..0278bbce02154b 100644
--- a/.github/workflows/danger.yml
+++ b/.github/workflows/danger.yml
@@ -21,7 +21,7 @@ jobs:
           version: 9
 
       - name: Setup Node
-        uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
         with:
           node-version: "20"
           cache: "pnpm"
diff --git a/.github/workflows/randomized_tests.yml b/.github/workflows/randomized_tests.yml
index 57f43d4961f3dd..947b5059bd7120 100644
--- a/.github/workflows/randomized_tests.yml
+++ b/.github/workflows/randomized_tests.yml
@@ -22,7 +22,7 @@ jobs:
       - buildjet-16vcpu-ubuntu-2204
     steps:
       - name: Install Node
-        uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
         with:
           node-version: "18"
 
diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml
index 2b973dcddc3d6f..4e8a257bdd1bb8 100644
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -70,7 +70,7 @@ jobs:
       ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Install Node
-        uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
         with:
           node-version: "18"
 

From e5bbd378a61ed719a8635c49bafdfb103d1b33d8 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 26 Sep 2024 11:44:38 -0400
Subject: [PATCH 354/762] Update Rust crate cargo_toml to v0.20.5 (#18365)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [cargo_toml](https://lib.rs/cargo_toml)
([source](https://gitlab.com/lib.rs/cargo_toml)) |
workspace.dependencies | patch | `0.20.4` -> `0.20.5` |

---

### Release Notes

<details>
<summary>lib.rs/cargo_toml (cargo_toml)</summary>

###
[`v0.20.5`](https://gitlab.com/lib.rs/cargo_toml/compare/v0.20.4...v0.20.5)

[Compare
Source](https://gitlab.com/lib.rs/cargo_toml/compare/v0.20.4...v0.20.5)

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4826b312f103eb..94b8205329d344 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2087,9 +2087,9 @@ dependencies = [
 
 [[package]]
 name = "cargo_toml"
-version = "0.20.4"
+version = "0.20.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad639525b1c67b6a298f378417b060fbc04618bea559482a8484381cce27d965"
+checksum = "88da5a13c620b4ca0078845707ea9c3faf11edbc3ffd8497d11d686211cd1ac0"
 dependencies = [
  "serde",
  "toml 0.8.19",

From 84a6ded657ecf8ced4fce6ad0e6485200a2a4c47 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 26 Sep 2024 11:52:12 -0400
Subject: [PATCH 355/762] Update Rust crate clap to v4.5.18 (#18369)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [clap](https://redirect.github.com/clap-rs/clap) |
workspace.dependencies | patch | `4.5.17` -> `4.5.18` |

---

### Release Notes

<details>
<summary>clap-rs/clap (clap)</summary>

###
[`v4.5.18`](https://redirect.github.com/clap-rs/clap/blob/HEAD/CHANGELOG.md#4518---2024-09-20)

[Compare
Source](https://redirect.github.com/clap-rs/clap/compare/v4.5.17...v4.5.18)

##### Features

- *(builder)* Expose `Arg::get_display_order` and
`Command::get_display_order`

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 94b8205329d344..7cd40d4226d636 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2283,9 +2283,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.17"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e5a21b8495e732f1b3c364c9949b201ca7bae518c502c80256c96ad79eaf6ac"
+checksum = "b0956a43b323ac1afaffc053ed5c4b7c1f1800bacd1683c353aabbb752515dd3"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -2293,9 +2293,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.17"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cf2dd12af7a047ad9d6da2b6b249759a22a7abc0f474c1dae1777afa4b21a73"
+checksum = "4d72166dd41634086d5803a47eb71ae740e61d84709c36f3c34110173db3961b"
 dependencies = [
  "anstream",
  "anstyle",
@@ -2315,9 +2315,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.13"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501d359d5f3dcaf6ecdeee48833ae73ec6e42723a1e52419c79abf9507eec0a0"
+checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
@@ -6478,7 +6478,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
  "cfg-if",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -13536,7 +13536,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]

From c7a79cfc02bcacfb3983a9d8b3ad15bb06d33380 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 26 Sep 2024 12:16:49 -0400
Subject: [PATCH 356/762] Update Rust crate libc to v0.2.159 (#18370)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [libc](https://redirect.github.com/rust-lang/libc) |
workspace.dependencies | patch | `0.2.158` -> `0.2.159` |

---

### Release Notes

<details>
<summary>rust-lang/libc (libc)</summary>

###
[`v0.2.159`](https://redirect.github.com/rust-lang/libc/releases/tag/0.2.159)

[Compare
Source](https://redirect.github.com/rust-lang/libc/compare/0.2.158...0.2.159)

##### Added

- Android: add more `AT_*` constants in
[#&#8203;3779](https://redirect.github.com/rust-lang/libc/pull/3779)
- Apple: add missing `NOTE_*` constants in
[#&#8203;3883](https://redirect.github.com/rust-lang/libc/pull/3883)
- Hermit: add missing error numbers in
[#&#8203;3858](https://redirect.github.com/rust-lang/libc/pull/3858)
- Hurd: add `__timeval` for 64-bit support in
[#&#8203;3786](https://redirect.github.com/rust-lang/libc/pull/3786)
- Linux: add `epoll_pwait2` in
[#&#8203;3868](https://redirect.github.com/rust-lang/libc/pull/3868)
- Linux: add `mq_notify` in
[#&#8203;3849](https://redirect.github.com/rust-lang/libc/pull/3849)
- Linux: add missing `NFT_CT_*` constants in
[#&#8203;3844](https://redirect.github.com/rust-lang/libc/pull/3844)
- Linux: add the `fchmodat2` syscall in
[#&#8203;3588](https://redirect.github.com/rust-lang/libc/pull/3588)
- Linux: add the `mseal` syscall in
[#&#8203;3798](https://redirect.github.com/rust-lang/libc/pull/3798)
- OpenBSD: add `sendmmsg` and `recvmmsg` in
[#&#8203;3831](https://redirect.github.com/rust-lang/libc/pull/3831)
- Unix: add `IN6ADDR_ANY_INIT` and `IN6ADDR_LOOPBACK_INIT` in
[#&#8203;3693](https://redirect.github.com/rust-lang/libc/pull/3693)
- VxWorks: add `S_ISVTX` in
[#&#8203;3768](https://redirect.github.com/rust-lang/libc/pull/3768)
- VxWorks: add `vxCpuLib` and `taskLib` functions
[#&#8203;3861](https://redirect.github.com/rust-lang/libc/pull/3861)
- WASIp2: add definitions for `std::net` support in
[#&#8203;3892](https://redirect.github.com/rust-lang/libc/pull/3892)

##### Fixed

- Correctly handle version checks when `clippy-driver` is used
[#&#8203;3893](https://redirect.github.com/rust-lang/libc/pull/3893)

##### Changed

- EspIdf: change signal constants to c_int in
[#&#8203;3895](https://redirect.github.com/rust-lang/libc/pull/3895)
- HorizonOS: update network definitions in
[#&#8203;3863](https://redirect.github.com/rust-lang/libc/pull/3863)
- Linux: combine `ioctl` APIs in
[#&#8203;3722](https://redirect.github.com/rust-lang/libc/pull/3722)
- WASI: enable CI testing in
[#&#8203;3869](https://redirect.github.com/rust-lang/libc/pull/3869)
- WASIp2: enable CI testing in
[#&#8203;3870](https://redirect.github.com/rust-lang/libc/pull/3870)

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC44MC4wIiwidXBkYXRlZEluVmVyIjoiMzguODAuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7cd40d4226d636..68dad1f74613f1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6434,9 +6434,9 @@ checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
 
 [[package]]
 name = "libc"
-version = "0.2.158"
+version = "0.2.159"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5"
 
 [[package]]
 name = "libdbus-sys"

From 11058765bec3bb1e0510254904276d29d4fc31f1 Mon Sep 17 00:00:00 2001
From: thataboy <dearbart@yahoo.com>
Date: Thu, 26 Sep 2024 09:48:23 -0700
Subject: [PATCH 357/762] Add ability to separately set background color for
 highlighted brackets (#17566)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes https://github.com/zed-industries/zed/issues/16380

Currently brackets are highlighted with
`editor.document_highlight.read_background`. This commit adds a separate
`editor.document_highlight.bracket_background` theme setting so bracket
highlights can be made more prominent without doing the same to other
highlights, making the display too busy.

(My own theme)


https://github.com/user-attachments/assets/29a8c05e-2f1a-4c16-9be8-a4b4cb143548

I set defaults for light and dark theme that I hope are sensible and not
too obnoxious, but noticeable so people can change it if they don't like
it.

Release Notes:

- Added `editor.document_highlight.bracket_background` field to the
theme to set background color of highlighted brackets.
- This will fall back to `editor.document_highlight.read_background`, if
not set.

<img width="355" alt="Screenshot 2024-09-08 at 8 46 57 AM"
src="https://github.com/user-attachments/assets/3270bb4d-19f5-4b34-8003-982377b2ceb6">
<img width="444" alt="Screenshot 2024-09-08 at 9 03 27 AM"
src="https://github.com/user-attachments/assets/3b12d84d-913c-4bde-9132-9b10f4a8d49b">

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 .../editor/src/highlight_matching_bracket.rs  |  2 +-
 crates/theme/src/default_colors.rs            |  2 ++
 crates/theme/src/one_themes.rs                |  1 +
 crates/theme/src/schema.rs                    | 21 +++++++++++++++----
 crates/theme/src/styles/colors.rs             |  4 ++++
 5 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/crates/editor/src/highlight_matching_bracket.rs b/crates/editor/src/highlight_matching_bracket.rs
index 67915d4d7b4990..f63b363f34f475 100644
--- a/crates/editor/src/highlight_matching_bracket.rs
+++ b/crates/editor/src/highlight_matching_bracket.rs
@@ -32,7 +32,7 @@ pub fn refresh_matching_bracket_highlights(editor: &mut Editor, cx: &mut ViewCon
                 opening_range.to_anchors(&snapshot.buffer_snapshot),
                 closing_range.to_anchors(&snapshot.buffer_snapshot),
             ],
-            |theme| theme.editor_document_highlight_read_background,
+            |theme| theme.editor_document_highlight_bracket_background,
             cx,
         )
     }
diff --git a/crates/theme/src/default_colors.rs b/crates/theme/src/default_colors.rs
index 4def0bb8d74d62..a7521bd374d1c3 100644
--- a/crates/theme/src/default_colors.rs
+++ b/crates/theme/src/default_colors.rs
@@ -80,6 +80,7 @@ impl ThemeColors {
             editor_indent_guide_active: neutral().light_alpha().step_6(),
             editor_document_highlight_read_background: neutral().light_alpha().step_3(),
             editor_document_highlight_write_background: neutral().light_alpha().step_4(),
+            editor_document_highlight_bracket_background: green().light_alpha().step_5(),
             terminal_background: neutral().light().step_1(),
             terminal_foreground: black().light().step_12(),
             terminal_bright_foreground: black().light().step_11(),
@@ -179,6 +180,7 @@ impl ThemeColors {
             editor_indent_guide_active: neutral().dark_alpha().step_6(),
             editor_document_highlight_read_background: neutral().dark_alpha().step_4(),
             editor_document_highlight_write_background: neutral().dark_alpha().step_4(),
+            editor_document_highlight_bracket_background: green().dark_alpha().step_6(),
             terminal_background: neutral().dark().step_1(),
             terminal_ansi_background: neutral().dark().step_1(),
             terminal_foreground: white().dark().step_12(),
diff --git a/crates/theme/src/one_themes.rs b/crates/theme/src/one_themes.rs
index 69e69ce23dc8d1..50a4184e8bc934 100644
--- a/crates/theme/src/one_themes.rs
+++ b/crates/theme/src/one_themes.rs
@@ -102,6 +102,7 @@ pub(crate) fn one_dark() -> Theme {
                     0.2,
                 ),
                 editor_document_highlight_write_background: gpui::red(),
+                editor_document_highlight_bracket_background: gpui::green(),
 
                 terminal_background: bg,
                 // todo("Use one colors for terminal")
diff --git a/crates/theme/src/schema.rs b/crates/theme/src/schema.rs
index 0229b1ea98d590..91863061236f24 100644
--- a/crates/theme/src/schema.rs
+++ b/crates/theme/src/schema.rs
@@ -413,6 +413,12 @@ pub struct ThemeColorsContent {
     #[serde(rename = "editor.document_highlight.write_background")]
     pub editor_document_highlight_write_background: Option<String>,
 
+    /// Highlighted brackets background color.
+    ///
+    /// Matching brackets in the cursor scope are highlighted with this background color.
+    #[serde(rename = "editor.document_highlight.bracket_background")]
+    pub editor_document_highlight_bracket_background: Option<String>,
+
     /// Terminal background color.
     #[serde(rename = "terminal.background")]
     pub terminal_background: Option<String>,
@@ -540,6 +546,10 @@ impl ThemeColorsContent {
             .border
             .as_ref()
             .and_then(|color| try_parse_color(color).ok());
+        let editor_document_highlight_read_background = self
+            .editor_document_highlight_read_background
+            .as_ref()
+            .and_then(|color| try_parse_color(color).ok());
         ThemeColorsRefinement {
             border,
             border_variant: self
@@ -784,14 +794,17 @@ impl ThemeColorsContent {
                 .editor_indent_guide_active
                 .as_ref()
                 .and_then(|color| try_parse_color(color).ok()),
-            editor_document_highlight_read_background: self
-                .editor_document_highlight_read_background
-                .as_ref()
-                .and_then(|color| try_parse_color(color).ok()),
+            editor_document_highlight_read_background,
             editor_document_highlight_write_background: self
                 .editor_document_highlight_write_background
                 .as_ref()
                 .and_then(|color| try_parse_color(color).ok()),
+            editor_document_highlight_bracket_background: self
+                .editor_document_highlight_bracket_background
+                .as_ref()
+                .and_then(|color| try_parse_color(color).ok())
+                // Fall back to `editor.document_highlight.read_background`, for backwards compatibility.
+                .or(editor_document_highlight_read_background),
             terminal_background: self
                 .terminal_background
                 .as_ref()
diff --git a/crates/theme/src/styles/colors.rs b/crates/theme/src/styles/colors.rs
index 0b37be09923c79..225275f37b6191 100644
--- a/crates/theme/src/styles/colors.rs
+++ b/crates/theme/src/styles/colors.rs
@@ -171,6 +171,10 @@ pub struct ThemeColors {
     /// special attention. Usually a document highlight is visualized by changing
     /// the background color of its range.
     pub editor_document_highlight_write_background: Hsla,
+    /// Highlighted brackets background color.
+    ///
+    /// Matching brackets in the cursor scope are highlighted with this background color.
+    pub editor_document_highlight_bracket_background: Hsla,
 
     // ===
     // Terminal

From 71da81c74326f1f9763803a6d1cd776b48b58125 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Thu, 26 Sep 2024 12:03:57 -0700
Subject: [PATCH 358/762] SSH Remoting: Fix bugs in worktree syncing (#18406)

Release Notes:

- N/A

---------

Co-authored-by: conrad <conrad@zed.dev>
---
 crates/collab/src/db/ids.rs                   |  1 +
 crates/collab/src/db/queries/projects.rs      |  2 +-
 .../collab/src/tests/channel_buffer_tests.rs  |  2 +-
 crates/collab/src/tests/editor_tests.rs       | 30 ++++----
 crates/collab/src/tests/following_tests.rs    | 16 ++--
 crates/collab/src/tests/integration_tests.rs  | 74 +++++++++----------
 .../remote_editing_collaboration_tests.rs     | 25 ++++++-
 crates/collab/src/tests/test_server.rs        |  2 +-
 crates/project/src/worktree_store.rs          | 32 ++++----
 .../remote_server/src/remote_editing_tests.rs | 42 +++++++++++
 crates/worktree/src/worktree.rs               |  7 +-
 script/zed-local                              | 16 ++--
 12 files changed, 157 insertions(+), 92 deletions(-)

diff --git a/crates/collab/src/db/ids.rs b/crates/collab/src/db/ids.rs
index 1434bc07cf6c37..9bf767329d0024 100644
--- a/crates/collab/src/db/ids.rs
+++ b/crates/collab/src/db/ids.rs
@@ -32,6 +32,7 @@ macro_rules! id_type {
             #[allow(unused)]
             #[allow(missing_docs)]
             pub fn from_proto(value: u64) -> Self {
+                debug_assert!(value != 0);
                 Self(value as i32)
             }
 
diff --git a/crates/collab/src/db/queries/projects.rs b/crates/collab/src/db/queries/projects.rs
index b514d4bb03601b..8091c6620570f2 100644
--- a/crates/collab/src/db/queries/projects.rs
+++ b/crates/collab/src/db/queries/projects.rs
@@ -285,7 +285,7 @@ impl Database {
                 )
                 .one(&*tx)
                 .await?
-                .ok_or_else(|| anyhow!("no such project"))?;
+                .ok_or_else(|| anyhow!("no such project: {project_id}"))?;
 
             // Update metadata.
             worktree::Entity::update(worktree::ActiveModel {
diff --git a/crates/collab/src/tests/channel_buffer_tests.rs b/crates/collab/src/tests/channel_buffer_tests.rs
index 1ba41c45bb6068..b5bfd0f03b9ec7 100644
--- a/crates/collab/src/tests/channel_buffer_tests.rs
+++ b/crates/collab/src/tests/channel_buffer_tests.rs
@@ -246,7 +246,7 @@ async fn test_channel_notes_participant_indices(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     let (workspace_b, cx_b) = client_b.build_workspace(&project_b, cx_b);
 
     // Clients A and B open the same file.
diff --git a/crates/collab/src/tests/editor_tests.rs b/crates/collab/src/tests/editor_tests.rs
index d2835edc619e20..f9bc21efb1abdf 100644
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -76,7 +76,7 @@ async fn test_host_disconnect(
         .await
         .unwrap();
 
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     cx_a.background_executor.run_until_parked();
 
     assert!(worktree_a.read_with(cx_a, |tree, _| tree.has_update_observer()));
@@ -192,7 +192,7 @@ async fn test_newline_above_or_below_does_not_move_guest_cursor(
         .await
         .unwrap();
 
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Open a buffer as client A
     let buffer_a = project_a
@@ -308,7 +308,7 @@ async fn test_collaborating_with_completion(cx_a: &mut TestAppContext, cx_b: &mu
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Open a file in an editor as the guest.
     let buffer_b = project_b
@@ -565,7 +565,7 @@ async fn test_collaborating_with_code_actions(
         .unwrap();
 
     // Join the project as client B.
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     let (workspace_b, cx_b) = client_b.build_workspace(&project_b, cx_b);
     let editor_b = workspace_b
         .update(cx_b, |workspace, cx| {
@@ -780,7 +780,7 @@ async fn test_collaborating_with_renames(cx_a: &mut TestAppContext, cx_b: &mut T
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     let (workspace_b, cx_b) = client_b.build_workspace(&project_b, cx_b);
     let editor_b = workspace_b
@@ -1030,7 +1030,7 @@ async fn test_language_server_statuses(cx_a: &mut TestAppContext, cx_b: &mut Tes
         .await
         .unwrap();
     executor.run_until_parked();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     project_b.read_with(cx_b, |project, cx| {
         let status = project.language_server_statuses(cx).next().unwrap().1;
@@ -1126,9 +1126,7 @@ async fn test_share_project(
         .await
         .unwrap();
     let client_b_peer_id = client_b.peer_id().unwrap();
-    let project_b = client_b
-        .build_dev_server_project(initial_project.id, cx_b)
-        .await;
+    let project_b = client_b.join_remote_project(initial_project.id, cx_b).await;
 
     let replica_id_b = project_b.read_with(cx_b, |project, _| project.replica_id());
 
@@ -1230,9 +1228,7 @@ async fn test_share_project(
         .update(cx_c, |call, cx| call.accept_incoming(cx))
         .await
         .unwrap();
-    let _project_c = client_c
-        .build_dev_server_project(initial_project.id, cx_c)
-        .await;
+    let _project_c = client_c.join_remote_project(initial_project.id, cx_c).await;
 
     // Client B closes the editor, and client A sees client B's selections removed.
     cx_b.update(move |_| drop(editor_b));
@@ -1291,7 +1287,7 @@ async fn test_on_input_format_from_host_to_guest(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Open a file in an editor as the host.
     let buffer_a = project_a
@@ -1411,7 +1407,7 @@ async fn test_on_input_format_from_guest_to_host(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Open a file in an editor as the guest.
     let buffer_b = project_b
@@ -1574,7 +1570,7 @@ async fn test_mutual_editor_inlay_hint_cache_update(
         .unwrap();
 
     // Client B joins the project
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     active_call_b
         .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
         .await
@@ -1836,7 +1832,7 @@ async fn test_inlay_hint_refresh_is_forwarded(
         .await
         .unwrap();
 
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     active_call_b
         .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
         .await
@@ -2050,7 +2046,7 @@ async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestA
         .unwrap();
 
     // Join the project as client B.
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     let (workspace_b, cx_b) = client_b.build_workspace(&project_b, cx_b);
     let editor_b = workspace_b
         .update(cx_b, |workspace, cx| {
diff --git a/crates/collab/src/tests/following_tests.rs b/crates/collab/src/tests/following_tests.rs
index 9a39d6f3eb2e74..5e9c001491c6ce 100644
--- a/crates/collab/src/tests/following_tests.rs
+++ b/crates/collab/src/tests/following_tests.rs
@@ -74,7 +74,7 @@ async fn test_basic_following(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     active_call_b
         .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
         .await
@@ -162,7 +162,7 @@ async fn test_basic_following(
 
     executor.run_until_parked();
     let active_call_c = cx_c.read(ActiveCall::global);
-    let project_c = client_c.build_dev_server_project(project_id, cx_c).await;
+    let project_c = client_c.join_remote_project(project_id, cx_c).await;
     let (workspace_c, cx_c) = client_c.build_workspace(&project_c, cx_c);
     active_call_c
         .update(cx_c, |call, cx| call.set_location(Some(&project_c), cx))
@@ -175,7 +175,7 @@ async fn test_basic_following(
 
     cx_d.executor().run_until_parked();
     let active_call_d = cx_d.read(ActiveCall::global);
-    let project_d = client_d.build_dev_server_project(project_id, cx_d).await;
+    let project_d = client_d.join_remote_project(project_id, cx_d).await;
     let (workspace_d, cx_d) = client_d.build_workspace(&project_d, cx_d);
     active_call_d
         .update(cx_d, |call, cx| call.set_location(Some(&project_d), cx))
@@ -569,7 +569,7 @@ async fn test_following_tab_order(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     active_call_b
         .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
         .await
@@ -686,7 +686,7 @@ async fn test_peers_following_each_other(cx_a: &mut TestAppContext, cx_b: &mut T
         .unwrap();
 
     // Client B joins the project.
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     active_call_b
         .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
         .await
@@ -1199,7 +1199,7 @@ async fn test_auto_unfollowing(cx_a: &mut TestAppContext, cx_b: &mut TestAppCont
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     active_call_b
         .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
         .await
@@ -1335,7 +1335,7 @@ async fn test_peers_simultaneously_following_each_other(
         .await
         .unwrap();
 
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     let (workspace_b, cx_b) = client_b.build_workspace(&project_b, cx_b);
 
     executor.run_until_parked();
@@ -1685,7 +1685,7 @@ async fn test_following_into_excluded_file(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     active_call_b
         .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
         .await
diff --git a/crates/collab/src/tests/integration_tests.rs b/crates/collab/src/tests/integration_tests.rs
index d5cef3589cce33..afc3e7cfb84ee2 100644
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -1372,7 +1372,7 @@ async fn test_unshare_project(
         .unwrap();
 
     let worktree_a = project_a.read_with(cx_a, |project, cx| project.worktrees(cx).next().unwrap());
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     executor.run_until_parked();
 
     assert!(worktree_a.read_with(cx_a, |tree, _| tree.has_update_observer()));
@@ -1392,7 +1392,7 @@ async fn test_unshare_project(
     assert!(project_b.read_with(cx_b, |project, _| project.is_disconnected()));
 
     // Client C opens the project.
-    let project_c = client_c.build_dev_server_project(project_id, cx_c).await;
+    let project_c = client_c.join_remote_project(project_id, cx_c).await;
 
     // When client A unshares the project, client C's project becomes read-only.
     project_a
@@ -1409,7 +1409,7 @@ async fn test_unshare_project(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_c2 = client_c.build_dev_server_project(project_id, cx_c).await;
+    let project_c2 = client_c.join_remote_project(project_id, cx_c).await;
     executor.run_until_parked();
 
     assert!(worktree_a.read_with(cx_a, |tree, _| tree.has_update_observer()));
@@ -1514,9 +1514,9 @@ async fn test_project_reconnect(
         .await
         .unwrap();
 
-    let project_b1 = client_b.build_dev_server_project(project1_id, cx_b).await;
-    let project_b2 = client_b.build_dev_server_project(project2_id, cx_b).await;
-    let project_b3 = client_b.build_dev_server_project(project3_id, cx_b).await;
+    let project_b1 = client_b.join_remote_project(project1_id, cx_b).await;
+    let project_b2 = client_b.join_remote_project(project2_id, cx_b).await;
+    let project_b3 = client_b.join_remote_project(project3_id, cx_b).await;
     executor.run_until_parked();
 
     let worktree1_id = worktree_a1.read_with(cx_a, |worktree, _| {
@@ -2310,8 +2310,8 @@ async fn test_propagate_saves_and_fs_changes(
         .unwrap();
 
     // Join that worktree as clients B and C.
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
-    let project_c = client_c.build_dev_server_project(project_id, cx_c).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
+    let project_c = client_c.join_remote_project(project_id, cx_c).await;
 
     let worktree_b = project_b.read_with(cx_b, |p, cx| p.worktrees(cx).next().unwrap());
 
@@ -2535,7 +2535,7 @@ async fn test_git_diff_base_change(
         .await
         .unwrap();
 
-    let project_remote = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_remote = client_b.join_remote_project(project_id, cx_b).await;
 
     let diff_base = "
         one
@@ -2791,7 +2791,7 @@ async fn test_git_branch_name(
         .await
         .unwrap();
 
-    let project_remote = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_remote = client_b.join_remote_project(project_id, cx_b).await;
     client_a
         .fs()
         .set_branch_name(Path::new("/dir/.git"), Some("branch-1"));
@@ -2836,7 +2836,7 @@ async fn test_git_branch_name(
         assert_branch(Some("branch-2"), project, cx)
     });
 
-    let project_remote_c = client_c.build_dev_server_project(project_id, cx_c).await;
+    let project_remote_c = client_c.join_remote_project(project_id, cx_c).await;
     executor.run_until_parked();
 
     project_remote_c.read_with(cx_c, |project, cx| {
@@ -2891,7 +2891,7 @@ async fn test_git_status_sync(
         .await
         .unwrap();
 
-    let project_remote = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_remote = client_b.join_remote_project(project_id, cx_b).await;
 
     // Wait for it to catch up to the new status
     executor.run_until_parked();
@@ -2967,7 +2967,7 @@ async fn test_git_status_sync(
     });
 
     // And synchronization while joining
-    let project_remote_c = client_c.build_dev_server_project(project_id, cx_c).await;
+    let project_remote_c = client_c.join_remote_project(project_id, cx_c).await;
     executor.run_until_parked();
 
     project_remote_c.read_with(cx_c, |project, cx| {
@@ -3015,7 +3015,7 @@ async fn test_fs_operations(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     let worktree_a = project_a.read_with(cx_a, |project, cx| project.worktrees(cx).next().unwrap());
     let worktree_b = project_b.read_with(cx_b, |project, cx| project.worktrees(cx).next().unwrap());
@@ -3316,7 +3316,7 @@ async fn test_local_settings(
     executor.run_until_parked();
 
     // As client B, join that project and observe the local settings.
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     let worktree_b = project_b.read_with(cx_b, |project, cx| project.worktrees(cx).next().unwrap());
     executor.run_until_parked();
@@ -3439,7 +3439,7 @@ async fn test_buffer_conflict_after_save(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Open a buffer as client B
     let buffer_b = project_b
@@ -3503,7 +3503,7 @@ async fn test_buffer_reloading(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Open a buffer as client B
     let buffer_b = project_b
@@ -3557,7 +3557,7 @@ async fn test_editing_while_guest_opens_buffer(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Open a buffer as client A
     let buffer_a = project_a
@@ -3605,7 +3605,7 @@ async fn test_leaving_worktree_while_opening_buffer(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // See that a guest has joined as client A.
     executor.run_until_parked();
@@ -3652,7 +3652,7 @@ async fn test_canceling_buffer_opening(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     let buffer_a = project_a
         .update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
@@ -3709,8 +3709,8 @@ async fn test_leaving_project(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b1 = client_b.build_dev_server_project(project_id, cx_b).await;
-    let project_c = client_c.build_dev_server_project(project_id, cx_c).await;
+    let project_b1 = client_b.join_remote_project(project_id, cx_b).await;
+    let project_c = client_c.join_remote_project(project_id, cx_c).await;
 
     // Client A sees that a guest has joined.
     executor.run_until_parked();
@@ -3751,7 +3751,7 @@ async fn test_leaving_project(
     });
 
     // Client B re-joins the project and can open buffers as before.
-    let project_b2 = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b2 = client_b.join_remote_project(project_id, cx_b).await;
     executor.run_until_parked();
 
     project_a.read_with(cx_a, |project, _| {
@@ -3927,7 +3927,7 @@ async fn test_collaborating_with_diagnostics(
     );
 
     // Join the worktree as client B.
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Wait for server to see the diagnostics update.
     executor.run_until_parked();
@@ -3952,7 +3952,7 @@ async fn test_collaborating_with_diagnostics(
     });
 
     // Join project as client C and observe the diagnostics.
-    let project_c = client_c.build_dev_server_project(project_id, cx_c).await;
+    let project_c = client_c.join_remote_project(project_id, cx_c).await;
     executor.run_until_parked();
     let project_c_diagnostic_summaries =
         Rc::new(RefCell::new(project_c.read_with(cx_c, |project, cx| {
@@ -4160,7 +4160,7 @@ async fn test_collaborating_with_lsp_progress_updates_and_diagnostics_ordering(
         .unwrap();
 
     // Join the project as client B and open all three files.
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     let guest_buffers = futures::future::try_join_all(file_names.iter().map(|file_name| {
         project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, file_name), cx))
     }))
@@ -4266,7 +4266,7 @@ async fn test_reloading_buffer_manually(
         .await
         .unwrap();
 
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
     let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
@@ -4364,7 +4364,7 @@ async fn test_formatting_buffer(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
     let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
@@ -4486,7 +4486,7 @@ async fn test_prettier_formatting_buffer(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.ts"), cx));
     let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();
 
@@ -4599,7 +4599,7 @@ async fn test_definition(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Open the file on client B.
     let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
@@ -4744,7 +4744,7 @@ async fn test_references(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Open the file on client B.
     let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "one.rs"), cx));
@@ -4901,7 +4901,7 @@ async fn test_project_search(
         .await
         .unwrap();
 
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Perform a search as the guest.
     let mut results = HashMap::default();
@@ -4991,7 +4991,7 @@ async fn test_document_highlights(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Open the file on client B.
     let open_b = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx));
@@ -5109,7 +5109,7 @@ async fn test_lsp_hover(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Open the file as the guest
     let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx));
@@ -5286,7 +5286,7 @@ async fn test_project_symbols(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Cause the language server to start.
     let open_buffer_task =
@@ -5381,7 +5381,7 @@ async fn test_open_buffer_while_getting_definition_pointing_to_it(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     let open_buffer_task = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.rs"), cx));
     let buffer_b1 = cx_b.executor().spawn(open_buffer_task).await.unwrap();
@@ -6470,7 +6470,7 @@ async fn test_context_collaboration_with_reconnect(
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
         .await
         .unwrap();
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
 
     // Client A sees that a guest has joined.
     executor.run_until_parked();
diff --git a/crates/collab/src/tests/remote_editing_collaboration_tests.rs b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
index bad5ef9053ce70..a9cc32c1dd3a67 100644
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -9,7 +9,7 @@ use remote_server::HeadlessProject;
 use serde_json::json;
 use std::{path::Path, sync::Arc};
 
-#[gpui::test]
+#[gpui::test(iterations = 10)]
 async fn test_sharing_an_ssh_remote_project(
     cx_a: &mut TestAppContext,
     cx_b: &mut TestAppContext,
@@ -54,9 +54,8 @@ async fn test_sharing_an_ssh_remote_project(
     let (project_a, worktree_id) = client_a
         .build_ssh_project("/code/project1", client_ssh, cx_a)
         .await;
-    executor.run_until_parked();
 
-    // User A shares the remote project.
+    // While the SSH worktree is being scanned, user A shares the remote project.
     let active_call_a = cx_a.read(ActiveCall::global);
     let project_id = active_call_a
         .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
@@ -64,12 +63,30 @@ async fn test_sharing_an_ssh_remote_project(
         .unwrap();
 
     // User B joins the project.
-    let project_b = client_b.build_dev_server_project(project_id, cx_b).await;
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
     let worktree_b = project_b
         .update(cx_b, |project, cx| project.worktree_for_id(worktree_id, cx))
         .unwrap();
 
+    let worktree_a = project_a
+        .update(cx_a, |project, cx| project.worktree_for_id(worktree_id, cx))
+        .unwrap();
+
     executor.run_until_parked();
+
+    worktree_a.update(cx_a, |worktree, _cx| {
+        assert_eq!(
+            worktree.paths().map(Arc::as_ref).collect::<Vec<_>>(),
+            vec![
+                Path::new(".zed"),
+                Path::new(".zed/settings.json"),
+                Path::new("README.md"),
+                Path::new("src"),
+                Path::new("src/lib.rs"),
+            ]
+        );
+    });
+
     worktree_b.update(cx_b, |worktree, _cx| {
         assert_eq!(
             worktree.paths().map(Arc::as_ref).collect::<Vec<_>>(),
diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs
index 6f07d76b0b26b0..94c7d3907ff4ff 100644
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -921,7 +921,7 @@ impl TestClient {
         })
     }
 
-    pub async fn build_dev_server_project(
+    pub async fn join_remote_project(
         &self,
         host_project_id: u64,
         guest_cx: &mut TestAppContext,
diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index e445eab2dd6392..1fc04a0d0b4f44 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -204,8 +204,11 @@ impl WorktreeStore {
             self.loading_worktrees.insert(path.clone(), task.shared());
         }
         let task = self.loading_worktrees.get(&path).unwrap().clone();
-        cx.background_executor().spawn(async move {
-            match task.await {
+        cx.spawn(|this, mut cx| async move {
+            let result = task.await;
+            this.update(&mut cx, |this, _| this.loading_worktrees.remove(&path))
+                .ok();
+            match result {
                 Ok(worktree) => Ok(worktree),
                 Err(err) => Err((*err).cloned()),
             }
@@ -219,7 +222,8 @@ impl WorktreeStore {
         visible: bool,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Model<Worktree>, Arc<anyhow::Error>>> {
-        let mut abs_path = abs_path.as_ref().to_string_lossy().to_string();
+        let path_key: Arc<Path> = abs_path.as_ref().into();
+        let mut abs_path = path_key.clone().to_string_lossy().to_string();
         // If we start with `/~` that means the ssh path was something like `ssh://user@host/~/home-dir-folder/`
         // in which case want to strip the leading the `/`.
         // On the host-side, the `~` will get expanded.
@@ -261,8 +265,9 @@ impl WorktreeStore {
                 )
             })?;
 
-            this.update(&mut cx, |this, cx| this.add(&worktree, cx))?;
-
+            this.update(&mut cx, |this, cx| {
+                this.add(&worktree, cx);
+            })?;
             Ok(worktree)
         })
     }
@@ -280,10 +285,6 @@ impl WorktreeStore {
         cx.spawn(move |this, mut cx| async move {
             let worktree = Worktree::local(path.clone(), visible, fs, next_entry_id, &mut cx).await;
 
-            this.update(&mut cx, |project, _| {
-                project.loading_worktrees.remove(&path);
-            })?;
-
             let worktree = worktree?;
             this.update(&mut cx, |this, cx| this.add(&worktree, cx))?;
 
@@ -317,7 +318,7 @@ impl WorktreeStore {
         });
 
         let abs_path = abs_path.as_ref().to_path_buf();
-        cx.spawn(move |project, mut cx| async move {
+        cx.spawn(move |project, cx| async move {
             let (tx, rx) = futures::channel::oneshot::channel();
             let tx = RefCell::new(Some(tx));
             let Some(project) = project.upgrade() else {
@@ -339,14 +340,10 @@ impl WorktreeStore {
             request.await?;
             let worktree = rx.await.map_err(|e| anyhow!(e))?;
             drop(observer);
-            project.update(&mut cx, |project, _| {
-                project.loading_worktrees.remove(&path);
-            })?;
             Ok(worktree)
         })
     }
 
-    #[track_caller]
     pub fn add(&mut self, worktree: &Model<Worktree>, cx: &mut ModelContext<Self>) {
         let worktree_id = worktree.read(cx).id();
         debug_assert!(self.worktrees().all(|w| w.read(cx).id() != worktree_id));
@@ -553,9 +550,12 @@ impl WorktreeStore {
                                 let client = client.clone();
                                 async move {
                                     if client.is_via_collab() {
-                                        client.request(update).map(|result| result.is_ok()).await
+                                        client
+                                            .request(update)
+                                            .map(|result| result.log_err().is_some())
+                                            .await
                                     } else {
-                                        client.send(update).is_ok()
+                                        client.send(update).log_err().is_some()
                                     }
                                 }
                             }
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 084fcf9929f014..892063942754c1 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -564,6 +564,48 @@ async fn test_canceling_buffer_opening(cx: &mut TestAppContext, server_cx: &mut
     });
 }
 
+#[gpui::test]
+async fn test_adding_then_removing_then_adding_worktrees(
+    cx: &mut TestAppContext,
+    server_cx: &mut TestAppContext,
+) {
+    let (project, _headless, _fs) = init_test(cx, server_cx).await;
+    let (_worktree, _) = project
+        .update(cx, |project, cx| {
+            project.find_or_create_worktree("/code/project1", true, cx)
+        })
+        .await
+        .unwrap();
+
+    let (worktree_2, _) = project
+        .update(cx, |project, cx| {
+            project.find_or_create_worktree("/code/project2", true, cx)
+        })
+        .await
+        .unwrap();
+    let worktree_id_2 = worktree_2.read_with(cx, |tree, _| tree.id());
+
+    project.update(cx, |project, cx| project.remove_worktree(worktree_id_2, cx));
+
+    let (worktree_2, _) = project
+        .update(cx, |project, cx| {
+            project.find_or_create_worktree("/code/project2", true, cx)
+        })
+        .await
+        .unwrap();
+
+    cx.run_until_parked();
+    worktree_2.update(cx, |worktree, _cx| {
+        assert!(worktree.is_visible());
+        let entries = worktree.entries(true, 0).collect::<Vec<_>>();
+        assert_eq!(entries.len(), 2);
+        assert_eq!(
+            entries[1].path.to_string_lossy().to_string(),
+            "README.md".to_string()
+        )
+    })
+}
+
 fn init_logger() {
     if std::env::var("RUST_LOG").is_ok() {
         env_logger::try_init().ok();
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index f91a832b80d783..d81c91132b9d39 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -1826,10 +1826,13 @@ impl RemoteWorktree {
         let initial_update = self
             .snapshot
             .build_initial_update(project_id, self.id().to_proto());
-        self.updates_tx = Some(tx);
+        self.update_observer = Some(tx);
         cx.spawn(|this, mut cx| async move {
             let mut update = initial_update;
             loop {
+                // SSH projects use a special project ID of 0, and we need to
+                // remap it to the correct one here.
+                update.project_id = project_id;
                 if !callback(update).await {
                     break;
                 }
@@ -1841,7 +1844,7 @@ impl RemoteWorktree {
             }
             this.update(&mut cx, |this, _| {
                 let this = this.as_remote_mut().unwrap();
-                this.updates_tx.take();
+                this.update_observer.take();
             })
         })
         .detach();
diff --git a/script/zed-local b/script/zed-local
index c3dfb2879d175d..9ec9b24af7509d 100755
--- a/script/zed-local
+++ b/script/zed-local
@@ -9,12 +9,18 @@ SUMMARY
   Each instance of Zed will be signed in as a different user specified in
   either \`.admins.json\` or \`.admins.default.json\`.
 
+  All arguments after the initial options will be passed through to the first
+  instance of Zed. This can be used to test SSH remoting along with collab, like
+  so:
+
+  $ script/zed-local -2 ssh://your-ssh-uri-here
+
 OPTIONS
-  --help           Print this help message
-  --release        Build Zed in release mode
-  -2, -3, -4, ...  Spawn multiple Zed instances, with their windows tiled.
-  --top            Arrange the Zed windows so they take up the top half of the screen.
-  --stable         Use stable Zed release installed on local machine for all instances (except for the first one).
+  --help            Print this help message
+  --release         Build Zed in release mode
+  -2, -3, -4, ...   Spawn multiple Zed instances, with their windows tiled.
+  --top             Arrange the Zed windows so they take up the top half of the screen.
+  --stable          Use stable Zed release installed on local machine for all instances (except for the first one).
 `.trim();
 
 const { spawn, execSync, execFileSync } = require("child_process");

From c1a039a5d77f4ce2f23d17ad3ffa0bebd267b620 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Thu, 26 Sep 2024 12:10:39 -0700
Subject: [PATCH 359/762] Remove old project search code path, bump
 min-supported zed version for collaboration (#18404)

Release Notes:

- N/A
---
 crates/collab/src/rpc.rs                 | 44 +------------------
 crates/collab/src/rpc/connection_pool.rs | 20 +++++----
 crates/project/src/project.rs            | 55 +++---------------------
 crates/project/src/search.rs             | 37 +---------------
 crates/proto/proto/zed.proto             | 19 +-------
 crates/proto/src/proto.rs                |  4 --
 6 files changed, 22 insertions(+), 157 deletions(-)

diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index bc0f827e78ba51..d9683fb8b366c1 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -474,9 +474,6 @@ impl Server {
             .add_request_handler(user_handler(
                 forward_read_only_project_request::<proto::GetReferences>,
             ))
-            .add_request_handler(user_handler(
-                forward_read_only_project_request::<proto::SearchProject>,
-            ))
             .add_request_handler(user_handler(forward_find_search_candidates_request))
             .add_request_handler(user_handler(
                 forward_read_only_project_request::<proto::GetDocumentHighlights>,
@@ -2298,7 +2295,7 @@ async fn list_remote_directory(
     let dev_server_connection_id = session
         .connection_pool()
         .await
-        .dev_server_connection_id_supporting(dev_server_id, ZedVersion::with_list_directory())?;
+        .online_dev_server_connection_id(dev_server_id)?;
 
     session
         .db()
@@ -2337,10 +2334,7 @@ async fn update_dev_server_project(
     let dev_server_connection_id = session
         .connection_pool()
         .await
-        .dev_server_connection_id_supporting(
-            dev_server_project.dev_server_id,
-            ZedVersion::with_list_directory(),
-        )?;
+        .online_dev_server_connection_id(dev_server_project.dev_server_id)?;
 
     session.peer.send(
         dev_server_connection_id,
@@ -2950,40 +2944,6 @@ async fn forward_find_search_candidates_request(
         .await
         .host_for_read_only_project_request(project_id, session.connection_id, session.user_id())
         .await?;
-
-    let host_version = session
-        .connection_pool()
-        .await
-        .connection(host_connection_id)
-        .map(|c| c.zed_version);
-
-    if host_version.is_some_and(|host_version| host_version < ZedVersion::with_search_candidates())
-    {
-        let query = request.query.ok_or_else(|| anyhow!("missing query"))?;
-        let search = proto::SearchProject {
-            project_id: project_id.to_proto(),
-            query: query.query,
-            regex: query.regex,
-            whole_word: query.whole_word,
-            case_sensitive: query.case_sensitive,
-            files_to_include: query.files_to_include,
-            files_to_exclude: query.files_to_exclude,
-            include_ignored: query.include_ignored,
-        };
-
-        let payload = session
-            .peer
-            .forward_request(session.connection_id, host_connection_id, search)
-            .await?;
-        return response.send(proto::FindSearchCandidatesResponse {
-            buffer_ids: payload
-                .locations
-                .into_iter()
-                .map(|loc| loc.buffer_id)
-                .collect(),
-        });
-    }
-
     let payload = session
         .peer
         .forward_request(session.connection_id, host_connection_id, request)
diff --git a/crates/collab/src/rpc/connection_pool.rs b/crates/collab/src/rpc/connection_pool.rs
index ad0131aaa18e5f..96deefba7949c7 100644
--- a/crates/collab/src/rpc/connection_pool.rs
+++ b/crates/collab/src/rpc/connection_pool.rs
@@ -32,15 +32,7 @@ impl fmt::Display for ZedVersion {
 
 impl ZedVersion {
     pub fn can_collaborate(&self) -> bool {
-        self.0 >= SemanticVersion::new(0, 134, 0)
-    }
-
-    pub fn with_list_directory() -> ZedVersion {
-        ZedVersion(SemanticVersion::new(0, 145, 0))
-    }
-
-    pub fn with_search_candidates() -> ZedVersion {
-        ZedVersion(SemanticVersion::new(0, 151, 0))
+        self.0 >= SemanticVersion::new(0, 151, 0)
     }
 }
 
@@ -169,6 +161,16 @@ impl ConnectionPool {
         self.connected_dev_servers.get(&dev_server_id).copied()
     }
 
+    pub fn online_dev_server_connection_id(
+        &self,
+        dev_server_id: DevServerId,
+    ) -> Result<ConnectionId> {
+        match self.connected_dev_servers.get(&dev_server_id) {
+            Some(cid) => Ok(*cid),
+            None => Err(anyhow!(proto::ErrorCode::DevServerOffline)),
+        }
+    }
+
     pub fn dev_server_connection_id_supporting(
         &self,
         dev_server_id: DevServerId,
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index c3b3c383c11ffd..fa373af61951be 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -558,7 +558,6 @@ impl Project {
         client.add_model_message_handler(Self::handle_update_worktree);
         client.add_model_request_handler(Self::handle_synchronize_buffers);
 
-        client.add_model_request_handler(Self::handle_search_project);
         client.add_model_request_handler(Self::handle_search_candidate_buffers);
         client.add_model_request_handler(Self::handle_open_buffer_by_id);
         client.add_model_request_handler(Self::handle_open_buffer_by_path);
@@ -2692,9 +2691,9 @@ impl Project {
         let (result_tx, result_rx) = smol::channel::unbounded();
 
         let matching_buffers_rx = if query.is_opened_only() {
-            self.sort_candidate_buffers(&query, cx)
+            self.sort_search_candidates(&query, cx)
         } else {
-            self.search_for_candidate_buffers(&query, MAX_SEARCH_RESULT_FILES + 1, cx)
+            self.find_search_candidate_buffers(&query, MAX_SEARCH_RESULT_FILES + 1, cx)
         };
 
         cx.spawn(|_, cx| async move {
@@ -2757,7 +2756,7 @@ impl Project {
         result_rx
     }
 
-    fn search_for_candidate_buffers(
+    fn find_search_candidate_buffers(
         &mut self,
         query: &SearchQuery,
         limit: usize,
@@ -2769,11 +2768,11 @@ impl Project {
                 buffer_store.find_search_candidates(query, limit, fs, cx)
             })
         } else {
-            self.search_for_candidate_buffers_remote(query, limit, cx)
+            self.find_search_candidates_remote(query, limit, cx)
         }
     }
 
-    fn sort_candidate_buffers(
+    fn sort_search_candidates(
         &mut self,
         search_query: &SearchQuery,
         cx: &mut ModelContext<Project>,
@@ -2815,7 +2814,7 @@ impl Project {
         rx
     }
 
-    fn search_for_candidate_buffers_remote(
+    fn find_search_candidates_remote(
         &mut self,
         query: &SearchQuery,
         limit: usize,
@@ -3656,46 +3655,6 @@ impl Project {
         Ok(proto::TaskTemplatesResponse { templates })
     }
 
-    async fn handle_search_project(
-        this: Model<Self>,
-        envelope: TypedEnvelope<proto::SearchProject>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::SearchProjectResponse> {
-        let peer_id = envelope.original_sender_id()?;
-        let query = SearchQuery::from_proto_v1(envelope.payload)?;
-        let mut result = this.update(&mut cx, |this, cx| this.search(query, cx))?;
-
-        cx.spawn(move |mut cx| async move {
-            let mut locations = Vec::new();
-            let mut limit_reached = false;
-            while let Some(result) = result.next().await {
-                match result {
-                    SearchResult::Buffer { buffer, ranges } => {
-                        for range in ranges {
-                            let start = serialize_anchor(&range.start);
-                            let end = serialize_anchor(&range.end);
-                            let buffer_id = this.update(&mut cx, |this, cx| {
-                                this.create_buffer_for_peer(&buffer, peer_id, cx).into()
-                            })?;
-                            locations.push(proto::Location {
-                                buffer_id,
-                                start: Some(start),
-                                end: Some(end),
-                            });
-                        }
-                    }
-                    SearchResult::LimitReached => limit_reached = true,
-                }
-            }
-            Ok(proto::SearchProjectResponse {
-                locations,
-                limit_reached,
-                // will restart
-            })
-        })
-        .await
-    }
-
     async fn handle_search_candidate_buffers(
         this: Model<Self>,
         envelope: TypedEnvelope<proto::FindSearchCandidates>,
@@ -3709,7 +3668,7 @@ impl Project {
                 .ok_or_else(|| anyhow!("missing query field"))?,
         )?;
         let mut results = this.update(&mut cx, |this, cx| {
-            this.search_for_candidate_buffers(&query, message.limit as _, cx)
+            this.find_search_candidate_buffers(&query, message.limit as _, cx)
         })?;
 
         let mut response = proto::FindSearchCandidatesResponse {
diff --git a/crates/project/src/search.rs b/crates/project/src/search.rs
index d0e435aa135418..4205f3173039c2 100644
--- a/crates/project/src/search.rs
+++ b/crates/project/src/search.rs
@@ -147,30 +147,6 @@ impl SearchQuery {
         })
     }
 
-    pub fn from_proto_v1(message: proto::SearchProject) -> Result<Self> {
-        if message.regex {
-            Self::regex(
-                message.query,
-                message.whole_word,
-                message.case_sensitive,
-                message.include_ignored,
-                deserialize_path_matches(&message.files_to_include)?,
-                deserialize_path_matches(&message.files_to_exclude)?,
-                None,
-            )
-        } else {
-            Self::text(
-                message.query,
-                message.whole_word,
-                message.case_sensitive,
-                message.include_ignored,
-                deserialize_path_matches(&message.files_to_include)?,
-                deserialize_path_matches(&message.files_to_exclude)?,
-                None,
-            )
-        }
-    }
-
     pub fn from_proto(message: proto::SearchQuery) -> Result<Self> {
         if message.regex {
             Self::regex(
@@ -194,6 +170,7 @@ impl SearchQuery {
             )
         }
     }
+
     pub fn with_replacement(mut self, new_replacement: String) -> Self {
         match self {
             Self::Text {
@@ -209,18 +186,6 @@ impl SearchQuery {
             }
         }
     }
-    pub fn to_protov1(&self, project_id: u64) -> proto::SearchProject {
-        proto::SearchProject {
-            project_id,
-            query: self.as_str().to_string(),
-            regex: self.is_regex(),
-            whole_word: self.whole_word(),
-            case_sensitive: self.case_sensitive(),
-            include_ignored: self.include_ignored(),
-            files_to_include: self.files_to_include().sources().join(","),
-            files_to_exclude: self.files_to_exclude().sources().join(","),
-        }
-    }
 
     pub fn to_proto(&self) -> proto::SearchQuery {
         proto::SearchQuery {
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index d81ef35f6bffbd..07f64557f47e1d 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -108,8 +108,6 @@ message Envelope {
         PrepareRenameResponse prepare_rename_response = 84;
         PerformRename perform_rename = 85;
         PerformRenameResponse perform_rename_response = 86;
-        SearchProject search_project = 87;
-        SearchProjectResponse search_project_response = 88;
 
         UpdateContacts update_contacts = 89;
         UpdateInviteInfo update_invite_info = 90;
@@ -287,6 +285,7 @@ message Envelope {
         CheckFileExistsResponse check_file_exists_response = 256; // current max
     }
 
+    reserved 87 to 88;
     reserved 158 to 161;
     reserved 166 to 169;
     reserved 224 to 229;
@@ -1238,22 +1237,6 @@ message PerformRenameResponse {
     ProjectTransaction transaction = 2;
 }
 
-message SearchProject {
-    uint64 project_id = 1;
-    string query = 2;
-    bool regex = 3;
-    bool whole_word = 4;
-    bool case_sensitive = 5;
-    string files_to_include = 6;
-    string files_to_exclude = 7;
-    bool include_ignored = 8;
-}
-
-message SearchProjectResponse {
-    repeated Location locations = 1;
-    bool limit_reached = 2;
-}
-
 message SearchQuery {
     string query = 2;
     bool regex = 3;
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 799d51defec718..fe1725e0d1c964 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -279,8 +279,6 @@ messages!(
     (SaveBuffer, Foreground),
     (SetChannelMemberRole, Foreground),
     (SetChannelVisibility, Foreground),
-    (SearchProject, Background),
-    (SearchProjectResponse, Background),
     (SendChannelMessage, Background),
     (SendChannelMessageResponse, Background),
     (ShareProject, Foreground),
@@ -454,7 +452,6 @@ request_messages!(
     (RespondToChannelInvite, Ack),
     (RespondToContactRequest, Ack),
     (SaveBuffer, BufferSaved),
-    (SearchProject, SearchProjectResponse),
     (FindSearchCandidates, FindSearchCandidatesResponse),
     (SendChannelMessage, SendChannelMessageResponse),
     (SetChannelMemberRole, Ack),
@@ -541,7 +538,6 @@ entity_messages!(
     ResolveCompletionDocumentation,
     ResolveInlayHint,
     SaveBuffer,
-    SearchProject,
     StartLanguageServer,
     SynchronizeBuffers,
     TaskContextForLocation,

From e28496d4e2ef581def4854b1e7c4df8cbb542251 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 26 Sep 2024 14:01:05 -0600
Subject: [PATCH 360/762] Stop leaking isahc assumption (#18408)

Users of our http_client crate knew they were interacting with isahc as
they set its extensions on the request. This change adds our own
equivalents for their APIs in preparation for changing the default http
client.

Release Notes:

- N/A
---
 Cargo.lock                                    |  8 --
 crates/anthropic/Cargo.toml                   |  1 -
 crates/anthropic/src/anthropic.rs             |  7 +-
 crates/copilot/Cargo.toml                     |  1 -
 crates/copilot/src/copilot_chat.rs            |  7 +-
 crates/extension/Cargo.toml                   |  1 -
 crates/extension/src/extension_store.rs       |  2 +-
 .../src/wasm_host/wit/since_v0_1_0.rs         | 13 +--
 .../src/wasm_host/wit/since_v0_2_0.rs         | 13 +--
 crates/feedback/Cargo.toml                    |  1 -
 crates/feedback/src/feedback_modal.rs         |  3 +-
 .../src/providers/codeberg.rs                 |  8 +-
 .../src/providers/github.rs                   |  8 +-
 crates/google_ai/Cargo.toml                   |  1 -
 crates/google_ai/src/google_ai.rs             |  7 +-
 crates/gpui/src/app.rs                        |  3 +-
 crates/http_client/src/http_client.rs         | 90 +++++++++++--------
 .../src/isahc_http_client.rs                  | 26 ++++--
 crates/language_model/Cargo.toml              |  1 -
 crates/language_model/src/provider/cloud.rs   |  5 +-
 crates/open_ai/Cargo.toml                     |  1 -
 crates/open_ai/src/open_ai.rs                 |  7 +-
 crates/zed/Cargo.toml                         |  1 -
 crates/zed/src/reliability.rs                 |  5 +-
 24 files changed, 114 insertions(+), 106 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 68dad1f74613f1..85a62c9519e012 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -245,7 +245,6 @@ dependencies = [
  "chrono",
  "futures 0.3.30",
  "http_client",
- "isahc",
  "schemars",
  "serde",
  "serde_json",
@@ -2850,7 +2849,6 @@ dependencies = [
  "gpui",
  "http_client",
  "indoc",
- "isahc",
  "language",
  "lsp",
  "menu",
@@ -4128,7 +4126,6 @@ dependencies = [
  "gpui",
  "http_client",
  "indexed_docs",
- "isahc",
  "isahc_http_client",
  "language",
  "log",
@@ -4289,7 +4286,6 @@ dependencies = [
  "gpui",
  "http_client",
  "human_bytes",
- "isahc",
  "language",
  "log",
  "menu",
@@ -5016,7 +5012,6 @@ dependencies = [
  "anyhow",
  "futures 0.3.30",
  "http_client",
- "isahc",
  "schemars",
  "serde",
  "serde_json",
@@ -6288,7 +6283,6 @@ dependencies = [
  "http_client",
  "image",
  "inline_completion_button",
- "isahc",
  "language",
  "log",
  "menu",
@@ -7591,7 +7585,6 @@ dependencies = [
  "anyhow",
  "futures 0.3.30",
  "http_client",
- "isahc",
  "schemars",
  "serde",
  "serde_json",
@@ -14435,7 +14428,6 @@ dependencies = [
  "image_viewer",
  "inline_completion_button",
  "install_cli",
- "isahc",
  "isahc_http_client",
  "journal",
  "language",
diff --git a/crates/anthropic/Cargo.toml b/crates/anthropic/Cargo.toml
index 9e48ad0e57d81d..ec12932fb74f1e 100644
--- a/crates/anthropic/Cargo.toml
+++ b/crates/anthropic/Cargo.toml
@@ -20,7 +20,6 @@ anyhow.workspace = true
 chrono.workspace = true
 futures.workspace = true
 http_client.workspace = true
-isahc.workspace = true
 schemars = { workspace = true, optional = true }
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/anthropic/src/anthropic.rs b/crates/anthropic/src/anthropic.rs
index 91b6723e90be97..6b8972284208a1 100644
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -6,9 +6,8 @@ use std::{pin::Pin, str::FromStr};
 use anyhow::{anyhow, Context, Result};
 use chrono::{DateTime, Utc};
 use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, Stream, StreamExt};
-use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
-use isahc::config::Configurable;
-use isahc::http::{HeaderMap, HeaderValue};
+use http_client::http::{HeaderMap, HeaderValue};
+use http_client::{AsyncBody, HttpClient, HttpRequestExt, Method, Request as HttpRequest};
 use serde::{Deserialize, Serialize};
 use strum::{EnumIter, EnumString};
 use thiserror::Error;
@@ -289,7 +288,7 @@ pub async fn stream_completion_with_rate_limit_info(
         .header("X-Api-Key", api_key)
         .header("Content-Type", "application/json");
     if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
+        request_builder = request_builder.read_timeout(low_speed_timeout);
     }
     let serialized_request =
         serde_json::to_string(&request).context("failed to serialize request")?;
diff --git a/crates/copilot/Cargo.toml b/crates/copilot/Cargo.toml
index 54abbaa112060b..2a54497562a243 100644
--- a/crates/copilot/Cargo.toml
+++ b/crates/copilot/Cargo.toml
@@ -37,7 +37,6 @@ fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
 http_client.workspace = true
-isahc.workspace = true
 language.workspace = true
 lsp.workspace = true
 menu.workspace = true
diff --git a/crates/copilot/src/copilot_chat.rs b/crates/copilot/src/copilot_chat.rs
index 5d80c89a6649dd..c5ba1bfc6a5895 100644
--- a/crates/copilot/src/copilot_chat.rs
+++ b/crates/copilot/src/copilot_chat.rs
@@ -7,8 +7,7 @@ use chrono::DateTime;
 use fs::Fs;
 use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, StreamExt};
 use gpui::{AppContext, AsyncAppContext, Global};
-use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
-use isahc::config::Configurable;
+use http_client::{AsyncBody, HttpClient, HttpRequestExt, Method, Request as HttpRequest};
 use paths::home_dir;
 use serde::{Deserialize, Serialize};
 use settings::watch_config_file;
@@ -275,7 +274,7 @@ async fn request_api_token(
         .header("Accept", "application/json");
 
     if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
+        request_builder = request_builder.read_timeout(low_speed_timeout);
     }
 
     let request = request_builder.body(AsyncBody::empty())?;
@@ -332,7 +331,7 @@ async fn stream_completion(
         .header("Copilot-Integration-Id", "vscode-chat");
 
     if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
+        request_builder = request_builder.read_timeout(low_speed_timeout);
     }
     let request = request_builder.body(AsyncBody::from(serde_json::to_string(&request)?))?;
     let mut response = client.send(request).await?;
diff --git a/crates/extension/Cargo.toml b/crates/extension/Cargo.toml
index edf6184d38475d..6ce1bd6862a1dd 100644
--- a/crates/extension/Cargo.toml
+++ b/crates/extension/Cargo.toml
@@ -28,7 +28,6 @@ futures.workspace = true
 gpui.workspace = true
 http_client.workspace = true
 indexed_docs.workspace = true
-isahc.workspace = true
 language.workspace = true
 log.workspace = true
 lsp.workspace = true
diff --git a/crates/extension/src/extension_store.rs b/crates/extension/src/extension_store.rs
index 5f9fbffb11b2ec..535d68326f9c3e 100644
--- a/crates/extension/src/extension_store.rs
+++ b/crates/extension/src/extension_store.rs
@@ -664,7 +664,7 @@ impl ExtensionStore {
 
             let content_length = response
                 .headers()
-                .get(isahc::http::header::CONTENT_LENGTH)
+                .get(http_client::http::header::CONTENT_LENGTH)
                 .and_then(|value| value.to_str().ok()?.parse::<usize>().ok());
 
             let mut body = BufReader::new(response.body_mut());
diff --git a/crates/extension/src/wasm_host/wit/since_v0_1_0.rs b/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
index 3835f58f885290..862e2e7c7f7894 100644
--- a/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
+++ b/crates/extension/src/wasm_host/wit/since_v0_1_0.rs
@@ -1,5 +1,5 @@
 use crate::wasm_host::{wit::ToWasmtimeResult, WasmState};
-use ::http_client::AsyncBody;
+use ::http_client::{AsyncBody, HttpRequestExt};
 use ::settings::{Settings, WorktreeId};
 use anyhow::{anyhow, bail, Context, Result};
 use async_compression::futures::bufread::GzipDecoder;
@@ -8,7 +8,6 @@ use async_trait::async_trait;
 use futures::{io::BufReader, FutureExt as _};
 use futures::{lock::Mutex, AsyncReadExt};
 use indexed_docs::IndexedDocsDatabase;
-use isahc::config::{Configurable, RedirectPolicy};
 use language::{
     language_settings::AllLanguageSettings, LanguageServerBinaryStatus, LspAdapterDelegate,
 };
@@ -297,10 +296,12 @@ fn convert_request(
     let mut request = ::http_client::Request::builder()
         .method(::http_client::Method::from(extension_request.method))
         .uri(&extension_request.url)
-        .redirect_policy(match extension_request.redirect_policy {
-            http_client::RedirectPolicy::NoFollow => RedirectPolicy::None,
-            http_client::RedirectPolicy::FollowLimit(limit) => RedirectPolicy::Limit(limit),
-            http_client::RedirectPolicy::FollowAll => RedirectPolicy::Follow,
+        .follow_redirects(match extension_request.redirect_policy {
+            http_client::RedirectPolicy::NoFollow => ::http_client::RedirectPolicy::NoFollow,
+            http_client::RedirectPolicy::FollowLimit(limit) => {
+                ::http_client::RedirectPolicy::FollowLimit(limit)
+            }
+            http_client::RedirectPolicy::FollowAll => ::http_client::RedirectPolicy::FollowAll,
         });
     for (key, value) in &extension_request.headers {
         request = request.header(key, value);
diff --git a/crates/extension/src/wasm_host/wit/since_v0_2_0.rs b/crates/extension/src/wasm_host/wit/since_v0_2_0.rs
index eb6e1a09a2ae99..e7f5432e1d32cc 100644
--- a/crates/extension/src/wasm_host/wit/since_v0_2_0.rs
+++ b/crates/extension/src/wasm_host/wit/since_v0_2_0.rs
@@ -1,5 +1,5 @@
 use crate::wasm_host::{wit::ToWasmtimeResult, WasmState};
-use ::http_client::AsyncBody;
+use ::http_client::{AsyncBody, HttpRequestExt};
 use ::settings::{Settings, WorktreeId};
 use anyhow::{anyhow, bail, Context, Result};
 use async_compression::futures::bufread::GzipDecoder;
@@ -8,7 +8,6 @@ use async_trait::async_trait;
 use futures::{io::BufReader, FutureExt as _};
 use futures::{lock::Mutex, AsyncReadExt};
 use indexed_docs::IndexedDocsDatabase;
-use isahc::config::{Configurable, RedirectPolicy};
 use language::{
     language_settings::AllLanguageSettings, LanguageServerBinaryStatus, LspAdapterDelegate,
 };
@@ -213,10 +212,12 @@ fn convert_request(
     let mut request = ::http_client::Request::builder()
         .method(::http_client::Method::from(extension_request.method))
         .uri(&extension_request.url)
-        .redirect_policy(match extension_request.redirect_policy {
-            http_client::RedirectPolicy::NoFollow => RedirectPolicy::None,
-            http_client::RedirectPolicy::FollowLimit(limit) => RedirectPolicy::Limit(limit),
-            http_client::RedirectPolicy::FollowAll => RedirectPolicy::Follow,
+        .follow_redirects(match extension_request.redirect_policy {
+            http_client::RedirectPolicy::NoFollow => ::http_client::RedirectPolicy::NoFollow,
+            http_client::RedirectPolicy::FollowLimit(limit) => {
+                ::http_client::RedirectPolicy::FollowLimit(limit)
+            }
+            http_client::RedirectPolicy::FollowAll => ::http_client::RedirectPolicy::FollowAll,
         });
     for (key, value) in &extension_request.headers {
         request = request.header(key, value);
diff --git a/crates/feedback/Cargo.toml b/crates/feedback/Cargo.toml
index 83c726e3e9ab4a..0447858ca53b4f 100644
--- a/crates/feedback/Cargo.toml
+++ b/crates/feedback/Cargo.toml
@@ -23,7 +23,6 @@ editor.workspace = true
 futures.workspace = true
 gpui.workspace = true
 human_bytes = "0.4.1"
-isahc.workspace = true
 http_client.workspace = true
 language.workspace = true
 log.workspace = true
diff --git a/crates/feedback/src/feedback_modal.rs b/crates/feedback/src/feedback_modal.rs
index 4762b228d3e44f..5270492aee5c33 100644
--- a/crates/feedback/src/feedback_modal.rs
+++ b/crates/feedback/src/feedback_modal.rs
@@ -11,7 +11,6 @@ use gpui::{
     PromptLevel, Render, Task, View, ViewContext,
 };
 use http_client::HttpClient;
-use isahc::Request;
 use language::Buffer;
 use project::Project;
 use regex::Regex;
@@ -299,7 +298,7 @@ impl FeedbackModal {
             is_staff: is_staff.unwrap_or(false),
         };
         let json_bytes = serde_json::to_vec(&request)?;
-        let request = Request::post(feedback_endpoint)
+        let request = http_client::http::Request::post(feedback_endpoint)
             .header("content-type", "application/json")
             .body(json_bytes.into())?;
         let mut response = http_client.send(request).await?;
diff --git a/crates/git_hosting_providers/src/providers/codeberg.rs b/crates/git_hosting_providers/src/providers/codeberg.rs
index eaadca1ecf9618..3f6a016f68fd4a 100644
--- a/crates/git_hosting_providers/src/providers/codeberg.rs
+++ b/crates/git_hosting_providers/src/providers/codeberg.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use anyhow::{bail, Context, Result};
 use async_trait::async_trait;
 use futures::AsyncReadExt;
-use http_client::{AsyncBody, HttpClient, Request};
+use http_client::{AsyncBody, HttpClient, HttpRequestExt, Request};
 use serde::Deserialize;
 use url::Url;
 
@@ -49,14 +49,16 @@ impl Codeberg {
         let url =
             format!("https://codeberg.org/api/v1/repos/{repo_owner}/{repo}/git/commits/{commit}");
 
-        let mut request = Request::get(&url).header("Content-Type", "application/json");
+        let mut request = Request::get(&url)
+            .header("Content-Type", "application/json")
+            .follow_redirects(http_client::RedirectPolicy::FollowAll);
 
         if let Ok(codeberg_token) = std::env::var("CODEBERG_TOKEN") {
             request = request.header("Authorization", format!("Bearer {}", codeberg_token));
         }
 
         let mut response = client
-            .send_with_redirect_policy(request.body(AsyncBody::default())?, true)
+            .send(request.body(AsyncBody::default())?)
             .await
             .with_context(|| format!("error fetching Codeberg commit details at {:?}", url))?;
 
diff --git a/crates/git_hosting_providers/src/providers/github.rs b/crates/git_hosting_providers/src/providers/github.rs
index 77eaa80961e61c..4078025fa004fc 100644
--- a/crates/git_hosting_providers/src/providers/github.rs
+++ b/crates/git_hosting_providers/src/providers/github.rs
@@ -3,7 +3,7 @@ use std::sync::{Arc, OnceLock};
 use anyhow::{bail, Context, Result};
 use async_trait::async_trait;
 use futures::AsyncReadExt;
-use http_client::{AsyncBody, HttpClient, Request};
+use http_client::{AsyncBody, HttpClient, HttpRequestExt, Request};
 use regex::Regex;
 use serde::Deserialize;
 use url::Url;
@@ -53,14 +53,16 @@ impl Github {
     ) -> Result<Option<User>> {
         let url = format!("https://api.github.com/repos/{repo_owner}/{repo}/commits/{commit}");
 
-        let mut request = Request::get(&url).header("Content-Type", "application/json");
+        let mut request = Request::get(&url)
+            .header("Content-Type", "application/json")
+            .follow_redirects(http_client::RedirectPolicy::FollowAll);
 
         if let Ok(github_token) = std::env::var("GITHUB_TOKEN") {
             request = request.header("Authorization", format!("Bearer {}", github_token));
         }
 
         let mut response = client
-            .send_with_redirect_policy(request.body(AsyncBody::default())?, true)
+            .send(request.body(AsyncBody::default())?)
             .await
             .with_context(|| format!("error fetching GitHub commit details at {:?}", url))?;
 
diff --git a/crates/google_ai/Cargo.toml b/crates/google_ai/Cargo.toml
index 2a52f1968dcb6b..f923e0ec917426 100644
--- a/crates/google_ai/Cargo.toml
+++ b/crates/google_ai/Cargo.toml
@@ -18,7 +18,6 @@ schemars = ["dep:schemars"]
 anyhow.workspace = true
 futures.workspace = true
 http_client.workspace = true
-isahc.workspace = true
 schemars = { workspace = true, optional = true }
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/google_ai/src/google_ai.rs b/crates/google_ai/src/google_ai.rs
index f1dcedf5b31e0c..7991c67956bb85 100644
--- a/crates/google_ai/src/google_ai.rs
+++ b/crates/google_ai/src/google_ai.rs
@@ -2,8 +2,7 @@ mod supported_countries;
 
 use anyhow::{anyhow, Result};
 use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, Stream, StreamExt};
-use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
-use isahc::config::Configurable;
+use http_client::{AsyncBody, HttpClient, HttpRequestExt, Method, Request as HttpRequest};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 
@@ -30,7 +29,7 @@ pub async fn stream_generate_content(
         .header("Content-Type", "application/json");
 
     if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
+        request_builder = request_builder.read_timeout(low_speed_timeout);
     };
 
     let request = request_builder.body(AsyncBody::from(serde_json::to_string(&request)?))?;
@@ -85,7 +84,7 @@ pub async fn count_tokens(
         .header("Content-Type", "application/json");
 
     if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
+        request_builder = request_builder.read_timeout(low_speed_timeout);
     }
 
     let http_request = request_builder.body(AsyncBody::from(request))?;
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index 6cb491b100810b..540e459ce1a314 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -1524,10 +1524,9 @@ pub struct KeystrokeEvent {
 struct NullHttpClient;
 
 impl HttpClient for NullHttpClient {
-    fn send_with_redirect_policy(
+    fn send(
         &self,
         _req: http_client::Request<http_client::AsyncBody>,
-        _follow_redirects: bool,
     ) -> futures::future::BoxFuture<
         'static,
         Result<http_client::Response<http_client::AsyncBody>, anyhow::Error>,
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index c0630151519c5a..2f029a1d236bba 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -10,22 +10,46 @@ use futures::future::BoxFuture;
 use http::request::Builder;
 #[cfg(feature = "test-support")]
 use std::fmt;
-use std::sync::{Arc, Mutex};
+use std::{
+    sync::{Arc, Mutex},
+    time::Duration,
+};
 pub use url::Url;
 
+pub struct ReadTimeout(pub Duration);
+#[derive(Default, Debug, Clone)]
+pub enum RedirectPolicy {
+    #[default]
+    NoFollow,
+    FollowLimit(u32),
+    FollowAll,
+}
+pub struct FollowRedirects(pub bool);
+
+pub trait HttpRequestExt {
+    /// Set a read timeout on the request.
+    /// For isahc, this is the low_speed_timeout.
+    /// For other clients, this is the timeout used for read calls when reading the response.
+    /// In all cases this prevents servers stalling completely, but allows them to send data slowly.
+    fn read_timeout(self, timeout: Duration) -> Self;
+    /// Whether or not to follow redirects
+    fn follow_redirects(self, follow: RedirectPolicy) -> Self;
+}
+
+impl HttpRequestExt for http::request::Builder {
+    fn read_timeout(self, timeout: Duration) -> Self {
+        self.extension(ReadTimeout(timeout))
+    }
+
+    fn follow_redirects(self, follow: RedirectPolicy) -> Self {
+        self.extension(follow)
+    }
+}
+
 pub trait HttpClient: 'static + Send + Sync {
     fn send(
         &self,
         req: http::Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
-        self.send_with_redirect_policy(req, false)
-    }
-
-    // TODO: Make a better API for this
-    fn send_with_redirect_policy(
-        &self,
-        req: Request<AsyncBody>,
-        follow_redirects: bool,
     ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>>;
 
     fn get<'a>(
@@ -34,14 +58,17 @@ pub trait HttpClient: 'static + Send + Sync {
         body: AsyncBody,
         follow_redirects: bool,
     ) -> BoxFuture<'a, Result<Response<AsyncBody>, anyhow::Error>> {
-        let request = Builder::new().uri(uri).body(body);
+        let request = Builder::new()
+            .uri(uri)
+            .follow_redirects(if follow_redirects {
+                RedirectPolicy::FollowAll
+            } else {
+                RedirectPolicy::NoFollow
+            })
+            .body(body);
 
         match request {
-            Ok(request) => Box::pin(async move {
-                self.send_with_redirect_policy(request, follow_redirects)
-                    .await
-                    .map_err(Into::into)
-            }),
+            Ok(request) => Box::pin(async move { self.send(request).await.map_err(Into::into) }),
             Err(e) => Box::pin(async move { Err(e.into()) }),
         }
     }
@@ -92,12 +119,11 @@ impl HttpClientWithProxy {
 }
 
 impl HttpClient for HttpClientWithProxy {
-    fn send_with_redirect_policy(
+    fn send(
         &self,
         req: Request<AsyncBody>,
-        follow_redirects: bool,
     ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
-        self.client.send_with_redirect_policy(req, follow_redirects)
+        self.client.send(req)
     }
 
     fn proxy(&self) -> Option<&Uri> {
@@ -106,12 +132,11 @@ impl HttpClient for HttpClientWithProxy {
 }
 
 impl HttpClient for Arc<HttpClientWithProxy> {
-    fn send_with_redirect_policy(
+    fn send(
         &self,
         req: Request<AsyncBody>,
-        follow_redirects: bool,
     ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
-        self.client.send_with_redirect_policy(req, follow_redirects)
+        self.client.send(req)
     }
 
     fn proxy(&self) -> Option<&Uri> {
@@ -218,12 +243,11 @@ impl HttpClientWithUrl {
 }
 
 impl HttpClient for Arc<HttpClientWithUrl> {
-    fn send_with_redirect_policy(
+    fn send(
         &self,
         req: Request<AsyncBody>,
-        follow_redirects: bool,
     ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
-        self.client.send_with_redirect_policy(req, follow_redirects)
+        self.client.send(req)
     }
 
     fn proxy(&self) -> Option<&Uri> {
@@ -232,12 +256,11 @@ impl HttpClient for Arc<HttpClientWithUrl> {
 }
 
 impl HttpClient for HttpClientWithUrl {
-    fn send_with_redirect_policy(
+    fn send(
         &self,
         req: Request<AsyncBody>,
-        follow_redirects: bool,
     ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
-        self.client.send_with_redirect_policy(req, follow_redirects)
+        self.client.send(req)
     }
 
     fn proxy(&self) -> Option<&Uri> {
@@ -283,14 +306,6 @@ impl HttpClient for BlockedHttpClient {
     fn proxy(&self) -> Option<&Uri> {
         None
     }
-
-    fn send_with_redirect_policy(
-        &self,
-        req: Request<AsyncBody>,
-        _: bool,
-    ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
-        self.send(req)
-    }
 }
 
 #[cfg(feature = "test-support")]
@@ -352,10 +367,9 @@ impl fmt::Debug for FakeHttpClient {
 
 #[cfg(feature = "test-support")]
 impl HttpClient for FakeHttpClient {
-    fn send_with_redirect_policy(
+    fn send(
         &self,
         req: Request<AsyncBody>,
-        _follow_redirects: bool,
     ) -> BoxFuture<'static, Result<Response<AsyncBody>, anyhow::Error>> {
         let future = (self.handler)(req);
         future
diff --git a/crates/isahc_http_client/src/isahc_http_client.rs b/crates/isahc_http_client/src/isahc_http_client.rs
index 6c40b9f53b3f8e..778f6a04598909 100644
--- a/crates/isahc_http_client/src/isahc_http_client.rs
+++ b/crates/isahc_http_client/src/isahc_http_client.rs
@@ -1,7 +1,6 @@
 use std::{mem, sync::Arc, time::Duration};
 
 use futures::future::BoxFuture;
-use isahc::config::RedirectPolicy;
 use util::maybe;
 
 pub use isahc::config::Configurable;
@@ -36,18 +35,29 @@ impl HttpClient for IsahcHttpClient {
         None
     }
 
-    fn send_with_redirect_policy(
+    fn send(
         &self,
         req: http_client::http::Request<http_client::AsyncBody>,
-        follow_redirects: bool,
     ) -> BoxFuture<'static, Result<http_client::Response<http_client::AsyncBody>, anyhow::Error>>
     {
+        let redirect_policy = req
+            .extensions()
+            .get::<http_client::RedirectPolicy>()
+            .cloned()
+            .unwrap_or_default();
+        let read_timeout = req
+            .extensions()
+            .get::<http_client::ReadTimeout>()
+            .map(|t| t.0);
         let req = maybe!({
             let (mut parts, body) = req.into_parts();
             let mut builder = isahc::Request::builder()
                 .method(parts.method)
                 .uri(parts.uri)
                 .version(parts.version);
+            if let Some(read_timeout) = read_timeout {
+                builder = builder.low_speed_timeout(100, read_timeout);
+            }
 
             let headers = builder.headers_mut()?;
             mem::swap(headers, &mut parts.headers);
@@ -64,10 +74,12 @@ impl HttpClient for IsahcHttpClient {
             };
 
             builder
-                .redirect_policy(if follow_redirects {
-                    RedirectPolicy::Follow
-                } else {
-                    RedirectPolicy::None
+                .redirect_policy(match redirect_policy {
+                    http_client::RedirectPolicy::FollowAll => isahc::config::RedirectPolicy::Follow,
+                    http_client::RedirectPolicy::FollowLimit(limit) => {
+                        isahc::config::RedirectPolicy::Limit(limit)
+                    }
+                    http_client::RedirectPolicy::NoFollow => isahc::config::RedirectPolicy::None,
                 })
                 .body(isahc_body)
                 .ok()
diff --git a/crates/language_model/Cargo.toml b/crates/language_model/Cargo.toml
index b63428c544369b..ef273ac44fca39 100644
--- a/crates/language_model/Cargo.toml
+++ b/crates/language_model/Cargo.toml
@@ -32,7 +32,6 @@ futures.workspace = true
 google_ai = { workspace = true, features = ["schemars"] }
 gpui.workspace = true
 http_client.workspace = true
-isahc.workspace = true
 inline_completion_button.workspace = true
 log.workspace = true
 menu.workspace = true
diff --git a/crates/language_model/src/provider/cloud.rs b/crates/language_model/src/provider/cloud.rs
index 606a6fbacec7b0..3c407b77d929de 100644
--- a/crates/language_model/src/provider/cloud.rs
+++ b/crates/language_model/src/provider/cloud.rs
@@ -18,8 +18,7 @@ use gpui::{
     AnyElement, AnyView, AppContext, AsyncAppContext, FontWeight, Model, ModelContext,
     Subscription, Task,
 };
-use http_client::{AsyncBody, HttpClient, Method, Response};
-use isahc::config::Configurable;
+use http_client::{AsyncBody, HttpClient, HttpRequestExt, Method, Response};
 use schemars::JsonSchema;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use serde_json::value::RawValue;
@@ -396,7 +395,7 @@ impl CloudLanguageModel {
         let response = loop {
             let mut request_builder = http_client::Request::builder();
             if let Some(low_speed_timeout) = low_speed_timeout {
-                request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
+                request_builder = request_builder.read_timeout(low_speed_timeout);
             };
             let request = request_builder
                 .method(Method::POST)
diff --git a/crates/open_ai/Cargo.toml b/crates/open_ai/Cargo.toml
index db9c77bac6bfe4..4f729598f82cdb 100644
--- a/crates/open_ai/Cargo.toml
+++ b/crates/open_ai/Cargo.toml
@@ -19,7 +19,6 @@ schemars = ["dep:schemars"]
 anyhow.workspace = true
 futures.workspace = true
 http_client.workspace = true
-isahc.workspace = true
 schemars = { workspace = true, optional = true }
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/open_ai/src/open_ai.rs b/crates/open_ai/src/open_ai.rs
index e67fe1af27cdb8..6a24eec69610c7 100644
--- a/crates/open_ai/src/open_ai.rs
+++ b/crates/open_ai/src/open_ai.rs
@@ -6,8 +6,7 @@ use futures::{
     stream::{self, BoxStream},
     AsyncBufReadExt, AsyncReadExt, Stream, StreamExt,
 };
-use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
-use isahc::config::Configurable;
+use http_client::{AsyncBody, HttpClient, HttpRequestExt, Method, Request as HttpRequest};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::{
@@ -318,7 +317,7 @@ pub async fn complete(
         .header("Content-Type", "application/json")
         .header("Authorization", format!("Bearer {}", api_key));
     if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
+        request_builder = request_builder.read_timeout(low_speed_timeout);
     };
 
     let mut request_body = request;
@@ -413,7 +412,7 @@ pub async fn stream_completion(
         .header("Authorization", format!("Bearer {}", api_key));
 
     if let Some(low_speed_timeout) = low_speed_timeout {
-        request_builder = request_builder.low_speed_timeout(100, low_speed_timeout);
+        request_builder = request_builder.read_timeout(low_speed_timeout);
     };
 
     let request = request_builder.body(AsyncBody::from(serde_json::to_string(&request)?))?;
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index 897e0e9a28bca8..5422f8b29aa98d 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -57,7 +57,6 @@ http_client.workspace = true
 image_viewer.workspace = true
 inline_completion_button.workspace = true
 install_cli.workspace = true
-isahc.workspace = true
 isahc_http_client.workspace = true
 journal.workspace = true
 language.workspace = true
diff --git a/crates/zed/src/reliability.rs b/crates/zed/src/reliability.rs
index 9e811d7c9afbb4..50e5a05b823ed0 100644
--- a/crates/zed/src/reliability.rs
+++ b/crates/zed/src/reliability.rs
@@ -4,8 +4,7 @@ use chrono::Utc;
 use client::telemetry;
 use db::kvp::KEY_VALUE_STORE;
 use gpui::{AppContext, SemanticVersion};
-use http_client::Method;
-use isahc::config::Configurable;
+use http_client::{HttpRequestExt, Method};
 
 use http_client::{self, HttpClient, HttpClientWithUrl};
 use paths::{crashes_dir, crashes_retired_dir};
@@ -491,7 +490,7 @@ async fn upload_previous_crashes(
                 .context("error reading crash file")?;
 
             let mut request = http_client::Request::post(&crash_report_url.to_string())
-                .redirect_policy(isahc::config::RedirectPolicy::Follow)
+                .follow_redirects(http_client::RedirectPolicy::FollowAll)
                 .header("Content-Type", "text/plain");
 
             if let Some((panicked_on, payload)) = most_recent_panic.as_ref() {

From 48c6eb9ac7a0cebc096cf576c163d054de41c92f Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Thu, 26 Sep 2024 16:21:20 -0400
Subject: [PATCH 361/762] Add script to generate license dependencies as csv
 (#18411)

Co-authored-by: Joseph T. Lyons <JosephTLyons@gmail.com>
---
 .gitignore                                    |  2 +-
 script/generate-licenses                      |  6 ++++-
 script/generate-licenses-csv                  | 23 +++++++++++++++++++
 script/licenses/template.csv.hbs              |  6 +++++
 .../{template.hbs.md => template.md.hbs}      |  0
 5 files changed, 35 insertions(+), 2 deletions(-)
 create mode 100755 script/generate-licenses-csv
 create mode 100644 script/licenses/template.csv.hbs
 rename script/licenses/{template.hbs.md => template.md.hbs} (100%)

diff --git a/.gitignore b/.gitignore
index 634b73ac943cc3..d19c5a102aac8a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,7 +10,7 @@
 /crates/collab/seed.json
 /crates/zed/resources/flatpak/flatpak-cargo-sources.json
 /dev.zed.Zed*.json
-/assets/*licenses.md
+/assets/*licenses.*
 **/venv
 .build
 *.wasm
diff --git a/script/generate-licenses b/script/generate-licenses
index 43b2f5c4588af4..9602813f0ced27 100755
--- a/script/generate-licenses
+++ b/script/generate-licenses
@@ -4,6 +4,7 @@ set -euo pipefail
 
 CARGO_ABOUT_VERSION="0.6.1"
 OUTPUT_FILE="${1:-$(pwd)/assets/licenses.md}"
+TEMPLATE_FILE="script/licenses/template.md.hbs"
 
 > $OUTPUT_FILE
 
@@ -23,7 +24,10 @@ else
 fi
 
 echo "Generating cargo licenses"
-cargo about generate --fail -c script/licenses/zed-licenses.toml script/licenses/template.hbs.md >> $OUTPUT_FILE
+cargo about generate \
+    --fail \
+    -c script/licenses/zed-licenses.toml \
+    "${TEMPLATE_FILE}" >> $OUTPUT_FILE
 
 
 sed -i.bak 's/&quot;/"/g' $OUTPUT_FILE
diff --git a/script/generate-licenses-csv b/script/generate-licenses-csv
new file mode 100755
index 00000000000000..63bfee83a5cbb1
--- /dev/null
+++ b/script/generate-licenses-csv
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+CARGO_ABOUT_VERSION="0.6.1"
+OUTPUT_FILE="${1:-$(pwd)/assets/licenses.csv}"
+TEMPLATE_FILE="script/licenses/template.csv.hbs"
+
+if ! cargo install --list | grep "cargo-about v$CARGO_ABOUT_VERSION" > /dev/null; then
+  echo "Installing cargo-about@$CARGO_ABOUT_VERSION..."
+  cargo install "cargo-about@$CARGO_ABOUT_VERSION"
+else
+  echo "cargo-about@$CARGO_ABOUT_VERSION is already installed."
+fi
+
+echo "Generating cargo licenses"
+cargo about generate \
+    --fail \
+    -c script/licenses/zed-licenses.toml \
+    script/licenses/template.csv.hbs \
+    | awk 'NR==1{print;next} NF{print | "sort"}' \
+    > $OUTPUT_FILE
+echo "Completed. See $OUTPUT_FILE"
diff --git a/script/licenses/template.csv.hbs b/script/licenses/template.csv.hbs
new file mode 100644
index 00000000000000..1459aa648d8da8
--- /dev/null
+++ b/script/licenses/template.csv.hbs
@@ -0,0 +1,6 @@
+Crate Name,Crate Version,License,Url
+{{#each licenses}}
+{{#each used_by}}
+{{crate.name}},{{crate.version}},{{../name}},{{#if crate.repository}}{{crate.repository}}{{else}}https://crates.io/crates/{{crate.name}}{{/if}}
+{{/each}}
+{{/each}}
diff --git a/script/licenses/template.hbs.md b/script/licenses/template.md.hbs
similarity index 100%
rename from script/licenses/template.hbs.md
rename to script/licenses/template.md.hbs

From c83d007138587d832c5ce3a13c8cb99913c016be Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Thu, 26 Sep 2024 23:43:58 +0300
Subject: [PATCH 362/762] Remove non-wrapping settings from the language
 configuration (#18412)

Closes https://github.com/zed-industries/zed/issues/17736

Those are limited with 1024 symbols before wrapping still, and were
introduced for git diff deleted hunks display.
Instead of confusing people with actually wrapping, restores behavior
that was before https://github.com/zed-industries/zed/pull/11080

Release Notes:

- Removed confusing soft wrap option behavior
([#17736]https://github.com/zed-industries/zed/issues/17736)
---
 assets/settings/default.json             |  7 +++----
 crates/editor/src/editor.rs              | 24 +++++++++++++++++-------
 crates/editor/src/element.rs             |  6 ++----
 crates/language/src/language_settings.rs |  9 +++++----
 docs/src/configuring-zed.md              |  6 +++---
 5 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index cf0de6a5e7f9aa..b3be17ad2cedcf 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -535,17 +535,16 @@
   // How to soft-wrap long lines of text.
   // Possible values:
   //
-  // 1. Do not soft wrap.
-  //      "soft_wrap": "none",
   // 2. Prefer a single line generally, unless an overly long line is encountered.
-  //      "soft_wrap": "prefer_line",
+  //      "soft_wrap": "none",
+  //      "soft_wrap": "prefer_line", // (deprecated, same as "none")
   // 3. Soft wrap lines that overflow the editor.
   //      "soft_wrap": "editor_width",
   // 4. Soft wrap lines at the preferred line length.
   //      "soft_wrap": "preferred_line_length",
   // 5. Soft wrap lines at the preferred line length or the editor width (whichever is smaller).
   //      "soft_wrap": "bounded",
-  "soft_wrap": "prefer_line",
+  "soft_wrap": "none",
   // The column at which to soft-wrap lines, for buffers where soft-wrap
   // is enabled.
   "preferred_line_length": 80,
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 54d23a8219d4f4..b7f825df9eec60 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -376,12 +376,20 @@ pub enum EditorMode {
     Full,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Copy, Clone, Debug)]
 pub enum SoftWrap {
+    /// Prefer not to wrap at all.
+    ///
+    /// Note: this is currently internal, as actually limited by [`crate::MAX_LINE_LEN`] until it wraps.
+    /// The mode is used inside git diff hunks, where it's seems currently more useful to not wrap as much as possible.
+    GitDiff,
+    /// Prefer a single line generally, unless an overly long line is encountered.
     None,
-    PreferLine,
+    /// Soft wrap lines that exceed the editor width.
     EditorWidth,
+    /// Soft wrap lines at the preferred line length.
     Column(u32),
+    /// Soft wrap line at the preferred line length or the editor width (whichever is smaller).
     Bounded(u32),
 }
 
@@ -1837,7 +1845,7 @@ impl Editor {
         let blink_manager = cx.new_model(|cx| BlinkManager::new(CURSOR_BLINK_INTERVAL, cx));
 
         let soft_wrap_mode_override = matches!(mode, EditorMode::SingleLine { .. })
-            .then(|| language_settings::SoftWrap::PreferLine);
+            .then(|| language_settings::SoftWrap::None);
 
         let mut project_subscriptions = Vec::new();
         if mode == EditorMode::Full {
@@ -10898,8 +10906,9 @@ impl Editor {
         let settings = self.buffer.read(cx).settings_at(0, cx);
         let mode = self.soft_wrap_mode_override.unwrap_or(settings.soft_wrap);
         match mode {
-            language_settings::SoftWrap::None => SoftWrap::None,
-            language_settings::SoftWrap::PreferLine => SoftWrap::PreferLine,
+            language_settings::SoftWrap::PreferLine | language_settings::SoftWrap::None => {
+                SoftWrap::None
+            }
             language_settings::SoftWrap::EditorWidth => SoftWrap::EditorWidth,
             language_settings::SoftWrap::PreferredLineLength => {
                 SoftWrap::Column(settings.preferred_line_length)
@@ -10947,9 +10956,10 @@ impl Editor {
             self.soft_wrap_mode_override.take();
         } else {
             let soft_wrap = match self.soft_wrap_mode(cx) {
-                SoftWrap::None | SoftWrap::PreferLine => language_settings::SoftWrap::EditorWidth,
+                SoftWrap::GitDiff => return,
+                SoftWrap::None => language_settings::SoftWrap::EditorWidth,
                 SoftWrap::EditorWidth | SoftWrap::Column(_) | SoftWrap::Bounded(_) => {
-                    language_settings::SoftWrap::PreferLine
+                    language_settings::SoftWrap::None
                 }
             };
             self.soft_wrap_mode_override = Some(soft_wrap);
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 6f30062d47ec77..bad16b225f3298 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -4994,10 +4994,8 @@ impl Element for EditorElement {
                             snapshot
                         } else {
                             let wrap_width = match editor.soft_wrap_mode(cx) {
-                                SoftWrap::None => None,
-                                SoftWrap::PreferLine => {
-                                    Some((MAX_LINE_LEN / 2) as f32 * em_advance)
-                                }
+                                SoftWrap::GitDiff => None,
+                                SoftWrap::None => Some((MAX_LINE_LEN / 2) as f32 * em_advance),
                                 SoftWrap::EditorWidth => Some(editor_width),
                                 SoftWrap::Column(column) => Some(column as f32 * em_advance),
                                 SoftWrap::Bounded(column) => {
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index f830c5f25c308c..2f1a7be2bf492d 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -379,15 +379,16 @@ pub struct FeaturesContent {
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum SoftWrap {
-    /// Do not soft wrap.
+    /// Prefer a single line generally, unless an overly long line is encountered.
     None,
+    /// Deprecated: use None instead. Left to avoid breakin existing users' configs.
     /// Prefer a single line generally, unless an overly long line is encountered.
     PreferLine,
-    /// Soft wrap lines that exceed the editor width
+    /// Soft wrap lines that exceed the editor width.
     EditorWidth,
-    /// Soft wrap lines at the preferred line length
+    /// Soft wrap lines at the preferred line length.
     PreferredLineLength,
-    /// Soft wrap line at the preferred line length or the editor width (whichever is smaller)
+    /// Soft wrap line at the preferred line length or the editor width (whichever is smaller).
     Bounded,
 }
 
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 7837044a60a669..18d66708ad7fc8 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -1357,12 +1357,12 @@ Or to set a `socks5` proxy:
 
 - Description: Whether or not to automatically wrap lines of text to fit editor / preferred width.
 - Setting: `soft_wrap`
-- Default: `prefer_line`
+- Default: `none`
 
 **Options**
 
-1. `none` to stop the soft-wrapping
-2. `prefer_line` to avoid wrapping generally, unless the line is too long
+1. `none` to avoid wrapping generally, unless the line is too long
+2. `prefer_line` (deprecated, same as `none`)
 3. `editor_width` to wrap lines that overflow the editor width
 4. `preferred_line_length` to wrap lines that overflow `preferred_line_length` config value
 

From 32605e9ea4d9c1de2b23ac084d30df5c36b5f4dc Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 26 Sep 2024 20:27:49 -0600
Subject: [PATCH 363/762] Fix register selection in visual mode (#18418)

Related to #12895

Release Notes:

- vim: Fix register selection in visual yank
---
 crates/vim/src/normal/mark.rs                    | 1 -
 crates/vim/src/normal/paste.rs                   | 3 +++
 crates/vim/test_data/test_special_registers.json | 7 +++++++
 3 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/crates/vim/src/normal/mark.rs b/crates/vim/src/normal/mark.rs
index 787430e747e3f2..743ab59ee286cc 100644
--- a/crates/vim/src/normal/mark.rs
+++ b/crates/vim/src/normal/mark.rs
@@ -63,7 +63,6 @@ impl Vim {
         self.marks.insert("<".to_string(), starts);
         self.marks.insert(">".to_string(), ends);
         self.stored_visual_mode.replace((mode, reversed));
-        self.clear_operator(cx);
     }
 
     pub fn jump(&mut self, text: Arc<str>, line: bool, cx: &mut ViewContext<Self>) {
diff --git a/crates/vim/src/normal/paste.rs b/crates/vim/src/normal/paste.rs
index 05469dbf9f168f..5322f913c1769b 100644
--- a/crates/vim/src/normal/paste.rs
+++ b/crates/vim/src/normal/paste.rs
@@ -673,6 +673,9 @@ mod test {
         cx.simulate_shared_keystrokes("\" _ d d").await;
         cx.shared_register('_').await.assert_eq("");
 
+        cx.simulate_shared_keystrokes("shift-v \" _ y w").await;
+        cx.shared_register('"').await.assert_eq("jumps");
+
         cx.shared_state().await.assert_eq(indoc! {"
                 The quick brown
                 the ˇlazy dog"});
diff --git a/crates/vim/test_data/test_special_registers.json b/crates/vim/test_data/test_special_registers.json
index 8b6b098af659fd..35f181a05c4f64 100644
--- a/crates/vim/test_data/test_special_registers.json
+++ b/crates/vim/test_data/test_special_registers.json
@@ -10,6 +10,13 @@
 {"Key":"d"}
 {"Get":{"state":"The quick brown\nthe ˇlazy dog","mode":"Normal"}}
 {"ReadRegister":{"name":"_","value":""}}
+{"Key":"shift-v"}
+{"Key":"\""}
+{"Key":"_"}
+{"Key":"y"}
+{"Key":"w"}
+{"Get":{"state":"The quick brown\nthe ˇlazy dog","mode":"Normal"}}
+{"ReadRegister":{"name":"\"","value":"jumps"}}
 {"Get":{"state":"The quick brown\nthe ˇlazy dog","mode":"Normal"}}
 {"Key":"\""}
 {"Key":"\""}

From 1be3c44550012c9c7657de0450044c973f8c2d10 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 26 Sep 2024 23:52:07 -0600
Subject: [PATCH 364/762] vim: Support za (#18421)

Closes #6822
Updates #5142

Release Notes:

- Added new fold actions to toggle folds (`cmd-k cmd-l`), fold every
fold (`cmd-k cmd-0`) unfold every fold (`cmd-k cmd-j`) to fold
recursively (`cmd-k cmd-[`) and unfold recursively (`cmd-k cmd-]`).
- vim: Added `za` to toggle fold under cursor.
- vim: Added `zO`/`zC`/`zA` to open, close and toggle folds recursively
(and fixed `zc` to not recurse into selections).
- vim: Added `zR`/`zM` to open/close all folds in the buffer.
---
 assets/keymaps/default-linux.json |   5 +
 assets/keymaps/default-macos.json |   5 +
 assets/keymaps/vim.json           |   6 ++
 crates/editor/src/actions.rs      |   6 ++
 crates/editor/src/editor.rs       | 151 +++++++++++++++++++++++++++++-
 crates/editor/src/editor_tests.rs |   6 +-
 crates/editor/src/element.rs      |   6 ++
 7 files changed, 179 insertions(+), 6 deletions(-)

diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index f15c4dfe22b6c0..8d4871d95648db 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -310,6 +310,11 @@
       "ctrl-shift-\\": "editor::MoveToEnclosingBracket",
       "ctrl-shift-[": "editor::Fold",
       "ctrl-shift-]": "editor::UnfoldLines",
+      "ctrl-k ctrl-l": "editor::ToggleFold",
+      "ctrl-k ctrl-[": "editor::FoldRecursive",
+      "ctrl-k ctrl-]": "editor::UnfoldRecursive",
+      "ctrl-k ctrl-0": "editor::FoldAll",
+      "ctrl-k ctrl-j": "editor::UnfoldAll",
       "ctrl-space": "editor::ShowCompletions",
       "ctrl-.": "editor::ToggleCodeActions",
       "alt-ctrl-r": "editor::RevealInFileManager",
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index a58112b3c0b927..a980ae14e22a95 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -347,6 +347,11 @@
       "cmd-shift-\\": "editor::MoveToEnclosingBracket",
       "alt-cmd-[": "editor::Fold",
       "alt-cmd-]": "editor::UnfoldLines",
+      "cmd-k cmd-l": "editor::ToggleFold",
+      "cmd-k cmd-[": "editor::FoldRecursive",
+      "cmd-k cmd-]": "editor::UnfoldRecursive",
+      "cmd-k cmd-0": "editor::FoldAll",
+      "cmd-k cmd-j": "editor::UnfoldAll",
       "ctrl-space": "editor::ShowCompletions",
       "cmd-.": "editor::ToggleCodeActions",
       "alt-cmd-r": "editor::RevealInFileManager",
diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index 6656ea0ddf22c3..f3a088f11e5d27 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -132,9 +132,15 @@
       "z z": "editor::ScrollCursorCenter",
       "z .": ["workspace::SendKeystrokes", "z z ^"],
       "z b": "editor::ScrollCursorBottom",
+      "z a": "editor::ToggleFold",
+      "z A": "editor::ToggleFoldRecursive",
       "z c": "editor::Fold",
+      "z C": "editor::FoldRecursive",
       "z o": "editor::UnfoldLines",
+      "z O": "editor::UnfoldRecursive",
       "z f": "editor::FoldSelectedRanges",
+      "z M": "editor::FoldAll",
+      "z R": "editor::UnfoldAll",
       "shift-z shift-q": ["pane::CloseActiveItem", { "saveIntent": "skip" }],
       "shift-z shift-z": ["pane::CloseActiveItem", { "saveIntent": "saveAll" }],
       // Count support
diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs
index 2383c7f71af8a9..b5935782580ba3 100644
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -230,7 +230,11 @@ gpui::actions!(
         ExpandMacroRecursively,
         FindAllReferences,
         Fold,
+        FoldAll,
+        FoldRecursive,
         FoldSelectedRanges,
+        ToggleFold,
+        ToggleFoldRecursive,
         Format,
         GoToDeclaration,
         GoToDeclarationSplit,
@@ -340,7 +344,9 @@ gpui::actions!(
         Transpose,
         Undo,
         UndoSelection,
+        UnfoldAll,
         UnfoldLines,
+        UnfoldRecursive,
         UniqueLinesCaseInsensitive,
         UniqueLinesCaseSensitive,
     ]
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index b7f825df9eec60..44de6014ec8137 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -10551,17 +10551,79 @@ impl Editor {
         }
     }
 
-    pub fn fold(&mut self, _: &actions::Fold, cx: &mut ViewContext<Self>) {
-        let mut fold_ranges = Vec::new();
+    pub fn toggle_fold(&mut self, _: &actions::ToggleFold, cx: &mut ViewContext<Self>) {
+        let selection = self.selections.newest::<Point>(cx);
+
+        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
+        let range = if selection.is_empty() {
+            let point = selection.head().to_display_point(&display_map);
+            let start = DisplayPoint::new(point.row(), 0).to_point(&display_map);
+            let end = DisplayPoint::new(point.row(), display_map.line_len(point.row()))
+                .to_point(&display_map);
+            start..end
+        } else {
+            selection.range()
+        };
+        if display_map.folds_in_range(range).next().is_some() {
+            self.unfold_lines(&Default::default(), cx)
+        } else {
+            self.fold(&Default::default(), cx)
+        }
+    }
+
+    pub fn toggle_fold_recursive(
+        &mut self,
+        _: &actions::ToggleFoldRecursive,
+        cx: &mut ViewContext<Self>,
+    ) {
+        let selection = self.selections.newest::<Point>(cx);
 
         let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
+        let range = if selection.is_empty() {
+            let point = selection.head().to_display_point(&display_map);
+            let start = DisplayPoint::new(point.row(), 0).to_point(&display_map);
+            let end = DisplayPoint::new(point.row(), display_map.line_len(point.row()))
+                .to_point(&display_map);
+            start..end
+        } else {
+            selection.range()
+        };
+        if display_map.folds_in_range(range).next().is_some() {
+            self.unfold_recursive(&Default::default(), cx)
+        } else {
+            self.fold_recursive(&Default::default(), cx)
+        }
+    }
 
+    pub fn fold(&mut self, _: &actions::Fold, cx: &mut ViewContext<Self>) {
+        let mut fold_ranges = Vec::new();
+        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
         let selections = self.selections.all_adjusted(cx);
+
         for selection in selections {
             let range = selection.range().sorted();
             let buffer_start_row = range.start.row;
 
-            for row in (0..=range.end.row).rev() {
+            if range.start.row != range.end.row {
+                let mut found = false;
+                let mut row = range.start.row;
+                while row <= range.end.row {
+                    if let Some((foldable_range, fold_text)) =
+                        { display_map.foldable_range(MultiBufferRow(row)) }
+                    {
+                        found = true;
+                        row = foldable_range.end.row + 1;
+                        fold_ranges.push((foldable_range, fold_text));
+                    } else {
+                        row += 1
+                    }
+                }
+                if found {
+                    continue;
+                }
+            }
+
+            for row in (0..=range.start.row).rev() {
                 if let Some((foldable_range, fold_text)) =
                     display_map.foldable_range(MultiBufferRow(row))
                 {
@@ -10578,6 +10640,61 @@ impl Editor {
         self.fold_ranges(fold_ranges, true, cx);
     }
 
+    pub fn fold_all(&mut self, _: &actions::FoldAll, cx: &mut ViewContext<Self>) {
+        let mut fold_ranges = Vec::new();
+        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
+
+        for row in 0..display_map.max_buffer_row().0 {
+            if let Some((foldable_range, fold_text)) =
+                display_map.foldable_range(MultiBufferRow(row))
+            {
+                fold_ranges.push((foldable_range, fold_text));
+            }
+        }
+
+        self.fold_ranges(fold_ranges, true, cx);
+    }
+
+    pub fn fold_recursive(&mut self, _: &actions::FoldRecursive, cx: &mut ViewContext<Self>) {
+        let mut fold_ranges = Vec::new();
+        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
+        let selections = self.selections.all_adjusted(cx);
+
+        for selection in selections {
+            let range = selection.range().sorted();
+            let buffer_start_row = range.start.row;
+
+            if range.start.row != range.end.row {
+                let mut found = false;
+                for row in range.start.row..=range.end.row {
+                    if let Some((foldable_range, fold_text)) =
+                        { display_map.foldable_range(MultiBufferRow(row)) }
+                    {
+                        found = true;
+                        fold_ranges.push((foldable_range, fold_text));
+                    }
+                }
+                if found {
+                    continue;
+                }
+            }
+
+            for row in (0..=range.start.row).rev() {
+                if let Some((foldable_range, fold_text)) =
+                    display_map.foldable_range(MultiBufferRow(row))
+                {
+                    if foldable_range.end.row >= buffer_start_row {
+                        fold_ranges.push((foldable_range, fold_text));
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+
+        self.fold_ranges(fold_ranges, true, cx);
+    }
+
     pub fn fold_at(&mut self, fold_at: &FoldAt, cx: &mut ViewContext<Self>) {
         let buffer_row = fold_at.buffer_row;
         let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
@@ -10612,6 +10729,24 @@ impl Editor {
         self.unfold_ranges(ranges, true, true, cx);
     }
 
+    pub fn unfold_recursive(&mut self, _: &UnfoldRecursive, cx: &mut ViewContext<Self>) {
+        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
+        let selections = self.selections.all::<Point>(cx);
+        let ranges = selections
+            .iter()
+            .map(|s| {
+                let mut range = s.display_range(&display_map).sorted();
+                *range.start.column_mut() = 0;
+                *range.end.column_mut() = display_map.line_len(range.end.row());
+                let start = range.start.to_point(&display_map);
+                let end = range.end.to_point(&display_map);
+                start..end
+            })
+            .collect::<Vec<_>>();
+
+        self.unfold_ranges(ranges, true, true, cx);
+    }
+
     pub fn unfold_at(&mut self, unfold_at: &UnfoldAt, cx: &mut ViewContext<Self>) {
         let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
 
@@ -10630,6 +10765,16 @@ impl Editor {
         self.unfold_ranges(std::iter::once(intersection_range), true, autoscroll, cx)
     }
 
+    pub fn unfold_all(&mut self, _: &actions::UnfoldAll, cx: &mut ViewContext<Self>) {
+        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
+        self.unfold_ranges(
+            [Point::zero()..display_map.max_point().to_point(&display_map)],
+            true,
+            true,
+            cx,
+        );
+    }
+
     pub fn fold_selected_ranges(&mut self, _: &FoldSelectedRanges, cx: &mut ViewContext<Self>) {
         let selections = self.selections.all::<Point>(cx);
         let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index de1b12abe00778..31a69918026f72 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -852,7 +852,7 @@ fn test_fold_action(cx: &mut TestAppContext) {
     _ = view.update(cx, |view, cx| {
         view.change_selections(None, cx, |s| {
             s.select_display_ranges([
-                DisplayPoint::new(DisplayRow(8), 0)..DisplayPoint::new(DisplayRow(12), 0)
+                DisplayPoint::new(DisplayRow(7), 0)..DisplayPoint::new(DisplayRow(12), 0)
             ]);
         });
         view.fold(&Fold, cx);
@@ -940,7 +940,7 @@ fn test_fold_action_whitespace_sensitive_language(cx: &mut TestAppContext) {
     _ = view.update(cx, |view, cx| {
         view.change_selections(None, cx, |s| {
             s.select_display_ranges([
-                DisplayPoint::new(DisplayRow(7), 0)..DisplayPoint::new(DisplayRow(10), 0)
+                DisplayPoint::new(DisplayRow(6), 0)..DisplayPoint::new(DisplayRow(10), 0)
             ]);
         });
         view.fold(&Fold, cx);
@@ -1022,7 +1022,7 @@ fn test_fold_action_multiple_line_breaks(cx: &mut TestAppContext) {
     _ = view.update(cx, |view, cx| {
         view.change_selections(None, cx, |s| {
             s.select_display_ranges([
-                DisplayPoint::new(DisplayRow(7), 0)..DisplayPoint::new(DisplayRow(11), 0)
+                DisplayPoint::new(DisplayRow(6), 0)..DisplayPoint::new(DisplayRow(11), 0)
             ]);
         });
         view.fold(&Fold, cx);
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index bad16b225f3298..e5c067e37ec3dc 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -335,8 +335,14 @@ impl EditorElement {
         register_action(view, cx, Editor::open_url);
         register_action(view, cx, Editor::open_file);
         register_action(view, cx, Editor::fold);
+        register_action(view, cx, Editor::fold_all);
         register_action(view, cx, Editor::fold_at);
+        register_action(view, cx, Editor::fold_recursive);
+        register_action(view, cx, Editor::toggle_fold);
+        register_action(view, cx, Editor::toggle_fold_recursive);
         register_action(view, cx, Editor::unfold_lines);
+        register_action(view, cx, Editor::unfold_recursive);
+        register_action(view, cx, Editor::unfold_all);
         register_action(view, cx, Editor::unfold_at);
         register_action(view, cx, Editor::fold_selected_ranges);
         register_action(view, cx, Editor::show_completions);

From 02d05615866a35da38e31630ac41c61aaf64a59d Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Fri, 27 Sep 2024 00:36:17 -0600
Subject: [PATCH 365/762] Fix read timeout for ollama (#18417)

Supercedes: #18310

Release Notes:

- Fixed `low_speed_timeout_in_seconds` for Ollama
---
 crates/ollama/src/ollama.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/crates/ollama/src/ollama.rs b/crates/ollama/src/ollama.rs
index 84404afce13b10..a38b9e7a564512 100644
--- a/crates/ollama/src/ollama.rs
+++ b/crates/ollama/src/ollama.rs
@@ -1,6 +1,6 @@
 use anyhow::{anyhow, Context, Result};
 use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, StreamExt};
-use http_client::{http, AsyncBody, HttpClient, Method, Request as HttpRequest};
+use http_client::{http, AsyncBody, HttpClient, HttpRequestExt, Method, Request as HttpRequest};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_json::{value::RawValue, Value};
@@ -262,14 +262,18 @@ pub async fn stream_chat_completion(
     client: &dyn HttpClient,
     api_url: &str,
     request: ChatRequest,
-    _: Option<Duration>,
+    low_speed_timeout: Option<Duration>,
 ) -> Result<BoxStream<'static, Result<ChatResponseDelta>>> {
     let uri = format!("{api_url}/api/chat");
-    let request_builder = http::Request::builder()
+    let mut request_builder = http::Request::builder()
         .method(Method::POST)
         .uri(uri)
         .header("Content-Type", "application/json");
 
+    if let Some(low_speed_timeout) = low_speed_timeout {
+        request_builder = request_builder.read_timeout(low_speed_timeout);
+    }
+
     let request = request_builder.body(AsyncBody::from(serde_json::to_string(&request)?))?;
     let mut response = client.send(request).await?;
     if response.status().is_success() {

From 8559731e0d5bb570dcbb427746d10299d12e2889 Mon Sep 17 00:00:00 2001
From: CharlesChen0823 <yongchen0823@gmail.com>
Date: Fri, 27 Sep 2024 14:55:35 +0800
Subject: [PATCH 366/762] project: Fix worktree store event missing in remote
 projects (#18376)

Release Notes:

- N/A
---
 crates/project/src/project.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index fa373af61951be..b91250e6b2c4a3 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -886,6 +886,9 @@ impl Project {
             cx.spawn(move |this, cx| Self::send_buffer_ordered_messages(this, rx, cx))
                 .detach();
 
+            cx.subscribe(&worktree_store, Self::on_worktree_store_event)
+                .detach();
+
             cx.subscribe(&buffer_store, Self::on_buffer_store_event)
                 .detach();
             cx.subscribe(&lsp_store, Self::on_lsp_store_event).detach();

From 5199135b54c98d571af8d9cc16635fd94a0b85ac Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Fri, 27 Sep 2024 09:31:45 +0200
Subject: [PATCH 367/762] ssh remoting: Show error if opening connection timed
 out (#18401)

This shows an error if opening a connection to a remote host didn't work
in the timeout of 10s (maybe we'll need to make that configurable in the
future? for now it seems fine.)

![screenshot-2024-09-26-18 01
07@2x](https://github.com/user-attachments/assets/cbfa0e9f-9c29-4b6c-bade-07fdd7393c9d)


Release Notes:

- N/A

---------

Co-authored-by: Bennet <bennet@zed.dev>
Co-authored-by: Conrad <conrad@zed.dev>
---
 crates/recent_projects/src/ssh_connections.rs |  55 +++++++---
 crates/remote/src/ssh_session.rs              | 101 +++++++++++++-----
 2 files changed, 115 insertions(+), 41 deletions(-)

diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 1722c58f075399..dd30f15f267fc7 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -16,8 +16,9 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 use ui::{
-    h_flex, v_flex, FluentBuilder as _, Icon, IconName, IconSize, InteractiveElement, IntoElement,
-    Label, LabelCommon, Styled, StyledExt as _, ViewContext, VisualContext, WindowContext,
+    h_flex, v_flex, Color, FluentBuilder as _, Icon, IconName, IconSize, InteractiveElement,
+    IntoElement, Label, LabelCommon, Styled, StyledExt as _, ViewContext, VisualContext,
+    WindowContext,
 };
 use workspace::{AppState, ModalView, Workspace};
 
@@ -79,6 +80,7 @@ impl Settings for SshSettings {
 pub struct SshPrompt {
     connection_string: SharedString,
     status_message: Option<SharedString>,
+    error_message: Option<SharedString>,
     prompt: Option<(SharedString, oneshot::Sender<Result<String>>)>,
     editor: View<Editor>,
 }
@@ -92,6 +94,7 @@ impl SshPrompt {
         Self {
             connection_string,
             status_message: None,
+            error_message: None,
             prompt: None,
             editor: cx.new_view(Editor::single_line),
         }
@@ -121,6 +124,11 @@ impl SshPrompt {
         cx.notify();
     }
 
+    pub fn set_error(&mut self, error_message: String, cx: &mut ViewContext<Self>) {
+        self.error_message = Some(error_message.into());
+        cx.notify();
+    }
+
     pub fn confirm(&mut self, cx: &mut ViewContext<Self>) {
         if let Some((_, tx)) = self.prompt.take() {
             self.editor.update(cx, |editor, cx| {
@@ -140,7 +148,12 @@ impl Render for SshPrompt {
             .child(
                 h_flex()
                     .gap_2()
-                    .child(
+                    .child(if self.error_message.is_some() {
+                        Icon::new(IconName::XCircle)
+                            .size(IconSize::Medium)
+                            .color(Color::Error)
+                            .into_any_element()
+                    } else {
                         Icon::new(IconName::ArrowCircle)
                             .size(IconSize::Medium)
                             .with_animation(
@@ -149,16 +162,21 @@ impl Render for SshPrompt {
                                 |icon, delta| {
                                     icon.transform(Transformation::rotate(percentage(delta)))
                                 },
-                            ),
-                    )
+                            )
+                            .into_any_element()
+                    })
                     .child(
                         Label::new(format!("ssh {}…", self.connection_string))
                             .size(ui::LabelSize::Large),
                     ),
             )
-            .when_some(self.status_message.as_ref(), |el, status| {
-                el.child(Label::new(status.clone()))
+            .when_some(self.error_message.as_ref(), |el, error| {
+                el.child(Label::new(error.clone()))
             })
+            .when(
+                self.error_message.is_none() && self.status_message.is_some(),
+                |el| el.child(Label::new(self.status_message.clone().unwrap())),
+            )
             .when_some(self.prompt.as_ref(), |el, prompt| {
                 el.child(Label::new(prompt.0.clone()))
                     .child(self.editor.clone())
@@ -238,6 +256,10 @@ impl remote::SshClientDelegate for SshClientDelegate {
         self.update_status(status, cx)
     }
 
+    fn set_error(&self, error: String, cx: &mut AsyncAppContext) {
+        self.update_error(error, cx)
+    }
+
     fn get_server_binary(
         &self,
         platform: SshPlatform,
@@ -270,6 +292,16 @@ impl SshClientDelegate {
             .ok();
     }
 
+    fn update_error(&self, error: String, cx: &mut AsyncAppContext) {
+        self.window
+            .update(cx, |_, cx| {
+                self.ui.update(cx, |modal, cx| {
+                    modal.set_error(error, cx);
+                })
+            })
+            .ok();
+    }
+
     async fn get_server_binary_impl(
         &self,
         platform: SshPlatform,
@@ -388,7 +420,7 @@ pub async fn open_ssh_project(
         })?
     };
 
-    let result = window
+    let session = window
         .update(cx, |workspace, cx| {
             cx.activate_window();
             workspace.toggle_modal(cx, |cx| SshConnectionModal::new(&connection_options, cx));
@@ -400,12 +432,7 @@ pub async fn open_ssh_project(
                 .clone();
             connect_over_ssh(connection_options.clone(), ui, cx)
         })?
-        .await;
-
-    if result.is_err() {
-        window.update(cx, |_, cx| cx.remove_window()).ok();
-    }
-    let session = result?;
+        .await?;
 
     cx.update(|cx| {
         workspace::open_ssh_project(window, connection_options, session, app_state, paths, cx)
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 06a7f810e67210..915595fd9d2957 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -129,6 +129,7 @@ pub trait SshClientDelegate {
         cx: &mut AsyncAppContext,
     ) -> oneshot::Receiver<Result<(PathBuf, SemanticVersion)>>;
     fn set_status(&self, status: Option<&str>, cx: &mut AsyncAppContext);
+    fn set_error(&self, error_message: String, cx: &mut AsyncAppContext);
 }
 
 type ResponseChannels = Mutex<HashMap<MessageId, oneshot::Sender<(Envelope, oneshot::Sender<()>)>>>;
@@ -208,16 +209,16 @@ impl SshSession {
 
                     result = child_stdout.read(&mut stdout_buffer).fuse() => {
                         match result {
-                            Ok(len) => {
-                                if len == 0 {
-                                    child_stdin.close().await?;
-                                    let status = remote_server_child.status().await?;
-                                    if !status.success() {
-                                        log::info!("channel exited with status: {status:?}");
-                                    }
-                                    return Ok(());
+                            Ok(0) => {
+                                child_stdin.close().await?;
+                                outgoing_rx.close();
+                                let status = remote_server_child.status().await?;
+                                if !status.success() {
+                                    log::error!("channel exited with status: {status:?}");
                                 }
-
+                                return Ok(());
+                            }
+                            Ok(len) => {
                                 if len < stdout_buffer.len() {
                                     child_stdout.read_exact(&mut stdout_buffer[len..]).await?;
                                 }
@@ -419,8 +420,13 @@ impl SshSession {
         let mut response_channels_lock = self.response_channels.lock();
         response_channels_lock.insert(MessageId(envelope.id), tx);
         drop(response_channels_lock);
-        self.outgoing_tx.unbounded_send(envelope).ok();
+        let result = self.outgoing_tx.unbounded_send(envelope);
         async move {
+            if let Err(error) = &result {
+                log::error!("failed to send message: {}", error);
+                return Err(anyhow!("failed to send message: {}", error));
+            }
+
             let response = rx.await.context("connection lost")?.0;
             if let Some(proto::envelope::Payload::Error(error)) = &response.payload {
                 return Err(RpcError::from_proto(error, type_name));
@@ -525,22 +531,25 @@ impl SshClientState {
         let listener =
             UnixListener::bind(&askpass_socket).context("failed to create askpass socket")?;
 
-        let askpass_task = cx.spawn(|mut cx| async move {
-            while let Ok((mut stream, _)) = listener.accept().await {
-                let mut buffer = Vec::new();
-                let mut reader = BufReader::new(&mut stream);
-                if reader.read_until(b'\0', &mut buffer).await.is_err() {
-                    buffer.clear();
-                }
-                let password_prompt = String::from_utf8_lossy(&buffer);
-                if let Some(password) = delegate
-                    .ask_password(password_prompt.to_string(), &mut cx)
-                    .await
-                    .context("failed to get ssh password")
-                    .and_then(|p| p)
-                    .log_err()
-                {
-                    stream.write_all(password.as_bytes()).await.log_err();
+        let askpass_task = cx.spawn({
+            let delegate = delegate.clone();
+            |mut cx| async move {
+                while let Ok((mut stream, _)) = listener.accept().await {
+                    let mut buffer = Vec::new();
+                    let mut reader = BufReader::new(&mut stream);
+                    if reader.read_until(b'\0', &mut buffer).await.is_err() {
+                        buffer.clear();
+                    }
+                    let password_prompt = String::from_utf8_lossy(&buffer);
+                    if let Some(password) = delegate
+                        .ask_password(password_prompt.to_string(), &mut cx)
+                        .await
+                        .context("failed to get ssh password")
+                        .and_then(|p| p)
+                        .log_err()
+                    {
+                        stream.write_all(password.as_bytes()).await.log_err();
+                    }
                 }
             }
         });
@@ -575,7 +584,22 @@ impl SshClientState {
         // has completed.
         let stdout = master_process.stdout.as_mut().unwrap();
         let mut output = Vec::new();
-        stdout.read_to_end(&mut output).await?;
+        let connection_timeout = std::time::Duration::from_secs(10);
+        let result = read_with_timeout(stdout, connection_timeout, &mut output).await;
+        if let Err(e) = result {
+            let error_message = if e.kind() == std::io::ErrorKind::TimedOut {
+                format!(
+                    "Failed to connect to host. Timed out after {:?}.",
+                    connection_timeout
+                )
+            } else {
+                format!("Failed to connect to host: {}.", e)
+            };
+
+            delegate.set_error(error_message, cx);
+            return Err(e.into());
+        }
+
         drop(askpass_task);
 
         if master_process.try_status()?.is_some() {
@@ -716,6 +740,29 @@ impl SshClientState {
     }
 }
 
+#[cfg(unix)]
+async fn read_with_timeout(
+    stdout: &mut process::ChildStdout,
+    timeout: std::time::Duration,
+    output: &mut Vec<u8>,
+) -> Result<(), std::io::Error> {
+    smol::future::or(
+        async {
+            stdout.read_to_end(output).await?;
+            Ok::<_, std::io::Error>(())
+        },
+        async {
+            smol::Timer::after(timeout).await;
+
+            Err(std::io::Error::new(
+                std::io::ErrorKind::TimedOut,
+                "Read operation timed out",
+            ))
+        },
+    )
+    .await
+}
+
 impl Drop for SshClientState {
     fn drop(&mut self) {
         if let Err(error) = self.master_process.kill() {

From 568a21a7009ea41c93a97a3382874c3f62816889 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Fri, 27 Sep 2024 10:48:34 +0300
Subject: [PATCH 368/762] Fix the numeration in line wrap docs (#18428)

Follow-up of https://github.com/zed-industries/zed/pull/18412

Release Notes:

- N/A

Co-authored-by: Thorsten Ball <thorsten@zed.dev>
---
 assets/settings/default.json | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index b3be17ad2cedcf..82778dc8f6c484 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -535,14 +535,14 @@
   // How to soft-wrap long lines of text.
   // Possible values:
   //
-  // 2. Prefer a single line generally, unless an overly long line is encountered.
+  // 1. Prefer a single line generally, unless an overly long line is encountered.
   //      "soft_wrap": "none",
   //      "soft_wrap": "prefer_line", // (deprecated, same as "none")
-  // 3. Soft wrap lines that overflow the editor.
+  // 2. Soft wrap lines that overflow the editor.
   //      "soft_wrap": "editor_width",
-  // 4. Soft wrap lines at the preferred line length.
+  // 3. Soft wrap lines at the preferred line length.
   //      "soft_wrap": "preferred_line_length",
-  // 5. Soft wrap lines at the preferred line length or the editor width (whichever is smaller).
+  // 4. Soft wrap lines at the preferred line length or the editor width (whichever is smaller).
   //      "soft_wrap": "bounded",
   "soft_wrap": "none",
   // The column at which to soft-wrap lines, for buffers where soft-wrap

From a1d2e1106e15aeb072827170f79950f6ce02fd8d Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Fri, 27 Sep 2024 10:51:49 +0200
Subject: [PATCH 369/762] assistant: Fix copy/cut not working when selection is
 empty (#18403)

Release Notes:

- Fixed copy/cut/paste not working in the assistant panel when selection
was empty
---
 crates/assistant/src/assistant_panel.rs | 108 ++++++++++++++----------
 1 file changed, 63 insertions(+), 45 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index c7a06b428b9f1a..15f9e5c59dfef9 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -72,6 +72,7 @@ use std::{
     time::Duration,
 };
 use terminal_view::{terminal_panel::TerminalPanel, TerminalView};
+use text::SelectionGoal;
 use ui::TintColor;
 use ui::{
     prelude::*,
@@ -3438,7 +3439,7 @@ impl ContextEditor {
 
     fn copy(&mut self, _: &editor::actions::Copy, cx: &mut ViewContext<Self>) {
         if self.editor.read(cx).selections.count() == 1 {
-            let (copied_text, metadata) = self.get_clipboard_contents(cx);
+            let (copied_text, metadata, _) = self.get_clipboard_contents(cx);
             cx.write_to_clipboard(ClipboardItem::new_string_with_json_metadata(
                 copied_text,
                 metadata,
@@ -3452,11 +3453,9 @@ impl ContextEditor {
 
     fn cut(&mut self, _: &editor::actions::Cut, cx: &mut ViewContext<Self>) {
         if self.editor.read(cx).selections.count() == 1 {
-            let (copied_text, metadata) = self.get_clipboard_contents(cx);
+            let (copied_text, metadata, selections) = self.get_clipboard_contents(cx);
 
             self.editor.update(cx, |editor, cx| {
-                let selections = editor.selections.all::<Point>(cx);
-
                 editor.transact(cx, |this, cx| {
                     this.change_selections(Some(Autoscroll::fit()), cx, |s| {
                         s.select(selections);
@@ -3476,52 +3475,71 @@ impl ContextEditor {
         cx.propagate();
     }
 
-    fn get_clipboard_contents(&mut self, cx: &mut ViewContext<Self>) -> (String, CopyMetadata) {
-        let creases = self.editor.update(cx, |editor, cx| {
-            let selection = editor.selections.newest::<Point>(cx);
-            let selection_start = editor.selections.newest::<usize>(cx).start;
+    fn get_clipboard_contents(
+        &mut self,
+        cx: &mut ViewContext<Self>,
+    ) -> (String, CopyMetadata, Vec<text::Selection<usize>>) {
+        let (snapshot, selection, creases) = self.editor.update(cx, |editor, cx| {
+            let mut selection = editor.selections.newest::<Point>(cx);
             let snapshot = editor.buffer().read(cx).snapshot(cx);
-            editor.display_map.update(cx, |display_map, cx| {
-                display_map
-                    .snapshot(cx)
-                    .crease_snapshot
-                    .creases_in_range(
-                        MultiBufferRow(selection.start.row)..MultiBufferRow(selection.end.row + 1),
-                        &snapshot,
-                    )
-                    .filter_map(|crease| {
-                        if let Some(metadata) = &crease.metadata {
-                            let start = crease
-                                .range
-                                .start
-                                .to_offset(&snapshot)
-                                .saturating_sub(selection_start);
-                            let end = crease
-                                .range
-                                .end
-                                .to_offset(&snapshot)
-                                .saturating_sub(selection_start);
-
-                            let range_relative_to_selection = start..end;
-
-                            if range_relative_to_selection.is_empty() {
-                                None
+
+            let is_entire_line = selection.is_empty() || editor.selections.line_mode;
+            if is_entire_line {
+                selection.start = Point::new(selection.start.row, 0);
+                selection.end =
+                    cmp::min(snapshot.max_point(), Point::new(selection.start.row + 1, 0));
+                selection.goal = SelectionGoal::None;
+            }
+
+            let selection_start = snapshot.point_to_offset(selection.start);
+
+            (
+                snapshot.clone(),
+                selection.clone(),
+                editor.display_map.update(cx, |display_map, cx| {
+                    display_map
+                        .snapshot(cx)
+                        .crease_snapshot
+                        .creases_in_range(
+                            MultiBufferRow(selection.start.row)
+                                ..MultiBufferRow(selection.end.row + 1),
+                            &snapshot,
+                        )
+                        .filter_map(|crease| {
+                            if let Some(metadata) = &crease.metadata {
+                                let start = crease
+                                    .range
+                                    .start
+                                    .to_offset(&snapshot)
+                                    .saturating_sub(selection_start);
+                                let end = crease
+                                    .range
+                                    .end
+                                    .to_offset(&snapshot)
+                                    .saturating_sub(selection_start);
+
+                                let range_relative_to_selection = start..end;
+
+                                if range_relative_to_selection.is_empty() {
+                                    None
+                                } else {
+                                    Some(SelectedCreaseMetadata {
+                                        range_relative_to_selection,
+                                        crease: metadata.clone(),
+                                    })
+                                }
                             } else {
-                                Some(SelectedCreaseMetadata {
-                                    range_relative_to_selection,
-                                    crease: metadata.clone(),
-                                })
+                                None
                             }
-                        } else {
-                            None
-                        }
-                    })
-                    .collect::<Vec<_>>()
-            })
+                        })
+                        .collect::<Vec<_>>()
+                }),
+            )
         });
 
+        let selection = selection.map(|point| snapshot.point_to_offset(point));
         let context = self.context.read(cx);
-        let selection = self.editor.read(cx).selections.newest::<usize>(cx);
+
         let mut text = String::new();
         for message in context.messages(cx) {
             if message.offset_range.start >= selection.range().end {
@@ -3540,7 +3558,7 @@ impl ContextEditor {
             }
         }
 
-        (text, CopyMetadata { creases })
+        (text, CopyMetadata { creases }, vec![selection])
     }
 
     fn paste(&mut self, action: &editor::actions::Paste, cx: &mut ViewContext<Self>) {

From 1c5d9c221a3ec66f496b762fcc720183240bd212 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Fri, 27 Sep 2024 11:06:48 +0200
Subject: [PATCH 370/762] Add missing shortcuts in tooltips (#18282)

Fixes some missing shortcuts from Tooltips like the project search,
buffer search, quick action bar, ....


https://github.com/user-attachments/assets/d3a0160a-8d6e-4ddc-bf82-1fabeca42d59

This should hopefully help new users learn and discover some nice
keyboard shortcuts

Release Notes:

- Display keyboard shortcuts inside tooltips in the project search,
buffer search etc.
---
 assets/keymaps/default-linux.json             |  2 +-
 assets/keymaps/default-macos.json             |  2 +-
 crates/breadcrumbs/src/breadcrumbs.rs         | 35 +++++---
 .../quick_action_bar/src/quick_action_bar.rs  | 15 +++-
 crates/search/src/buffer_search.rs            | 80 ++++++++++++++++---
 crates/search/src/project_search.rs           | 78 ++++++++++++++++--
 crates/search/src/search.rs                   |  5 +-
 crates/search/src/search_bar.rs               |  5 +-
 crates/terminal_view/src/terminal_panel.rs    | 20 ++++-
 9 files changed, 199 insertions(+), 43 deletions(-)

diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index 8d4871d95648db..d33df0274725af 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -196,7 +196,7 @@
     }
   },
   {
-    "context": "BufferSearchBar && in_replace",
+    "context": "BufferSearchBar && in_replace > Editor",
     "bindings": {
       "enter": "search::ReplaceNext",
       "ctrl-enter": "search::ReplaceAll"
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index a980ae14e22a95..b405ee18528431 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -232,7 +232,7 @@
     }
   },
   {
-    "context": "BufferSearchBar && in_replace",
+    "context": "BufferSearchBar && in_replace > Editor",
     "bindings": {
       "enter": "search::ReplaceNext",
       "cmd-enter": "search::ReplaceAll"
diff --git a/crates/breadcrumbs/src/breadcrumbs.rs b/crates/breadcrumbs/src/breadcrumbs.rs
index 93ebfa06435843..09b29c0436f6ed 100644
--- a/crates/breadcrumbs/src/breadcrumbs.rs
+++ b/crates/breadcrumbs/src/breadcrumbs.rs
@@ -1,7 +1,7 @@
 use editor::Editor;
 use gpui::{
-    Element, EventEmitter, IntoElement, ParentElement, Render, StyledText, Subscription,
-    ViewContext,
+    Element, EventEmitter, FocusableView, IntoElement, ParentElement, Render, StyledText,
+    Subscription, ViewContext,
 };
 use itertools::Itertools;
 use std::cmp;
@@ -90,17 +90,30 @@ impl Render for Breadcrumbs {
                 ButtonLike::new("toggle outline view")
                     .child(breadcrumbs_stack)
                     .style(ButtonStyle::Transparent)
-                    .on_click(move |_, cx| {
-                        if let Some(editor) = editor.upgrade() {
-                            outline::toggle(editor, &editor::actions::ToggleOutline, cx)
+                    .on_click({
+                        let editor = editor.clone();
+                        move |_, cx| {
+                            if let Some(editor) = editor.upgrade() {
+                                outline::toggle(editor, &editor::actions::ToggleOutline, cx)
+                            }
                         }
                     })
-                    .tooltip(|cx| {
-                        Tooltip::for_action(
-                            "Show symbol outline",
-                            &editor::actions::ToggleOutline,
-                            cx,
-                        )
+                    .tooltip(move |cx| {
+                        if let Some(editor) = editor.upgrade() {
+                            let focus_handle = editor.read(cx).focus_handle(cx);
+                            Tooltip::for_action_in(
+                                "Show symbol outline",
+                                &editor::actions::ToggleOutline,
+                                &focus_handle,
+                                cx,
+                            )
+                        } else {
+                            Tooltip::for_action(
+                                "Show symbol outline",
+                                &editor::actions::ToggleOutline,
+                                cx,
+                            )
+                        }
                     }),
             ),
             None => element
diff --git a/crates/quick_action_bar/src/quick_action_bar.rs b/crates/quick_action_bar/src/quick_action_bar.rs
index 57418b54b7e05a..fb05065a19fc18 100644
--- a/crates/quick_action_bar/src/quick_action_bar.rs
+++ b/crates/quick_action_bar/src/quick_action_bar.rs
@@ -8,8 +8,8 @@ use editor::actions::{
 use editor::{Editor, EditorSettings};
 
 use gpui::{
-    Action, AnchorCorner, ClickEvent, ElementId, EventEmitter, InteractiveElement, ParentElement,
-    Render, Styled, Subscription, View, ViewContext, WeakView,
+    Action, AnchorCorner, ClickEvent, ElementId, EventEmitter, FocusHandle, FocusableView,
+    InteractiveElement, ParentElement, Render, Styled, Subscription, View, ViewContext, WeakView,
 };
 use search::{buffer_search, BufferSearchBar};
 use settings::{Settings, SettingsStore};
@@ -110,12 +110,15 @@ impl Render for QuickActionBar {
             )
         };
 
+        let focus_handle = editor.read(cx).focus_handle(cx);
+
         let search_button = editor.is_singleton(cx).then(|| {
             QuickActionBarButton::new(
                 "toggle buffer search",
                 IconName::MagnifyingGlass,
                 !self.buffer_search_bar.read(cx).is_dismissed(),
                 Box::new(buffer_search::Deploy::find()),
+                focus_handle.clone(),
                 "Buffer Search",
                 {
                     let buffer_search_bar = self.buffer_search_bar.clone();
@@ -133,6 +136,7 @@ impl Render for QuickActionBar {
             IconName::ZedAssistant,
             false,
             Box::new(InlineAssist::default()),
+            focus_handle.clone(),
             "Inline Assist",
             {
                 let workspace = self.workspace.clone();
@@ -321,6 +325,7 @@ struct QuickActionBarButton {
     icon: IconName,
     toggled: bool,
     action: Box<dyn Action>,
+    focus_handle: FocusHandle,
     tooltip: SharedString,
     on_click: Box<dyn Fn(&ClickEvent, &mut WindowContext)>,
 }
@@ -331,6 +336,7 @@ impl QuickActionBarButton {
         icon: IconName,
         toggled: bool,
         action: Box<dyn Action>,
+        focus_handle: FocusHandle,
         tooltip: impl Into<SharedString>,
         on_click: impl Fn(&ClickEvent, &mut WindowContext) + 'static,
     ) -> Self {
@@ -339,6 +345,7 @@ impl QuickActionBarButton {
             icon,
             toggled,
             action,
+            focus_handle,
             tooltip: tooltip.into(),
             on_click: Box::new(on_click),
         }
@@ -355,7 +362,9 @@ impl RenderOnce for QuickActionBarButton {
             .icon_size(IconSize::Small)
             .style(ButtonStyle::Subtle)
             .selected(self.toggled)
-            .tooltip(move |cx| Tooltip::for_action(tooltip.clone(), &*action, cx))
+            .tooltip(move |cx| {
+                Tooltip::for_action_in(tooltip.clone(), &*action, &self.focus_handle, cx)
+            })
             .on_click(move |event, cx| (self.on_click)(event, cx))
     }
 }
diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs
index 9ba7dfd7965b15..6e660a963b987d 100644
--- a/crates/search/src/buffer_search.rs
+++ b/crates/search/src/buffer_search.rs
@@ -13,9 +13,10 @@ use editor::{
 };
 use futures::channel::oneshot;
 use gpui::{
-    actions, div, impl_actions, Action, AppContext, ClickEvent, EventEmitter, FocusableView, Hsla,
-    InteractiveElement as _, IntoElement, KeyContext, ParentElement as _, Render, ScrollHandle,
-    Styled, Subscription, Task, TextStyle, View, ViewContext, VisualContext as _, WindowContext,
+    actions, div, impl_actions, Action, AppContext, ClickEvent, EventEmitter, FocusHandle,
+    FocusableView, Hsla, InteractiveElement as _, IntoElement, KeyContext, ParentElement as _,
+    Render, ScrollHandle, Styled, Subscription, Task, TextStyle, View, ViewContext,
+    VisualContext as _, WindowContext,
 };
 use project::{
     search::SearchQuery,
@@ -142,6 +143,8 @@ impl Render for BufferSearchBar {
             return div().id("search_bar");
         }
 
+        let focus_handle = self.focus_handle(cx);
+
         let narrow_mode =
             self.scroll_handle.bounds().size.width / cx.rem_size() < 340. / BASE_REM_SIZE_IN_PX;
         let hide_inline_icons = self.editor_needed_width
@@ -217,6 +220,7 @@ impl Render for BufferSearchBar {
                         div.children(supported_options.case.then(|| {
                             self.render_search_option_button(
                                 SearchOptions::CASE_SENSITIVE,
+                                focus_handle.clone(),
                                 cx.listener(|this, _, cx| {
                                     this.toggle_case_sensitive(&ToggleCaseSensitive, cx)
                                 }),
@@ -225,6 +229,7 @@ impl Render for BufferSearchBar {
                         .children(supported_options.word.then(|| {
                             self.render_search_option_button(
                                 SearchOptions::WHOLE_WORD,
+                                focus_handle.clone(),
                                 cx.listener(|this, _, cx| {
                                     this.toggle_whole_word(&ToggleWholeWord, cx)
                                 }),
@@ -233,6 +238,7 @@ impl Render for BufferSearchBar {
                         .children(supported_options.regex.then(|| {
                             self.render_search_option_button(
                                 SearchOptions::REGEX,
+                                focus_handle.clone(),
                                 cx.listener(|this, _, cx| this.toggle_regex(&ToggleRegex, cx)),
                             )
                         }))
@@ -250,7 +256,17 @@ impl Render for BufferSearchBar {
                         }))
                         .selected(self.replace_enabled)
                         .size(ButtonSize::Compact)
-                        .tooltip(|cx| Tooltip::for_action("Toggle replace", &ToggleReplace, cx)),
+                        .tooltip({
+                            let focus_handle = focus_handle.clone();
+                            move |cx| {
+                                Tooltip::for_action_in(
+                                    "Toggle replace",
+                                    &ToggleReplace,
+                                    &focus_handle,
+                                    cx,
+                                )
+                            }
+                        }),
                 )
             })
             .when(supported_options.selection, |this| {
@@ -268,8 +284,16 @@ impl Render for BufferSearchBar {
                     }))
                     .selected(self.selection_search_enabled)
                     .size(ButtonSize::Compact)
-                    .tooltip(|cx| {
-                        Tooltip::for_action("Toggle search selection", &ToggleSelection, cx)
+                    .tooltip({
+                        let focus_handle = focus_handle.clone();
+                        move |cx| {
+                            Tooltip::for_action_in(
+                                "Toggle search selection",
+                                &ToggleSelection,
+                                &focus_handle,
+                                cx,
+                            )
+                        }
                     }),
                 )
             })
@@ -280,8 +304,16 @@ impl Render for BufferSearchBar {
                         IconButton::new("select-all", ui::IconName::SelectAll)
                             .on_click(|_, cx| cx.dispatch_action(SelectAllMatches.boxed_clone()))
                             .size(ButtonSize::Compact)
-                            .tooltip(|cx| {
-                                Tooltip::for_action("Select all matches", &SelectAllMatches, cx)
+                            .tooltip({
+                                let focus_handle = focus_handle.clone();
+                                move |cx| {
+                                    Tooltip::for_action_in(
+                                        "Select all matches",
+                                        &SelectAllMatches,
+                                        &focus_handle,
+                                        cx,
+                                    )
+                                }
                             }),
                     )
                     .child(render_nav_button(
@@ -289,12 +321,14 @@ impl Render for BufferSearchBar {
                         self.active_match_index.is_some(),
                         "Select previous match",
                         &SelectPrevMatch,
+                        focus_handle.clone(),
                     ))
                     .child(render_nav_button(
                         ui::IconName::ChevronRight,
                         self.active_match_index.is_some(),
                         "Select next match",
                         &SelectNextMatch,
+                        focus_handle.clone(),
                     ))
                     .when(!narrow_mode, |this| {
                         this.child(h_flex().ml_2().min_w(rems_from_px(40.)).child(
@@ -335,8 +369,16 @@ impl Render for BufferSearchBar {
                         .flex_none()
                         .child(
                             IconButton::new("search-replace-next", ui::IconName::ReplaceNext)
-                                .tooltip(move |cx| {
-                                    Tooltip::for_action("Replace next", &ReplaceNext, cx)
+                                .tooltip({
+                                    let focus_handle = focus_handle.clone();
+                                    move |cx| {
+                                        Tooltip::for_action_in(
+                                            "Replace next match",
+                                            &ReplaceNext,
+                                            &focus_handle,
+                                            cx,
+                                        )
+                                    }
                                 })
                                 .on_click(
                                     cx.listener(|this, _, cx| this.replace_next(&ReplaceNext, cx)),
@@ -344,8 +386,16 @@ impl Render for BufferSearchBar {
                         )
                         .child(
                             IconButton::new("search-replace-all", ui::IconName::ReplaceAll)
-                                .tooltip(move |cx| {
-                                    Tooltip::for_action("Replace all", &ReplaceAll, cx)
+                                .tooltip({
+                                    let focus_handle = focus_handle.clone();
+                                    move |cx| {
+                                        Tooltip::for_action_in(
+                                            "Replace all matches",
+                                            &ReplaceAll,
+                                            &focus_handle,
+                                            cx,
+                                        )
+                                    }
                                 })
                                 .on_click(
                                     cx.listener(|this, _, cx| this.replace_all(&ReplaceAll, cx)),
@@ -719,10 +769,11 @@ impl BufferSearchBar {
     fn render_search_option_button(
         &self,
         option: SearchOptions,
+        focus_handle: FocusHandle,
         action: impl Fn(&ClickEvent, &mut WindowContext) + 'static,
     ) -> impl IntoElement {
         let is_active = self.search_options.contains(option);
-        option.as_button(is_active, action)
+        option.as_button(is_active, focus_handle, action)
     }
 
     pub fn focus_editor(&mut self, _: &FocusEditor, cx: &mut ViewContext<Self>) {
@@ -1122,6 +1173,7 @@ impl BufferSearchBar {
         });
         cx.focus(handle);
     }
+
     fn toggle_replace(&mut self, _: &ToggleReplace, cx: &mut ViewContext<Self>) {
         if self.active_searchable_item.is_some() {
             self.replace_enabled = !self.replace_enabled;
@@ -1134,6 +1186,7 @@ impl BufferSearchBar {
             cx.notify();
         }
     }
+
     fn replace_next(&mut self, _: &ReplaceNext, cx: &mut ViewContext<Self>) {
         let mut should_propagate = true;
         if !self.dismissed && self.active_search.is_some() {
@@ -1161,6 +1214,7 @@ impl BufferSearchBar {
             cx.stop_propagation();
         }
     }
+
     pub fn replace_all(&mut self, _: &ReplaceAll, cx: &mut ViewContext<Self>) {
         if !self.dismissed && self.active_search.is_some() {
             if let Some(searchable_item) = self.active_searchable_item.as_ref() {
diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs
index ea94d27daf61d5..12e6ccc12dc496 100644
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -1551,6 +1551,7 @@ impl Render for ProjectSearchBar {
             return div();
         };
         let search = search.read(cx);
+        let focus_handle = search.focus_handle(cx);
 
         let query_column = h_flex()
             .flex_1()
@@ -1571,18 +1572,21 @@ impl Render for ProjectSearchBar {
                 h_flex()
                     .child(SearchOptions::CASE_SENSITIVE.as_button(
                         self.is_option_enabled(SearchOptions::CASE_SENSITIVE, cx),
+                        focus_handle.clone(),
                         cx.listener(|this, _, cx| {
                             this.toggle_search_option(SearchOptions::CASE_SENSITIVE, cx);
                         }),
                     ))
                     .child(SearchOptions::WHOLE_WORD.as_button(
                         self.is_option_enabled(SearchOptions::WHOLE_WORD, cx),
+                        focus_handle.clone(),
                         cx.listener(|this, _, cx| {
                             this.toggle_search_option(SearchOptions::WHOLE_WORD, cx);
                         }),
                     ))
                     .child(SearchOptions::REGEX.as_button(
                         self.is_option_enabled(SearchOptions::REGEX, cx),
+                        focus_handle.clone(),
                         cx.listener(|this, _, cx| {
                             this.toggle_search_option(SearchOptions::REGEX, cx);
                         }),
@@ -1603,7 +1607,17 @@ impl Render for ProjectSearchBar {
                                 .map(|search| search.read(cx).filters_enabled)
                                 .unwrap_or_default(),
                         )
-                        .tooltip(|cx| Tooltip::for_action("Toggle filters", &ToggleFilters, cx)),
+                        .tooltip({
+                            let focus_handle = focus_handle.clone();
+                            move |cx| {
+                                Tooltip::for_action_in(
+                                    "Toggle filters",
+                                    &ToggleFilters,
+                                    &focus_handle,
+                                    cx,
+                                )
+                            }
+                        }),
                 )
                 .child(
                     IconButton::new("project-search-toggle-replace", IconName::Replace)
@@ -1616,7 +1630,17 @@ impl Render for ProjectSearchBar {
                                 .map(|search| search.read(cx).replace_enabled)
                                 .unwrap_or_default(),
                         )
-                        .tooltip(|cx| Tooltip::for_action("Toggle replace", &ToggleReplace, cx)),
+                        .tooltip({
+                            let focus_handle = focus_handle.clone();
+                            move |cx| {
+                                Tooltip::for_action_in(
+                                    "Toggle replace",
+                                    &ToggleReplace,
+                                    &focus_handle,
+                                    cx,
+                                )
+                            }
+                        }),
                 ),
         );
 
@@ -1650,8 +1674,16 @@ impl Render for ProjectSearchBar {
                             })
                         }
                     }))
-                    .tooltip(|cx| {
-                        Tooltip::for_action("Go to previous match", &SelectPrevMatch, cx)
+                    .tooltip({
+                        let focus_handle = focus_handle.clone();
+                        move |cx| {
+                            Tooltip::for_action_in(
+                                "Go to previous match",
+                                &SelectPrevMatch,
+                                &focus_handle,
+                                cx,
+                            )
+                        }
                     }),
             )
             .child(
@@ -1664,7 +1696,17 @@ impl Render for ProjectSearchBar {
                             })
                         }
                     }))
-                    .tooltip(|cx| Tooltip::for_action("Go to next match", &SelectNextMatch, cx)),
+                    .tooltip({
+                        let focus_handle = focus_handle.clone();
+                        move |cx| {
+                            Tooltip::for_action_in(
+                                "Go to next match",
+                                &SelectNextMatch,
+                                &focus_handle,
+                                cx,
+                            )
+                        }
+                    }),
             )
             .child(
                 h_flex()
@@ -1702,6 +1744,7 @@ impl Render for ProjectSearchBar {
                 .border_color(cx.theme().colors().border)
                 .rounded_lg()
                 .child(self.render_text_input(&search.replacement_editor, cx));
+            let focus_handle = search.replacement_editor.read(cx).focus_handle(cx);
             let replace_actions = h_flex().when(search.replace_enabled, |this| {
                 this.child(
                     IconButton::new("project-search-replace-next", IconName::ReplaceNext)
@@ -1712,7 +1755,17 @@ impl Render for ProjectSearchBar {
                                 })
                             }
                         }))
-                        .tooltip(|cx| Tooltip::for_action("Replace next match", &ReplaceNext, cx)),
+                        .tooltip({
+                            let focus_handle = focus_handle.clone();
+                            move |cx| {
+                                Tooltip::for_action_in(
+                                    "Replace next match",
+                                    &ReplaceNext,
+                                    &focus_handle,
+                                    cx,
+                                )
+                            }
+                        }),
                 )
                 .child(
                     IconButton::new("project-search-replace-all", IconName::ReplaceAll)
@@ -1723,7 +1776,17 @@ impl Render for ProjectSearchBar {
                                 })
                             }
                         }))
-                        .tooltip(|cx| Tooltip::for_action("Replace all matches", &ReplaceAll, cx)),
+                        .tooltip({
+                            let focus_handle = focus_handle.clone();
+                            move |cx| {
+                                Tooltip::for_action_in(
+                                    "Replace all matches",
+                                    &ReplaceAll,
+                                    &focus_handle,
+                                    cx,
+                                )
+                            }
+                        }),
                 )
             });
             h_flex()
@@ -1790,6 +1853,7 @@ impl Render for ProjectSearchBar {
                         search
                             .search_options
                             .contains(SearchOptions::INCLUDE_IGNORED),
+                        focus_handle.clone(),
                         cx.listener(|this, _, cx| {
                             this.toggle_search_option(SearchOptions::INCLUDE_IGNORED, cx);
                         }),
diff --git a/crates/search/src/search.rs b/crates/search/src/search.rs
index b99672c532d6bb..d13a12576b0f94 100644
--- a/crates/search/src/search.rs
+++ b/crates/search/src/search.rs
@@ -1,7 +1,7 @@
 use bitflags::bitflags;
 pub use buffer_search::BufferSearchBar;
 use editor::SearchSettings;
-use gpui::{actions, Action, AppContext, IntoElement};
+use gpui::{actions, Action, AppContext, FocusHandle, IntoElement};
 use project::search::SearchQuery;
 pub use project_search::ProjectSearchView;
 use ui::{prelude::*, Tooltip};
@@ -106,6 +106,7 @@ impl SearchOptions {
     pub fn as_button(
         &self,
         active: bool,
+        focus_handle: FocusHandle,
         action: impl Fn(&gpui::ClickEvent, &mut WindowContext) + 'static,
     ) -> impl IntoElement {
         IconButton::new(self.label(), self.icon())
@@ -115,7 +116,7 @@ impl SearchOptions {
             .tooltip({
                 let action = self.to_toggle_action();
                 let label = self.label();
-                move |cx| Tooltip::for_action(label, &*action, cx)
+                move |cx| Tooltip::for_action_in(label, &*action, &focus_handle, cx)
             })
     }
 }
diff --git a/crates/search/src/search_bar.rs b/crates/search/src/search_bar.rs
index 0594036c25483c..102f04c4b95c28 100644
--- a/crates/search/src/search_bar.rs
+++ b/crates/search/src/search_bar.rs
@@ -1,4 +1,4 @@
-use gpui::{Action, IntoElement};
+use gpui::{Action, FocusHandle, IntoElement};
 use ui::IconButton;
 use ui::{prelude::*, Tooltip};
 
@@ -7,12 +7,13 @@ pub(super) fn render_nav_button(
     active: bool,
     tooltip: &'static str,
     action: &'static dyn Action,
+    focus_handle: FocusHandle,
 ) -> impl IntoElement {
     IconButton::new(
         SharedString::from(format!("search-nav-button-{}", action.name())),
         icon,
     )
     .on_click(|_, cx| cx.dispatch_action(action.boxed_clone()))
-    .tooltip(move |cx| Tooltip::for_action(tooltip, action, cx))
+    .tooltip(move |cx| Tooltip::for_action_in(tooltip, action, &focus_handle, cx))
     .disabled(!active)
 }
diff --git a/crates/terminal_view/src/terminal_panel.rs b/crates/terminal_view/src/terminal_panel.rs
index 72f8606fa21765..7d95613804414c 100644
--- a/crates/terminal_view/src/terminal_panel.rs
+++ b/crates/terminal_view/src/terminal_panel.rs
@@ -166,7 +166,16 @@ impl TerminalPanel {
     pub fn asssistant_enabled(&mut self, enabled: bool, cx: &mut ViewContext<Self>) {
         self.assistant_enabled = enabled;
         if enabled {
-            self.assistant_tab_bar_button = Some(cx.new_view(|_| InlineAssistTabBarButton).into());
+            let focus_handle = self
+                .pane
+                .read(cx)
+                .active_item()
+                .map(|item| item.focus_handle(cx))
+                .unwrap_or(self.focus_handle(cx));
+            self.assistant_tab_bar_button = Some(
+                cx.new_view(move |_| InlineAssistTabBarButton { focus_handle })
+                    .into(),
+            );
         } else {
             self.assistant_tab_bar_button = None;
         }
@@ -859,16 +868,21 @@ impl Panel for TerminalPanel {
     }
 }
 
-struct InlineAssistTabBarButton;
+struct InlineAssistTabBarButton {
+    focus_handle: FocusHandle,
+}
 
 impl Render for InlineAssistTabBarButton {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let focus_handle = self.focus_handle.clone();
         IconButton::new("terminal_inline_assistant", IconName::ZedAssistant)
             .icon_size(IconSize::Small)
             .on_click(cx.listener(|_, _, cx| {
                 cx.dispatch_action(InlineAssist::default().boxed_clone());
             }))
-            .tooltip(move |cx| Tooltip::for_action("Inline Assist", &InlineAssist::default(), cx))
+            .tooltip(move |cx| {
+                Tooltip::for_action_in("Inline Assist", &InlineAssist::default(), &focus_handle, cx)
+            })
     }
 }
 

From 73ff8c0f1fd19ffcf93bc0bc2b8ba9d05f5eb935 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Fri, 27 Sep 2024 14:16:14 +0200
Subject: [PATCH 371/762] Fix missing tooltips for selected buttons (#18435)

Reverts #13857. Hiding tooltips for selected buttons prevents tooltips
like "Close x dock" from showing up, see #14938 for an example.
The intention of the original PR was to hide the "Show application menu"
tooltip, while the context menu is open.
In order to fix this without breaking other UI elements, we track the
state of the context menu using `PopoverMenuHandle` now, which allows us
to prevent the tooltip from showing up while the context menu is open.

Closes #14938

Release Notes:

- Fixed an issue where some tooltips would not show up
---
 crates/storybook/src/story_selector.rs        |  4 +++-
 crates/title_bar/src/application_menu.rs      | 24 ++++++++++++-------
 .../title_bar/src/stories/application_menu.rs | 16 ++++++++++---
 crates/title_bar/src/title_bar.rs             | 22 ++++++++++-------
 .../ui/src/components/button/button_like.rs   |  6 ++---
 5 files changed, 47 insertions(+), 25 deletions(-)

diff --git a/crates/storybook/src/story_selector.rs b/crates/storybook/src/story_selector.rs
index 881fd83f8f21b9..3a1c2f56306d89 100644
--- a/crates/storybook/src/story_selector.rs
+++ b/crates/storybook/src/story_selector.rs
@@ -46,7 +46,9 @@ pub enum ComponentStory {
 impl ComponentStory {
     pub fn story(&self, cx: &mut WindowContext) -> AnyView {
         match self {
-            Self::ApplicationMenu => cx.new_view(|_| title_bar::ApplicationMenuStory).into(),
+            Self::ApplicationMenu => cx
+                .new_view(|cx| title_bar::ApplicationMenuStory::new(cx))
+                .into(),
             Self::AutoHeightEditor => AutoHeightEditorStory::new(cx).into(),
             Self::Avatar => cx.new_view(|_| ui::AvatarStory).into(),
             Self::Button => cx.new_view(|_| ui::ButtonStory).into(),
diff --git a/crates/title_bar/src/application_menu.rs b/crates/title_bar/src/application_menu.rs
index 47d4818da5e92b..13ee10c141073e 100644
--- a/crates/title_bar/src/application_menu.rs
+++ b/crates/title_bar/src/application_menu.rs
@@ -1,16 +1,19 @@
-use ui::{prelude::*, ContextMenu, NumericStepper, PopoverMenu, Tooltip};
+use ui::{prelude::*, ContextMenu, NumericStepper, PopoverMenu, PopoverMenuHandle, Tooltip};
 
-#[derive(IntoElement)]
-pub struct ApplicationMenu;
+pub struct ApplicationMenu {
+    context_menu_handle: PopoverMenuHandle<ContextMenu>,
+}
 
 impl ApplicationMenu {
-    pub fn new() -> Self {
-        Self
+    pub fn new(_: &mut ViewContext<Self>) -> Self {
+        Self {
+            context_menu_handle: PopoverMenuHandle::default(),
+        }
     }
 }
 
-impl RenderOnce for ApplicationMenu {
-    fn render(self, _cx: &mut WindowContext) -> impl IntoElement {
+impl Render for ApplicationMenu {
+    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
         PopoverMenu::new("application-menu")
             .menu(move |cx| {
                 ContextMenu::build(cx, move |menu, cx| {
@@ -125,9 +128,12 @@ impl RenderOnce for ApplicationMenu {
             .trigger(
                 IconButton::new("application-menu", ui::IconName::Menu)
                     .style(ButtonStyle::Subtle)
-                    .tooltip(|cx| Tooltip::text("Open Application Menu", cx))
-                    .icon_size(IconSize::Small),
+                    .icon_size(IconSize::Small)
+                    .when(!self.context_menu_handle.is_deployed(), |this| {
+                        this.tooltip(|cx| Tooltip::text("Open Application Menu", cx))
+                    }),
             )
+            .with_handle(self.context_menu_handle.clone())
             .into_any_element()
     }
 }
diff --git a/crates/title_bar/src/stories/application_menu.rs b/crates/title_bar/src/stories/application_menu.rs
index 0b804209fd1a33..c3f8c700ae6f59 100644
--- a/crates/title_bar/src/stories/application_menu.rs
+++ b/crates/title_bar/src/stories/application_menu.rs
@@ -1,11 +1,21 @@
-use gpui::Render;
+use gpui::{Render, View};
 use story::{Story, StoryItem, StorySection};
 
 use ui::prelude::*;
 
 use crate::application_menu::ApplicationMenu;
 
-pub struct ApplicationMenuStory;
+pub struct ApplicationMenuStory {
+    menu: View<ApplicationMenu>,
+}
+
+impl ApplicationMenuStory {
+    pub fn new(cx: &mut WindowContext) -> Self {
+        Self {
+            menu: cx.new_view(ApplicationMenu::new),
+        }
+    }
+}
 
 impl Render for ApplicationMenuStory {
     fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
@@ -13,7 +23,7 @@ impl Render for ApplicationMenuStory {
             .child(Story::title_for::<ApplicationMenu>())
             .child(StorySection::new().child(StoryItem::new(
                 "Application Menu",
-                h_flex().child(ApplicationMenu::new()),
+                h_flex().child(self.menu.clone()),
             )))
     }
 }
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index e2d45a923b7d06..73a82e9ee06201 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -15,7 +15,7 @@ use feature_flags::{FeatureFlagAppExt, ZedPro};
 use gpui::{
     actions, div, px, Action, AnyElement, AppContext, Decorations, Element, InteractiveElement,
     Interactivity, IntoElement, Model, MouseButton, ParentElement, Render, Stateful,
-    StatefulInteractiveElement, Styled, Subscription, ViewContext, VisualContext, WeakView,
+    StatefulInteractiveElement, Styled, Subscription, View, ViewContext, VisualContext, WeakView,
 };
 use project::{Project, RepositoryEntry};
 use recent_projects::RecentProjects;
@@ -65,6 +65,7 @@ pub struct TitleBar {
     client: Arc<Client>,
     workspace: WeakView<Workspace>,
     should_move: bool,
+    application_menu: Option<View<ApplicationMenu>>,
     _subscriptions: Vec<Subscription>,
 }
 
@@ -131,12 +132,7 @@ impl Render for TitleBar {
                     .child(
                         h_flex()
                             .gap_1()
-                            .children(match self.platform_style {
-                                PlatformStyle::Mac => None,
-                                PlatformStyle::Linux | PlatformStyle::Windows => {
-                                    Some(ApplicationMenu::new())
-                                }
-                            })
+                            .when_some(self.application_menu.clone(), |this, menu| this.child(menu))
                             .children(self.render_project_host(cx))
                             .child(self.render_project_name(cx))
                             .children(self.render_project_branch(cx))
@@ -215,6 +211,15 @@ impl TitleBar {
         let user_store = workspace.app_state().user_store.clone();
         let client = workspace.app_state().client.clone();
         let active_call = ActiveCall::global(cx);
+
+        let platform_style = PlatformStyle::platform();
+        let application_menu = match platform_style {
+            PlatformStyle::Mac => None,
+            PlatformStyle::Linux | PlatformStyle::Windows => {
+                Some(cx.new_view(ApplicationMenu::new))
+            }
+        };
+
         let mut subscriptions = Vec::new();
         subscriptions.push(
             cx.observe(&workspace.weak_handle().upgrade().unwrap(), |_, _, cx| {
@@ -227,9 +232,10 @@ impl TitleBar {
         subscriptions.push(cx.observe(&user_store, |_, _, cx| cx.notify()));
 
         Self {
-            platform_style: PlatformStyle::platform(),
+            platform_style,
             content: div().id(id.into()),
             children: SmallVec::new(),
+            application_menu,
             workspace: workspace.weak_handle(),
             should_move: false,
             project,
diff --git a/crates/ui/src/components/button/button_like.rs b/crates/ui/src/components/button/button_like.rs
index 625875e4c9eb92..a22c27d24176d0 100644
--- a/crates/ui/src/components/button/button_like.rs
+++ b/crates/ui/src/components/button/button_like.rs
@@ -523,10 +523,8 @@ impl RenderOnce for ButtonLike {
                         })
                 },
             )
-            .when(!self.selected, |this| {
-                this.when_some(self.tooltip, |this, tooltip| {
-                    this.tooltip(move |cx| tooltip(cx))
-                })
+            .when_some(self.tooltip, |this, tooltip| {
+                this.tooltip(move |cx| tooltip(cx))
             })
             .children(self.children)
     }

From 03c7f085812a2ffddbf0673f04804851f11230ce Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 27 Sep 2024 10:29:49 -0400
Subject: [PATCH 372/762] docs: Ollama api_url improvements (#18440)

---
 docs/src/assistant/configuration.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/src/assistant/configuration.md b/docs/src/assistant/configuration.md
index 17b52a27d88010..9d9c62d8c6bc56 100644
--- a/docs/src/assistant/configuration.md
+++ b/docs/src/assistant/configuration.md
@@ -124,7 +124,7 @@ Download and install Ollama from [ollama.com/download](https://ollama.com/downlo
 
 3. In the assistant panel, select one of the Ollama models using the model dropdown.
 
-4. (Optional) Specify a [custom api_url](#custom-endpoint) or [custom `low_speed_timeout_in_seconds`](#provider-timeout) if required.
+4. (Optional) Specify an [`api_url`](#custom-endpoint) or [`low_speed_timeout_in_seconds`](#provider-timeout) if required.
 
 #### Ollama Context Length {#ollama-context}
 
@@ -138,6 +138,7 @@ Depending on your hardware or use-case you may wish to limit or increase the con
 {
   "language_models": {
     "ollama": {
+      "api_url": "http://localhost:11434",
       "low_speed_timeout_in_seconds": 120,
       "available_models": [
         {

From dc5ffe6994b0f2467164a7e1dd77dada96b64980 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=96mer=20Sinan=20A=C4=9Facan?= <omeragacan@gmail.com>
Date: Fri, 27 Sep 2024 16:55:03 +0200
Subject: [PATCH 373/762] Fix GoToDefinition changing the viewport
 unnecessarily (#18441)

Closes #10738.

Release Notes:

- Fixed `GoToDefinition` changing the viewport (scrolling up/down) even when the definition is already within the viewport. ([#10738](https://github.com/zed-industries/zed/issues/10738))
---
 crates/editor/src/editor.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 44de6014ec8137..cfffa584b6c214 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -9697,7 +9697,7 @@ impl Editor {
                     if Some(&target.buffer) == editor.buffer.read(cx).as_singleton().as_ref() {
                         let buffer = target.buffer.read(cx);
                         let range = check_multiline_range(buffer, range);
-                        editor.change_selections(Some(Autoscroll::focused()), cx, |s| {
+                        editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
                             s.select_ranges([range]);
                         });
                     } else {

From 6d4ecac6100f7908278e78cb8c5102f7f91c54c5 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Fri, 27 Sep 2024 10:59:19 -0400
Subject: [PATCH 374/762] Add a `get-release-notes-since` script (#18445)

Release Notes:

- N/A
---
 ...-changes-since => get-pull-requests-since} |   4 +-
 script/get-release-notes-since                | 125 ++++++++++++++++++
 2 files changed, 127 insertions(+), 2 deletions(-)
 rename script/{get-changes-since => get-pull-requests-since} (94%)
 create mode 100755 script/get-release-notes-since

diff --git a/script/get-changes-since b/script/get-pull-requests-since
similarity index 94%
rename from script/get-changes-since
rename to script/get-pull-requests-since
index 3b889ce991ade6..c8509480a6c5cd 100755
--- a/script/get-changes-since
+++ b/script/get-pull-requests-since
@@ -22,12 +22,12 @@ async function main() {
   const startDate = new Date(process.argv[2]);
   const today = new Date();
 
-  console.log(`Changes from ${startDate} to ${today}\n`);
+  console.log(`Pull requests from ${startDate} to ${today}\n`);
 
   let pullRequestNumbers = getPullRequestNumbers(startDate, today);
 
   // Fetch the pull requests from the GitHub API.
-  console.log("Merged Pull requests:");
+  console.log("Merged pull requests:");
   for (const pullRequestNumber of pullRequestNumbers) {
     const webURL = `https://github.com/zed-industries/zed/pull/${pullRequestNumber}`;
     const apiURL = `https://api.github.com/repos/zed-industries/zed/pulls/${pullRequestNumber}`;
diff --git a/script/get-release-notes-since b/script/get-release-notes-since
new file mode 100755
index 00000000000000..20a6fc18dee9e3
--- /dev/null
+++ b/script/get-release-notes-since
@@ -0,0 +1,125 @@
+#!/usr/bin/env node --redirect-warnings=/dev/null
+
+const { execFileSync } = require("child_process");
+const { GITHUB_ACCESS_TOKEN } = process.env;
+
+main();
+
+async function main() {
+  const startDate = new Date(process.argv[2]);
+  const today = new Date();
+
+  console.log(`Release notes from ${startDate} to ${today}\n`);
+
+  const releases = await getReleases(startDate, today);
+  const previewReleases = releases.filter((release) =>
+    release.tagName.includes("-pre"),
+  );
+
+  const stableReleases = releases.filter(
+    (release) => !release.tagName.includes("-pre"),
+  );
+
+  // Filter out all preview release, as all of those changes have made it to the stable release, except for the latest preview release
+  const aggregatedReleases = stableReleases
+    .concat(previewReleases[0])
+    .reverse();
+
+  const aggregatedReleaseTitles = aggregatedReleases
+    .map((release) => release.name)
+    .join(", ");
+
+  console.log();
+  console.log(`Release titles: ${aggregatedReleaseTitles}`);
+
+  console.log("Release notes:");
+  console.log();
+
+  for (const release of aggregatedReleases) {
+    const publishedDate = release.publishedAt.split("T")[0];
+    console.log(`${release.name}: ${publishedDate}`);
+    console.log();
+    console.log(release.description);
+    console.log();
+  }
+}
+
+async function getReleases(startDate, endDate) {
+  const query = `
+    query ($owner: String!, $repo: String!, $cursor: String) {
+      repository(owner: $owner, name: $repo) {
+        releases(first: 100, orderBy: {field: CREATED_AT, direction: DESC}, after: $cursor) {
+          nodes {
+            tagName
+            name
+            createdAt
+            publishedAt
+            description
+            url
+            author {
+              login
+            }
+          }
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+        }
+      }
+    }
+  `;
+
+  let allReleases = [];
+  let hasNextPage = true;
+  let cursor = null;
+
+  while (hasNextPage) {
+    const response = await fetch("https://api.github.com/graphql", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${GITHUB_ACCESS_TOKEN}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        query,
+        variables: { owner: "zed-industries", repo: "zed", cursor },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const data = await response.json();
+
+    if (data.errors) {
+      throw new Error(`GraphQL error: ${JSON.stringify(data.errors)}`);
+    }
+
+    if (!data.data || !data.data.repository || !data.data.repository.releases) {
+      throw new Error(`Unexpected response structure: ${JSON.stringify(data)}`);
+    }
+
+    const releases = data.data.repository.releases.nodes;
+    allReleases = allReleases.concat(releases);
+
+    hasNextPage = data.data.repository.releases.pageInfo.hasNextPage;
+    cursor = data.data.repository.releases.pageInfo.endCursor;
+
+    lastReleaseOnPage = releases[releases.length - 1];
+
+    if (
+      releases.length > 0 &&
+      new Date(lastReleaseOnPage.createdAt) < startDate
+    ) {
+      break;
+    }
+  }
+
+  const filteredReleases = allReleases.filter((release) => {
+    const releaseDate = new Date(release.createdAt);
+    return releaseDate >= startDate && releaseDate <= endDate;
+  });
+
+  return filteredReleases;
+}

From ffd1083cc185ddd13760391dc81231c18236e912 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Fri, 27 Sep 2024 10:06:19 -0600
Subject: [PATCH 375/762] vim: Command selection fixes (#18424)

Release Notes:

- vim: Fixed cursor position after `:{range}yank`.
- vim: Added `:fo[ld]`, `:foldo[pen]` and `:foldc[lose]`
---
 crates/vim/src/command.rs     | 260 +++++++++++++++++++++++-----------
 crates/vim/src/indent.rs      |   8 +-
 crates/vim/src/normal.rs      |   6 +-
 crates/vim/src/normal/yank.rs |  32 ++++-
 crates/vim/src/visual.rs      |  14 +-
 5 files changed, 218 insertions(+), 102 deletions(-)

diff --git a/crates/vim/src/command.rs b/crates/vim/src/command.rs
index 49e739faadfeaf..605bc3a05e43c8 100644
--- a/crates/vim/src/command.rs
+++ b/crates/vim/src/command.rs
@@ -1,4 +1,9 @@
-use std::{iter::Peekable, ops::Range, str::Chars, sync::OnceLock};
+use std::{
+    iter::Peekable,
+    ops::{Deref, Range},
+    str::Chars,
+    sync::OnceLock,
+};
 
 use anyhow::{anyhow, Result};
 use command_palette_hooks::CommandInterceptResult;
@@ -21,7 +26,7 @@ use crate::{
         JoinLines,
     },
     state::Mode,
-    visual::{VisualDeleteLine, VisualYankLine},
+    visual::VisualDeleteLine,
     Vim,
 };
 
@@ -30,38 +35,55 @@ pub struct GoToLine {
     range: CommandRange,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+pub struct YankCommand {
+    range: CommandRange,
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct WithRange {
-    is_count: bool,
+    restore_selection: bool,
     range: CommandRange,
-    action: Box<dyn Action>,
+    action: WrappedAction,
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+pub struct WithCount {
+    count: u32,
+    action: WrappedAction,
 }
 
+#[derive(Debug)]
+struct WrappedAction(Box<dyn Action>);
+
 actions!(vim, [VisualCommand, CountCommand]);
-impl_actions!(vim, [GoToLine, WithRange]);
+impl_actions!(vim, [GoToLine, YankCommand, WithRange, WithCount]);
 
-impl<'de> Deserialize<'de> for WithRange {
+impl<'de> Deserialize<'de> for WrappedAction {
     fn deserialize<D>(_: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
     {
-        Err(serde::de::Error::custom("Cannot deserialize WithRange"))
+        Err(serde::de::Error::custom("Cannot deserialize WrappedAction"))
     }
 }
 
-impl PartialEq for WithRange {
+impl PartialEq for WrappedAction {
     fn eq(&self, other: &Self) -> bool {
-        self.range == other.range && self.action.partial_eq(&*other.action)
+        self.0.partial_eq(&*other.0)
     }
 }
 
-impl Clone for WithRange {
+impl Clone for WrappedAction {
     fn clone(&self) -> Self {
-        Self {
-            is_count: self.is_count,
-            range: self.range.clone(),
-            action: self.action.boxed_clone(),
-        }
+        Self(self.0.boxed_clone())
+    }
+}
+
+impl Deref for WrappedAction {
+    type Target = dyn Action;
+    fn deref(&self) -> &dyn Action {
+        &*self.0
     }
 }
 
@@ -110,13 +132,33 @@ pub fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {
         vim.move_cursor(Motion::StartOfDocument, Some(buffer_row.0 as usize + 1), cx);
     });
 
-    Vim::action(editor, cx, |vim, action: &WithRange, cx| {
-        if action.is_count {
-            for _ in 0..action.range.as_count() {
-                cx.dispatch_action(action.action.boxed_clone())
+    Vim::action(editor, cx, |vim, action: &YankCommand, cx| {
+        vim.update_editor(cx, |vim, editor, cx| {
+            let snapshot = editor.snapshot(cx);
+            if let Ok(range) = action.range.buffer_range(vim, editor, cx) {
+                let end = if range.end < snapshot.max_buffer_row() {
+                    Point::new(range.end.0 + 1, 0)
+                } else {
+                    snapshot.buffer_snapshot.max_point()
+                };
+                vim.copy_ranges(
+                    editor,
+                    true,
+                    true,
+                    vec![Point::new(range.start.0, 0)..end],
+                    cx,
+                )
             }
-            return;
+        });
+    });
+
+    Vim::action(editor, cx, |_, action: &WithCount, cx| {
+        for _ in 0..action.count {
+            cx.dispatch_action(action.action.boxed_clone())
         }
+    });
+
+    Vim::action(editor, cx, |vim, action: &WithRange, cx| {
         let result = vim.update_editor(cx, |vim, editor, cx| {
             action.range.buffer_range(vim, editor, cx)
         });
@@ -134,31 +176,51 @@ pub fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {
             }
             Some(Ok(result)) => result,
         };
-        vim.update_editor(cx, |_, editor, cx| {
-            editor.change_selections(None, cx, |s| {
-                let end = Point::new(range.end.0, s.buffer().line_len(range.end));
-                s.select_ranges([end..Point::new(range.start.0, 0)]);
+
+        let previous_selections = vim
+            .update_editor(cx, |_, editor, cx| {
+                let selections = action
+                    .restore_selection
+                    .then(|| editor.selections.disjoint_anchor_ranges());
+                editor.change_selections(None, cx, |s| {
+                    let end = Point::new(range.end.0, s.buffer().line_len(range.end));
+                    s.select_ranges([end..Point::new(range.start.0, 0)]);
+                });
+                selections
             })
-        });
+            .flatten();
         cx.dispatch_action(action.action.boxed_clone());
         cx.defer(move |vim, cx| {
             vim.update_editor(cx, |_, editor, cx| {
                 editor.change_selections(None, cx, |s| {
-                    s.select_ranges([Point::new(range.start.0, 0)..Point::new(range.start.0, 0)]);
+                    if let Some(previous_selections) = previous_selections {
+                        s.select_ranges(previous_selections);
+                    } else {
+                        s.select_ranges([
+                            Point::new(range.start.0, 0)..Point::new(range.start.0, 0)
+                        ]);
+                    }
                 })
             });
         });
     });
 }
 
-#[derive(Debug, Default)]
+#[derive(Default)]
 struct VimCommand {
     prefix: &'static str,
     suffix: &'static str,
     action: Option<Box<dyn Action>>,
     action_name: Option<&'static str>,
     bang_action: Option<Box<dyn Action>>,
-    has_range: bool,
+    range: Option<
+        Box<
+            dyn Fn(Box<dyn Action>, &CommandRange) -> Option<Box<dyn Action>>
+                + Send
+                + Sync
+                + 'static,
+        >,
+    >,
     has_count: bool,
 }
 
@@ -187,16 +249,25 @@ impl VimCommand {
         self
     }
 
-    fn range(mut self) -> Self {
-        self.has_range = true;
+    fn range(
+        mut self,
+        f: impl Fn(Box<dyn Action>, &CommandRange) -> Option<Box<dyn Action>> + Send + Sync + 'static,
+    ) -> Self {
+        self.range = Some(Box::new(f));
         self
     }
+
     fn count(mut self) -> Self {
         self.has_count = true;
         self
     }
 
-    fn parse(&self, mut query: &str, cx: &AppContext) -> Option<Box<dyn Action>> {
+    fn parse(
+        &self,
+        mut query: &str,
+        range: &Option<CommandRange>,
+        cx: &AppContext,
+    ) -> Option<Box<dyn Action>> {
         let has_bang = query.ends_with('!');
         if has_bang {
             query = &query[..query.len() - 1];
@@ -207,14 +278,20 @@ impl VimCommand {
             return None;
         }
 
-        if has_bang && self.bang_action.is_some() {
-            Some(self.bang_action.as_ref().unwrap().boxed_clone())
+        let action = if has_bang && self.bang_action.is_some() {
+            self.bang_action.as_ref().unwrap().boxed_clone()
         } else if let Some(action) = self.action.as_ref() {
-            Some(action.boxed_clone())
+            action.boxed_clone()
         } else if let Some(action_name) = self.action_name {
-            cx.build_action(action_name, None).log_err()
+            cx.build_action(action_name, None).log_err()?
         } else {
-            None
+            return None;
+        };
+
+        if let Some(range) = range {
+            self.range.as_ref().and_then(|f| f(action, range))
+        } else {
+            Some(action)
         }
     }
 
@@ -405,27 +482,17 @@ impl CommandRange {
         }
     }
 
-    pub fn as_count(&self) -> u32 {
+    pub fn as_count(&self) -> Option<u32> {
         if let CommandRange {
             start: Position::Line { row, offset: 0 },
             end: None,
         } = &self
         {
-            *row
+            Some(*row)
         } else {
-            0
+            None
         }
     }
-
-    pub fn is_count(&self) -> bool {
-        matches!(
-            &self,
-            CommandRange {
-                start: Position::Line { row: _, offset: 0 },
-                end: None
-            }
-        )
-    }
 }
 
 fn generate_commands(_: &AppContext) -> Vec<VimCommand> {
@@ -578,18 +645,32 @@ fn generate_commands(_: &AppContext) -> Vec<VimCommand> {
         VimCommand::str(("cl", "ist"), "diagnostics::Deploy"),
         VimCommand::new(("cc", ""), editor::actions::Hover),
         VimCommand::new(("ll", ""), editor::actions::Hover),
-        VimCommand::new(("cn", "ext"), editor::actions::GoToDiagnostic).count(),
-        VimCommand::new(("cp", "revious"), editor::actions::GoToPrevDiagnostic).count(),
-        VimCommand::new(("cN", "ext"), editor::actions::GoToPrevDiagnostic).count(),
-        VimCommand::new(("lp", "revious"), editor::actions::GoToPrevDiagnostic).count(),
-        VimCommand::new(("lN", "ext"), editor::actions::GoToPrevDiagnostic).count(),
-        VimCommand::new(("j", "oin"), JoinLines).range(),
-        VimCommand::new(("dif", "fupdate"), editor::actions::ToggleHunkDiff).range(),
-        VimCommand::new(("rev", "ert"), editor::actions::RevertSelectedHunks).range(),
-        VimCommand::new(("d", "elete"), VisualDeleteLine).range(),
-        VimCommand::new(("y", "ank"), VisualYankLine).range(),
-        VimCommand::new(("sor", "t"), SortLinesCaseSensitive).range(),
-        VimCommand::new(("sort i", ""), SortLinesCaseInsensitive).range(),
+        VimCommand::new(("cn", "ext"), editor::actions::GoToDiagnostic).range(wrap_count),
+        VimCommand::new(("cp", "revious"), editor::actions::GoToPrevDiagnostic).range(wrap_count),
+        VimCommand::new(("cN", "ext"), editor::actions::GoToPrevDiagnostic).range(wrap_count),
+        VimCommand::new(("lp", "revious"), editor::actions::GoToPrevDiagnostic).range(wrap_count),
+        VimCommand::new(("lN", "ext"), editor::actions::GoToPrevDiagnostic).range(wrap_count),
+        VimCommand::new(("j", "oin"), JoinLines).range(select_range),
+        VimCommand::new(("fo", "ld"), editor::actions::FoldSelectedRanges).range(act_on_range),
+        VimCommand::new(("foldo", "pen"), editor::actions::UnfoldLines)
+            .bang(editor::actions::UnfoldRecursive)
+            .range(act_on_range),
+        VimCommand::new(("foldc", "lose"), editor::actions::Fold)
+            .bang(editor::actions::FoldRecursive)
+            .range(act_on_range),
+        VimCommand::new(("dif", "fupdate"), editor::actions::ToggleHunkDiff).range(act_on_range),
+        VimCommand::new(("rev", "ert"), editor::actions::RevertSelectedHunks).range(act_on_range),
+        VimCommand::new(("d", "elete"), VisualDeleteLine).range(select_range),
+        VimCommand::new(("y", "ank"), gpui::NoAction).range(|_, range| {
+            Some(
+                YankCommand {
+                    range: range.clone(),
+                }
+                .boxed_clone(),
+            )
+        }),
+        VimCommand::new(("sor", "t"), SortLinesCaseSensitive).range(select_range),
+        VimCommand::new(("sort i", ""), SortLinesCaseInsensitive).range(select_range),
         VimCommand::str(("E", "xplore"), "project_panel::ToggleFocus"),
         VimCommand::str(("H", "explore"), "project_panel::ToggleFocus"),
         VimCommand::str(("L", "explore"), "project_panel::ToggleFocus"),
@@ -620,6 +701,38 @@ fn commands(cx: &AppContext) -> &Vec<VimCommand> {
         .0
 }
 
+fn act_on_range(action: Box<dyn Action>, range: &CommandRange) -> Option<Box<dyn Action>> {
+    Some(
+        WithRange {
+            restore_selection: true,
+            range: range.clone(),
+            action: WrappedAction(action),
+        }
+        .boxed_clone(),
+    )
+}
+
+fn select_range(action: Box<dyn Action>, range: &CommandRange) -> Option<Box<dyn Action>> {
+    Some(
+        WithRange {
+            restore_selection: false,
+            range: range.clone(),
+            action: WrappedAction(action),
+        }
+        .boxed_clone(),
+    )
+}
+
+fn wrap_count(action: Box<dyn Action>, range: &CommandRange) -> Option<Box<dyn Action>> {
+    range.as_count().map(|count| {
+        WithCount {
+            count,
+            action: WrappedAction(action),
+        }
+        .boxed_clone()
+    })
+}
+
 pub fn command_interceptor(mut input: &str, cx: &AppContext) -> Option<CommandInterceptResult> {
     // NOTE: We also need to support passing arguments to commands like :w
     // (ideally with filename autocompletion).
@@ -679,25 +792,12 @@ pub fn command_interceptor(mut input: &str, cx: &AppContext) -> Option<CommandIn
     }
 
     for command in commands(cx).iter() {
-        if let Some(action) = command.parse(query, cx) {
-            let string = ":".to_owned() + &range_prefix + command.prefix + command.suffix;
-            let positions = generate_positions(&string, &(range_prefix + query));
-
-            if let Some(range) = &range {
-                if command.has_range || (range.is_count() && command.has_count) {
-                    return Some(CommandInterceptResult {
-                        action: Box::new(WithRange {
-                            is_count: command.has_count,
-                            range: range.clone(),
-                            action,
-                        }),
-                        string,
-                        positions,
-                    });
-                } else {
-                    return None;
-                }
+        if let Some(action) = command.parse(query, &range, cx) {
+            let mut string = ":".to_owned() + &range_prefix + command.prefix + command.suffix;
+            if query.ends_with('!') {
+                string.push('!');
             }
+            let positions = generate_positions(&string, &(range_prefix + query));
 
             return Some(CommandInterceptResult {
                 action,
diff --git a/crates/vim/src/indent.rs b/crates/vim/src/indent.rs
index 676713c816da52..b6ca2de34c63e9 100644
--- a/crates/vim/src/indent.rs
+++ b/crates/vim/src/indent.rs
@@ -20,11 +20,11 @@ pub(crate) fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {
         vim.store_visual_marks(cx);
         vim.update_editor(cx, |vim, editor, cx| {
             editor.transact(cx, |editor, cx| {
-                let mut original_positions = vim.save_selection_starts(editor, cx);
+                let original_positions = vim.save_selection_starts(editor, cx);
                 for _ in 0..count {
                     editor.indent(&Default::default(), cx);
                 }
-                vim.restore_selection_cursors(editor, cx, &mut original_positions);
+                vim.restore_selection_cursors(editor, cx, original_positions);
             });
         });
         if vim.mode.is_visual() {
@@ -38,11 +38,11 @@ pub(crate) fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {
         vim.store_visual_marks(cx);
         vim.update_editor(cx, |vim, editor, cx| {
             editor.transact(cx, |editor, cx| {
-                let mut original_positions = vim.save_selection_starts(editor, cx);
+                let original_positions = vim.save_selection_starts(editor, cx);
                 for _ in 0..count {
                     editor.outdent(&Default::default(), cx);
                 }
-                vim.restore_selection_cursors(editor, cx, &mut original_positions);
+                vim.restore_selection_cursors(editor, cx, original_positions);
             });
         });
         if vim.mode.is_visual() {
diff --git a/crates/vim/src/normal.rs b/crates/vim/src/normal.rs
index 10bf3c8e8d73b4..4a4927a2fc5bfd 100644
--- a/crates/vim/src/normal.rs
+++ b/crates/vim/src/normal.rs
@@ -395,9 +395,9 @@ impl Vim {
         self.store_visual_marks(cx);
         self.update_editor(cx, |vim, editor, cx| {
             editor.transact(cx, |editor, cx| {
-                let mut original_positions = vim.save_selection_starts(editor, cx);
+                let original_positions = vim.save_selection_starts(editor, cx);
                 editor.toggle_comments(&Default::default(), cx);
-                vim.restore_selection_cursors(editor, cx, &mut original_positions);
+                vim.restore_selection_cursors(editor, cx, original_positions);
             });
         });
         if self.mode.is_visual() {
@@ -467,7 +467,7 @@ impl Vim {
         &self,
         editor: &mut Editor,
         cx: &mut ViewContext<Editor>,
-        positions: &mut HashMap<usize, Anchor>,
+        mut positions: HashMap<usize, Anchor>,
     ) {
         editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
             s.move_with(|map, selection| {
diff --git a/crates/vim/src/normal/yank.rs b/crates/vim/src/normal/yank.rs
index 8271aa6cabc163..c176cd6ca9cf3d 100644
--- a/crates/vim/src/normal/yank.rs
+++ b/crates/vim/src/normal/yank.rs
@@ -1,4 +1,4 @@
-use std::time::Duration;
+use std::{ops::Range, time::Duration};
 
 use crate::{
     motion::Motion,
@@ -73,7 +73,18 @@ impl Vim {
         linewise: bool,
         cx: &mut ViewContext<Editor>,
     ) {
-        self.copy_selections_content_internal(editor, linewise, true, cx);
+        self.copy_ranges(
+            editor,
+            linewise,
+            true,
+            editor
+                .selections
+                .all_adjusted(cx)
+                .iter()
+                .map(|s| s.range())
+                .collect(),
+            cx,
+        )
     }
 
     pub fn copy_selections_content(
@@ -82,17 +93,28 @@ impl Vim {
         linewise: bool,
         cx: &mut ViewContext<Editor>,
     ) {
-        self.copy_selections_content_internal(editor, linewise, false, cx);
+        self.copy_ranges(
+            editor,
+            linewise,
+            false,
+            editor
+                .selections
+                .all_adjusted(cx)
+                .iter()
+                .map(|s| s.range())
+                .collect(),
+            cx,
+        )
     }
 
-    fn copy_selections_content_internal(
+    pub(crate) fn copy_ranges(
         &mut self,
         editor: &mut Editor,
         linewise: bool,
         is_yank: bool,
+        selections: Vec<Range<Point>>,
         cx: &mut ViewContext<Editor>,
     ) {
-        let selections = editor.selections.all_adjusted(cx);
         let buffer = editor.buffer().read(cx).snapshot(cx);
         let mut text = String::new();
         let mut clipboard_selections = Vec::with_capacity(selections.len());
diff --git a/crates/vim/src/visual.rs b/crates/vim/src/visual.rs
index 1503eaac1b6b43..72474d3ae40781 100644
--- a/crates/vim/src/visual.rs
+++ b/crates/vim/src/visual.rs
@@ -63,12 +63,7 @@ pub fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {
         vim.record_current_action(cx);
         vim.visual_delete(true, cx);
     });
-    Vim::action(editor, cx, |vim, _: &VisualYank, cx| {
-        vim.visual_yank(false, cx)
-    });
-    Vim::action(editor, cx, |vim, _: &VisualYankLine, cx| {
-        vim.visual_yank(true, cx)
-    });
+    Vim::action(editor, cx, |vim, _: &VisualYank, cx| vim.visual_yank(cx));
 
     Vim::action(editor, cx, Vim::select_next);
     Vim::action(editor, cx, Vim::select_previous);
@@ -483,11 +478,10 @@ impl Vim {
         self.switch_mode(Mode::Normal, true, cx);
     }
 
-    pub fn visual_yank(&mut self, line_mode: bool, cx: &mut ViewContext<Self>) {
+    pub fn visual_yank(&mut self, cx: &mut ViewContext<Self>) {
         self.store_visual_marks(cx);
         self.update_editor(cx, |vim, editor, cx| {
-            let line_mode = line_mode || editor.selections.line_mode;
-            editor.selections.line_mode = line_mode;
+            let line_mode = editor.selections.line_mode;
             vim.yank_selections_content(editor, line_mode, cx);
             editor.change_selections(None, cx, |s| {
                 s.move_with(|map, selection| {
@@ -657,7 +651,7 @@ impl Vim {
                 self.stop_recording(cx);
                 self.visual_delete(false, cx)
             }
-            Some(Operator::Yank) => self.visual_yank(false, cx),
+            Some(Operator::Yank) => self.visual_yank(cx),
             _ => {} // Ignoring other operators
         }
     }

From caaa9a00a987855d6f64e6ef88f70cfd2499f848 Mon Sep 17 00:00:00 2001
From: Richard Feldman <oss@rtfeldman.com>
Date: Fri, 27 Sep 2024 13:30:25 -0400
Subject: [PATCH 376/762] Remove Qwen2 model (#18444)

Removed deprecated Qwen2 7B Instruct model from zed.dev provider (staff
only).

Release Notes:

- N/A
---
 crates/collab/k8s/collab.template.yml         | 12 ---
 crates/collab/src/lib.rs                      |  4 -
 crates/collab/src/llm.rs                      | 36 --------
 crates/collab/src/llm/authorization.rs        |  2 -
 crates/collab/src/llm/db/seed.rs              |  9 --
 .../collab/src/llm/db/tests/provider_tests.rs |  1 -
 crates/collab/src/tests/test_server.rs        |  2 -
 .../language_model/src/model/cloud_model.rs   | 27 ------
 crates/language_model/src/provider/cloud.rs   | 84 +------------------
 crates/rpc/src/llm.rs                         |  1 -
 10 files changed, 2 insertions(+), 176 deletions(-)

diff --git a/crates/collab/k8s/collab.template.yml b/crates/collab/k8s/collab.template.yml
index 7ddb871503cccb..7d4ea6eb9a3cb2 100644
--- a/crates/collab/k8s/collab.template.yml
+++ b/crates/collab/k8s/collab.template.yml
@@ -149,18 +149,6 @@ spec:
                 secretKeyRef:
                   name: google-ai
                   key: api_key
-            - name: RUNPOD_API_KEY
-              valueFrom:
-                secretKeyRef:
-                  name: runpod
-                  key: api_key
-                  optional: true
-            - name: RUNPOD_API_SUMMARY_URL
-              valueFrom:
-                secretKeyRef:
-                  name: runpod
-                  key: summary
-                  optional: true
             - name: BLOB_STORE_ACCESS_KEY
               valueFrom:
                 secretKeyRef:
diff --git a/crates/collab/src/lib.rs b/crates/collab/src/lib.rs
index 81ff3ff21f6926..6c32023a97a287 100644
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -170,8 +170,6 @@ pub struct Config {
     pub anthropic_api_key: Option<Arc<str>>,
     pub anthropic_staff_api_key: Option<Arc<str>>,
     pub llm_closed_beta_model_name: Option<Arc<str>>,
-    pub runpod_api_key: Option<Arc<str>>,
-    pub runpod_api_summary_url: Option<Arc<str>>,
     pub zed_client_checksum_seed: Option<String>,
     pub slack_panics_webhook: Option<String>,
     pub auto_join_channel_id: Option<ChannelId>,
@@ -235,8 +233,6 @@ impl Config {
             stripe_api_key: None,
             stripe_price_id: None,
             supermaven_admin_api_key: None,
-            runpod_api_key: None,
-            runpod_api_summary_url: None,
             user_backfiller_github_access_token: None,
         }
     }
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index 53f0bfdfd0130a..14f10342a78dd7 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -400,42 +400,6 @@ async fn perform_completion(
                 })
                 .boxed()
         }
-        LanguageModelProvider::Zed => {
-            let api_key = state
-                .config
-                .runpod_api_key
-                .as_ref()
-                .context("no Qwen2-7B API key configured on the server")?;
-            let api_url = state
-                .config
-                .runpod_api_summary_url
-                .as_ref()
-                .context("no Qwen2-7B URL configured on the server")?;
-            let chunks = open_ai::stream_completion(
-                &state.http_client,
-                api_url,
-                api_key,
-                serde_json::from_str(params.provider_request.get())?,
-                None,
-            )
-            .await?;
-
-            chunks
-                .map(|event| {
-                    event.map(|chunk| {
-                        let input_tokens =
-                            chunk.usage.as_ref().map_or(0, |u| u.prompt_tokens) as usize;
-                        let output_tokens =
-                            chunk.usage.as_ref().map_or(0, |u| u.completion_tokens) as usize;
-                        (
-                            serde_json::to_vec(&chunk).unwrap(),
-                            input_tokens,
-                            output_tokens,
-                        )
-                    })
-                })
-                .boxed()
-        }
     };
 
     Ok(Response::new(Body::wrap_stream(TokenCountingStream {
diff --git a/crates/collab/src/llm/authorization.rs b/crates/collab/src/llm/authorization.rs
index cc345579eca229..9f82af51c39b73 100644
--- a/crates/collab/src/llm/authorization.rs
+++ b/crates/collab/src/llm/authorization.rs
@@ -77,7 +77,6 @@ fn authorize_access_for_country(
         LanguageModelProvider::Anthropic => anthropic::is_supported_country(country_code),
         LanguageModelProvider::OpenAi => open_ai::is_supported_country(country_code),
         LanguageModelProvider::Google => google_ai::is_supported_country(country_code),
-        LanguageModelProvider::Zed => true,
     };
     if !is_country_supported_by_provider {
         Err(Error::http(
@@ -213,7 +212,6 @@ mod tests {
             (LanguageModelProvider::Anthropic, "T1"), // Tor
             (LanguageModelProvider::OpenAi, "T1"),    // Tor
             (LanguageModelProvider::Google, "T1"),    // Tor
-            (LanguageModelProvider::Zed, "T1"),       // Tor
         ];
 
         for (provider, country_code) in cases {
diff --git a/crates/collab/src/llm/db/seed.rs b/crates/collab/src/llm/db/seed.rs
index 24bc224227c8d2..55c6c30cd5d8bf 100644
--- a/crates/collab/src/llm/db/seed.rs
+++ b/crates/collab/src/llm/db/seed.rs
@@ -40,15 +40,6 @@ pub async fn seed_database(_config: &Config, db: &mut LlmDatabase, _force: bool)
             price_per_million_input_tokens: 25,   // $0.25/MTok
             price_per_million_output_tokens: 125, // $1.25/MTok
         },
-        ModelParams {
-            provider: LanguageModelProvider::Zed,
-            name: "Qwen/Qwen2-7B-Instruct".into(),
-            max_requests_per_minute: 5,
-            max_tokens_per_minute: 25_000, // These are arbitrary limits we've set to cap costs; we control this number
-            max_tokens_per_day: 300_000,
-            price_per_million_input_tokens: 25,
-            price_per_million_output_tokens: 125,
-        },
     ])
     .await
 }
diff --git a/crates/collab/src/llm/db/tests/provider_tests.rs b/crates/collab/src/llm/db/tests/provider_tests.rs
index ef0da1c373fca6..0bb55ee4b69a6c 100644
--- a/crates/collab/src/llm/db/tests/provider_tests.rs
+++ b/crates/collab/src/llm/db/tests/provider_tests.rs
@@ -26,7 +26,6 @@ async fn test_initialize_providers(db: &mut LlmDatabase) {
             LanguageModelProvider::Anthropic,
             LanguageModelProvider::Google,
             LanguageModelProvider::OpenAi,
-            LanguageModelProvider::Zed
         ]
     )
 }
diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs
index 94c7d3907ff4ff..5ff4a720741bc8 100644
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -679,8 +679,6 @@ impl TestServer {
                 stripe_api_key: None,
                 stripe_price_id: None,
                 supermaven_admin_api_key: None,
-                runpod_api_key: None,
-                runpod_api_summary_url: None,
                 user_backfiller_github_access_token: None,
             },
         })
diff --git a/crates/language_model/src/model/cloud_model.rs b/crates/language_model/src/model/cloud_model.rs
index 2ce48931f6d4db..9242f80e6e16c7 100644
--- a/crates/language_model/src/model/cloud_model.rs
+++ b/crates/language_model/src/model/cloud_model.rs
@@ -12,7 +12,6 @@ pub enum CloudModel {
     Anthropic(anthropic::Model),
     OpenAi(open_ai::Model),
     Google(google_ai::Model),
-    Zed(ZedModel),
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema, EnumIter)]
@@ -21,26 +20,6 @@ pub enum ZedModel {
     Qwen2_7bInstruct,
 }
 
-impl ZedModel {
-    pub fn id(&self) -> &str {
-        match self {
-            ZedModel::Qwen2_7bInstruct => "Qwen/Qwen2-7B-Instruct",
-        }
-    }
-
-    pub fn display_name(&self) -> &str {
-        match self {
-            ZedModel::Qwen2_7bInstruct => "Qwen2 7B Instruct",
-        }
-    }
-
-    pub fn max_token_count(&self) -> usize {
-        match self {
-            ZedModel::Qwen2_7bInstruct => 28000,
-        }
-    }
-}
-
 impl Default for CloudModel {
     fn default() -> Self {
         Self::Anthropic(anthropic::Model::default())
@@ -53,7 +32,6 @@ impl CloudModel {
             Self::Anthropic(model) => model.id(),
             Self::OpenAi(model) => model.id(),
             Self::Google(model) => model.id(),
-            Self::Zed(model) => model.id(),
         }
     }
 
@@ -62,7 +40,6 @@ impl CloudModel {
             Self::Anthropic(model) => model.display_name(),
             Self::OpenAi(model) => model.display_name(),
             Self::Google(model) => model.display_name(),
-            Self::Zed(model) => model.display_name(),
         }
     }
 
@@ -78,7 +55,6 @@ impl CloudModel {
             Self::Anthropic(model) => model.max_token_count(),
             Self::OpenAi(model) => model.max_token_count(),
             Self::Google(model) => model.max_token_count(),
-            Self::Zed(model) => model.max_token_count(),
         }
     }
 
@@ -115,9 +91,6 @@ impl CloudModel {
                     LanguageModelAvailability::RequiresPlan(Plan::ZedPro)
                 }
             },
-            Self::Zed(model) => match model {
-                ZedModel::Qwen2_7bInstruct => LanguageModelAvailability::RequiresPlan(Plan::ZedPro),
-            },
         }
     }
 }
diff --git a/crates/language_model/src/provider/cloud.rs b/crates/language_model/src/provider/cloud.rs
index 3c407b77d929de..b81f6f9fba3363 100644
--- a/crates/language_model/src/provider/cloud.rs
+++ b/crates/language_model/src/provider/cloud.rs
@@ -3,7 +3,7 @@ use crate::provider::anthropic::map_to_language_model_completion_events;
 use crate::{
     settings::AllLanguageModelSettings, CloudModel, LanguageModel, LanguageModelCacheConfiguration,
     LanguageModelId, LanguageModelName, LanguageModelProviderId, LanguageModelProviderName,
-    LanguageModelProviderState, LanguageModelRequest, RateLimiter, ZedModel,
+    LanguageModelProviderState, LanguageModelRequest, RateLimiter,
 };
 use anthropic::AnthropicError;
 use anyhow::{anyhow, Result};
@@ -219,9 +219,6 @@ impl LanguageModelProvider for CloudLanguageModelProvider {
                     models.insert(model.id().to_string(), CloudModel::Google(model));
                 }
             }
-            for model in ZedModel::iter() {
-                models.insert(model.id().to_string(), CloudModel::Zed(model));
-            }
         } else {
             models.insert(
                 anthropic::Model::Claude3_5Sonnet.id().to_string(),
@@ -472,7 +469,7 @@ impl LanguageModel for CloudLanguageModel {
                         min_total_token: cache.min_total_token,
                     })
             }
-            CloudModel::OpenAi(_) | CloudModel::Google(_) | CloudModel::Zed(_) => None,
+            CloudModel::OpenAi(_) | CloudModel::Google(_) => None,
         }
     }
 
@@ -502,9 +499,6 @@ impl LanguageModel for CloudLanguageModel {
                 }
                 .boxed()
             }
-            CloudModel::Zed(_) => {
-                count_open_ai_tokens(request, open_ai::Model::ThreePointFiveTurbo, cx)
-            }
         }
     }
 
@@ -603,35 +597,6 @@ impl LanguageModel for CloudLanguageModel {
                 }
                 .boxed()
             }
-            CloudModel::Zed(model) => {
-                let client = self.client.clone();
-                let mut request = request.into_open_ai(model.id().into(), None);
-                request.max_tokens = Some(4000);
-                let llm_api_token = self.llm_api_token.clone();
-                let future = self.request_limiter.stream(async move {
-                    let response = Self::perform_llm_completion(
-                        client.clone(),
-                        llm_api_token,
-                        PerformCompletionParams {
-                            provider: client::LanguageModelProvider::Zed,
-                            model: request.model.clone(),
-                            provider_request: RawValue::from_string(serde_json::to_string(
-                                &request,
-                            )?)?,
-                        },
-                        None,
-                    )
-                    .await?;
-                    Ok(open_ai::extract_text_from_events(response_lines(response)))
-                });
-                async move {
-                    Ok(future
-                        .await?
-                        .map(|result| result.map(LanguageModelCompletionEvent::Text))
-                        .boxed())
-                }
-                .boxed()
-            }
         }
     }
 
@@ -735,51 +700,6 @@ impl LanguageModel for CloudLanguageModel {
             CloudModel::Google(_) => {
                 future::ready(Err(anyhow!("tool use not implemented for Google AI"))).boxed()
             }
-            CloudModel::Zed(model) => {
-                // All Zed models are OpenAI-based at the time of writing.
-                let mut request = request.into_open_ai(model.id().into(), None);
-                request.tool_choice = Some(open_ai::ToolChoice::Other(
-                    open_ai::ToolDefinition::Function {
-                        function: open_ai::FunctionDefinition {
-                            name: tool_name.clone(),
-                            description: None,
-                            parameters: None,
-                        },
-                    },
-                ));
-                request.tools = vec![open_ai::ToolDefinition::Function {
-                    function: open_ai::FunctionDefinition {
-                        name: tool_name.clone(),
-                        description: Some(tool_description),
-                        parameters: Some(input_schema),
-                    },
-                }];
-
-                self.request_limiter
-                    .run(async move {
-                        let response = Self::perform_llm_completion(
-                            client.clone(),
-                            llm_api_token,
-                            PerformCompletionParams {
-                                provider: client::LanguageModelProvider::Zed,
-                                model: request.model.clone(),
-                                provider_request: RawValue::from_string(serde_json::to_string(
-                                    &request,
-                                )?)?,
-                            },
-                            None,
-                        )
-                        .await?;
-
-                        Ok(open_ai::extract_tool_args_from_events(
-                            tool_name,
-                            Box::pin(response_lines(response)),
-                        )
-                        .await?
-                        .boxed())
-                    })
-                    .boxed()
-            }
         }
     }
 }
diff --git a/crates/rpc/src/llm.rs b/crates/rpc/src/llm.rs
index 6cae54b3090d56..681f2d8db32d18 100644
--- a/crates/rpc/src/llm.rs
+++ b/crates/rpc/src/llm.rs
@@ -12,7 +12,6 @@ pub enum LanguageModelProvider {
     Anthropic,
     OpenAi,
     Google,
-    Zed,
 }
 
 #[derive(Debug, Serialize, Deserialize)]

From c3075dfe9afc788a1a0a2b965f0eb4f9a4ba77b4 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Fri, 27 Sep 2024 11:14:28 -0700
Subject: [PATCH 377/762] Fix bugs in diff hunk highlighting (#18454)

Fixes https://github.com/zed-industries/zed/issues/18405

In https://github.com/zed-industries/zed/pull/18313, we introduced a
problem where git addition highlights might spuriously return when
undoing certain changes. It turned out, there were already some cases
where git hunk highlighting was incorrect when editing at the boundaries
of expanded diff hunks.

In this PR, I've introduced a test helper method for more rigorously
(and readably) testing the editor's git state. You can assert about the
entire state of an editor's diff decorations using a formatted diff:

```rust
    cx.assert_diff_hunks(
        r#"
        - use some::mod1;
          use some::mod2;
          const A: u32 = 42;
        - const B: u32 = 42;
          const C: u32 = 42;
          fn main() {
        -     println!("hello");
        +     //println!("hello");
              println!("world");
        +     //
        +     //
          }
          fn another() {
              println!("another");
        +     println!("another");
          }
        - fn another2() {
              println!("another2");
          }
        "#
        .unindent(),
    );
```

This will assert about the editor's actual row highlights, not just the
editor's internal hunk-tracking state.

I rewrote all of our editor diff tests to use these more high-level
assertions, and it caught the new bug, as well as some pre-existing bugs
in the highlighting of added content.

The problem was how we *remove* highlighted rows. Previously, it relied
on supplying exactly the same range as one that we had previously
highlighted. I've added a `remove_highlighted_rows(ranges)` APIs which
is much simpler - it clears out any row ranges that intersect the given
ranges (which is all that we need for the Git diff use case).

Release Notes:

- N/A
---
 Cargo.lock                                    |    1 +
 crates/assistant/src/inline_assistant.rs      |    4 +-
 crates/editor/Cargo.toml                      |    5 +-
 crates/editor/src/editor.rs                   |  157 +-
 crates/editor/src/editor_tests.rs             | 1682 +++++------------
 crates/editor/src/hunk_diff.rs                |   45 +-
 crates/editor/src/test.rs                     |  113 --
 crates/editor/src/test/editor_test_context.rs |  129 +-
 crates/go_to_line/src/go_to_line.rs           |    2 +-
 crates/outline/src/outline.rs                 |    8 +-
 10 files changed, 710 insertions(+), 1436 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 85a62c9519e012..123141d188e0eb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3729,6 +3729,7 @@ dependencies = [
  "multi_buffer",
  "ordered-float 2.10.1",
  "parking_lot",
+ "pretty_assertions",
  "project",
  "rand 0.8.5",
  "release_channel",
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index 9c117e66653e93..e2f2fa190d3977 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -1142,7 +1142,7 @@ impl InlineAssistant {
             for row_range in inserted_row_ranges {
                 editor.highlight_rows::<InlineAssist>(
                     row_range,
-                    Some(cx.theme().status().info_background),
+                    cx.theme().status().info_background,
                     false,
                     cx,
                 );
@@ -1209,7 +1209,7 @@ impl InlineAssistant {
                     editor.set_show_inline_completions(Some(false), cx);
                     editor.highlight_rows::<DeletedLines>(
                         Anchor::min()..=Anchor::max(),
-                        Some(cx.theme().status().deleted_background),
+                        cx.theme().status().deleted_background,
                         false,
                         cx,
                     );
diff --git a/crates/editor/Cargo.toml b/crates/editor/Cargo.toml
index b6b22ef64d33f6..cfd9284f807650 100644
--- a/crates/editor/Cargo.toml
+++ b/crates/editor/Cargo.toml
@@ -24,7 +24,8 @@ test-support = [
     "workspace/test-support",
     "tree-sitter-rust",
     "tree-sitter-typescript",
-    "tree-sitter-html"
+    "tree-sitter-html",
+    "unindent",
 ]
 
 [dependencies]
@@ -54,6 +55,7 @@ markdown.workspace = true
 multi_buffer.workspace = true
 ordered-float.workspace = true
 parking_lot.workspace = true
+pretty_assertions.workspace = true
 project.workspace = true
 rand.workspace = true
 rpc.workspace = true
@@ -74,6 +76,7 @@ theme.workspace = true
 tree-sitter-html = { workspace = true, optional = true }
 tree-sitter-rust = { workspace = true, optional = true }
 tree-sitter-typescript = { workspace = true, optional = true }
+unindent = { workspace = true, optional = true }
 ui.workspace = true
 url.workspace = true
 util.workspace = true
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index cfffa584b6c214..48785dbaa55cfc 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -822,7 +822,7 @@ impl SelectionHistory {
 struct RowHighlight {
     index: usize,
     range: RangeInclusive<Anchor>,
-    color: Option<Hsla>,
+    color: Hsla,
     should_autoscroll: bool,
 }
 
@@ -11500,41 +11500,125 @@ impl Editor {
         }
     }
 
-    /// Adds or removes (on `None` color) a highlight for the rows corresponding to the anchor range given.
-    /// On matching anchor range, replaces the old highlight; does not clear the other existing highlights.
-    /// If multiple anchor ranges will produce highlights for the same row, the last range added will be used.
+    /// Adds a row highlight for the given range. If a row has multiple highlights, the
+    /// last highlight added will be used.
     pub fn highlight_rows<T: 'static>(
         &mut self,
-        rows: RangeInclusive<Anchor>,
-        color: Option<Hsla>,
+        range: RangeInclusive<Anchor>,
+        color: Hsla,
         should_autoscroll: bool,
         cx: &mut ViewContext<Self>,
     ) {
         let snapshot = self.buffer().read(cx).snapshot(cx);
         let row_highlights = self.highlighted_rows.entry(TypeId::of::<T>()).or_default();
-        let existing_highlight_index = row_highlights.binary_search_by(|highlight| {
-            highlight
-                .range
-                .start()
-                .cmp(rows.start(), &snapshot)
-                .then(highlight.range.end().cmp(rows.end(), &snapshot))
+        let ix = row_highlights.binary_search_by(|highlight| {
+            Ordering::Equal
+                .then_with(|| highlight.range.start().cmp(&range.start(), &snapshot))
+                .then_with(|| highlight.range.end().cmp(&range.end(), &snapshot))
         });
-        match (color, existing_highlight_index) {
-            (Some(_), Ok(ix)) | (_, Err(ix)) => row_highlights.insert(
-                ix,
-                RowHighlight {
-                    index: post_inc(&mut self.highlight_order),
-                    range: rows,
-                    should_autoscroll,
-                    color,
-                },
-            ),
-            (None, Ok(i)) => {
-                row_highlights.remove(i);
+
+        if let Err(mut ix) = ix {
+            let index = post_inc(&mut self.highlight_order);
+
+            // If this range intersects with the preceding highlight, then merge it with
+            // the preceding highlight. Otherwise insert a new highlight.
+            let mut merged = false;
+            if ix > 0 {
+                let prev_highlight = &mut row_highlights[ix - 1];
+                if prev_highlight
+                    .range
+                    .end()
+                    .cmp(&range.start(), &snapshot)
+                    .is_ge()
+                {
+                    ix -= 1;
+                    if prev_highlight
+                        .range
+                        .end()
+                        .cmp(&range.end(), &snapshot)
+                        .is_lt()
+                    {
+                        prev_highlight.range = *prev_highlight.range.start()..=*range.end();
+                    }
+                    merged = true;
+                    prev_highlight.index = index;
+                    prev_highlight.color = color;
+                    prev_highlight.should_autoscroll = should_autoscroll;
+                }
+            }
+
+            if !merged {
+                row_highlights.insert(
+                    ix,
+                    RowHighlight {
+                        range: range.clone(),
+                        index,
+                        color,
+                        should_autoscroll,
+                    },
+                );
+            }
+
+            // If any of the following highlights intersect with this one, merge them.
+            while let Some(next_highlight) = row_highlights.get(ix + 1) {
+                let highlight = &row_highlights[ix];
+                if next_highlight
+                    .range
+                    .start()
+                    .cmp(&highlight.range.end(), &snapshot)
+                    .is_le()
+                {
+                    if next_highlight
+                        .range
+                        .end()
+                        .cmp(&highlight.range.end(), &snapshot)
+                        .is_gt()
+                    {
+                        row_highlights[ix].range =
+                            *highlight.range.start()..=*next_highlight.range.end();
+                    }
+                    row_highlights.remove(ix + 1);
+                } else {
+                    break;
+                }
             }
         }
     }
 
+    /// Remove any highlighted row ranges of the given type that intersect the
+    /// given ranges.
+    pub fn remove_highlighted_rows<T: 'static>(
+        &mut self,
+        ranges_to_remove: Vec<Range<Anchor>>,
+        cx: &mut ViewContext<Self>,
+    ) {
+        let snapshot = self.buffer().read(cx).snapshot(cx);
+        let row_highlights = self.highlighted_rows.entry(TypeId::of::<T>()).or_default();
+        let mut ranges_to_remove = ranges_to_remove.iter().peekable();
+        row_highlights.retain(|highlight| {
+            while let Some(range_to_remove) = ranges_to_remove.peek() {
+                match range_to_remove.end.cmp(&highlight.range.start(), &snapshot) {
+                    Ordering::Less => {
+                        ranges_to_remove.next();
+                    }
+                    Ordering::Equal => {
+                        return false;
+                    }
+                    Ordering::Greater => {
+                        match range_to_remove.start.cmp(&highlight.range.end(), &snapshot) {
+                            Ordering::Less | Ordering::Equal => {
+                                return false;
+                            }
+                            Ordering::Greater => break,
+                        }
+                    }
+                }
+            }
+
+            true
+        })
+    }
+
     /// Clear all anchor ranges for a certain highlight context type, so no corresponding rows will be highlighted.
     pub fn clear_row_highlights<T: 'static>(&mut self) {
         self.highlighted_rows.remove(&TypeId::of::<T>());
@@ -11543,13 +11627,12 @@ impl Editor {
     /// For a highlight given context type, gets all anchor ranges that will be used for row highlighting.
     pub fn highlighted_rows<T: 'static>(
         &self,
-    ) -> Option<impl Iterator<Item = (&RangeInclusive<Anchor>, Option<&Hsla>)>> {
-        Some(
-            self.highlighted_rows
-                .get(&TypeId::of::<T>())?
-                .iter()
-                .map(|highlight| (&highlight.range, highlight.color.as_ref())),
-        )
+    ) -> impl '_ + Iterator<Item = (RangeInclusive<Anchor>, Hsla)> {
+        self.highlighted_rows
+            .get(&TypeId::of::<T>())
+            .map_or(&[] as &[_], |vec| vec.as_slice())
+            .iter()
+            .map(|highlight| (highlight.range.clone(), highlight.color))
     }
 
     /// Merges all anchor ranges for all context types ever set, picking the last highlight added in case of a row conflict.
@@ -11574,10 +11657,7 @@ impl Editor {
                             used_highlight_orders.entry(row).or_insert(highlight.index);
                         if highlight.index >= *used_index {
                             *used_index = highlight.index;
-                            match highlight.color {
-                                Some(hsla) => unique_rows.insert(DisplayRow(row), hsla),
-                                None => unique_rows.remove(&DisplayRow(row)),
-                            };
+                            unique_rows.insert(DisplayRow(row), highlight.color);
                         }
                     }
                     unique_rows
@@ -11593,10 +11673,11 @@ impl Editor {
             .values()
             .flat_map(|highlighted_rows| highlighted_rows.iter())
             .filter_map(|highlight| {
-                if highlight.color.is_none() || !highlight.should_autoscroll {
-                    return None;
+                if highlight.should_autoscroll {
+                    Some(highlight.range.start().to_display_point(snapshot).row())
+                } else {
+                    None
                 }
-                Some(highlight.range.start().to_display_point(snapshot).row())
             })
             .min()
     }
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 31a69918026f72..b17d94a5eb0f03 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -2,9 +2,8 @@ use super::*;
 use crate::{
     scroll::scroll_amount::ScrollAmount,
     test::{
-        assert_text_with_selections, build_editor, editor_hunks,
-        editor_lsp_test_context::EditorLspTestContext, editor_test_context::EditorTestContext,
-        expanded_hunks, expanded_hunks_background_highlights, select_ranges,
+        assert_text_with_selections, build_editor, editor_lsp_test_context::EditorLspTestContext,
+        editor_test_context::EditorTestContext, select_ranges,
     },
     JoinLines,
 };
@@ -11196,36 +11195,30 @@ async fn test_toggle_hunk_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
 
     cx.set_diff_base(Some(&diff_base));
     executor.run_until_parked();
-    let unexpanded_hunks = vec![
-        (
-            "use some::mod;\n".to_string(),
-            DiffHunkStatus::Modified,
-            DisplayRow(0)..DisplayRow(1),
-        ),
-        (
-            "const A: u32 = 42;\n".to_string(),
-            DiffHunkStatus::Removed,
-            DisplayRow(2)..DisplayRow(2),
-        ),
-        (
-            "    println!(\"hello\");\n".to_string(),
-            DiffHunkStatus::Modified,
-            DisplayRow(4)..DisplayRow(5),
-        ),
-        (
-            "".to_string(),
-            DiffHunkStatus::Added,
-            DisplayRow(6)..DisplayRow(7),
-        ),
-    ];
+
     cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        assert_eq!(all_hunks, unexpanded_hunks);
+        editor.go_to_next_hunk(&GoToHunk, cx);
+        editor.toggle_hunk_diff(&ToggleHunkDiff, cx);
     });
+    executor.run_until_parked();
+    cx.assert_diff_hunks(
+        r#"
+          use some::modified;
+
+
+          fn main() {
+        -     println!("hello");
+        +     println!("hello there");
+
+              println!("around the");
+              println!("world");
+          }
+        "#
+        .unindent(),
+    );
 
     cx.update_editor(|editor, cx| {
-        for _ in 0..4 {
+        for _ in 0..3 {
             editor.go_to_next_hunk(&GoToHunk, cx);
             editor.toggle_hunk_diff(&ToggleHunkDiff, cx);
         }
@@ -11245,57 +11238,47 @@ async fn test_toggle_hunk_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
         "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![
-                ("use some::mod;\n".to_string(), DiffHunkStatus::Modified, DisplayRow(2)..DisplayRow(3)),
-                ("const A: u32 = 42;\n".to_string(), DiffHunkStatus::Removed, DisplayRow(6)..DisplayRow(6)),
-                ("    println!(\"hello\");\n".to_string(), DiffHunkStatus::Modified, DisplayRow(10)..DisplayRow(11)),
-                ("".to_string(), DiffHunkStatus::Added, DisplayRow(13)..DisplayRow(14)),
-            ],
-            "After expanding, all hunks' display rows should have shifted by the amount of deleted lines added \
-            (from modified and removed hunks)"
-        );
-        assert_eq!(
-            all_hunks, all_expanded_hunks,
-            "Editor hunks should not change and all be expanded"
-        );
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(2)..=DisplayRow(2), DisplayRow(10)..=DisplayRow(10), DisplayRow(13)..=DisplayRow(13)],
-            "After expanding, all git additions should be highlighted for Modified (split into added and removed) and Added hunks"
-        );
-    });
+
+    cx.assert_diff_hunks(
+        r#"
+        - use some::mod;
+        + use some::modified;
+
+        - const A: u32 = 42;
+
+          fn main() {
+        -     println!("hello");
+        +     println!("hello there");
+
+        +     println!("around the");
+              println!("world");
+          }
+        "#
+        .unindent(),
+    );
 
     cx.update_editor(|editor, cx| {
         editor.cancel(&Cancel, cx);
-
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            Vec::new(),
-            "After cancelling in editor, no git highlights should be left"
-        );
-        assert_eq!(
-            all_expanded_hunks,
-            Vec::new(),
-            "After cancelling in editor, no hunks should be expanded"
-        );
-        assert_eq!(
-            all_hunks, unexpanded_hunks,
-            "After cancelling in editor, regular hunks' coordinates should get back to normal"
-        );
     });
+
+    cx.assert_diff_hunks(
+        r#"
+          use some::modified;
+
+
+          fn main() {
+              println!("hello there");
+
+              println!("around the");
+              println!("world");
+          }
+        "#
+        .unindent(),
+    );
 }
 
 #[gpui::test]
-async fn test_toggled_diff_base_change(
+async fn test_diff_base_change_with_expanded_diff_hunks(
     executor: BackgroundExecutor,
     cx: &mut gpui::TestAppContext,
 ) {
@@ -11339,115 +11322,78 @@ async fn test_toggled_diff_base_change(
 
     cx.set_diff_base(Some(&diff_base));
     executor.run_until_parked();
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![
-                (
-                    "use some::mod1;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(0)..DisplayRow(0)
-                ),
-                (
-                    "const B: u32 = 42;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(3)..DisplayRow(3)
-                ),
-                (
-                    "    println!(\"hello\");\n".to_string(),
-                    DiffHunkStatus::Modified,
-                    DisplayRow(6)..DisplayRow(7)
-                ),
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(9)..DisplayRow(11)
-                ),
-            ]
-        );
-    });
 
     cx.update_editor(|editor, cx| {
         editor.expand_all_hunk_diffs(&ExpandAllHunkDiffs, cx);
     });
     executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
-        use some::mod2;
+    cx.assert_diff_hunks(
+        r#"
+        - use some::mod1;
+          use some::mod2;
+
+          const A: u32 = 42;
+        - const B: u32 = 42;
+          const C: u32 = 42;
+
+          fn main() {
+        -     println!("hello");
+        +     //println!("hello");
+
+              println!("world");
+        +     //
+        +     //
+          }
+        "#
+        .unindent(),
+    );
 
-        const A: u32 = 42;
-        const C: u32 = 42;
+    cx.set_diff_base(Some("new diff base!"));
+    executor.run_until_parked();
+    cx.assert_diff_hunks(
+        r#"
+          use some::mod2;
 
-        fn main(ˇ) {
-            //println!("hello");
+          const A: u32 = 42;
+          const C: u32 = 42;
 
-            println!("world");
-            //
-            //
-        }
+          fn main() {
+              //println!("hello");
+
+              println!("world");
+              //
+              //
+          }
         "#
         .unindent(),
     );
 
     cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![
-                ("use some::mod1;\n".to_string(), DiffHunkStatus::Removed, DisplayRow(2)..DisplayRow(2)),
-                ("const B: u32 = 42;\n".to_string(), DiffHunkStatus::Removed, DisplayRow(7)..DisplayRow(7)),
-                ("    println!(\"hello\");\n".to_string(), DiffHunkStatus::Modified, DisplayRow(12)..DisplayRow(13)),
-                ("".to_string(), DiffHunkStatus::Added, DisplayRow(16)..DisplayRow(18)),
-            ],
-            "After expanding, all hunks' display rows should have shifted by the amount of deleted lines added \
-            (from modified and removed hunks)"
-        );
-        assert_eq!(
-            all_hunks, all_expanded_hunks,
-            "Editor hunks should not change and all be expanded"
-        );
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(12)..=DisplayRow(12), DisplayRow(16)..=DisplayRow(17)],
-            "After expanding, all git additions should be highlighted for Modified (split into added and removed) and Added hunks"
-        );
+        editor.expand_all_hunk_diffs(&ExpandAllHunkDiffs, cx);
     });
-
-    cx.set_diff_base(Some("new diff base!"));
     executor.run_until_parked();
-
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            Vec::new(),
-            "After diff base is changed, old git highlights should be removed"
-        );
-        assert_eq!(
-            all_expanded_hunks,
-            Vec::new(),
-            "After diff base is changed, old git hunk expansions should be removed"
-        );
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "new diff base!".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(0)..snapshot.display_snapshot.max_point().row()
-            )],
-            "After diff base is changed, hunks should update"
-        );
-    });
+    cx.assert_diff_hunks(
+        r#"
+        - new diff base!
+        + use some::mod2;
+        +
+        + const A: u32 = 42;
+        + const C: u32 = 42;
+        +
+        + fn main() {
+        +     //println!("hello");
+        +
+        +     println!("world");
+        +     //
+        +     //
+        + }
+        "#
+        .unindent(),
+    );
 }
 
 #[gpui::test]
-async fn test_fold_unfold_diff(executor: BackgroundExecutor, cx: &mut gpui::TestAppContext) {
+async fn test_fold_unfold_diff_hunk(executor: BackgroundExecutor, cx: &mut gpui::TestAppContext) {
     init_test(cx, |_| {});
 
     let mut cx = EditorTestContext::new(cx).await;
@@ -11504,337 +11450,138 @@ async fn test_fold_unfold_diff(executor: BackgroundExecutor, cx: &mut gpui::Test
 
     cx.set_diff_base(Some(&diff_base));
     executor.run_until_parked();
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![
-                (
-                    "use some::mod1;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(0)..DisplayRow(0)
-                ),
-                (
-                    "const B: u32 = 42;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(3)..DisplayRow(3)
-                ),
-                (
-                    "    println!(\"hello\");\n".to_string(),
-                    DiffHunkStatus::Modified,
-                    DisplayRow(6)..DisplayRow(7)
-                ),
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(9)..DisplayRow(11)
-                ),
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(15)..DisplayRow(16)
-                ),
-                (
-                    "fn another2() {\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(18)..DisplayRow(18)
-                ),
-            ]
-        );
-    });
 
     cx.update_editor(|editor, cx| {
         editor.expand_all_hunk_diffs(&ExpandAllHunkDiffs, cx);
     });
     executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
-        «use some::mod2;
 
-        const A: u32 = 42;
-        const C: u32 = 42;
+    cx.assert_diff_hunks(
+        r#"
+        - use some::mod1;
+          use some::mod2;
 
-        fn main() {
-            //println!("hello");
+          const A: u32 = 42;
+        - const B: u32 = 42;
+          const C: u32 = 42;
 
-            println!("world");
-            //
-            //ˇ»
-        }
+          fn main() {
+        -     println!("hello");
+        +     //println!("hello");
 
-        fn another() {
-            println!("another");
-            println!("another");
-        }
+              println!("world");
+        +     //
+        +     //
+          }
 
-            println!("another2");
-        }
+          fn another() {
+              println!("another");
+        +     println!("another");
+          }
+
+        - fn another2() {
+              println!("another2");
+          }
         "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![
-                (
-                    "use some::mod1;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(2)..DisplayRow(2)
-                ),
-                (
-                    "const B: u32 = 42;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(7)..DisplayRow(7)
-                ),
-                (
-                    "    println!(\"hello\");\n".to_string(),
-                    DiffHunkStatus::Modified,
-                    DisplayRow(12)..DisplayRow(13)
-                ),
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(16)..DisplayRow(18)
-                ),
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(23)..DisplayRow(24)
-                ),
-                (
-                    "fn another2() {\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(28)..DisplayRow(28)
-                ),
-            ],
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![
-                DisplayRow(12)..=DisplayRow(12),
-                DisplayRow(16)..=DisplayRow(17),
-                DisplayRow(23)..=DisplayRow(23)
-            ]
-        );
-    });
 
+    // Fold across some of the diff hunks. They should no longer appear expanded.
     cx.update_editor(|editor, cx| editor.fold_selected_ranges(&FoldSelectedRanges, cx));
     cx.executor().run_until_parked();
-    cx.assert_editor_state(
-        &r#"
-        «use some::mod2;
 
-        const A: u32 = 42;
-        const C: u32 = 42;
+    // Hunks are not shown if their position is within a fold
+    cx.assert_diff_hunks(
+        r#"
+          use some::mod2;
 
-        fn main() {
-            //println!("hello");
+          const A: u32 = 42;
+          const C: u32 = 42;
 
-            println!("world");
-            //
-            //ˇ»
-        }
+          fn main() {
+              //println!("hello");
 
-        fn another() {
-            println!("another");
-            println!("another");
-        }
+              println!("world");
+              //
+              //
+          }
 
-            println!("another2");
-        }
+          fn another() {
+              println!("another");
+        +     println!("another");
+          }
+
+        - fn another2() {
+              println!("another2");
+          }
         "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![
-                (
-                    "use some::mod1;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(0)..DisplayRow(0)
-                ),
-                (
-                    "const B: u32 = 42;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(0)..DisplayRow(0)
-                ),
-                (
-                    "    println!(\"hello\");\n".to_string(),
-                    DiffHunkStatus::Modified,
-                    DisplayRow(0)..DisplayRow(0)
-                ),
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(0)..DisplayRow(1)
-                ),
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(6)..DisplayRow(7)
-                ),
-                (
-                    "fn another2() {\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(11)..DisplayRow(11)
-                ),
-            ],
-            "Hunk list should still return shifted folded hunks"
-        );
-        assert_eq!(
-            all_expanded_hunks,
-            vec![
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(6)..DisplayRow(7)
-                ),
-                (
-                    "fn another2() {\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(11)..DisplayRow(11)
-                ),
-            ],
-            "Only non-folded hunks should be left expanded"
-        );
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(0)..=DisplayRow(0), DisplayRow(6)..=DisplayRow(6)],
-            "Only one hunk is left not folded, its highlight should be visible"
-        );
-    });
 
     cx.update_editor(|editor, cx| {
         editor.select_all(&SelectAll, cx);
         editor.unfold_lines(&UnfoldLines, cx);
     });
     cx.executor().run_until_parked();
-    cx.assert_editor_state(
-        &r#"
-        «use some::mod2;
 
-        const A: u32 = 42;
-        const C: u32 = 42;
+    // The deletions reappear when unfolding.
+    cx.assert_diff_hunks(
+        r#"
+        - use some::mod1;
+          use some::mod2;
+
+          const A: u32 = 42;
+        - const B: u32 = 42;
+          const C: u32 = 42;
+
+          fn main() {
+        -     println!("hello");
+        +     //println!("hello");
+
+              println!("world");
+        +     //
+        +     //
+          }
+
+          fn another() {
+              println!("another");
+        +     println!("another");
+          }
+
+        - fn another2() {
+              println!("another2");
+          }
+        "#
+        .unindent(),
+    );
+}
 
-        fn main() {
-            //println!("hello");
+#[gpui::test]
+async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut gpui::TestAppContext) {
+    init_test(cx, |_| {});
 
-            println!("world");
-            //
-            //
-        }
+    let file_1_old = "aaa\nbbb\nccc\nddd\neee\nfff\nggg\nhhh\niii\njjj";
+    let file_1_new = "aaa\nccc\nddd\neee\nfff\nggg\nhhh\niii\njjj";
+    let file_2_old = "lll\nmmm\nnnn\nooo\nppp\nqqq\nrrr\nsss\nttt\nuuu";
+    let file_2_new = "lll\nmmm\nNNN\nooo\nppp\nqqq\nrrr\nsss\nttt\nuuu";
+    let file_3_old = "111\n222\n333\n444\n555\n777\n888\n999\n000\n!!!";
+    let file_3_new = "111\n222\n333\n444\n555\n666\n777\n888\n999\n000\n!!!";
 
-        fn another() {
-            println!("another");
-            println!("another");
-        }
-
-            println!("another2");
-        }
-        ˇ»"#
-        .unindent(),
-    );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![
-                (
-                    "use some::mod1;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(2)..DisplayRow(2)
-                ),
-                (
-                    "const B: u32 = 42;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(7)..DisplayRow(7)
-                ),
-                (
-                    "    println!(\"hello\");\n".to_string(),
-                    DiffHunkStatus::Modified,
-                    DisplayRow(12)..DisplayRow(13)
-                ),
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(16)..DisplayRow(18)
-                ),
-                (
-                    "".to_string(),
-                    DiffHunkStatus::Added,
-                    DisplayRow(23)..DisplayRow(24)
-                ),
-                (
-                    "fn another2() {\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(28)..DisplayRow(28)
-                ),
-            ],
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![
-                DisplayRow(12)..=DisplayRow(12),
-                DisplayRow(16)..=DisplayRow(17),
-                DisplayRow(23)..=DisplayRow(23)
-            ],
-            "After unfolding, all hunk diffs should be visible again"
-        );
-    });
-}
-
-#[gpui::test]
-async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut gpui::TestAppContext) {
-    init_test(cx, |_| {});
-
-    let cols = 4;
-    let rows = 10;
-    let sample_text_1 = sample_text(rows, cols, 'a');
-    assert_eq!(
-        sample_text_1,
-        "aaaa\nbbbb\ncccc\ndddd\neeee\nffff\ngggg\nhhhh\niiii\njjjj"
-    );
-    let modified_sample_text_1 = "aaaa\ncccc\ndddd\neeee\nffff\ngggg\nhhhh\niiii\njjjj";
-    let sample_text_2 = sample_text(rows, cols, 'l');
-    assert_eq!(
-        sample_text_2,
-        "llll\nmmmm\nnnnn\noooo\npppp\nqqqq\nrrrr\nssss\ntttt\nuuuu"
-    );
-    let modified_sample_text_2 = "llll\nmmmm\n1n1n1n1n1\noooo\npppp\nqqqq\nrrrr\nssss\ntttt\nuuuu";
-    let sample_text_3 = sample_text(rows, cols, 'v');
-    assert_eq!(
-        sample_text_3,
-        "vvvv\nwwww\nxxxx\nyyyy\nzzzz\n{{{{\n||||\n}}}}\n~~~~\n\u{7f}\u{7f}\u{7f}\u{7f}"
-    );
-    let modified_sample_text_3 =
-        "vvvv\nwwww\nxxxx\nyyyy\nzzzz\n@@@@\n{{{{\n||||\n}}}}\n~~~~\n\u{7f}\u{7f}\u{7f}\u{7f}";
-    let buffer_1 = cx.new_model(|cx| {
-        let mut buffer = Buffer::local(modified_sample_text_1.to_string(), cx);
-        buffer.set_diff_base(Some(sample_text_1.clone()), cx);
-        buffer
-    });
-    let buffer_2 = cx.new_model(|cx| {
-        let mut buffer = Buffer::local(modified_sample_text_2.to_string(), cx);
-        buffer.set_diff_base(Some(sample_text_2.clone()), cx);
-        buffer
-    });
-    let buffer_3 = cx.new_model(|cx| {
-        let mut buffer = Buffer::local(modified_sample_text_3.to_string(), cx);
-        buffer.set_diff_base(Some(sample_text_3.clone()), cx);
-        buffer
-    });
+    let buffer_1 = cx.new_model(|cx| {
+        let mut buffer = Buffer::local(file_1_new.to_string(), cx);
+        buffer.set_diff_base(Some(file_1_old.into()), cx);
+        buffer
+    });
+    let buffer_2 = cx.new_model(|cx| {
+        let mut buffer = Buffer::local(file_2_new.to_string(), cx);
+        buffer.set_diff_base(Some(file_2_old.into()), cx);
+        buffer
+    });
+    let buffer_3 = cx.new_model(|cx| {
+        let mut buffer = Buffer::local(file_3_new.to_string(), cx);
+        buffer.set_diff_base(Some(file_3_old.into()), cx);
+        buffer
+    });
 
     let multi_buffer = cx.new_model(|cx| {
         let mut multibuffer = MultiBuffer::new(ReadWrite);
@@ -11850,7 +11597,7 @@ async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut gpui::TestAppContext)
                     primary: None,
                 },
                 ExcerptRange {
-                    context: Point::new(9, 0)..Point::new(10, 4),
+                    context: Point::new(9, 0)..Point::new(10, 3),
                     primary: None,
                 },
             ],
@@ -11868,7 +11615,7 @@ async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut gpui::TestAppContext)
                     primary: None,
                 },
                 ExcerptRange {
-                    context: Point::new(9, 0)..Point::new(10, 4),
+                    context: Point::new(9, 0)..Point::new(10, 3),
                     primary: None,
                 },
             ],
@@ -11886,7 +11633,7 @@ async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut gpui::TestAppContext)
                     primary: None,
                 },
                 ExcerptRange {
-                    context: Point::new(9, 0)..Point::new(10, 4),
+                    context: Point::new(9, 0)..Point::new(10, 3),
                     primary: None,
                 },
             ],
@@ -11895,143 +11642,81 @@ async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut gpui::TestAppContext)
         multibuffer
     });
 
-    let fs = FakeFs::new(cx.executor());
-    fs.insert_tree(
-        "/a",
-        json!({
-            "main.rs": modified_sample_text_1,
-            "other.rs": modified_sample_text_2,
-            "lib.rs": modified_sample_text_3,
-        }),
-    )
-    .await;
+    let editor = cx.add_window(|cx| Editor::new(EditorMode::Full, multi_buffer, None, true, cx));
+    let mut cx = EditorTestContext::for_editor(editor, cx).await;
+    cx.run_until_parked();
 
-    let project = Project::test(fs, ["/a".as_ref()], cx).await;
-    let workspace = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
-    let cx = &mut VisualTestContext::from_window(*workspace.deref(), cx);
-    let multi_buffer_editor = cx.new_view(|cx| {
-        Editor::new(
-            EditorMode::Full,
-            multi_buffer,
-            Some(project.clone()),
-            true,
-            cx,
-        )
-    });
-    cx.executor().run_until_parked();
+    cx.assert_editor_state(
+        &"
+            ˇaaa
+            ccc
+            ddd
 
-    let expected_all_hunks = vec![
-        (
-            "bbbb\n".to_string(),
-            DiffHunkStatus::Removed,
-            DisplayRow(4)..DisplayRow(4),
-        ),
-        (
-            "nnnn\n".to_string(),
-            DiffHunkStatus::Modified,
-            DisplayRow(21)..DisplayRow(22),
-        ),
-        (
-            "".to_string(),
-            DiffHunkStatus::Added,
-            DisplayRow(41)..DisplayRow(42),
-        ),
-    ];
-    let expected_all_hunks_shifted = vec![
-        (
-            "bbbb\n".to_string(),
-            DiffHunkStatus::Removed,
-            DisplayRow(6)..DisplayRow(6),
-        ),
-        (
-            "nnnn\n".to_string(),
-            DiffHunkStatus::Modified,
-            DisplayRow(25)..DisplayRow(26),
-        ),
-        (
-            "".to_string(),
-            DiffHunkStatus::Added,
-            DisplayRow(46)..DisplayRow(47),
-        ),
-    ];
+            ggg
+            hhh
 
-    multi_buffer_editor.update(cx, |editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(expanded_hunks_background_highlights(editor, cx), Vec::new());
-        assert_eq!(all_hunks, expected_all_hunks);
-        assert_eq!(all_expanded_hunks, Vec::new());
-    });
 
-    multi_buffer_editor.update(cx, |editor, cx| {
+            lll
+            mmm
+            NNN
+
+            qqq
+            rrr
+
+            uuu
+            111
+            222
+            333
+
+            666
+            777
+
+            000
+            !!!"
+        .unindent(),
+    );
+
+    cx.update_editor(|editor, cx| {
         editor.select_all(&SelectAll, cx);
         editor.toggle_hunk_diff(&ToggleHunkDiff, cx);
     });
     cx.executor().run_until_parked();
-    multi_buffer_editor.update(cx, |editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![
-                DisplayRow(25)..=DisplayRow(25),
-                DisplayRow(46)..=DisplayRow(46)
-            ],
-        );
-        assert_eq!(all_hunks, expected_all_hunks_shifted);
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
 
-    multi_buffer_editor.update(cx, |editor, cx| {
-        editor.toggle_hunk_diff(&ToggleHunkDiff, cx);
-    });
-    cx.executor().run_until_parked();
-    multi_buffer_editor.update(cx, |editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(expanded_hunks_background_highlights(editor, cx), Vec::new());
-        assert_eq!(all_hunks, expected_all_hunks);
-        assert_eq!(all_expanded_hunks, Vec::new());
-    });
+    cx.assert_diff_hunks(
+        "
+            aaa
+          - bbb
+            ccc
+            ddd
 
-    multi_buffer_editor.update(cx, |editor, cx| {
-        editor.toggle_hunk_diff(&ToggleHunkDiff, cx);
-    });
-    cx.executor().run_until_parked();
-    multi_buffer_editor.update(cx, |editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![
-                DisplayRow(25)..=DisplayRow(25),
-                DisplayRow(46)..=DisplayRow(46)
-            ],
-        );
-        assert_eq!(all_hunks, expected_all_hunks_shifted);
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
+            ggg
+            hhh
 
-    multi_buffer_editor.update(cx, |editor, cx| {
-        editor.toggle_hunk_diff(&ToggleHunkDiff, cx);
-    });
-    cx.executor().run_until_parked();
-    multi_buffer_editor.update(cx, |editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(expanded_hunks_background_highlights(editor, cx), Vec::new());
-        assert_eq!(all_hunks, expected_all_hunks);
-        assert_eq!(all_expanded_hunks, Vec::new());
-    });
+
+            lll
+            mmm
+          - nnn
+          + NNN
+
+            qqq
+            rrr
+
+            uuu
+            111
+            222
+            333
+
+          + 666
+            777
+
+            000
+            !!!"
+        .unindent(),
+    );
 }
 
 #[gpui::test]
-async fn test_edits_around_toggled_additions(
+async fn test_edits_around_expanded_insertion_hunks(
     executor: BackgroundExecutor,
     cx: &mut gpui::TestAppContext,
 ) {
@@ -12074,71 +11759,21 @@ async fn test_edits_around_toggled_additions(
 
     cx.set_diff_base(Some(&diff_base));
     executor.run_until_parked();
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "".to_string(),
-                DiffHunkStatus::Added,
-                DisplayRow(4)..DisplayRow(7)
-            )]
-        );
-    });
+
     cx.update_editor(|editor, cx| {
         editor.expand_all_hunk_diffs(&ExpandAllHunkDiffs, cx);
     });
     executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
-        use some::mod1;
-        use some::mod2;
-
-        const A: u32 = 42;
-        const B: u32 = 42;
-        const C: u32 = 42;
-        ˇ
-
-        fn main() {
-            println!("hello");
 
-            println!("world");
-        }
-        "#
-        .unindent(),
-    );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "".to_string(),
-                DiffHunkStatus::Added,
-                DisplayRow(5)..DisplayRow(8)
-            )]
-        );
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(5)..=DisplayRow(7)]
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
-
-    cx.update_editor(|editor, cx| editor.handle_input("const D: u32 = 42;\n", cx));
-    executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
+    cx.assert_diff_hunks(
+        r#"
         use some::mod1;
         use some::mod2;
 
         const A: u32 = 42;
-        const B: u32 = 42;
-        const C: u32 = 42;
-        const D: u32 = 42;
-        ˇ
+      + const B: u32 = 42;
+      + const C: u32 = 42;
+      +
 
         fn main() {
             println!("hello");
@@ -12148,134 +11783,20 @@ async fn test_edits_around_toggled_additions(
         "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "".to_string(),
-                DiffHunkStatus::Added,
-                DisplayRow(5)..DisplayRow(9)
-            )]
-        );
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(5)..=DisplayRow(7)],
-            "Edited hunk should have one more line added"
-        );
-        assert_eq!(
-            all_hunks, all_expanded_hunks,
-            "Expanded hunk should also grow with the addition"
-        );
-    });
 
-    cx.update_editor(|editor, cx| editor.handle_input("const E: u32 = 42;\n", cx));
+    cx.update_editor(|editor, cx| editor.handle_input("const D: u32 = 42;\n", cx));
     executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
-        use some::mod1;
-        use some::mod2;
-
-        const A: u32 = 42;
-        const B: u32 = 42;
-        const C: u32 = 42;
-        const D: u32 = 42;
-        const E: u32 = 42;
-        ˇ
-
-        fn main() {
-            println!("hello");
 
-            println!("world");
-        }
-        "#
-        .unindent(),
-    );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "".to_string(),
-                DiffHunkStatus::Added,
-                DisplayRow(5)..DisplayRow(10)
-            )]
-        );
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(5)..=DisplayRow(7)],
-            "Edited hunk should have one more line added"
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
-
-    cx.update_editor(|editor, cx| {
-        editor.move_up(&MoveUp, cx);
-        editor.delete_line(&DeleteLine, cx);
-    });
-    executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
+    cx.assert_diff_hunks(
+        r#"
         use some::mod1;
         use some::mod2;
 
         const A: u32 = 42;
-        const B: u32 = 42;
-        const C: u32 = 42;
-        const D: u32 = 42;
-        ˇ
-
-        fn main() {
-            println!("hello");
-
-            println!("world");
-        }
-        "#
-        .unindent(),
-    );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "".to_string(),
-                DiffHunkStatus::Added,
-                DisplayRow(5)..DisplayRow(9)
-            )]
-        );
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(5)..=DisplayRow(7)],
-            "Deleting a line should shrint the hunk"
-        );
-        assert_eq!(
-            all_hunks, all_expanded_hunks,
-            "Expanded hunk should also shrink with the addition"
-        );
-    });
-
-    cx.update_editor(|editor, cx| {
-        editor.move_up(&MoveUp, cx);
-        editor.delete_line(&DeleteLine, cx);
-        editor.move_up(&MoveUp, cx);
-        editor.delete_line(&DeleteLine, cx);
-        editor.move_up(&MoveUp, cx);
-        editor.delete_line(&DeleteLine, cx);
-    });
-    executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
-        use some::mod1;
-        use some::mod2;
-
-        const A: u32 = 42;
-        ˇ
+      + const B: u32 = 42;
+      + const C: u32 = 42;
+      + const D: u32 = 42;
+      +
 
         fn main() {
             println!("hello");
@@ -12285,148 +11806,21 @@ async fn test_edits_around_toggled_additions(
         "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "".to_string(),
-                DiffHunkStatus::Added,
-                DisplayRow(6)..DisplayRow(7)
-            )]
-        );
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(6)..=DisplayRow(6)]
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
 
-    cx.update_editor(|editor, cx| {
-        editor.select_up_by_lines(&SelectUpByLines { lines: 5 }, cx);
-        editor.delete_line(&DeleteLine, cx);
-    });
-    executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
-        ˇ
-
-        fn main() {
-            println!("hello");
-
-            println!("world");
-        }
-        "#
-        .unindent(),
-    );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![
-                (
-                    "use some::mod1;\nuse some::mod2;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(0)..DisplayRow(0)
-                ),
-                (
-                    "const A: u32 = 42;\n".to_string(),
-                    DiffHunkStatus::Removed,
-                    DisplayRow(3)..DisplayRow(3)
-                )
-            ]
-        );
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            Vec::new(),
-            "Should close all stale expanded addition hunks"
-        );
-        assert_eq!(
-            all_expanded_hunks,
-            vec![(
-                "const A: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Removed,
-                DisplayRow(3)..DisplayRow(3)
-            )],
-            "Should open hunks that were adjacent to the stale addition one"
-        );
-    });
-}
-
-#[gpui::test]
-async fn test_edits_around_toggled_deletions(
-    executor: BackgroundExecutor,
-    cx: &mut gpui::TestAppContext,
-) {
-    init_test(cx, |_| {});
-
-    let mut cx = EditorTestContext::new(cx).await;
-
-    let diff_base = r#"
-        use some::mod1;
-        use some::mod2;
-
-        const A: u32 = 42;
-        const B: u32 = 42;
-        const C: u32 = 42;
-
-
-        fn main() {
-            println!("hello");
-
-            println!("world");
-        }
-        "#
-    .unindent();
+    cx.update_editor(|editor, cx| editor.handle_input("const E: u32 = 42;\n", cx));
     executor.run_until_parked();
-    cx.set_state(
-        &r#"
-        use some::mod1;
-        use some::mod2;
-
-        ˇconst B: u32 = 42;
-        const C: u32 = 42;
-
-
-        fn main() {
-            println!("hello");
-
-            println!("world");
-        }
-        "#
-        .unindent(),
-    );
 
-    cx.set_diff_base(Some(&diff_base));
-    executor.run_until_parked();
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const A: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Removed,
-                DisplayRow(3)..DisplayRow(3)
-            )]
-        );
-    });
-    cx.update_editor(|editor, cx| {
-        editor.expand_all_hunk_diffs(&ExpandAllHunkDiffs, cx);
-    });
-    executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
+    cx.assert_diff_hunks(
+        r#"
         use some::mod1;
-        use some::mod2;
-
-        ˇconst B: u32 = 42;
-        const C: u32 = 42;
+        use some::mod2;
 
+        const A: u32 = 42;
+      + const B: u32 = 42;
+      + const C: u32 = 42;
+      + const D: u32 = 42;
+      + const E: u32 = 42;
+      +
 
         fn main() {
             println!("hello");
@@ -12436,33 +11830,23 @@ async fn test_edits_around_toggled_deletions(
         "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(expanded_hunks_background_highlights(editor, cx), Vec::new());
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const A: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Removed,
-                DisplayRow(5)..DisplayRow(5)
-            )]
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
 
     cx.update_editor(|editor, cx| {
+        editor.move_up(&MoveUp, cx);
         editor.delete_line(&DeleteLine, cx);
     });
     executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
+
+    cx.assert_diff_hunks(
+        r#"
         use some::mod1;
         use some::mod2;
 
-        ˇconst C: u32 = 42;
-
+        const A: u32 = 42;
+      + const B: u32 = 42;
+      + const C: u32 = 42;
+      + const D: u32 = 42;
+      +
 
         fn main() {
             println!("hello");
@@ -12472,27 +11856,13 @@ async fn test_edits_around_toggled_deletions(
         "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            Vec::new(),
-            "Deleted hunks do not highlight current editor's background"
-        );
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const A: u32 = 42;\nconst B: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Removed,
-                DisplayRow(6)..DisplayRow(6)
-            )]
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
 
     cx.update_editor(|editor, cx| {
+        editor.move_up(&MoveUp, cx);
+        editor.delete_line(&DeleteLine, cx);
+        editor.move_up(&MoveUp, cx);
+        editor.delete_line(&DeleteLine, cx);
+        editor.move_up(&MoveUp, cx);
         editor.delete_line(&DeleteLine, cx);
     });
     executor.run_until_parked();
@@ -12501,6 +11871,7 @@ async fn test_edits_around_toggled_deletions(
         use some::mod1;
         use some::mod2;
 
+        const A: u32 = 42;
         ˇ
 
         fn main() {
@@ -12511,33 +11882,15 @@ async fn test_edits_around_toggled_deletions(
         "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(expanded_hunks_background_highlights(editor, cx), Vec::new());
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const A: u32 = 42;\nconst B: u32 = 42;\nconst C: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Removed,
-                DisplayRow(7)..DisplayRow(7)
-            )]
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
 
-    cx.update_editor(|editor, cx| {
-        editor.handle_input("replacement", cx);
-    });
-    executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
+    cx.assert_diff_hunks(
+        r#"
         use some::mod1;
         use some::mod2;
 
-        replacementˇ
+        const A: u32 = 42;
 
+      +
         fn main() {
             println!("hello");
 
@@ -12546,29 +11899,29 @@ async fn test_edits_around_toggled_deletions(
         "#
         .unindent(),
     );
+
     cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const A: u32 = 42;\nconst B: u32 = 42;\nconst C: u32 = 42;\n\n".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(8)..DisplayRow(9)
-            )]
-        );
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(8)..=DisplayRow(8)],
-            "Modified expanded hunks should display additions and highlight their background"
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
+        editor.select_up_by_lines(&SelectUpByLines { lines: 5 }, cx);
+        editor.delete_line(&DeleteLine, cx);
     });
+    executor.run_until_parked();
+    cx.assert_diff_hunks(
+        r#"
+
+      - const A: u32 = 42;
+
+        fn main() {
+            println!("hello");
+
+            println!("world");
+        }
+        "#
+        .unindent(),
+    );
 }
 
 #[gpui::test]
-async fn test_edits_around_toggled_modifications(
+async fn test_edits_around_expanded_deletion_hunks(
     executor: BackgroundExecutor,
     cx: &mut gpui::TestAppContext,
 ) {
@@ -12583,14 +11936,14 @@ async fn test_edits_around_toggled_modifications(
         const A: u32 = 42;
         const B: u32 = 42;
         const C: u32 = 42;
-        const D: u32 = 42;
 
 
         fn main() {
             println!("hello");
 
             println!("world");
-        }"#
+        }
+    "#
     .unindent();
     executor.run_until_parked();
     cx.set_state(
@@ -12598,298 +11951,165 @@ async fn test_edits_around_toggled_modifications(
         use some::mod1;
         use some::mod2;
 
-        const A: u32 = 42;
-        const B: u32 = 42;
-        const C: u32 = 43ˇ
-        const D: u32 = 42;
+        ˇconst B: u32 = 42;
+        const C: u32 = 42;
 
 
         fn main() {
             println!("hello");
 
             println!("world");
-        }"#
+        }
+        "#
         .unindent(),
     );
 
     cx.set_diff_base(Some(&diff_base));
     executor.run_until_parked();
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const C: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(5)..DisplayRow(6)
-            )]
-        );
-    });
+
     cx.update_editor(|editor, cx| {
         editor.expand_all_hunk_diffs(&ExpandAllHunkDiffs, cx);
     });
     executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
+
+    cx.assert_diff_hunks(
+        r#"
         use some::mod1;
         use some::mod2;
 
-        const A: u32 = 42;
+      - const A: u32 = 42;
         const B: u32 = 42;
-        const C: u32 = 43ˇ
-        const D: u32 = 42;
+        const C: u32 = 42;
 
 
         fn main() {
             println!("hello");
 
             println!("world");
-        }"#
+        }
+        "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(7)..=DisplayRow(7)],
-        );
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const C: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(7)..DisplayRow(8)
-            )]
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
 
     cx.update_editor(|editor, cx| {
-        editor.handle_input("\nnew_line\n", cx);
+        editor.delete_line(&DeleteLine, cx);
     });
     executor.run_until_parked();
     cx.assert_editor_state(
         &r#"
-            use some::mod1;
-            use some::mod2;
+        use some::mod1;
+        use some::mod2;
 
-            const A: u32 = 42;
-            const B: u32 = 42;
-            const C: u32 = 43
-            new_line
-            ˇ
-            const D: u32 = 42;
+        ˇconst C: u32 = 42;
 
 
-            fn main() {
-                println!("hello");
+        fn main() {
+            println!("hello");
 
-                println!("world");
-            }"#
+            println!("world");
+        }
+        "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(7)..=DisplayRow(7)],
-            "Modified hunk should grow highlighted lines on more text additions"
-        );
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const C: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(7)..DisplayRow(10)
-            )]
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
-
-    cx.update_editor(|editor, cx| {
-        editor.move_up(&MoveUp, cx);
-        editor.move_up(&MoveUp, cx);
-        editor.move_up(&MoveUp, cx);
-        editor.delete_line(&DeleteLine, cx);
-    });
-    executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
-            use some::mod1;
-            use some::mod2;
-
-            const A: u32 = 42;
-            ˇconst C: u32 = 43
-            new_line
+    cx.assert_diff_hunks(
+        r#"
+        use some::mod1;
+        use some::mod2;
 
-            const D: u32 = 42;
+      - const A: u32 = 42;
+      - const B: u32 = 42;
+        const C: u32 = 42;
 
 
-            fn main() {
-                println!("hello");
+        fn main() {
+            println!("hello");
 
-                println!("world");
-            }"#
+            println!("world");
+        }
+        "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(7)..=DisplayRow(9)],
-        );
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const B: u32 = 42;\nconst C: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(7)..DisplayRow(10)
-            )],
-            "Modified hunk should grow deleted lines on text deletions above"
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
 
     cx.update_editor(|editor, cx| {
-        editor.move_up(&MoveUp, cx);
-        editor.handle_input("v", cx);
+        editor.delete_line(&DeleteLine, cx);
     });
     executor.run_until_parked();
     cx.assert_editor_state(
         &r#"
-            use some::mod1;
-            use some::mod2;
+        use some::mod1;
+        use some::mod2;
+
+        ˇ
 
-            vˇconst A: u32 = 42;
-            const C: u32 = 43
-            new_line
+        fn main() {
+            println!("hello");
+
+            println!("world");
+        }
+        "#
+        .unindent(),
+    );
+    cx.assert_diff_hunks(
+        r#"
+        use some::mod1;
+        use some::mod2;
 
-            const D: u32 = 42;
+      - const A: u32 = 42;
+      - const B: u32 = 42;
+      - const C: u32 = 42;
 
 
-            fn main() {
-                println!("hello");
+        fn main() {
+            println!("hello");
 
-                println!("world");
-            }"#
+            println!("world");
+        }
+        "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(7)..=DisplayRow(10)],
-            "Modified hunk should grow deleted lines on text modifications above"
-        );
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const A: u32 = 42;\nconst B: u32 = 42;\nconst C: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(7)..DisplayRow(11)
-            )]
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
 
     cx.update_editor(|editor, cx| {
-        editor.move_down(&MoveDown, cx);
-        editor.move_down(&MoveDown, cx);
-        editor.delete_line(&DeleteLine, cx)
+        editor.handle_input("replacement", cx);
     });
     executor.run_until_parked();
     cx.assert_editor_state(
         &r#"
-            use some::mod1;
-            use some::mod2;
-
-            vconst A: u32 = 42;
-            const C: u32 = 43
-            ˇ
-            const D: u32 = 42;
+        use some::mod1;
+        use some::mod2;
 
+        replacementˇ
 
-            fn main() {
-                println!("hello");
+        fn main() {
+            println!("hello");
 
-                println!("world");
-            }"#
+            println!("world");
+        }
+        "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(7)..=DisplayRow(9)],
-            "Modified hunk should grow shrink lines on modification lines removal"
-        );
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const A: u32 = 42;\nconst B: u32 = 42;\nconst C: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(7)..DisplayRow(10)
-            )]
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
-
-    cx.update_editor(|editor, cx| {
-        editor.move_up(&MoveUp, cx);
-        editor.move_up(&MoveUp, cx);
-        editor.select_down_by_lines(&SelectDownByLines { lines: 4 }, cx);
-        editor.delete_line(&DeleteLine, cx)
-    });
-    executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
-            use some::mod1;
-            use some::mod2;
+    cx.assert_diff_hunks(
+        r#"
+        use some::mod1;
+        use some::mod2;
 
-            ˇ
+      - const A: u32 = 42;
+      - const B: u32 = 42;
+      - const C: u32 = 42;
+      -
+      + replacement
 
-            fn main() {
-                println!("hello");
+        fn main() {
+            println!("hello");
 
-                println!("world");
-            }"#
+            println!("world");
+        }
+        "#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            Vec::new(),
-            "Modified hunk should turn into a removed one on all modified lines removal"
-        );
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const A: u32 = 42;\nconst B: u32 = 42;\nconst C: u32 = 42;\nconst D: u32 = 42;\n"
-                    .to_string(),
-                DiffHunkStatus::Removed,
-                DisplayRow(8)..DisplayRow(8)
-            )]
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
 }
 
 #[gpui::test]
-async fn test_multiple_expanded_hunks_merge(
+async fn test_edit_after_expanded_modification_hunk(
     executor: BackgroundExecutor,
     cx: &mut gpui::TestAppContext,
 ) {
@@ -12913,7 +12133,7 @@ async fn test_multiple_expanded_hunks_merge(
             println!("world");
         }"#
     .unindent();
-    executor.run_until_parked();
+
     cx.set_state(
         &r#"
         use some::mod1;
@@ -12935,30 +12155,20 @@ async fn test_multiple_expanded_hunks_merge(
 
     cx.set_diff_base(Some(&diff_base));
     executor.run_until_parked();
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const C: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(5)..DisplayRow(6)
-            )]
-        );
-    });
     cx.update_editor(|editor, cx| {
         editor.expand_all_hunk_diffs(&ExpandAllHunkDiffs, cx);
     });
     executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
+
+    cx.assert_diff_hunks(
+        r#"
         use some::mod1;
         use some::mod2;
 
         const A: u32 = 42;
         const B: u32 = 42;
-        const C: u32 = 43ˇ
+      - const C: u32 = 42;
+      + const C: u32 = 43
         const D: u32 = 42;
 
 
@@ -12969,47 +12179,31 @@ async fn test_multiple_expanded_hunks_merge(
         }"#
         .unindent(),
     );
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let all_hunks = editor_hunks(editor, &snapshot, cx);
-        let all_expanded_hunks = expanded_hunks(editor, &snapshot, cx);
-        assert_eq!(
-            expanded_hunks_background_highlights(editor, cx),
-            vec![DisplayRow(7)..=DisplayRow(7)],
-        );
-        assert_eq!(
-            all_hunks,
-            vec![(
-                "const C: u32 = 42;\n".to_string(),
-                DiffHunkStatus::Modified,
-                DisplayRow(7)..DisplayRow(8)
-            )]
-        );
-        assert_eq!(all_hunks, all_expanded_hunks);
-    });
 
     cx.update_editor(|editor, cx| {
         editor.handle_input("\nnew_line\n", cx);
     });
     executor.run_until_parked();
-    cx.assert_editor_state(
-        &r#"
-            use some::mod1;
-            use some::mod2;
 
-            const A: u32 = 42;
-            const B: u32 = 42;
-            const C: u32 = 43
-            new_line
-            ˇ
-            const D: u32 = 42;
+    cx.assert_diff_hunks(
+        r#"
+        use some::mod1;
+        use some::mod2;
+
+        const A: u32 = 42;
+        const B: u32 = 42;
+      - const C: u32 = 42;
+      + const C: u32 = 43
+      + new_line
+      +
+        const D: u32 = 42;
 
 
-            fn main() {
-                println!("hello");
+        fn main() {
+            println!("hello");
 
-                println!("world");
-            }"#
+            println!("world");
+        }"#
         .unindent(),
     );
 }
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index 4fa1f10a8a17c9..e819032471f442 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -19,8 +19,8 @@ use util::RangeExt;
 use crate::{
     editor_settings::CurrentLineHighlight, hunk_status, hunks_for_selections, BlockDisposition,
     BlockProperties, BlockStyle, CustomBlockId, DiffRowHighlight, DisplayRow, DisplaySnapshot,
-    Editor, EditorElement, EditorSnapshot, ExpandAllHunkDiffs, GoToHunk, GoToPrevHunk,
-    RangeToAnchorExt, RevertFile, RevertSelectedHunks, ToDisplayPoint, ToggleHunkDiff,
+    Editor, EditorElement, EditorSnapshot, ExpandAllHunkDiffs, GoToHunk, GoToPrevHunk, RevertFile,
+    RevertSelectedHunks, ToDisplayPoint, ToggleHunkDiff,
 };
 
 #[derive(Debug, Clone)]
@@ -219,14 +219,7 @@ impl Editor {
                         });
                     }
 
-                    for removed_rows in highlights_to_remove {
-                        editor.highlight_rows::<DiffRowHighlight>(
-                            to_inclusive_row_range(removed_rows, &snapshot),
-                            None,
-                            false,
-                            cx,
-                        );
-                    }
+                    editor.remove_highlighted_rows::<DiffRowHighlight>(highlights_to_remove, cx);
                     editor.remove_blocks(blocks_to_remove, None, cx);
                     for hunk in hunks_to_expand {
                         editor.expand_diff_hunk(None, &hunk, cx);
@@ -306,7 +299,7 @@ impl Editor {
             DiffHunkStatus::Added => {
                 self.highlight_rows::<DiffRowHighlight>(
                     to_inclusive_row_range(hunk_start..hunk_end, &snapshot),
-                    Some(added_hunk_color(cx)),
+                    added_hunk_color(cx),
                     false,
                     cx,
                 );
@@ -315,7 +308,7 @@ impl Editor {
             DiffHunkStatus::Modified => {
                 self.highlight_rows::<DiffRowHighlight>(
                     to_inclusive_row_range(hunk_start..hunk_end, &snapshot),
-                    Some(added_hunk_color(cx)),
+                    added_hunk_color(cx),
                     false,
                     cx,
                 );
@@ -850,14 +843,7 @@ impl Editor {
                         retain
                     });
 
-                    for removed_rows in highlights_to_remove {
-                        editor.highlight_rows::<DiffRowHighlight>(
-                            to_inclusive_row_range(removed_rows, &snapshot),
-                            None,
-                            false,
-                            cx,
-                        );
-                    }
+                    editor.remove_highlighted_rows::<DiffRowHighlight>(highlights_to_remove, cx);
                     editor.remove_blocks(blocks_to_remove, None, cx);
 
                     if let Some(diff_base_buffer) = &diff_base_buffer {
@@ -978,7 +964,7 @@ fn editor_with_deleted_text(
         editor.set_show_inline_completions(Some(false), cx);
         editor.highlight_rows::<DiffRowHighlight>(
             Anchor::min()..=Anchor::max(),
-            Some(deleted_color),
+            deleted_color,
             false,
             cx,
         );
@@ -1060,15 +1046,16 @@ fn to_inclusive_row_range(
     row_range: Range<Anchor>,
     snapshot: &EditorSnapshot,
 ) -> RangeInclusive<Anchor> {
-    let mut display_row_range =
-        row_range.start.to_display_point(snapshot)..row_range.end.to_display_point(snapshot);
-    if display_row_range.end.row() > display_row_range.start.row() {
-        *display_row_range.end.row_mut() -= 1;
+    let mut end = row_range.end.to_point(&snapshot.buffer_snapshot);
+    if end.column == 0 && end.row > 0 {
+        end = Point::new(
+            end.row - 1,
+            snapshot
+                .buffer_snapshot
+                .line_len(MultiBufferRow(end.row - 1)),
+        );
     }
-    let point_range = display_row_range.start.to_point(&snapshot.display_snapshot)
-        ..display_row_range.end.to_point(&snapshot.display_snapshot);
-    let new_range = point_range.to_anchors(&snapshot.buffer_snapshot);
-    new_range.start..=new_range.end
+    row_range.start..=snapshot.buffer_snapshot.anchor_after(end)
 }
 
 impl DisplayDiffHunk {
diff --git a/crates/editor/src/test.rs b/crates/editor/src/test.rs
index 50214cd723ee31..d04b266e61802b 100644
--- a/crates/editor/src/test.rs
+++ b/crates/editor/src/test.rs
@@ -88,116 +88,3 @@ pub(crate) fn build_editor_with_project(
 ) -> Editor {
     Editor::new(EditorMode::Full, buffer, Some(project), true, cx)
 }
-
-#[cfg(any(test, feature = "test-support"))]
-pub fn editor_hunks(
-    editor: &Editor,
-    snapshot: &DisplaySnapshot,
-    cx: &mut ViewContext<'_, Editor>,
-) -> Vec<(
-    String,
-    git::diff::DiffHunkStatus,
-    std::ops::Range<crate::DisplayRow>,
-)> {
-    use multi_buffer::MultiBufferRow;
-    use text::Point;
-
-    use crate::hunk_status;
-
-    snapshot
-        .buffer_snapshot
-        .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
-        .map(|hunk| {
-            let display_range = Point::new(hunk.row_range.start.0, 0)
-                .to_display_point(snapshot)
-                .row()
-                ..Point::new(hunk.row_range.end.0, 0)
-                    .to_display_point(snapshot)
-                    .row();
-            let (_, buffer, _) = editor
-                .buffer()
-                .read(cx)
-                .excerpt_containing(Point::new(hunk.row_range.start.0, 0), cx)
-                .expect("no excerpt for expanded buffer's hunk start");
-            let diff_base = buffer
-                .read(cx)
-                .diff_base()
-                .expect("should have a diff base for expanded hunk")
-                .slice(hunk.diff_base_byte_range.clone())
-                .to_string();
-            (diff_base, hunk_status(&hunk), display_range)
-        })
-        .collect()
-}
-
-#[cfg(any(test, feature = "test-support"))]
-pub fn expanded_hunks(
-    editor: &Editor,
-    snapshot: &DisplaySnapshot,
-    cx: &mut ViewContext<'_, Editor>,
-) -> Vec<(
-    String,
-    git::diff::DiffHunkStatus,
-    std::ops::Range<crate::DisplayRow>,
-)> {
-    editor
-        .expanded_hunks
-        .hunks(false)
-        .map(|expanded_hunk| {
-            let hunk_display_range = expanded_hunk
-                .hunk_range
-                .start
-                .to_display_point(snapshot)
-                .row()
-                ..expanded_hunk
-                    .hunk_range
-                    .end
-                    .to_display_point(snapshot)
-                    .row();
-            let (_, buffer, _) = editor
-                .buffer()
-                .read(cx)
-                .excerpt_containing(expanded_hunk.hunk_range.start, cx)
-                .expect("no excerpt for expanded buffer's hunk start");
-            let diff_base = buffer
-                .read(cx)
-                .diff_base()
-                .expect("should have a diff base for expanded hunk")
-                .slice(expanded_hunk.diff_base_byte_range.clone())
-                .to_string();
-            (diff_base, expanded_hunk.status, hunk_display_range)
-        })
-        .collect()
-}
-
-#[cfg(any(test, feature = "test-support"))]
-pub fn expanded_hunks_background_highlights(
-    editor: &mut Editor,
-    cx: &mut gpui::WindowContext,
-) -> Vec<std::ops::RangeInclusive<crate::DisplayRow>> {
-    use crate::DisplayRow;
-
-    let mut highlights = Vec::new();
-
-    let mut range_start = 0;
-    let mut previous_highlighted_row = None;
-    for (highlighted_row, _) in editor.highlighted_display_rows(cx) {
-        match previous_highlighted_row {
-            Some(previous_row) => {
-                if previous_row + 1 != highlighted_row.0 {
-                    highlights.push(DisplayRow(range_start)..=DisplayRow(previous_row));
-                    range_start = highlighted_row.0;
-                }
-            }
-            None => {
-                range_start = highlighted_row.0;
-            }
-        }
-        previous_highlighted_row = Some(highlighted_row.0);
-    }
-    if let Some(previous_row) = previous_highlighted_row {
-        highlights.push(DisplayRow(range_start)..=DisplayRow(previous_row));
-    }
-
-    highlights
-}
diff --git a/crates/editor/src/test/editor_test_context.rs b/crates/editor/src/test/editor_test_context.rs
index 3e4ef174d422ae..2ec4f4a3b7b7bc 100644
--- a/crates/editor/src/test/editor_test_context.rs
+++ b/crates/editor/src/test/editor_test_context.rs
@@ -1,17 +1,18 @@
 use crate::{
-    display_map::ToDisplayPoint, AnchorRangeExt, Autoscroll, DisplayPoint, Editor, MultiBuffer,
-    RowExt,
+    display_map::ToDisplayPoint, AnchorRangeExt, Autoscroll, DiffRowHighlight, DisplayPoint,
+    Editor, MultiBuffer, RowExt,
 };
 use collections::BTreeMap;
 use futures::Future;
+use git::diff::DiffHunkStatus;
 use gpui::{
     AnyWindowHandle, AppContext, Keystroke, ModelContext, Pixels, Point, View, ViewContext,
-    VisualTestContext,
+    VisualTestContext, WindowHandle,
 };
 use indoc::indoc;
 use itertools::Itertools;
 use language::{Buffer, BufferSnapshot, LanguageRegistry};
-use multi_buffer::ExcerptRange;
+use multi_buffer::{ExcerptRange, ToPoint};
 use parking_lot::RwLock;
 use project::{FakeFs, Project};
 use std::{
@@ -71,6 +72,16 @@ impl EditorTestContext {
         }
     }
 
+    pub async fn for_editor(editor: WindowHandle<Editor>, cx: &mut gpui::TestAppContext) -> Self {
+        let editor_view = editor.root_view(cx).unwrap();
+        Self {
+            cx: VisualTestContext::from_window(*editor.deref(), cx),
+            window: editor.into(),
+            editor: editor_view,
+            assertion_cx: AssertionContextManager::new(),
+        }
+    }
+
     pub fn new_multibuffer<const COUNT: usize>(
         cx: &mut gpui::TestAppContext,
         excerpts: [&str; COUNT],
@@ -297,6 +308,76 @@ impl EditorTestContext {
         state_context
     }
 
+    #[track_caller]
+    pub fn assert_diff_hunks(&mut self, expected_diff: String) {
+        // Normalize the expected diff. If it has no diff markers, then insert blank markers
+        // before each line. Strip any whitespace-only lines.
+        let has_diff_markers = expected_diff
+            .lines()
+            .any(|line| line.starts_with("+") || line.starts_with("-"));
+        let expected_diff_text = expected_diff
+            .split('\n')
+            .map(|line| {
+                let trimmed = line.trim();
+                if trimmed.is_empty() {
+                    String::new()
+                } else if has_diff_markers {
+                    line.to_string()
+                } else {
+                    format!("  {line}")
+                }
+            })
+            .join("\n");
+
+        // Read the actual diff from the editor's row highlights and block
+        // decorations.
+        let actual_diff = self.editor.update(&mut self.cx, |editor, cx| {
+            let snapshot = editor.snapshot(cx);
+            let text = editor.text(cx);
+            let insertions = editor
+                .highlighted_rows::<DiffRowHighlight>()
+                .map(|(range, _)| {
+                    range.start().to_point(&snapshot.buffer_snapshot).row
+                        ..range.end().to_point(&snapshot.buffer_snapshot).row + 1
+                })
+                .collect::<Vec<_>>();
+            let deletions = editor
+                .expanded_hunks
+                .hunks
+                .iter()
+                .filter_map(|hunk| {
+                    if hunk.blocks.is_empty() {
+                        return None;
+                    }
+                    let row = hunk
+                        .hunk_range
+                        .start
+                        .to_point(&snapshot.buffer_snapshot)
+                        .row;
+                    let (_, buffer, _) = editor
+                        .buffer()
+                        .read(cx)
+                        .excerpt_containing(hunk.hunk_range.start, cx)
+                        .expect("no excerpt for expanded buffer's hunk start");
+                    let deleted_text = buffer
+                        .read(cx)
+                        .diff_base()
+                        .expect("should have a diff base for expanded hunk")
+                        .slice(hunk.diff_base_byte_range.clone())
+                        .to_string();
+                    if let DiffHunkStatus::Modified | DiffHunkStatus::Removed = hunk.status {
+                        Some((row, deleted_text))
+                    } else {
+                        None
+                    }
+                })
+                .collect::<Vec<_>>();
+            format_diff(text, deletions, insertions)
+        });
+
+        pretty_assertions::assert_eq!(actual_diff, expected_diff_text, "unexpected diff state");
+    }
+
     /// Make an assertion about the editor's text and the ranges and directions
     /// of its selections using a string containing embedded range markers.
     ///
@@ -401,6 +482,46 @@ impl EditorTestContext {
     }
 }
 
+fn format_diff(
+    text: String,
+    actual_deletions: Vec<(u32, String)>,
+    actual_insertions: Vec<Range<u32>>,
+) -> String {
+    let mut diff = String::new();
+    for (row, line) in text.split('\n').enumerate() {
+        let row = row as u32;
+        if row > 0 {
+            diff.push('\n');
+        }
+        if let Some(text) = actual_deletions
+            .iter()
+            .find_map(|(deletion_row, deleted_text)| {
+                if *deletion_row == row {
+                    Some(deleted_text)
+                } else {
+                    None
+                }
+            })
+        {
+            for line in text.lines() {
+                diff.push('-');
+                if !line.is_empty() {
+                    diff.push(' ');
+                    diff.push_str(line);
+                }
+                diff.push('\n');
+            }
+        }
+        let marker = if actual_insertions.iter().any(|range| range.contains(&row)) {
+            "+ "
+        } else {
+            "  "
+        };
+        diff.push_str(format!("{marker}{line}").trim_end());
+    }
+    diff
+}
+
 impl Deref for EditorTestContext {
     type Target = gpui::VisualTestContext;
 
diff --git a/crates/go_to_line/src/go_to_line.rs b/crates/go_to_line/src/go_to_line.rs
index 4f3e6194a022eb..fd631648c2c759 100644
--- a/crates/go_to_line/src/go_to_line.rs
+++ b/crates/go_to_line/src/go_to_line.rs
@@ -121,7 +121,7 @@ impl GoToLine {
                 active_editor.clear_row_highlights::<GoToLineRowHighlights>();
                 active_editor.highlight_rows::<GoToLineRowHighlights>(
                     anchor..=anchor,
-                    Some(cx.theme().colors().editor_highlighted_line_background),
+                    cx.theme().colors().editor_highlighted_line_background,
                     true,
                     cx,
                 );
diff --git a/crates/outline/src/outline.rs b/crates/outline/src/outline.rs
index cd641636349e39..520311b6f3c625 100644
--- a/crates/outline/src/outline.rs
+++ b/crates/outline/src/outline.rs
@@ -144,7 +144,7 @@ impl OutlineViewDelegate {
                 active_editor.clear_row_highlights::<OutlineRowHighlights>();
                 active_editor.highlight_rows::<OutlineRowHighlights>(
                     outline_item.range.start..=outline_item.range.end,
-                    Some(cx.theme().colors().editor_highlighted_line_background),
+                    cx.theme().colors().editor_highlighted_line_background,
                     true,
                     cx,
                 );
@@ -240,10 +240,10 @@ impl PickerDelegate for OutlineViewDelegate {
         self.prev_scroll_position.take();
 
         self.active_editor.update(cx, |active_editor, cx| {
-            if let Some(rows) = active_editor
+            let highlight = active_editor
                 .highlighted_rows::<OutlineRowHighlights>()
-                .and_then(|highlights| highlights.into_iter().next().map(|(rows, _)| rows.clone()))
-            {
+                .next();
+            if let Some((rows, _)) = highlight {
                 active_editor.change_selections(Some(Autoscroll::center()), cx, |s| {
                     s.select_ranges([*rows.start()..*rows.start()])
                 });

From d5f67406b0b7eb9ffd261b79467d17c1dc28a041 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Fri, 27 Sep 2024 22:42:04 +0300
Subject: [PATCH 378/762] Install cargo-edito without extra features (#18457)

https://github.com/killercup/cargo-edit/pull/907 removed the feature
from the crate

Release Notes:

- N/A
---
 .github/workflows/bump_patch_version.yml | 2 +-
 script/lib/bump-version.sh               | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/bump_patch_version.yml b/.github/workflows/bump_patch_version.yml
index d05da31e6a0f67..b875ff7b221028 100644
--- a/.github/workflows/bump_patch_version.yml
+++ b/.github/workflows/bump_patch_version.yml
@@ -41,7 +41,7 @@ jobs:
               exit 1
               ;;
           esac
-          which cargo-set-version > /dev/null || cargo install cargo-edit --features vendored-openssl
+          which cargo-set-version > /dev/null || cargo install cargo-edit
           output=$(cargo set-version -p zed --bump patch 2>&1 | sed 's/.* //')
           git commit -am "Bump to $output for @$GITHUB_ACTOR" --author "Zed Bot <hi@zed.dev>"
           git tag v${output}${tag_suffix}
diff --git a/script/lib/bump-version.sh b/script/lib/bump-version.sh
index 0e1dfa5131d6a7..ce955369505dbf 100755
--- a/script/lib/bump-version.sh
+++ b/script/lib/bump-version.sh
@@ -12,7 +12,7 @@ if [[ -n $(git status --short --untracked-files=no) ]]; then
   exit 1
 fi
 
-which cargo-set-version > /dev/null || cargo install cargo-edit --features vendored-openssl
+which cargo-set-version > /dev/null || cargo install cargo-edit
 which jq > /dev/null || brew install jq
 cargo set-version --package $package --bump $version_increment
 cargo check --quiet

From 1c5be9de4e8c17419480a922f33f513a2ff197de Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Fri, 27 Sep 2024 22:02:32 +0200
Subject: [PATCH 379/762] Capitalize tooltip labels on buffer search (#18458)

For consistency, as this seems to be the pattern we're using overall for
labels and buttons.

---

Release Notes:

- N/A
---
 crates/search/src/buffer_search.rs | 14 +++++++-------
 crates/search/src/search.rs        |  6 +++---
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs
index 6e660a963b987d..42b267c3c9563a 100644
--- a/crates/search/src/buffer_search.rs
+++ b/crates/search/src/buffer_search.rs
@@ -288,7 +288,7 @@ impl Render for BufferSearchBar {
                         let focus_handle = focus_handle.clone();
                         move |cx| {
                             Tooltip::for_action_in(
-                                "Toggle search selection",
+                                "Toggle Search Selection",
                                 &ToggleSelection,
                                 &focus_handle,
                                 cx,
@@ -308,7 +308,7 @@ impl Render for BufferSearchBar {
                                 let focus_handle = focus_handle.clone();
                                 move |cx| {
                                     Tooltip::for_action_in(
-                                        "Select all matches",
+                                        "Select All Matches",
                                         &SelectAllMatches,
                                         &focus_handle,
                                         cx,
@@ -319,14 +319,14 @@ impl Render for BufferSearchBar {
                     .child(render_nav_button(
                         ui::IconName::ChevronLeft,
                         self.active_match_index.is_some(),
-                        "Select previous match",
+                        "Select Previous Match",
                         &SelectPrevMatch,
                         focus_handle.clone(),
                     ))
                     .child(render_nav_button(
                         ui::IconName::ChevronRight,
                         self.active_match_index.is_some(),
-                        "Select next match",
+                        "Select Next Match",
                         &SelectNextMatch,
                         focus_handle.clone(),
                     ))
@@ -373,7 +373,7 @@ impl Render for BufferSearchBar {
                                     let focus_handle = focus_handle.clone();
                                     move |cx| {
                                         Tooltip::for_action_in(
-                                            "Replace next match",
+                                            "Replace Next Match",
                                             &ReplaceNext,
                                             &focus_handle,
                                             cx,
@@ -390,7 +390,7 @@ impl Render for BufferSearchBar {
                                     let focus_handle = focus_handle.clone();
                                     move |cx| {
                                         Tooltip::for_action_in(
-                                            "Replace all matches",
+                                            "Replace All Matches",
                                             &ReplaceAll,
                                             &focus_handle,
                                             cx,
@@ -442,7 +442,7 @@ impl Render for BufferSearchBar {
                         div.child(
                             IconButton::new(SharedString::from("Close"), IconName::Close)
                                 .tooltip(move |cx| {
-                                    Tooltip::for_action("Close search bar", &Dismiss, cx)
+                                    Tooltip::for_action("Close Search Bar", &Dismiss, cx)
                                 })
                                 .on_click(cx.listener(|this, _: &ClickEvent, cx| {
                                     this.dismiss(&Dismiss, cx)
diff --git a/crates/search/src/search.rs b/crates/search/src/search.rs
index d13a12576b0f94..0ceb8e710b5f41 100644
--- a/crates/search/src/search.rs
+++ b/crates/search/src/search.rs
@@ -53,10 +53,10 @@ bitflags! {
 impl SearchOptions {
     pub fn label(&self) -> &'static str {
         match *self {
-            SearchOptions::WHOLE_WORD => "Match whole words",
-            SearchOptions::CASE_SENSITIVE => "Match case sensitively",
+            SearchOptions::WHOLE_WORD => "Match Whole Words",
+            SearchOptions::CASE_SENSITIVE => "Match Case Sensitively",
             SearchOptions::INCLUDE_IGNORED => "Also search files ignored by configuration",
-            SearchOptions::REGEX => "Use regular expressions",
+            SearchOptions::REGEX => "Use Regular Expressions",
             _ => panic!("{:?} is not a named SearchOption", self),
         }
     }

From 689da9d0b1b8ff32ebecdd2dbe8d5c93b4c7a3bf Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Fri, 27 Sep 2024 13:13:55 -0700
Subject: [PATCH 380/762] Move git hunk controls to the left side (#18460)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

![Screenshot 2024-09-27 at 1 05
14 PM](https://github.com/user-attachments/assets/260a7d05-daa8-4a22-92bc-3b956035227f)

Release Notes:

- N/A
---
 crates/editor/src/hunk_diff.rs | 131 ++++++++++++++++-----------------
 1 file changed, 64 insertions(+), 67 deletions(-)

diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index e819032471f442..3e18b992c1dae8 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -513,49 +513,7 @@ impl Editor {
                                                         });
                                                     }
                                                 }),
-                                        ),
-                                )
-                                .child(
-                                    h_flex()
-                                        .gap_2()
-                                        .pr_6()
-                                        .child({
-                                            let focus = editor.focus_handle(cx);
-                                            PopoverMenu::new("hunk-controls-dropdown")
-                                                .trigger(
-                                                    IconButton::new(
-                                                        "toggle_editor_selections_icon",
-                                                        IconName::EllipsisVertical,
-                                                    )
-                                                    .shape(IconButtonShape::Square)
-                                                    .icon_size(IconSize::Small)
-                                                    .style(ButtonStyle::Subtle)
-                                                    .selected(
-                                                        hunk_controls_menu_handle.is_deployed(),
-                                                    )
-                                                    .when(
-                                                        !hunk_controls_menu_handle.is_deployed(),
-                                                        |this| {
-                                                            this.tooltip(|cx| {
-                                                                Tooltip::text("Hunk Controls", cx)
-                                                            })
-                                                        },
-                                                    ),
-                                                )
-                                                .anchor(AnchorCorner::TopRight)
-                                                .with_handle(hunk_controls_menu_handle)
-                                                .menu(move |cx| {
-                                                    let focus = focus.clone();
-                                                    let menu =
-                                                        ContextMenu::build(cx, move |menu, _| {
-                                                            menu.context(focus.clone()).action(
-                                                                "Discard All",
-                                                                RevertFile.boxed_clone(),
-                                                            )
-                                                        });
-                                                    Some(menu)
-                                                })
-                                        })
+                                        )
                                         .child(
                                             IconButton::new("discard", IconName::RotateCcw)
                                                 .shape(IconButtonShape::Square)
@@ -601,31 +559,70 @@ impl Editor {
                                                     }
                                                 }),
                                         )
-                                        .child(
-                                            IconButton::new("collapse", IconName::Close)
-                                                .shape(IconButtonShape::Square)
-                                                .icon_size(IconSize::Small)
-                                                .tooltip({
-                                                    let focus_handle = editor.focus_handle(cx);
-                                                    move |cx| {
-                                                        Tooltip::for_action_in(
-                                                            "Collapse Hunk",
-                                                            &ToggleHunkDiff,
-                                                            &focus_handle,
-                                                            cx,
-                                                        )
-                                                    }
-                                                })
-                                                .on_click({
-                                                    let editor = editor.clone();
-                                                    let hunk = hunk.clone();
-                                                    move |_event, cx| {
-                                                        editor.update(cx, |editor, cx| {
-                                                            editor.toggle_hovered_hunk(&hunk, cx);
+                                        .child({
+                                            let focus = editor.focus_handle(cx);
+                                            PopoverMenu::new("hunk-controls-dropdown")
+                                                .trigger(
+                                                    IconButton::new(
+                                                        "toggle_editor_selections_icon",
+                                                        IconName::EllipsisVertical,
+                                                    )
+                                                    .shape(IconButtonShape::Square)
+                                                    .icon_size(IconSize::Small)
+                                                    .style(ButtonStyle::Subtle)
+                                                    .selected(
+                                                        hunk_controls_menu_handle.is_deployed(),
+                                                    )
+                                                    .when(
+                                                        !hunk_controls_menu_handle.is_deployed(),
+                                                        |this| {
+                                                            this.tooltip(|cx| {
+                                                                Tooltip::text("Hunk Controls", cx)
+                                                            })
+                                                        },
+                                                    ),
+                                                )
+                                                .anchor(AnchorCorner::TopRight)
+                                                .with_handle(hunk_controls_menu_handle)
+                                                .menu(move |cx| {
+                                                    let focus = focus.clone();
+                                                    let menu =
+                                                        ContextMenu::build(cx, move |menu, _| {
+                                                            menu.context(focus.clone()).action(
+                                                                "Discard All",
+                                                                RevertFile.boxed_clone(),
+                                                            )
                                                         });
-                                                    }
-                                                }),
-                                        ),
+                                                    Some(menu)
+                                                })
+                                        }),
+                                )
+                                .child(
+                                    h_flex().gap_2().pr_6().child(
+                                        IconButton::new("collapse", IconName::Close)
+                                            .shape(IconButtonShape::Square)
+                                            .icon_size(IconSize::Small)
+                                            .tooltip({
+                                                let focus_handle = editor.focus_handle(cx);
+                                                move |cx| {
+                                                    Tooltip::for_action_in(
+                                                        "Collapse Hunk",
+                                                        &ToggleHunkDiff,
+                                                        &focus_handle,
+                                                        cx,
+                                                    )
+                                                }
+                                            })
+                                            .on_click({
+                                                let editor = editor.clone();
+                                                let hunk = hunk.clone();
+                                                move |_event, cx| {
+                                                    editor.update(cx, |editor, cx| {
+                                                        editor.toggle_hovered_hunk(&hunk, cx);
+                                                    });
+                                                }
+                                            }),
+                                    ),
                                 ),
                         )
                         .into_any_element()

From 0daa070448d3a5078cd274ddbd5ec18e425c63d3 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Fri, 27 Sep 2024 13:48:37 -0700
Subject: [PATCH 381/762] More git hunk highlighting fixes (#18459)

Follow-up to https://github.com/zed-industries/zed/pull/18454

Release Notes:

- N/A
---
 crates/assistant/src/inline_assistant.rs      |  8 +--
 crates/editor/src/editor.rs                   | 63 +++++++++----------
 crates/editor/src/editor_tests.rs             | 11 ++--
 crates/editor/src/hunk_diff.rs                | 29 ++-------
 crates/editor/src/test/editor_test_context.rs | 32 +++-------
 crates/go_to_line/src/go_to_line.rs           | 22 ++++---
 crates/outline/src/outline.rs                 |  4 +-
 7 files changed, 69 insertions(+), 100 deletions(-)

diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index e2f2fa190d3977..fac70f233c6562 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -1208,7 +1208,7 @@ impl InlineAssistant {
                     editor.set_read_only(true);
                     editor.set_show_inline_completions(Some(false), cx);
                     editor.highlight_rows::<DeletedLines>(
-                        Anchor::min()..=Anchor::max(),
+                        Anchor::min()..Anchor::max(),
                         cx.theme().status().deleted_background,
                         false,
                         cx,
@@ -2557,7 +2557,7 @@ enum CodegenStatus {
 #[derive(Default)]
 struct Diff {
     deleted_row_ranges: Vec<(Anchor, RangeInclusive<u32>)>,
-    inserted_row_ranges: Vec<RangeInclusive<Anchor>>,
+    inserted_row_ranges: Vec<Range<Anchor>>,
 }
 
 impl Diff {
@@ -3103,7 +3103,7 @@ impl CodegenAlternative {
                         new_end_row,
                         new_snapshot.line_len(MultiBufferRow(new_end_row)),
                     ));
-                    self.diff.inserted_row_ranges.push(start..=end);
+                    self.diff.inserted_row_ranges.push(start..end);
                     new_row += lines;
                 }
             }
@@ -3181,7 +3181,7 @@ impl CodegenAlternative {
                                     new_end_row,
                                     new_snapshot.line_len(MultiBufferRow(new_end_row)),
                                 ));
-                                inserted_row_ranges.push(start..=end);
+                                inserted_row_ranges.push(start..end);
                                 new_row += line_count;
                             }
                         }
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 48785dbaa55cfc..b604f388debd58 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -821,7 +821,7 @@ impl SelectionHistory {
 
 struct RowHighlight {
     index: usize,
-    range: RangeInclusive<Anchor>,
+    range: Range<Anchor>,
     color: Hsla,
     should_autoscroll: bool,
 }
@@ -11502,9 +11502,11 @@ impl Editor {
 
     /// Adds a row highlight for the given range. If a row has multiple highlights, the
     /// last highlight added will be used.
+    ///
+    /// If the range ends at the beginning of a line, then that line will not be highlighted.
     pub fn highlight_rows<T: 'static>(
         &mut self,
-        range: RangeInclusive<Anchor>,
+        range: Range<Anchor>,
         color: Hsla,
         should_autoscroll: bool,
         cx: &mut ViewContext<Self>,
@@ -11513,8 +11515,8 @@ impl Editor {
         let row_highlights = self.highlighted_rows.entry(TypeId::of::<T>()).or_default();
         let ix = row_highlights.binary_search_by(|highlight| {
             Ordering::Equal
-                .then_with(|| highlight.range.start().cmp(&range.start(), &snapshot))
-                .then_with(|| highlight.range.end().cmp(&range.end(), &snapshot))
+                .then_with(|| highlight.range.start.cmp(&range.start, &snapshot))
+                .then_with(|| highlight.range.end.cmp(&range.end, &snapshot))
         });
 
         if let Err(mut ix) = ix {
@@ -11527,18 +11529,13 @@ impl Editor {
                 let prev_highlight = &mut row_highlights[ix - 1];
                 if prev_highlight
                     .range
-                    .end()
-                    .cmp(&range.start(), &snapshot)
+                    .end
+                    .cmp(&range.start, &snapshot)
                     .is_ge()
                 {
                     ix -= 1;
-                    if prev_highlight
-                        .range
-                        .end()
-                        .cmp(&range.end(), &snapshot)
-                        .is_lt()
-                    {
-                        prev_highlight.range = *prev_highlight.range.start()..=*range.end();
+                    if prev_highlight.range.end.cmp(&range.end, &snapshot).is_lt() {
+                        prev_highlight.range.end = range.end;
                     }
                     merged = true;
                     prev_highlight.index = index;
@@ -11564,18 +11561,17 @@ impl Editor {
                 let highlight = &row_highlights[ix];
                 if next_highlight
                     .range
-                    .start()
-                    .cmp(&highlight.range.end(), &snapshot)
+                    .start
+                    .cmp(&highlight.range.end, &snapshot)
                     .is_le()
                 {
                     if next_highlight
                         .range
-                        .end()
-                        .cmp(&highlight.range.end(), &snapshot)
+                        .end
+                        .cmp(&highlight.range.end, &snapshot)
                         .is_gt()
                     {
-                        row_highlights[ix].range =
-                            *highlight.range.start()..=*next_highlight.range.end();
+                        row_highlights[ix].range.end = next_highlight.range.end;
                     }
                     row_highlights.remove(ix + 1);
                 } else {
@@ -11597,15 +11593,12 @@ impl Editor {
         let mut ranges_to_remove = ranges_to_remove.iter().peekable();
         row_highlights.retain(|highlight| {
             while let Some(range_to_remove) = ranges_to_remove.peek() {
-                match range_to_remove.end.cmp(&highlight.range.start(), &snapshot) {
-                    Ordering::Less => {
+                match range_to_remove.end.cmp(&highlight.range.start, &snapshot) {
+                    Ordering::Less | Ordering::Equal => {
                         ranges_to_remove.next();
                     }
-                    Ordering::Equal => {
-                        return false;
-                    }
                     Ordering::Greater => {
-                        match range_to_remove.start.cmp(&highlight.range.end(), &snapshot) {
+                        match range_to_remove.start.cmp(&highlight.range.end, &snapshot) {
                             Ordering::Less | Ordering::Equal => {
                                 return false;
                             }
@@ -11625,9 +11618,7 @@ impl Editor {
     }
 
     /// For a highlight given context type, gets all anchor ranges that will be used for row highlighting.
-    pub fn highlighted_rows<T: 'static>(
-        &self,
-    ) -> impl '_ + Iterator<Item = (RangeInclusive<Anchor>, Hsla)> {
+    pub fn highlighted_rows<T: 'static>(&self) -> impl '_ + Iterator<Item = (Range<Anchor>, Hsla)> {
         self.highlighted_rows
             .get(&TypeId::of::<T>())
             .map_or(&[] as &[_], |vec| vec.as_slice())
@@ -11650,9 +11641,17 @@ impl Editor {
             .fold(
                 BTreeMap::<DisplayRow, Hsla>::new(),
                 |mut unique_rows, highlight| {
-                    let start_row = highlight.range.start().to_display_point(&snapshot).row();
-                    let end_row = highlight.range.end().to_display_point(&snapshot).row();
-                    for row in start_row.0..=end_row.0 {
+                    let start = highlight.range.start.to_display_point(&snapshot);
+                    let end = highlight.range.end.to_display_point(&snapshot);
+                    let start_row = start.row().0;
+                    let end_row = if highlight.range.end.text_anchor != text::Anchor::MAX
+                        && end.column() == 0
+                    {
+                        end.row().0.saturating_sub(1)
+                    } else {
+                        end.row().0
+                    };
+                    for row in start_row..=end_row {
                         let used_index =
                             used_highlight_orders.entry(row).or_insert(highlight.index);
                         if highlight.index >= *used_index {
@@ -11674,7 +11673,7 @@ impl Editor {
             .flat_map(|highlighted_rows| highlighted_rows.iter())
             .filter_map(|highlight| {
                 if highlight.should_autoscroll {
-                    Some(highlight.range.start().to_display_point(snapshot).row())
+                    Some(highlight.range.start.to_display_point(snapshot).row())
                 } else {
                     None
                 }
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index b17d94a5eb0f03..249d0a474641d0 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -11832,7 +11832,6 @@ async fn test_edits_around_expanded_insertion_hunks(
     );
 
     cx.update_editor(|editor, cx| {
-        editor.move_up(&MoveUp, cx);
         editor.delete_line(&DeleteLine, cx);
     });
     executor.run_until_parked();
@@ -11846,7 +11845,7 @@ async fn test_edits_around_expanded_insertion_hunks(
       + const B: u32 = 42;
       + const C: u32 = 42;
       + const D: u32 = 42;
-      +
+      + const E: u32 = 42;
 
         fn main() {
             println!("hello");
@@ -11872,8 +11871,8 @@ async fn test_edits_around_expanded_insertion_hunks(
         use some::mod2;
 
         const A: u32 = 42;
+        const B: u32 = 42;
         ˇ
-
         fn main() {
             println!("hello");
 
@@ -11889,8 +11888,8 @@ async fn test_edits_around_expanded_insertion_hunks(
         use some::mod2;
 
         const A: u32 = 42;
+      + const B: u32 = 42;
 
-      +
         fn main() {
             println!("hello");
 
@@ -11907,7 +11906,9 @@ async fn test_edits_around_expanded_insertion_hunks(
     executor.run_until_parked();
     cx.assert_diff_hunks(
         r#"
-
+        use some::mod1;
+      - use some::mod2;
+      -
       - const A: u32 = 42;
 
         fn main() {
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index 3e18b992c1dae8..cf2a857b67d2ff 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -6,10 +6,7 @@ use multi_buffer::{
     Anchor, AnchorRangeExt, ExcerptRange, MultiBuffer, MultiBufferDiffHunk, MultiBufferRow,
     MultiBufferSnapshot, ToPoint,
 };
-use std::{
-    ops::{Range, RangeInclusive},
-    sync::Arc,
-};
+use std::{ops::Range, sync::Arc};
 use ui::{
     prelude::*, ActiveTheme, ContextMenu, IconButtonShape, InteractiveElement, IntoElement,
     ParentElement, PopoverMenu, Styled, Tooltip, ViewContext, VisualContext,
@@ -19,7 +16,7 @@ use util::RangeExt;
 use crate::{
     editor_settings::CurrentLineHighlight, hunk_status, hunks_for_selections, BlockDisposition,
     BlockProperties, BlockStyle, CustomBlockId, DiffRowHighlight, DisplayRow, DisplaySnapshot,
-    Editor, EditorElement, EditorSnapshot, ExpandAllHunkDiffs, GoToHunk, GoToPrevHunk, RevertFile,
+    Editor, EditorElement, ExpandAllHunkDiffs, GoToHunk, GoToPrevHunk, RevertFile,
     RevertSelectedHunks, ToDisplayPoint, ToggleHunkDiff,
 };
 
@@ -298,7 +295,7 @@ impl Editor {
             }
             DiffHunkStatus::Added => {
                 self.highlight_rows::<DiffRowHighlight>(
-                    to_inclusive_row_range(hunk_start..hunk_end, &snapshot),
+                    hunk_start..hunk_end,
                     added_hunk_color(cx),
                     false,
                     cx,
@@ -307,7 +304,7 @@ impl Editor {
             }
             DiffHunkStatus::Modified => {
                 self.highlight_rows::<DiffRowHighlight>(
-                    to_inclusive_row_range(hunk_start..hunk_end, &snapshot),
+                    hunk_start..hunk_end,
                     added_hunk_color(cx),
                     false,
                     cx,
@@ -960,7 +957,7 @@ fn editor_with_deleted_text(
         editor.set_read_only(true);
         editor.set_show_inline_completions(Some(false), cx);
         editor.highlight_rows::<DiffRowHighlight>(
-            Anchor::min()..=Anchor::max(),
+            Anchor::min()..Anchor::max(),
             deleted_color,
             false,
             cx,
@@ -1039,22 +1036,6 @@ fn buffer_diff_hunk(
     None
 }
 
-fn to_inclusive_row_range(
-    row_range: Range<Anchor>,
-    snapshot: &EditorSnapshot,
-) -> RangeInclusive<Anchor> {
-    let mut end = row_range.end.to_point(&snapshot.buffer_snapshot);
-    if end.column == 0 && end.row > 0 {
-        end = Point::new(
-            end.row - 1,
-            snapshot
-                .buffer_snapshot
-                .line_len(MultiBufferRow(end.row - 1)),
-        );
-    }
-    row_range.start..=snapshot.buffer_snapshot.anchor_after(end)
-}
-
 impl DisplayDiffHunk {
     pub fn start_display_row(&self) -> DisplayRow {
         match self {
diff --git a/crates/editor/src/test/editor_test_context.rs b/crates/editor/src/test/editor_test_context.rs
index 2ec4f4a3b7b7bc..7234d97c5b77e4 100644
--- a/crates/editor/src/test/editor_test_context.rs
+++ b/crates/editor/src/test/editor_test_context.rs
@@ -9,7 +9,6 @@ use gpui::{
     AnyWindowHandle, AppContext, Keystroke, ModelContext, Pixels, Point, View, ViewContext,
     VisualTestContext, WindowHandle,
 };
-use indoc::indoc;
 use itertools::Itertools;
 use language::{Buffer, BufferSnapshot, LanguageRegistry};
 use multi_buffer::{ExcerptRange, ToPoint};
@@ -337,8 +336,9 @@ impl EditorTestContext {
             let insertions = editor
                 .highlighted_rows::<DiffRowHighlight>()
                 .map(|(range, _)| {
-                    range.start().to_point(&snapshot.buffer_snapshot).row
-                        ..range.end().to_point(&snapshot.buffer_snapshot).row + 1
+                    let start = range.start.to_point(&snapshot.buffer_snapshot);
+                    let end = range.end.to_point(&snapshot.buffer_snapshot);
+                    start.row..end.row
                 })
                 .collect::<Vec<_>>();
             let deletions = editor
@@ -384,13 +384,8 @@ impl EditorTestContext {
     /// See the `util::test::marked_text_ranges` function for more information.
     #[track_caller]
     pub fn assert_editor_state(&mut self, marked_text: &str) {
-        let (unmarked_text, expected_selections) = marked_text_ranges(marked_text, true);
-        let buffer_text = self.buffer_text();
-
-        if buffer_text != unmarked_text {
-            panic!("Unmarked text doesn't match buffer text\nBuffer text: {buffer_text:?}\nUnmarked text: {unmarked_text:?}\nRaw buffer text\n{buffer_text}\nRaw unmarked text\n{unmarked_text}");
-        }
-
+        let (expected_text, expected_selections) = marked_text_ranges(marked_text, true);
+        pretty_assertions::assert_eq!(self.buffer_text(), expected_text, "unexpected buffer text");
         self.assert_selections(expected_selections, marked_text.to_string())
     }
 
@@ -463,20 +458,11 @@ impl EditorTestContext {
         let actual_marked_text =
             generate_marked_text(&self.buffer_text(), &actual_selections, true);
         if expected_selections != actual_selections {
-            panic!(
-                indoc! {"
-
-                {}Editor has unexpected selections.
-
-                Expected selections:
-                {}
-
-                Actual selections:
-                {}
-            "},
-                self.assertion_context(),
-                expected_marked_text,
+            pretty_assertions::assert_eq!(
                 actual_marked_text,
+                expected_marked_text,
+                "{}Editor has unexpected selections",
+                self.assertion_context(),
             );
         }
     }
diff --git a/crates/go_to_line/src/go_to_line.rs b/crates/go_to_line/src/go_to_line.rs
index fd631648c2c759..0e9482b7594144 100644
--- a/crates/go_to_line/src/go_to_line.rs
+++ b/crates/go_to_line/src/go_to_line.rs
@@ -116,11 +116,13 @@ impl GoToLine {
         if let Some(point) = self.point_from_query(cx) {
             self.active_editor.update(cx, |active_editor, cx| {
                 let snapshot = active_editor.snapshot(cx).display_snapshot;
-                let point = snapshot.buffer_snapshot.clip_point(point, Bias::Left);
-                let anchor = snapshot.buffer_snapshot.anchor_before(point);
+                let start = snapshot.buffer_snapshot.clip_point(point, Bias::Left);
+                let end = start + Point::new(1, 0);
+                let start = snapshot.buffer_snapshot.anchor_before(start);
+                let end = snapshot.buffer_snapshot.anchor_after(end);
                 active_editor.clear_row_highlights::<GoToLineRowHighlights>();
                 active_editor.highlight_rows::<GoToLineRowHighlights>(
-                    anchor..=anchor,
+                    start..end,
                     cx.theme().colors().editor_highlighted_line_background,
                     true,
                     cx,
@@ -244,13 +246,13 @@ mod tests {
                         field_1: i32,  // display line 3
                         field_2: i32,  // display line 4
                     }                  // display line 5
-                                       // display line 7
-                    struct Another {   // display line 8
-                        field_1: i32,  // display line 9
-                        field_2: i32,  // display line 10
-                        field_3: i32,  // display line 11
-                        field_4: i32,  // display line 12
-                    }                  // display line 13
+                                       // display line 6
+                    struct Another {   // display line 7
+                        field_1: i32,  // display line 8
+                        field_2: i32,  // display line 9
+                        field_3: i32,  // display line 10
+                        field_4: i32,  // display line 11
+                    }                  // display line 12
                 "}
             }),
         )
diff --git a/crates/outline/src/outline.rs b/crates/outline/src/outline.rs
index 520311b6f3c625..1d82d06ad85705 100644
--- a/crates/outline/src/outline.rs
+++ b/crates/outline/src/outline.rs
@@ -143,7 +143,7 @@ impl OutlineViewDelegate {
             self.active_editor.update(cx, |active_editor, cx| {
                 active_editor.clear_row_highlights::<OutlineRowHighlights>();
                 active_editor.highlight_rows::<OutlineRowHighlights>(
-                    outline_item.range.start..=outline_item.range.end,
+                    outline_item.range.start..outline_item.range.end,
                     cx.theme().colors().editor_highlighted_line_background,
                     true,
                     cx,
@@ -245,7 +245,7 @@ impl PickerDelegate for OutlineViewDelegate {
                 .next();
             if let Some((rows, _)) = highlight {
                 active_editor.change_selections(Some(Autoscroll::center()), cx, |s| {
-                    s.select_ranges([*rows.start()..*rows.start()])
+                    s.select_ranges([rows.start..rows.start])
                 });
                 active_editor.clear_row_highlights::<OutlineRowHighlights>();
                 active_editor.focus(cx);

From 3737d4eb4fa9e576204a367b020ba189ac4aa087 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Fri, 27 Sep 2024 23:25:02 +0200
Subject: [PATCH 382/762] Add tooltip for code actions icon button (#18461)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I have just recently discovered this keybinding myself out of talking to
folks, ha. The tooltip here might ease the discovery for other folks in
the future.

<img width="700" alt="Screenshot 2024-09-27 at 11 04 28 PM"
src="https://github.com/user-attachments/assets/844d3b55-15af-47f7-a8db-5c8832ceba29">

---

Release Notes:

- N/A
---
 crates/editor/src/editor.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index b604f388debd58..d1ca70f705ce56 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -5368,6 +5368,19 @@ impl Editor {
                     .icon_size(IconSize::XSmall)
                     .icon_color(Color::Muted)
                     .selected(is_active)
+                    .tooltip({
+                        let focus_handle = self.focus_handle.clone();
+                        move |cx| {
+                            Tooltip::for_action_in(
+                                "Toggle Code Actions",
+                                &ToggleCodeActions {
+                                    deployed_from_indicator: None,
+                                },
+                                &focus_handle,
+                                cx,
+                            )
+                        }
+                    })
                     .on_click(cx.listener(move |editor, _e, cx| {
                         editor.focus(cx);
                         editor.toggle_code_actions(

From 675673ed5462711916e7824528698fc235d679b2 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Sat, 28 Sep 2024 01:45:40 +0200
Subject: [PATCH 383/762] Fine-tune hunk control spacing (#18463)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

<img width="900" alt="Screenshot 2024-09-28 at 1 09 35 AM"
src="https://github.com/user-attachments/assets/0b9d744f-3b92-488a-bc74-987f5a9d8c6c">

---

Release Notes:

- N/A
---
 crates/editor/src/hunk_diff.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index cf2a857b67d2ff..4e7a0f05f4a25b 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -338,7 +338,7 @@ impl Editor {
         hunk: &HoveredHunk,
         cx: &mut ViewContext<'_, Editor>,
     ) -> BlockProperties<Anchor> {
-        let border_color = cx.theme().colors().border_disabled;
+        let border_color = cx.theme().colors().border_variant;
         let gutter_color = match hunk.status {
             DiffHunkStatus::Added => cx.theme().status().created,
             DiffHunkStatus::Modified => cx.theme().status().modified,
@@ -381,14 +381,15 @@ impl Editor {
                         )
                         .child(
                             h_flex()
+                                .pl_1p5()
+                                .pr_6()
                                 .size_full()
                                 .justify_between()
                                 .border_t_1()
                                 .border_color(border_color)
                                 .child(
                                     h_flex()
-                                        .gap_2()
-                                        .pl_6()
+                                        .gap_1()
                                         .child(
                                             IconButton::new("next-hunk", IconName::ArrowDown)
                                                 .shape(IconButtonShape::Square)
@@ -595,7 +596,7 @@ impl Editor {
                                         }),
                                 )
                                 .child(
-                                    h_flex().gap_2().pr_6().child(
+                                    div().child(
                                         IconButton::new("collapse", IconName::Close)
                                             .shape(IconButtonShape::Square)
                                             .icon_size(IconSize::Small)

From 1021f0e28808285e3d301fcb9ccf9af40854ea98 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Sat, 28 Sep 2024 14:21:13 -0400
Subject: [PATCH 384/762] Show release notes locally when showing update
 notification (#18486)

Closes https://github.com/zed-industries/zed/issues/17527

I think we are ok to switch to using the local action now. There are a
few things we don't support, like media, but we don't include media
directly too often, and I think this might help push the community to
maybe add support for it. That being said, I updated the markdown coming
back from the endpoint to include links to the web version of the
release notes, so they can always hop over to that version, if they
would like.


https://github.com/user-attachments/assets/b4d207a7-1640-48f1-91d0-94537f74116c

All forming of the Markdown happens in the endpoint, so if someone with
a better eye wants to update this, you can do that here:


https://github.com/zed-industries/zed.dev/blob/0e5923e3e7d1caa8b4bf32d0a7f8999b34dbe64c/src/pages/api/release_notes/v2/%5Bchannel_type%5D/%5Bversion%5D.ts#L50-L62

Release Notes:

- Changed the `view the release notes` button in the update toast to
trigger the local release notes action.
---
 crates/auto_update/src/auto_update.rs         | 12 +++++++-----
 crates/auto_update/src/update_notification.rs | 19 ++++++++++++++-----
 2 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index 1fe89cce0f9c4e..60d6369ee869c6 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -345,15 +345,17 @@ pub fn notify_of_any_new_update(cx: &mut ViewContext<Workspace>) -> Option<()> {
         let should_show_notification = should_show_notification.await?;
         if should_show_notification {
             workspace.update(&mut cx, |workspace, cx| {
+                let workspace_handle = workspace.weak_handle();
                 workspace.show_notification(
                     NotificationId::unique::<UpdateNotification>(),
                     cx,
-                    |cx| cx.new_view(|_| UpdateNotification::new(version)),
+                    |cx| cx.new_view(|_| UpdateNotification::new(version, workspace_handle)),
                 );
-                updater
-                    .read(cx)
-                    .set_should_show_update_notification(false, cx)
-                    .detach_and_log_err(cx);
+                updater.update(cx, |updater, cx| {
+                    updater
+                        .set_should_show_update_notification(false, cx)
+                        .detach_and_log_err(cx);
+                });
             })?;
         }
         anyhow::Ok(())
diff --git a/crates/auto_update/src/update_notification.rs b/crates/auto_update/src/update_notification.rs
index 66028c24011995..7568a0eb1a94e7 100644
--- a/crates/auto_update/src/update_notification.rs
+++ b/crates/auto_update/src/update_notification.rs
@@ -1,13 +1,18 @@
 use gpui::{
     div, DismissEvent, EventEmitter, InteractiveElement, IntoElement, ParentElement, Render,
-    SemanticVersion, StatefulInteractiveElement, Styled, ViewContext,
+    SemanticVersion, StatefulInteractiveElement, Styled, ViewContext, WeakView,
 };
 use menu::Cancel;
 use release_channel::ReleaseChannel;
-use workspace::ui::{h_flex, v_flex, Icon, IconName, Label, StyledExt};
+use util::ResultExt;
+use workspace::{
+    ui::{h_flex, v_flex, Icon, IconName, Label, StyledExt},
+    Workspace,
+};
 
 pub struct UpdateNotification {
     version: SemanticVersion,
+    workspace: WeakView<Workspace>,
 }
 
 impl EventEmitter<DismissEvent> for UpdateNotification {}
@@ -41,7 +46,11 @@ impl Render for UpdateNotification {
                     .child(Label::new("View the release notes"))
                     .cursor_pointer()
                     .on_click(cx.listener(|this, _, cx| {
-                        crate::view_release_notes(&Default::default(), cx);
+                        this.workspace
+                            .update(cx, |workspace, cx| {
+                                crate::view_release_notes_locally(workspace, cx);
+                            })
+                            .log_err();
                         this.dismiss(&menu::Cancel, cx)
                     })),
             )
@@ -49,8 +58,8 @@ impl Render for UpdateNotification {
 }
 
 impl UpdateNotification {
-    pub fn new(version: SemanticVersion) -> Self {
-        Self { version }
+    pub fn new(version: SemanticVersion, workspace: WeakView<Workspace>) -> Self {
+        Self { version, workspace }
     }
 
     pub fn dismiss(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {

From 8aeab4800c6133f4bb51541a01acb630bae739e8 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Sat, 28 Sep 2024 15:20:32 -0400
Subject: [PATCH 385/762] Continue to redirect to GitHub commits for nightly
 and dev release notes (#18487)

We are now using the `view release notes locally` action when clicking
on the update toast - the endpoint for this action does not currently
return anything for valid for these channels, as we don't have support
yet for diffing between these builds, so for now, [continue to do what
the `view release notes` action did and just send the user to the commit
view on
GitHub](https://github.com/zed-industries/zed/blob/caffb2733f8e859637050e3708dbd10b6e409762/crates/auto_update/src/auto_update.rs#L255-L260).
It is a bit counterintuitive to send the user to the browser when using
the "local" action, but this is just a patch in the interim.

If we make adjustments to our channels to keep the nightly tag stable
and add some sort of unique suffix, like a timestamp, we can then adjust
things to return these in the request body and show them in the editor.

Release Notes:

- N/A
---
 crates/auto_update/src/auto_update.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index 60d6369ee869c6..2c93ee4171c8b8 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -264,6 +264,18 @@ pub fn view_release_notes(_: &ViewReleaseNotes, cx: &mut AppContext) -> Option<(
 
 fn view_release_notes_locally(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
     let release_channel = ReleaseChannel::global(cx);
+
+    let url = match release_channel {
+        ReleaseChannel::Nightly => Some("https://github.com/zed-industries/zed/commits/nightly/"),
+        ReleaseChannel::Dev => Some("https://github.com/zed-industries/zed/commits/main/"),
+        _ => None,
+    };
+
+    if let Some(url) = url {
+        cx.open_url(url);
+        return;
+    }
+
     let version = AppVersion::global(cx).to_string();
 
     let client = client::Client::global(cx).http_client();

From 84ce81caf155fefb60b1a26e44b14b1a28cfb2cd Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Sun, 29 Sep 2024 10:30:48 -0600
Subject: [PATCH 386/762] Pass `Summary::Context` to `Item::summarize` (#18510)

We are going to use this in the multi-buffer to produce a summary for an
`Excerpt` that contains a `Range<Anchor>`.

Release Notes:

- N/A

Co-authored-by: Nathan <nathan@zed.dev>
---
 crates/channel/src/channel_chat.rs             |  2 +-
 crates/editor/src/display_map/block_map.rs     |  2 +-
 crates/editor/src/display_map/crease_map.rs    |  2 +-
 crates/editor/src/display_map/fold_map.rs      |  4 ++--
 crates/editor/src/display_map/inlay_map.rs     |  2 +-
 crates/editor/src/display_map/wrap_map.rs      |  2 +-
 crates/editor/src/git/blame.rs                 |  2 +-
 crates/git/src/diff.rs                         |  2 +-
 crates/gpui/src/elements/list.rs               |  2 +-
 crates/language/src/diagnostic_set.rs          |  2 +-
 crates/language/src/syntax_map.rs              |  2 +-
 crates/multi_buffer/src/multi_buffer.rs        |  4 ++--
 crates/notifications/src/notification_store.rs |  2 +-
 crates/rope/src/rope.rs                        |  2 +-
 crates/sum_tree/src/sum_tree.rs                | 12 ++++++------
 crates/sum_tree/src/tree_map.rs                |  2 +-
 crates/text/src/locator.rs                     |  2 +-
 crates/text/src/operation_queue.rs             |  2 +-
 crates/text/src/text.rs                        |  6 +++---
 crates/text/src/undo_map.rs                    |  2 +-
 crates/worktree/src/worktree.rs                |  4 ++--
 21 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/crates/channel/src/channel_chat.rs b/crates/channel/src/channel_chat.rs
index 1a9e46db0460a9..e5b5b74c16262b 100644
--- a/crates/channel/src/channel_chat.rs
+++ b/crates/channel/src/channel_chat.rs
@@ -808,7 +808,7 @@ pub fn mentions_to_proto(mentions: &[(Range<usize>, UserId)]) -> Vec<proto::Chat
 impl sum_tree::Item for ChannelMessage {
     type Summary = ChannelMessageSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         ChannelMessageSummary {
             max_id: self.id,
             count: 1,
diff --git a/crates/editor/src/display_map/block_map.rs b/crates/editor/src/display_map/block_map.rs
index efa026a56c6101..52e0ca2486d25d 100644
--- a/crates/editor/src/display_map/block_map.rs
+++ b/crates/editor/src/display_map/block_map.rs
@@ -1360,7 +1360,7 @@ impl<'a> Iterator for BlockBufferRows<'a> {
 impl sum_tree::Item for Transform {
     type Summary = TransformSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         self.summary.clone()
     }
 }
diff --git a/crates/editor/src/display_map/crease_map.rs b/crates/editor/src/display_map/crease_map.rs
index c3f2b0061ac732..531c650c43a6ed 100644
--- a/crates/editor/src/display_map/crease_map.rs
+++ b/crates/editor/src/display_map/crease_map.rs
@@ -291,7 +291,7 @@ impl sum_tree::Summary for ItemSummary {
 impl sum_tree::Item for CreaseItem {
     type Summary = ItemSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &MultiBufferSnapshot) -> Self::Summary {
         ItemSummary {
             range: self.crease.range.clone(),
         }
diff --git a/crates/editor/src/display_map/fold_map.rs b/crates/editor/src/display_map/fold_map.rs
index 37983030b8e1a7..5eb26ff9693883 100644
--- a/crates/editor/src/display_map/fold_map.rs
+++ b/crates/editor/src/display_map/fold_map.rs
@@ -944,7 +944,7 @@ struct TransformSummary {
 impl sum_tree::Item for Transform {
     type Summary = TransformSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         self.summary.clone()
     }
 }
@@ -1004,7 +1004,7 @@ impl Default for FoldRange {
 impl sum_tree::Item for Fold {
     type Summary = FoldSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &MultiBufferSnapshot) -> Self::Summary {
         FoldSummary {
             start: self.range.start,
             end: self.range.end,
diff --git a/crates/editor/src/display_map/inlay_map.rs b/crates/editor/src/display_map/inlay_map.rs
index 712db45e3f61a7..d4e39f2df9270e 100644
--- a/crates/editor/src/display_map/inlay_map.rs
+++ b/crates/editor/src/display_map/inlay_map.rs
@@ -74,7 +74,7 @@ impl Inlay {
 impl sum_tree::Item for Transform {
     type Summary = TransformSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         match self {
             Transform::Isomorphic(summary) => TransformSummary {
                 input: summary.clone(),
diff --git a/crates/editor/src/display_map/wrap_map.rs b/crates/editor/src/display_map/wrap_map.rs
index 564bba2158030e..dc4d93058cdf7f 100644
--- a/crates/editor/src/display_map/wrap_map.rs
+++ b/crates/editor/src/display_map/wrap_map.rs
@@ -917,7 +917,7 @@ impl Transform {
 impl sum_tree::Item for Transform {
     type Summary = TransformSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         self.summary.clone()
     }
 }
diff --git a/crates/editor/src/git/blame.rs b/crates/editor/src/git/blame.rs
index 733d42d0c57dda..303ead16b22319 100644
--- a/crates/editor/src/git/blame.rs
+++ b/crates/editor/src/git/blame.rs
@@ -29,7 +29,7 @@ pub struct GitBlameEntrySummary {
 impl sum_tree::Item for GitBlameEntry {
     type Summary = GitBlameEntrySummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         GitBlameEntrySummary { rows: self.rows }
     }
 }
diff --git a/crates/git/src/diff.rs b/crates/git/src/diff.rs
index 1f7930ce1442da..baad824577d301 100644
--- a/crates/git/src/diff.rs
+++ b/crates/git/src/diff.rs
@@ -34,7 +34,7 @@ struct InternalDiffHunk {
 impl sum_tree::Item for InternalDiffHunk {
     type Summary = DiffHunkSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &text::BufferSnapshot) -> Self::Summary {
         DiffHunkSummary {
             buffer_range: self.buffer_range.clone(),
         }
diff --git a/crates/gpui/src/elements/list.rs b/crates/gpui/src/elements/list.rs
index d03392867b5ee2..6ac6d2a9bf8d7d 100644
--- a/crates/gpui/src/elements/list.rs
+++ b/crates/gpui/src/elements/list.rs
@@ -858,7 +858,7 @@ impl Styled for List {
 impl sum_tree::Item for ListItem {
     type Summary = ListItemSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _: &()) -> Self::Summary {
         match self {
             ListItem::Unmeasured { focus_handle } => ListItemSummary {
                 count: 1,
diff --git a/crates/language/src/diagnostic_set.rs b/crates/language/src/diagnostic_set.rs
index c35659d9bbd4d1..38d4216beeabc4 100644
--- a/crates/language/src/diagnostic_set.rs
+++ b/crates/language/src/diagnostic_set.rs
@@ -224,7 +224,7 @@ impl DiagnosticSet {
 impl sum_tree::Item for DiagnosticEntry<Anchor> {
     type Summary = Summary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &text::BufferSnapshot) -> Self::Summary {
         Summary {
             start: self.range.start,
             end: self.range.end,
diff --git a/crates/language/src/syntax_map.rs b/crates/language/src/syntax_map.rs
index 55177f79620db7..8617696cc471ec 100644
--- a/crates/language/src/syntax_map.rs
+++ b/crates/language/src/syntax_map.rs
@@ -1739,7 +1739,7 @@ impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary>
 impl sum_tree::Item for SyntaxLayerEntry {
     type Summary = SyntaxLayerSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &BufferSnapshot) -> Self::Summary {
         SyntaxLayerSummary {
             min_depth: self.depth,
             max_depth: self.depth,
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index 828b39967d9e1f..7aa733ba8fa373 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -4596,7 +4596,7 @@ impl fmt::Debug for Excerpt {
 impl sum_tree::Item for Excerpt {
     type Summary = ExcerptSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         let mut text = self.text_summary.clone();
         if self.has_trailing_newline {
             text += TextSummary::from("\n");
@@ -4613,7 +4613,7 @@ impl sum_tree::Item for Excerpt {
 impl sum_tree::Item for ExcerptIdMapping {
     type Summary = ExcerptId;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         self.id
     }
 }
diff --git a/crates/notifications/src/notification_store.rs b/crates/notifications/src/notification_store.rs
index 48fcb5dfbb830a..5c3de53ee1895c 100644
--- a/crates/notifications/src/notification_store.rs
+++ b/crates/notifications/src/notification_store.rs
@@ -455,7 +455,7 @@ impl EventEmitter<NotificationEvent> for NotificationStore {}
 impl sum_tree::Item for NotificationEntry {
     type Summary = NotificationSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         NotificationSummary {
             max_id: self.id,
             count: 1,
diff --git a/crates/rope/src/rope.rs b/crates/rope/src/rope.rs
index 56fe7fc0544471..68ff7d5c6956aa 100644
--- a/crates/rope/src/rope.rs
+++ b/crates/rope/src/rope.rs
@@ -1159,7 +1159,7 @@ impl Chunk {
 impl sum_tree::Item for Chunk {
     type Summary = ChunkSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         ChunkSummary::from(self.0.as_str())
     }
 }
diff --git a/crates/sum_tree/src/sum_tree.rs b/crates/sum_tree/src/sum_tree.rs
index 7013dc66fd1ed7..fbfe3b06f3ab4c 100644
--- a/crates/sum_tree/src/sum_tree.rs
+++ b/crates/sum_tree/src/sum_tree.rs
@@ -20,7 +20,7 @@ pub const TREE_BASE: usize = 6;
 pub trait Item: Clone {
     type Summary: Summary;
 
-    fn summary(&self) -> Self::Summary;
+    fn summary(&self, cx: &<Self::Summary as Summary>::Context) -> Self::Summary;
 }
 
 /// An [`Item`] whose summary has a specific key that can be used to identify it
@@ -211,7 +211,7 @@ impl<T: Item> SumTree<T> {
         while iter.peek().is_some() {
             let items: ArrayVec<T, { 2 * TREE_BASE }> = iter.by_ref().take(2 * TREE_BASE).collect();
             let item_summaries: ArrayVec<T::Summary, { 2 * TREE_BASE }> =
-                items.iter().map(|item| item.summary()).collect();
+                items.iter().map(|item| item.summary(cx)).collect();
 
             let mut summary = item_summaries[0].clone();
             for item_summary in &item_summaries[1..] {
@@ -281,7 +281,7 @@ impl<T: Item> SumTree<T> {
             .map(|items| {
                 let items: ArrayVec<T, { 2 * TREE_BASE }> = items.into_iter().collect();
                 let item_summaries: ArrayVec<T::Summary, { 2 * TREE_BASE }> =
-                    items.iter().map(|item| item.summary()).collect();
+                    items.iter().map(|item| item.summary(cx)).collect();
                 let mut summary = item_summaries[0].clone();
                 for item_summary in &item_summaries[1..] {
                     <T::Summary as Summary>::add_summary(&mut summary, item_summary, cx);
@@ -405,7 +405,7 @@ impl<T: Item> SumTree<T> {
                 if let Some((item, item_summary)) = items.last_mut().zip(item_summaries.last_mut())
                 {
                     (f)(item);
-                    *item_summary = item.summary();
+                    *item_summary = item.summary(cx);
                     *summary = sum(item_summaries.iter(), cx);
                     Some(summary.clone())
                 } else {
@@ -461,7 +461,7 @@ impl<T: Item> SumTree<T> {
     }
 
     pub fn push(&mut self, item: T, cx: &<T::Summary as Summary>::Context) {
-        let summary = item.summary();
+        let summary = item.summary(cx);
         self.append(
             SumTree(Arc::new(Node::Leaf {
                 summary: summary.clone(),
@@ -1352,7 +1352,7 @@ mod tests {
     impl Item for u8 {
         type Summary = IntegersSummary;
 
-        fn summary(&self) -> Self::Summary {
+        fn summary(&self, _cx: &()) -> Self::Summary {
             IntegersSummary {
                 count: 1,
                 sum: *self as usize,
diff --git a/crates/sum_tree/src/tree_map.rs b/crates/sum_tree/src/tree_map.rs
index c57226b681432a..9a4d952e93f226 100644
--- a/crates/sum_tree/src/tree_map.rs
+++ b/crates/sum_tree/src/tree_map.rs
@@ -224,7 +224,7 @@ where
 {
     type Summary = MapKey<K>;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         self.key()
     }
 }
diff --git a/crates/text/src/locator.rs b/crates/text/src/locator.rs
index 7afc16f5815496..e38b9b58af22c2 100644
--- a/crates/text/src/locator.rs
+++ b/crates/text/src/locator.rs
@@ -69,7 +69,7 @@ impl Default for Locator {
 impl sum_tree::Item for Locator {
     type Summary = Locator;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         self.clone()
     }
 }
diff --git a/crates/text/src/operation_queue.rs b/crates/text/src/operation_queue.rs
index c7964f62674ca5..52b534a41b7395 100644
--- a/crates/text/src/operation_queue.rs
+++ b/crates/text/src/operation_queue.rs
@@ -107,7 +107,7 @@ impl<'a> Dimension<'a, OperationSummary> for OperationKey {
 impl<T: Operation> Item for OperationItem<T> {
     type Summary = OperationSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         OperationSummary {
             key: OperationKey::new(self.0.lamport_timestamp()),
             len: 1,
diff --git a/crates/text/src/text.rs b/crates/text/src/text.rs
index 8bdc9fdb03d89b..80eafcf4eba2d5 100644
--- a/crates/text/src/text.rs
+++ b/crates/text/src/text.rs
@@ -2617,7 +2617,7 @@ impl Fragment {
 impl sum_tree::Item for Fragment {
     type Summary = FragmentSummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &Option<clock::Global>) -> Self::Summary {
         let mut max_version = clock::Global::new();
         max_version.observe(self.timestamp);
         for deletion in &self.deletions {
@@ -2688,7 +2688,7 @@ impl Default for FragmentSummary {
 impl sum_tree::Item for InsertionFragment {
     type Summary = InsertionFragmentKey;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         InsertionFragmentKey {
             timestamp: self.timestamp,
             split_offset: self.split_offset,
@@ -2700,7 +2700,7 @@ impl sum_tree::KeyedItem for InsertionFragment {
     type Key = InsertionFragmentKey;
 
     fn key(&self) -> Self::Key {
-        sum_tree::Item::summary(self)
+        sum_tree::Item::summary(self, &())
     }
 }
 
diff --git a/crates/text/src/undo_map.rs b/crates/text/src/undo_map.rs
index 4e670fd456068d..ed363cfc6b6d77 100644
--- a/crates/text/src/undo_map.rs
+++ b/crates/text/src/undo_map.rs
@@ -11,7 +11,7 @@ struct UndoMapEntry {
 impl sum_tree::Item for UndoMapEntry {
     type Summary = UndoMapKey;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         self.key
     }
 }
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index d81c91132b9d39..a3daf8ea2eade7 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -3339,7 +3339,7 @@ impl EntryKind {
 impl sum_tree::Item for Entry {
     type Summary = EntrySummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         let non_ignored_count = if self.is_ignored || self.is_external {
             0
         } else {
@@ -3434,7 +3434,7 @@ struct PathEntry {
 impl sum_tree::Item for PathEntry {
     type Summary = PathEntrySummary;
 
-    fn summary(&self) -> Self::Summary {
+    fn summary(&self, _cx: &()) -> Self::Summary {
         PathEntrySummary { max_id: self.id }
     }
 }

From 5f35fa5d92d45269bf311f1aa5e9c1703e54ffc4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thorben=20Kr=C3=B6ger?= <dev@thorben.net>
Date: Sun, 29 Sep 2024 19:54:09 +0200
Subject: [PATCH 387/762] Associate `uv.lock` files with TOML (#18426)

The `uv` python package manager uses the TOML for it's `uv.lock` file,
see https://docs.astral.sh/uv/guides/projects/#uvlock.

Ref #7808

Release Notes:

- associate `uv.lock` files with the TOML language
---
 assets/settings/default.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 82778dc8f6c484..2a11a85d4efae4 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -769,7 +769,8 @@
       "**/Zed/**/*.json",
       "tsconfig.json",
       "pyrightconfig.json"
-    ]
+    ],
+    "TOML": ["uv.lock"]
   },
   /// By default use a recent system version of node, or install our own.
   /// You can override this to use a version of node that is not in $PATH with:

From 250f2e76eb6f97fe097ee39863c621335762c102 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Mon, 30 Sep 2024 08:05:51 +0200
Subject: [PATCH 388/762] tasks: Display runnables at the start of folds
 (#18526)

Release Notes:

- Fixed task indicators not showing up at the starts of folds.
---
 crates/editor/src/element.rs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index e5c067e37ec3dc..1c35fa6bcdd4e8 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -1646,7 +1646,16 @@ impl EditorElement {
                         return None;
                     }
                     if snapshot.is_line_folded(multibuffer_row) {
-                        return None;
+                        // Skip folded indicators, unless it's the starting line of a fold.
+                        if multibuffer_row
+                            .0
+                            .checked_sub(1)
+                            .map_or(false, |previous_row| {
+                                snapshot.is_line_folded(MultiBufferRow(previous_row))
+                            })
+                        {
+                            return None;
+                        }
                     }
                     let button = editor.render_run_indicator(
                         &self.style,

From 77df7e56f7852aaa121cafb0bc0596c9b43d3680 Mon Sep 17 00:00:00 2001
From: Tom Wieczorek <twz123@users.noreply.github.com>
Date: Mon, 30 Sep 2024 08:34:41 +0200
Subject: [PATCH 389/762] settings: Make external formatter arguments optional
 (#18340)

If specifying a formatter in the settings like this:

    "languages": {
      "foo": {
        "formatter": {
          "external": {
            "command": "/path/to/foo-formatter"
          }
        }
      }
    }

Zed will show an error like this:

    Invalid user settings file
    data did not match any variant of untagged enum SingleOrVec

This is because the arguments are not optional. The error is hard to
understand, so let's make the arguments actually optional, which makes
the above settings snippet valid.

Release Notes:

- Make external formatter arguments optional
---
 crates/collab/src/tests/integration_tests.rs |  2 +-
 crates/language/src/language_settings.rs     |  2 +-
 crates/project/src/lsp_store.rs              | 31 +++++++++++++-------
 3 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/crates/collab/src/tests/integration_tests.rs b/crates/collab/src/tests/integration_tests.rs
index afc3e7cfb84ee2..615ad52e2ef367 100644
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -4409,7 +4409,7 @@ async fn test_formatting_buffer(
                 file.defaults.formatter = Some(SelectedFormatter::List(FormatterList(
                     vec![Formatter::External {
                         command: "awk".into(),
-                        arguments: vec!["{sub(/two/,\"{buffer_path}\")}1".to_string()].into(),
+                        arguments: Some(vec!["{sub(/two/,\"{buffer_path}\")}1".to_string()].into()),
                     }]
                     .into(),
                 )));
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index 2f1a7be2bf492d..d610ab09865ce3 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -661,7 +661,7 @@ pub enum Formatter {
         /// The external program to run.
         command: Arc<str>,
         /// The arguments to pass to the program.
-        arguments: Arc<[String]>,
+        arguments: Option<Arc<[String]>>,
     },
     /// Files should be formatted using code actions executed by language servers.
     CodeActions(HashMap<String, bool>),
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 37922b7c2ee03b..a3763810e1a262 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -539,13 +539,19 @@ impl LocalLspStore {
             }
             Formatter::External { command, arguments } => {
                 let buffer_abs_path = buffer_abs_path.as_ref().map(|path| path.as_path());
-                Self::format_via_external_command(buffer, buffer_abs_path, command, arguments, cx)
-                    .await
-                    .context(format!(
-                        "failed to format via external command {:?}",
-                        command
-                    ))?
-                    .map(FormatOperation::External)
+                Self::format_via_external_command(
+                    buffer,
+                    buffer_abs_path,
+                    command,
+                    arguments.as_deref(),
+                    cx,
+                )
+                .await
+                .context(format!(
+                    "failed to format via external command {:?}",
+                    command
+                ))?
+                .map(FormatOperation::External)
             }
             Formatter::CodeActions(code_actions) => {
                 let code_actions = deserialize_code_actions(code_actions);
@@ -571,7 +577,7 @@ impl LocalLspStore {
         buffer: &Model<Buffer>,
         buffer_abs_path: Option<&Path>,
         command: &str,
-        arguments: &[String],
+        arguments: Option<&[String]>,
         cx: &mut AsyncAppContext,
     ) -> Result<Option<Diff>> {
         let working_dir_path = buffer.update(cx, |buffer, cx| {
@@ -595,14 +601,17 @@ impl LocalLspStore {
             child.current_dir(working_dir_path);
         }
 
-        let mut child = child
-            .args(arguments.iter().map(|arg| {
+        if let Some(arguments) = arguments {
+            child.args(arguments.iter().map(|arg| {
                 if let Some(buffer_abs_path) = buffer_abs_path {
                     arg.replace("{buffer_path}", &buffer_abs_path.to_string_lossy())
                 } else {
                     arg.replace("{buffer_path}", "Untitled")
                 }
-            }))
+            }));
+        }
+
+        let mut child = child
             .stdin(smol::process::Stdio::piped())
             .stdout(smol::process::Stdio::piped())
             .stderr(smol::process::Stdio::piped())

From e39695bf1c16b298552336fc2c063f4a88a46a45 Mon Sep 17 00:00:00 2001
From: Maksim Bondarenkov <119937608+ognevny@users.noreply.github.com>
Date: Mon, 30 Sep 2024 09:38:49 +0300
Subject: [PATCH 390/762] docs: Update msys2 section in development/windows
 (#18385)

merge after
https://packages.msys2.org/packages/mingw-w64-clang-x86_64-zed is
available. alternatively you can check the
[queue](https://packages.msys2.org/queue) for build status

Zed now compiles and runs under msys2/CLANG64 environment, so change the
docs to give the users a choice of their environment

Release Notes:

- N/A
---
 docs/src/development/windows.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/src/development/windows.md b/docs/src/development/windows.md
index 86eb21965e550e..67808186d1961b 100644
--- a/docs/src/development/windows.md
+++ b/docs/src/development/windows.md
@@ -63,16 +63,16 @@ cargo test --workspace
 
 ## Installing from msys2
 
-[MSYS2](https://msys2.org/) distribution provides Zed as a package [mingw-w64-zed](https://packages.msys2.org/base/mingw-w64-zed). To download the prebuilt binary, run
+[MSYS2](https://msys2.org/) distribution provides Zed as a package [mingw-w64-zed](https://packages.msys2.org/base/mingw-w64-zed). The package is available for UCRT64 and CLANG64. To download it, run
 
 ```sh
 pacman -Syu
-pacman -S mingw-w64-ucrt-x86_64-zed
+pacman -S $MINGW_PACKAGE_PREFIX-zed
 ```
 
-then you can run `zed` in a UCRT64 shell.
+then you can run `zed` in a shell.
 
-You can see the [build script](https://github.com/msys2/MINGW-packages/blob/master/mingw-w64-zed/PKGBUILD) for more details.
+You can see the [build script](https://github.com/msys2/MINGW-packages/blob/master/mingw-w64-zed/PKGBUILD) for more details on build process.
 
 > Please, report any issue in [msys2/MINGW-packages/issues](https://github.com/msys2/MINGW-packages/issues?q=is%3Aissue+is%3Aopen+zed) first.
 

From 5b40debb5f042a1d4230ceb5f012e7d09a785fb2 Mon Sep 17 00:00:00 2001
From: Stanislav Alekseev <43210583+WeetHet@users.noreply.github.com>
Date: Mon, 30 Sep 2024 09:54:22 +0300
Subject: [PATCH 391/762] Don't stop loading the env if direnv call fails
 (#18473)

Before this we we would stop loading the environment if the call to
direnv failed, which is not necessary in any way
cc @mrnugget

Release Notes:

- Fixed the environment not loading if `direnv` mode is set to `direct`
and `.envrc` is not allowed
---
 crates/project/src/environment.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/project/src/environment.rs b/crates/project/src/environment.rs
index 641ad206c05b27..23d23c9dc6bb01 100644
--- a/crates/project/src/environment.rs
+++ b/crates/project/src/environment.rs
@@ -198,8 +198,9 @@ async fn load_shell_environment(
 
         anyhow::ensure!(
             direnv_output.status.success(),
-            "direnv exited with error {:?}",
-            direnv_output.status
+            "direnv exited with error {:?}. Stderr:\n{}",
+            direnv_output.status,
+            String::from_utf8_lossy(&direnv_output.stderr)
         );
 
         let output = String::from_utf8_lossy(&direnv_output.stdout);
@@ -214,7 +215,7 @@ async fn load_shell_environment(
 
     let direnv_environment = match load_direnv {
         DirenvSettings::ShellHook => None,
-        DirenvSettings::Direct => load_direnv_environment(dir).await?,
+        DirenvSettings::Direct => load_direnv_environment(dir).await.log_err().flatten(),
     }
     .unwrap_or(HashMap::default());
 

From 898d48a57497011f6b96c98ddee35b511398fbd9 Mon Sep 17 00:00:00 2001
From: Sylvain Brunerie <sylvain.brunerie@gmail.com>
Date: Mon, 30 Sep 2024 09:02:12 +0200
Subject: [PATCH 392/762] php: Add syntax highlighting inside heredoc strings
 (#18368)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PHP heredoc strings make it easy to define string literals over multiple
lines:

```php
    $someString = <<<EOT
        multiline
        text
        EOT;
```

That `EOT` identifier can be anything else, and it is actually being
used in Sublime Text and VS Code to inject syntax highlighting for
another language in said string, depending on the identifier. For
instance, if the identifier is SQL, SQL syntax highlighting will be
applied to the contents of the string. Likewise if the identifier is CSS
or JS.

```php
    $someString = <<<SQL
        SELECT *
        FROM my_table
        SQL;
```

This PR changes the PHP extension so that it supports that feature too.

Release Notes:

- php: Added syntax highlighting inside heredoc strings
---
 extensions/php/languages/php/injections.scm | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/extensions/php/languages/php/injections.scm b/extensions/php/languages/php/injections.scm
index 3b5cd70064c42c..122d0b377af701 100644
--- a/extensions/php/languages/php/injections.scm
+++ b/extensions/php/languages/php/injections.scm
@@ -5,3 +5,5 @@
 ((comment) @content
   (#match? @content "^/\\*\\*[^*]")
   (#set! "language" "phpdoc"))
+
+((heredoc_body) (heredoc_end) @language) @content

From 3fafdeb1a8280c5313f235a45af41d30e1314cc7 Mon Sep 17 00:00:00 2001
From: jansol <jhs@psonet.com>
Date: Mon, 30 Sep 2024 10:09:13 +0300
Subject: [PATCH 393/762] gpui: Fix blur region on Plasma/Wayland (#18465)

Once again aping after what winit does - since we always want to have
the whole window blurred there is apparently no need to specify a blur
region at all. Rounded corners would be the exception, but that is not
possible with the current protocol (it is planned for the vendor-neutral
version though!)

This eliminates the problem where only a fixed region of the window
would get blurred if the window was resized to be larger than at launch.
Also a drive-by comment grammar fix :wink:

Release Notes:

- Fixed blur region handling on Plasma/Wayland
---
 crates/gpui/src/platform/linux/wayland/window.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/crates/gpui/src/platform/linux/wayland/window.rs b/crates/gpui/src/platform/linux/wayland/window.rs
index a0520f6b7056e5..329b6c185fbfe9 100644
--- a/crates/gpui/src/platform/linux/wayland/window.rs
+++ b/crates/gpui/src/platform/linux/wayland/window.rs
@@ -1046,8 +1046,8 @@ fn update_window(mut state: RefMut<WaylandWindowState>) {
         && state.decorations == WindowDecorations::Server
     {
         // Promise the compositor that this region of the window surface
-        // contains no transparent pixels. This allows the compositor to
-        // do skip whatever is behind the surface for better performance.
+        // contains no transparent pixels. This allows the compositor to skip
+        // updating whatever is behind the surface for better performance.
         state.surface.set_opaque_region(Some(&region));
     } else {
         state.surface.set_opaque_region(None);
@@ -1057,7 +1057,6 @@ fn update_window(mut state: RefMut<WaylandWindowState>) {
         if state.background_appearance == WindowBackgroundAppearance::Blurred {
             if state.blur.is_none() {
                 let blur = blur_manager.create(&state.surface, &state.globals.qh, ());
-                blur.set_region(Some(&region));
                 state.blur = Some(blur);
             }
             state.blur.as_ref().unwrap().commit();

From ed5eb725f93305642f02b10676ce56c8a7779d5d Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Mon, 30 Sep 2024 11:25:11 +0300
Subject: [PATCH 394/762] Improve language server log view split ergonomics
 (#18527)

Allows to split log view, and opens it split on the right, same as the
syntax tree view.

Release Notes:

- Improved language server log panel split ergonomics
---
 crates/language_tools/src/lsp_log.rs | 28 ++++++++++++++++++++++++----
 1 file changed, 24 insertions(+), 4 deletions(-)

diff --git a/crates/language_tools/src/lsp_log.rs b/crates/language_tools/src/lsp_log.rs
index d8fe3aa51840e4..aee39ff0a088e7 100644
--- a/crates/language_tools/src/lsp_log.rs
+++ b/crates/language_tools/src/lsp_log.rs
@@ -17,7 +17,7 @@ use ui::{prelude::*, Button, Checkbox, ContextMenu, Label, PopoverMenu, Selectio
 use workspace::{
     item::{Item, ItemHandle},
     searchable::{SearchEvent, SearchableItem, SearchableItemHandle},
-    ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace,
+    SplitDirection, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace, WorkspaceId,
 };
 
 const SEND_LINE: &str = "// Send:";
@@ -194,12 +194,11 @@ pub fn init(cx: &mut AppContext) {
         workspace.register_action(move |workspace, _: &OpenLanguageServerLogs, cx| {
             let project = workspace.project().read(cx);
             if project.is_local() {
-                workspace.add_item_to_active_pane(
+                workspace.split_item(
+                    SplitDirection::Right,
                     Box::new(cx.new_view(|cx| {
                         LspLogView::new(workspace.project().clone(), log_store.clone(), cx)
                     })),
-                    None,
-                    true,
                     cx,
                 );
             }
@@ -912,6 +911,27 @@ impl Item for LspLogView {
     fn as_searchable(&self, handle: &View<Self>) -> Option<Box<dyn SearchableItemHandle>> {
         Some(Box::new(handle.clone()))
     }
+
+    fn clone_on_split(
+        &self,
+        _workspace_id: Option<WorkspaceId>,
+        cx: &mut ViewContext<Self>,
+    ) -> Option<View<Self>>
+    where
+        Self: Sized,
+    {
+        Some(cx.new_view(|cx| {
+            let mut new_view = Self::new(self.project.clone(), self.log_store.clone(), cx);
+            if let Some(server_id) = self.current_server_id {
+                match self.active_entry_kind {
+                    LogKind::Rpc => new_view.show_rpc_trace_for_server(server_id, cx),
+                    LogKind::Trace => new_view.show_trace_for_server(server_id, cx),
+                    LogKind::Logs => new_view.show_logs_for_server(server_id, cx),
+                }
+            }
+            new_view
+        }))
+    }
 }
 
 impl SearchableItem for LspLogView {

From 1f72069b42543d380be892c415b7433519375771 Mon Sep 17 00:00:00 2001
From: VacheDesNeiges <33199153+VacheDesNeiges@users.noreply.github.com>
Date: Mon, 30 Sep 2024 10:27:30 +0200
Subject: [PATCH 395/762] Improve C++ Tree-sitter queries (#18016)

I made a few tree-sitter queries for improving the highlighting of C++.

There is one query that I'm not totally certain about and would
appreciate some feedback on it, the one that concerns attributes.

Many editor only highlight the identifier as a keyword (This is the
behavior implemented in this commit), while others, for example the
tree-sitter plugin for neovim, tags the entire attribute for
highlighting (double brackets included). I don't know which one is
preferable. Here are screenshots of the two versions:


![image](https://github.com/user-attachments/assets/4e1b92c8-adc7-4900-a5b1-dc43c98f4c67)


![image](https://github.com/user-attachments/assets/290a13e3-5cb3-45cb-b6d9-3dc3e6a8af2d)


Release Notes:


- Fixed C++ attributes identifiers being wrongly highlighed through the
tag "variable"
- C++ attribute identifiers (nodiscard,deprecated, noreturn, etc.. ) are
now highlighted through the tag "keyword"
- Changed C++ primitives types (void, bool, int, size_t, etc.. ) to no
longer be highlighted with the tag "keyword", they can now be
highlighted by the tag "type.primitive".
- Added a tag "concept" for highlighting C++ concept identifiers. (This
tag name has been chosen to be the same than the one returned by
clangd's semantic tokens)
---
 crates/languages/src/cpp/highlights.scm | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/crates/languages/src/cpp/highlights.scm b/crates/languages/src/cpp/highlights.scm
index 4c9db569285e39..2df9ec2923be3d 100644
--- a/crates/languages/src/cpp/highlights.scm
+++ b/crates/languages/src/cpp/highlights.scm
@@ -2,6 +2,10 @@
 (field_identifier) @property
 (namespace_identifier) @namespace
 
+(concept_definition
+    (identifier) @concept)
+
+
 (call_expression
   function: (qualified_identifier
     name: (identifier) @function))
@@ -64,6 +68,14 @@
 
 (auto) @type
 (type_identifier) @type
+type :(primitive_type) @type.primitive
+
+(requires_clause
+    constraint: (template_type
+        name: (type_identifier) @concept))
+
+(attribute
+    name: (identifier) @keyword)
 
 ((identifier) @constant
  (#match? @constant "^_*[A-Z][A-Z\\d_]*$"))
@@ -119,7 +131,6 @@
   "using"
   "virtual"
   "while"
-  (primitive_type)
   (sized_type_specifier)
   (storage_class_specifier)
   (type_qualifier)

From 707ccb04d2eb15129dce19e12388c1e5321aef57 Mon Sep 17 00:00:00 2001
From: Patrick MARIE <mycroft@users.noreply.github.com>
Date: Mon, 30 Sep 2024 10:27:47 +0200
Subject: [PATCH 396/762] Restore paste on middle-click on linux (#18503)

This is a partial revert of e6c1c51b37a, which removed the middle-click
pasting on linux (both x11 & wayland). It also restores the
`middle_click_paste` option behavior which became unexistent.

Release Notes:

- Restore Linux middle-click pasting.
---
 crates/editor/src/element.rs | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 1c35fa6bcdd4e8..98a5ff7f4dff50 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -636,11 +636,30 @@ impl EditorElement {
             cx.stop_propagation();
         } else if end_selection && pending_nonempty_selections {
             cx.stop_propagation();
-        } else if cfg!(target_os = "linux")
-            && event.button == MouseButton::Middle
-            && (!text_hitbox.is_hovered(cx) || editor.read_only(cx))
-        {
-            return;
+        } else if cfg!(target_os = "linux") && event.button == MouseButton::Middle {
+            if !text_hitbox.is_hovered(cx) || editor.read_only(cx) {
+                return;
+            }
+
+            #[cfg(target_os = "linux")]
+            if EditorSettings::get_global(cx).middle_click_paste {
+                if let Some(text) = cx.read_from_primary().and_then(|item| item.text()) {
+                    let point_for_position =
+                        position_map.point_for_position(text_hitbox.bounds, event.position);
+                    let position = point_for_position.previous_valid;
+
+                    editor.select(
+                        SelectPhase::Begin {
+                            position,
+                            add: false,
+                            click_count: 1,
+                        },
+                        cx,
+                    );
+                    editor.insert(&text, cx);
+                }
+                cx.stop_propagation()
+            }
         }
     }
 

From 57ad5778fad8cbdeada7815ca9c58fec63db90d8 Mon Sep 17 00:00:00 2001
From: 0hDEADBEAF <0xdeadbeaf@tutamail.com>
Date: Mon, 30 Sep 2024 10:34:44 +0200
Subject: [PATCH 397/762] Add a way to explicitly specify RC toolkit path
 (#18402)

Closes #18393

Release Notes:

- Added a `ZED_RC_TOOLKIT_PATH` env variable so `winresource` crate can fetch the RC executable path correctly on some configurations
---
 crates/zed/build.rs             |  7 +++++++
 docs/src/development/windows.md | 27 +++++++++++++++++++++++++++
 2 files changed, 34 insertions(+)

diff --git a/crates/zed/build.rs b/crates/zed/build.rs
index c0d5c418750a4d..3013773f918342 100644
--- a/crates/zed/build.rs
+++ b/crates/zed/build.rs
@@ -56,6 +56,13 @@ fn main() {
         println!("cargo:rerun-if-changed={}", icon.display());
 
         let mut res = winresource::WindowsResource::new();
+
+        // Depending on the security applied to the computer, winresource might fail
+        // fetching the RC path. Therefore, we add a way to explicitly specify the
+        // toolkit path, allowing winresource to use a valid RC path.
+        if let Some(explicit_rc_toolkit_path) = std::env::var("ZED_RC_TOOLKIT_PATH").ok() {
+            res.set_toolkit_path(explicit_rc_toolkit_path.as_str());
+        }
         res.set_icon(icon.to_str().unwrap());
         res.set("FileDescription", "Zed");
         res.set("ProductName", "Zed");
diff --git a/docs/src/development/windows.md b/docs/src/development/windows.md
index 67808186d1961b..03e8cae66b86d3 100644
--- a/docs/src/development/windows.md
+++ b/docs/src/development/windows.md
@@ -93,3 +93,30 @@ This error can happen if you are using the "rust-lld.exe" linker. Consider tryin
 If you are using a global config, consider moving the Zed repository to a nested directory and add a `.cargo/config.toml` with a custom linker config in the parent directory.
 
 See this issue for more information [#12041](https://github.com/zed-industries/zed/issues/12041)
+
+### Invalid RC path selected
+
+Sometimes, depending on the security rules applied to your laptop, you may get the following error while compiling Zed:
+
+```
+error: failed to run custom build command for `zed(C:\Users\USER\src\zed\crates\zed)`
+
+Caused by:
+  process didn't exit successfully: `C:\Users\USER\src\zed\target\debug\build\zed-b24f1e9300107efc\build-script-build` (exit code: 1)
+  --- stdout
+  cargo:rerun-if-changed=../../.git/logs/HEAD
+  cargo:rustc-env=ZED_COMMIT_SHA=25e2e9c6727ba9b77415588cfa11fd969612adb7
+  cargo:rustc-link-arg=/stack:8388608
+  cargo:rerun-if-changed=resources/windows/app-icon.ico
+  package.metadata.winresource does not exist
+  Selected RC path: 'bin\x64\rc.exe'
+
+  --- stderr
+  The system cannot find the path specified. (os error 3)
+warning: build failed, waiting for other jobs to finish...
+```
+
+In order to fix this issue, you can manually set the `ZED_RC_TOOLKIT_PATH` environment variable to the RC toolkit path. Usually, you can set it to:
+`C:\Program Files (x86)\Windows Kits\10\bin\<SDK_version>\x64`.
+
+See this [issue](https://github.com/zed-industries/zed/issues/18393) for more information.

From 533416c5a96d3201dfd5e639a6a2d8fc9798a6fb Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Mon, 30 Sep 2024 12:38:57 +0200
Subject: [PATCH 398/762] terminal: Make CursorShape configurable (#18530)

This builds on top of @Yevgen's #15840 and combines it with the settings
names introduced in #17572.

Closes #4731.

Release Notes:

- Added a setting for the terminal's default cursor shape. The setting
is `{"terminal": {"cursor_shape": "block"}}``. Possible values: `block`,
`bar`, `hollow`, `underline`.

Demo:


https://github.com/user-attachments/assets/96ed28c2-c222-436b-80cb-7cd63eeb47dd
---
 assets/settings/default.json              | 12 +++++++
 crates/project/src/terminals.rs           |  1 +
 crates/terminal/src/terminal.rs           | 13 +++++--
 crates/terminal/src/terminal_settings.rs  | 43 +++++++++++++++++++++++
 crates/terminal_view/src/terminal_view.rs | 23 ++++++++++--
 5 files changed, 88 insertions(+), 4 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 2a11a85d4efae4..ba95c2cfcdaaa5 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -671,6 +671,18 @@
     //  3. Always blink the cursor, ignoring the terminal mode
     //         "blinking": "on",
     "blinking": "terminal_controlled",
+    // Default cursor shape for the terminal.
+    //  1. A block that surrounds the following character
+    //     "block"
+    //  2. A vertical bar
+    //     "bar"
+    //  3. An underline that runs along the following character
+    //     "underscore"
+    //  4. A box drawn around the following character
+    //     "hollow"
+    //
+    // Default: not set, defaults to "block"
+    "cursor_shape": null,
     // Set whether Alternate Scroll mode (code: ?1007) is active by default.
     // Alternate Scroll mode converts mouse scroll events into up / down key
     // presses when in the alternate screen (e.g. when running applications
diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs
index 136842d158604c..ababb3261b3376 100644
--- a/crates/project/src/terminals.rs
+++ b/crates/project/src/terminals.rs
@@ -216,6 +216,7 @@ impl Project {
             shell,
             env,
             Some(settings.blinking),
+            settings.cursor_shape.unwrap_or_default(),
             settings.alternate_scroll,
             settings.max_scroll_history_lines,
             window,
diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs
index 8f8982f02c4701..f9767b07d12612 100644
--- a/crates/terminal/src/terminal.rs
+++ b/crates/terminal/src/terminal.rs
@@ -18,7 +18,9 @@ use alacritty_terminal::{
         Config, RenderableCursor, TermMode,
     },
     tty::{self},
-    vte::ansi::{ClearMode, Handler, NamedPrivateMode, PrivateMode},
+    vte::ansi::{
+        ClearMode, CursorStyle as AlacCursorStyle, Handler, NamedPrivateMode, PrivateMode,
+    },
     Term,
 };
 use anyhow::{bail, Result};
@@ -40,7 +42,7 @@ use serde::{Deserialize, Serialize};
 use settings::Settings;
 use smol::channel::{Receiver, Sender};
 use task::{HideStrategy, Shell, TaskId};
-use terminal_settings::{AlternateScroll, TerminalBlink, TerminalSettings};
+use terminal_settings::{AlternateScroll, CursorShape, TerminalBlink, TerminalSettings};
 use theme::{ActiveTheme, Theme};
 use util::truncate_and_trailoff;
 
@@ -314,6 +316,7 @@ impl TerminalBuilder {
         shell: Shell,
         mut env: HashMap<String, String>,
         blink_settings: Option<TerminalBlink>,
+        cursor_shape: CursorShape,
         alternate_scroll: AlternateScroll,
         max_scroll_history_lines: Option<usize>,
         window: AnyWindowHandle,
@@ -353,6 +356,7 @@ impl TerminalBuilder {
         // Setup Alacritty's env, which modifies the current process's environment
         alacritty_terminal::tty::setup_env();
 
+        let default_cursor_style = AlacCursorStyle::from(cursor_shape);
         let scrolling_history = if task.is_some() {
             // Tasks like `cargo build --all` may produce a lot of output, ergo allow maximum scrolling.
             // After the task finishes, we do not allow appending to that terminal, so small tasks output should not
@@ -365,6 +369,7 @@ impl TerminalBuilder {
         };
         let config = Config {
             scrolling_history,
+            default_cursor_style,
             ..Config::default()
         };
 
@@ -951,6 +956,10 @@ impl Terminal {
         &self.last_content
     }
 
+    pub fn set_cursor_shape(&mut self, cursor_shape: CursorShape) {
+        self.term.lock().set_cursor_style(Some(cursor_shape.into()));
+    }
+
     pub fn total_lines(&self) -> usize {
         let term = self.term.clone();
         let terminal = term.lock_unfair();
diff --git a/crates/terminal/src/terminal_settings.rs b/crates/terminal/src/terminal_settings.rs
index 4051caf864d25f..956cde19d90ed7 100644
--- a/crates/terminal/src/terminal_settings.rs
+++ b/crates/terminal/src/terminal_settings.rs
@@ -1,3 +1,6 @@
+use alacritty_terminal::vte::ansi::{
+    CursorShape as AlacCursorShape, CursorStyle as AlacCursorStyle,
+};
 use collections::HashMap;
 use gpui::{
     px, AbsoluteLength, AppContext, FontFallbacks, FontFeatures, FontWeight, Pixels, SharedString,
@@ -32,6 +35,7 @@ pub struct TerminalSettings {
     pub font_weight: Option<FontWeight>,
     pub line_height: TerminalLineHeight,
     pub env: HashMap<String, String>,
+    pub cursor_shape: Option<CursorShape>,
     pub blinking: TerminalBlink,
     pub alternate_scroll: AlternateScroll,
     pub option_as_meta: bool,
@@ -129,6 +133,11 @@ pub struct TerminalSettingsContent {
     ///
     /// Default: {}
     pub env: Option<HashMap<String, String>>,
+    /// Default cursor shape for the terminal.
+    /// Can be "bar", "block", "underscore", or "hollow".
+    ///
+    /// Default: None
+    pub cursor_shape: Option<CursorShape>,
     /// Sets the cursor blinking behavior in the terminal.
     ///
     /// Default: terminal_controlled
@@ -282,3 +291,37 @@ pub struct ToolbarContent {
     /// Default: true
     pub title: Option<bool>,
 }
+
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum CursorShape {
+    /// Cursor is a block like `█`.
+    #[default]
+    Block,
+    /// Cursor is an underscore like `_`.
+    Underline,
+    /// Cursor is a vertical bar like `⎸`.
+    Bar,
+    /// Cursor is a hollow box like `▯`.
+    Hollow,
+}
+
+impl From<CursorShape> for AlacCursorShape {
+    fn from(value: CursorShape) -> Self {
+        match value {
+            CursorShape::Block => AlacCursorShape::Block,
+            CursorShape::Underline => AlacCursorShape::Underline,
+            CursorShape::Bar => AlacCursorShape::Beam,
+            CursorShape::Hollow => AlacCursorShape::HollowBlock,
+        }
+    }
+}
+
+impl From<CursorShape> for AlacCursorStyle {
+    fn from(value: CursorShape) -> Self {
+        AlacCursorStyle {
+            shape: value.into(),
+            blinking: false,
+        }
+    }
+}
diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs
index e0b92035d107b3..f7b38e3f5ca3e4 100644
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -19,7 +19,7 @@ use terminal::{
         index::Point,
         term::{search::RegexSearch, TermMode},
     },
-    terminal_settings::{TerminalBlink, TerminalSettings, WorkingDirectory},
+    terminal_settings::{CursorShape, TerminalBlink, TerminalSettings, WorkingDirectory},
     Clear, Copy, Event, MaybeNavigationTarget, Paste, ScrollLineDown, ScrollLineUp, ScrollPageDown,
     ScrollPageUp, ScrollToBottom, ScrollToTop, ShowCharacterPalette, TaskStatus, Terminal,
     TerminalSize,
@@ -102,6 +102,7 @@ pub struct TerminalView {
     //Currently using iTerm bell, show bell emoji in tab until input is received
     has_bell: bool,
     context_menu: Option<(View<ContextMenu>, gpui::Point<Pixels>, Subscription)>,
+    cursor_shape: CursorShape,
     blink_state: bool,
     blinking_on: bool,
     blinking_paused: bool,
@@ -171,6 +172,9 @@ impl TerminalView {
         let focus_out = cx.on_focus_out(&focus_handle, |terminal_view, _event, cx| {
             terminal_view.focus_out(cx);
         });
+        let cursor_shape = TerminalSettings::get_global(cx)
+            .cursor_shape
+            .unwrap_or_default();
 
         Self {
             terminal,
@@ -178,6 +182,7 @@ impl TerminalView {
             has_bell: false,
             focus_handle,
             context_menu: None,
+            cursor_shape,
             blink_state: true,
             blinking_on: false,
             blinking_paused: false,
@@ -255,6 +260,16 @@ impl TerminalView {
     fn settings_changed(&mut self, cx: &mut ViewContext<Self>) {
         let settings = TerminalSettings::get_global(cx);
         self.show_title = settings.toolbar.title;
+
+        let new_cursor_shape = settings.cursor_shape.unwrap_or_default();
+        let old_cursor_shape = self.cursor_shape;
+        if old_cursor_shape != new_cursor_shape {
+            self.cursor_shape = new_cursor_shape;
+            self.terminal.update(cx, |term, _| {
+                term.set_cursor_shape(self.cursor_shape);
+            });
+        }
+
         cx.notify();
     }
 
@@ -903,7 +918,10 @@ impl TerminalView {
     }
 
     fn focus_in(&mut self, cx: &mut ViewContext<Self>) {
-        self.terminal.read(cx).focus_in();
+        self.terminal.update(cx, |terminal, _| {
+            terminal.set_cursor_shape(self.cursor_shape);
+            terminal.focus_in();
+        });
         self.blink_cursors(self.blink_epoch, cx);
         cx.invalidate_character_coordinates();
         cx.notify();
@@ -912,6 +930,7 @@ impl TerminalView {
     fn focus_out(&mut self, cx: &mut ViewContext<Self>) {
         self.terminal.update(cx, |terminal, _| {
             terminal.focus_out();
+            terminal.set_cursor_shape(CursorShape::Hollow);
         });
         cx.notify();
     }

From 65f6a7e5bc56daa33470fcfdcfb5fa7080c18b13 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Mon, 30 Sep 2024 12:39:11 +0200
Subject: [PATCH 399/762] linux/x11: Give title bar inactive bg on mouse down
 (#18529)

This fixes something that I felt was off for a while. Previously, when
you'd click on the titlebar to move the window, the titlebar would only
change its background once the moving starts, but not on mouse-down.

That felt really off, since the moving is down with mouse-down and move,
so I think giving the user feedback about the mouse-down event makes
more sense.

I know there's a subjectivity to this change, so I'm ready to hear other
opinions, but for now I want to go with this.

Release Notes:

- N/A
---
 crates/title_bar/src/title_bar.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index 73a82e9ee06201..d6cc839cfdb7bc 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -76,7 +76,7 @@ impl Render for TitleBar {
         let supported_controls = cx.window_controls();
         let decorations = cx.window_decorations();
         let titlebar_color = if cfg!(target_os = "linux") {
-            if cx.is_window_active() {
+            if cx.is_window_active() && !self.should_move {
                 cx.theme().colors().title_bar_background
             } else {
                 cx.theme().colors().title_bar_inactive_background

From 8ae74bc6df9f4480d70202a0dbc4d975d25158af Mon Sep 17 00:00:00 2001
From: wannacu <76616478+wannacu@users.noreply.github.com>
Date: Mon, 30 Sep 2024 18:57:59 +0800
Subject: [PATCH 400/762] gpui: Fix pre-edit position after applying scale
 factor (#18214)

before:

![image](https://github.com/user-attachments/assets/20590089-3333-4ca8-a371-b07acfbe43f9)

after:

![image](https://github.com/user-attachments/assets/2d25623e-0602-4d24-b563-64e1d2ec3492)

Release Notes:

- N/A
---
 crates/gpui/src/geometry.rs                      | 6 ++++++
 crates/gpui/src/platform.rs                      | 6 +++---
 crates/gpui/src/platform/linux/wayland/client.rs | 4 ++--
 crates/gpui/src/platform/linux/wayland/window.rs | 4 ++--
 crates/gpui/src/platform/linux/x11/client.rs     | 5 +++--
 crates/gpui/src/platform/linux/x11/window.rs     | 8 ++++----
 crates/gpui/src/platform/mac/window.rs           | 7 ++++---
 crates/gpui/src/platform/test/window.rs          | 6 +++---
 crates/gpui/src/platform/windows/window.rs       | 2 +-
 crates/gpui/src/window.rs                        | 4 +++-
 10 files changed, 31 insertions(+), 21 deletions(-)

diff --git a/crates/gpui/src/geometry.rs b/crates/gpui/src/geometry.rs
index 8de9e6f009d733..9b9b1698043919 100644
--- a/crates/gpui/src/geometry.rs
+++ b/crates/gpui/src/geometry.rs
@@ -2612,6 +2612,12 @@ impl From<ScaledPixels> for f64 {
     }
 }
 
+impl From<ScaledPixels> for u32 {
+    fn from(pixels: ScaledPixels) -> Self {
+        pixels.0 as u32
+    }
+}
+
 /// Represents a length in rems, a unit based on the font-size of the window, which can be assigned with [`WindowContext::set_rem_size`][set_rem_size].
 ///
 /// Rems are used for defining lengths that are scalable and consistent across different UI elements.
diff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rs
index 680c813078b86d..b5d6ae312783fe 100644
--- a/crates/gpui/src/platform.rs
+++ b/crates/gpui/src/platform.rs
@@ -23,8 +23,8 @@ use crate::{
     point, Action, AnyWindowHandle, AppContext, AsyncWindowContext, BackgroundExecutor, Bounds,
     DevicePixels, DispatchEventResult, Font, FontId, FontMetrics, FontRun, ForegroundExecutor,
     GPUSpecs, GlyphId, ImageSource, Keymap, LineLayout, Pixels, PlatformInput, Point,
-    RenderGlyphParams, RenderImage, RenderImageParams, RenderSvgParams, Scene, SharedString, Size,
-    SvgSize, Task, TaskLabel, WindowContext, DEFAULT_WINDOW_SIZE,
+    RenderGlyphParams, RenderImage, RenderImageParams, RenderSvgParams, ScaledPixels, Scene,
+    SharedString, Size, SvgSize, Task, TaskLabel, WindowContext, DEFAULT_WINDOW_SIZE,
 };
 use anyhow::Result;
 use async_task::Runnable;
@@ -381,7 +381,7 @@ pub(crate) trait PlatformWindow: HasWindowHandle + HasDisplayHandle {
     fn set_client_inset(&self, _inset: Pixels) {}
     fn gpu_specs(&self) -> Option<GPUSpecs>;
 
-    fn update_ime_position(&self, _bounds: Bounds<Pixels>);
+    fn update_ime_position(&self, _bounds: Bounds<ScaledPixels>);
 
     #[cfg(any(test, feature = "test-support"))]
     fn as_test(&mut self) -> Option<&mut TestWindow> {
diff --git a/crates/gpui/src/platform/linux/wayland/client.rs b/crates/gpui/src/platform/linux/wayland/client.rs
index 57c43a7e46a0c0..ba4971b63af6d2 100644
--- a/crates/gpui/src/platform/linux/wayland/client.rs
+++ b/crates/gpui/src/platform/linux/wayland/client.rs
@@ -84,7 +84,7 @@ use crate::{
 use crate::{
     AnyWindowHandle, CursorStyle, DisplayId, KeyDownEvent, KeyUpEvent, Keystroke, Modifiers,
     ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent,
-    NavigationDirection, Pixels, PlatformDisplay, PlatformInput, Point, ScrollDelta,
+    NavigationDirection, Pixels, PlatformDisplay, PlatformInput, Point, ScaledPixels, ScrollDelta,
     ScrollWheelEvent, TouchPhase,
 };
 use crate::{LinuxCommon, WindowParams};
@@ -313,7 +313,7 @@ impl WaylandClientStatePtr {
         }
     }
 
-    pub fn update_ime_position(&self, bounds: Bounds<Pixels>) {
+    pub fn update_ime_position(&self, bounds: Bounds<ScaledPixels>) {
         let client = self.get_client();
         let mut state = client.borrow_mut();
         if state.composing || state.text_input.is_none() || state.pre_edit_text.is_some() {
diff --git a/crates/gpui/src/platform/linux/wayland/window.rs b/crates/gpui/src/platform/linux/wayland/window.rs
index 329b6c185fbfe9..1ca358edecd0af 100644
--- a/crates/gpui/src/platform/linux/wayland/window.rs
+++ b/crates/gpui/src/platform/linux/wayland/window.rs
@@ -26,7 +26,7 @@ use crate::platform::{PlatformAtlas, PlatformInputHandler, PlatformWindow};
 use crate::scene::Scene;
 use crate::{
     px, size, AnyWindowHandle, Bounds, Decorations, GPUSpecs, Globals, Modifiers, Output, Pixels,
-    PlatformDisplay, PlatformInput, Point, PromptLevel, ResizeEdge, Size, Tiling,
+    PlatformDisplay, PlatformInput, Point, PromptLevel, ResizeEdge, ScaledPixels, Size, Tiling,
     WaylandClientStatePtr, WindowAppearance, WindowBackgroundAppearance, WindowBounds,
     WindowControls, WindowDecorations, WindowParams,
 };
@@ -1010,7 +1010,7 @@ impl PlatformWindow for WaylandWindow {
         }
     }
 
-    fn update_ime_position(&self, bounds: Bounds<Pixels>) {
+    fn update_ime_position(&self, bounds: Bounds<ScaledPixels>) {
         let state = self.borrow();
         state.client.update_ime_position(bounds);
     }
diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs
index d6c806236a9e47..7f5342a50360eb 100644
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -38,7 +38,8 @@ use crate::platform::{LinuxCommon, PlatformWindow};
 use crate::{
     modifiers_from_xinput_info, point, px, AnyWindowHandle, Bounds, ClipboardItem, CursorStyle,
     DisplayId, FileDropEvent, Keystroke, Modifiers, ModifiersChangedEvent, Pixels, Platform,
-    PlatformDisplay, PlatformInput, Point, ScrollDelta, Size, TouchPhase, WindowParams, X11Window,
+    PlatformDisplay, PlatformInput, Point, ScaledPixels, ScrollDelta, Size, TouchPhase,
+    WindowParams, X11Window,
 };
 
 use super::{button_of_key, modifiers_from_state, pressed_button_from_mask};
@@ -188,7 +189,7 @@ impl X11ClientStatePtr {
         }
     }
 
-    pub fn update_ime_position(&self, bounds: Bounds<Pixels>) {
+    pub fn update_ime_position(&self, bounds: Bounds<ScaledPixels>) {
         let client = self.get_client();
         let mut state = client.0.borrow_mut();
         if state.composing || state.ximc.is_none() {
diff --git a/crates/gpui/src/platform/linux/x11/window.rs b/crates/gpui/src/platform/linux/x11/window.rs
index b0cf82d605ffff..62b895d01f426c 100644
--- a/crates/gpui/src/platform/linux/x11/window.rs
+++ b/crates/gpui/src/platform/linux/x11/window.rs
@@ -4,9 +4,9 @@ use crate::{
     platform::blade::{BladeRenderer, BladeSurfaceConfig},
     px, size, AnyWindowHandle, Bounds, Decorations, DevicePixels, ForegroundExecutor, GPUSpecs,
     Modifiers, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput, PlatformInputHandler,
-    PlatformWindow, Point, PromptLevel, ResizeEdge, Scene, Size, Tiling, WindowAppearance,
-    WindowBackgroundAppearance, WindowBounds, WindowDecorations, WindowKind, WindowParams,
-    X11ClientStatePtr,
+    PlatformWindow, Point, PromptLevel, ResizeEdge, ScaledPixels, Scene, Size, Tiling,
+    WindowAppearance, WindowBackgroundAppearance, WindowBounds, WindowDecorations, WindowKind,
+    WindowParams, X11ClientStatePtr,
 };
 
 use blade_graphics as gpu;
@@ -1412,7 +1412,7 @@ impl PlatformWindow for X11Window {
         }
     }
 
-    fn update_ime_position(&self, bounds: Bounds<Pixels>) {
+    fn update_ime_position(&self, bounds: Bounds<ScaledPixels>) {
         let mut state = self.0.state.borrow_mut();
         let client = state.client.clone();
         drop(state);
diff --git a/crates/gpui/src/platform/mac/window.rs b/crates/gpui/src/platform/mac/window.rs
index bf8369069731f1..885c3565ccc899 100644
--- a/crates/gpui/src/platform/mac/window.rs
+++ b/crates/gpui/src/platform/mac/window.rs
@@ -3,8 +3,9 @@ use crate::{
     platform::PlatformInputHandler, point, px, size, AnyWindowHandle, Bounds, DisplayLink,
     ExternalPaths, FileDropEvent, ForegroundExecutor, KeyDownEvent, Keystroke, Modifiers,
     ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels,
-    PlatformAtlas, PlatformDisplay, PlatformInput, PlatformWindow, Point, PromptLevel, Size, Timer,
-    WindowAppearance, WindowBackgroundAppearance, WindowBounds, WindowKind, WindowParams,
+    PlatformAtlas, PlatformDisplay, PlatformInput, PlatformWindow, Point, PromptLevel,
+    ScaledPixels, Size, Timer, WindowAppearance, WindowBackgroundAppearance, WindowBounds,
+    WindowKind, WindowParams,
 };
 use block::ConcreteBlock;
 use cocoa::{
@@ -1119,7 +1120,7 @@ impl PlatformWindow for MacWindow {
         None
     }
 
-    fn update_ime_position(&self, _bounds: Bounds<Pixels>) {
+    fn update_ime_position(&self, _bounds: Bounds<ScaledPixels>) {
         unsafe {
             let input_context: id = msg_send![class!(NSTextInputContext), currentInputContext];
             let _: () = msg_send![input_context, invalidateCharacterCoordinates];
diff --git a/crates/gpui/src/platform/test/window.rs b/crates/gpui/src/platform/test/window.rs
index 1464dd8e73b384..ebbf6ecc12b466 100644
--- a/crates/gpui/src/platform/test/window.rs
+++ b/crates/gpui/src/platform/test/window.rs
@@ -1,8 +1,8 @@
 use crate::{
     AnyWindowHandle, AtlasKey, AtlasTextureId, AtlasTile, Bounds, DispatchEventResult, GPUSpecs,
     Pixels, PlatformAtlas, PlatformDisplay, PlatformInput, PlatformInputHandler, PlatformWindow,
-    Point, Size, TestPlatform, TileId, WindowAppearance, WindowBackgroundAppearance, WindowBounds,
-    WindowParams,
+    Point, ScaledPixels, Size, TestPlatform, TileId, WindowAppearance, WindowBackgroundAppearance,
+    WindowBounds, WindowParams,
 };
 use collections::HashMap;
 use parking_lot::Mutex;
@@ -274,7 +274,7 @@ impl PlatformWindow for TestWindow {
         unimplemented!()
     }
 
-    fn update_ime_position(&self, _bounds: Bounds<Pixels>) {}
+    fn update_ime_position(&self, _bounds: Bounds<ScaledPixels>) {}
 
     fn gpu_specs(&self) -> Option<GPUSpecs> {
         None
diff --git a/crates/gpui/src/platform/windows/window.rs b/crates/gpui/src/platform/windows/window.rs
index e2cfb38afd4dfc..d5ea3be6cac5e6 100644
--- a/crates/gpui/src/platform/windows/window.rs
+++ b/crates/gpui/src/platform/windows/window.rs
@@ -685,7 +685,7 @@ impl PlatformWindow for WindowsWindow {
         Some(self.0.state.borrow().renderer.gpu_specs())
     }
 
-    fn update_ime_position(&self, _bounds: Bounds<Pixels>) {
+    fn update_ime_position(&self, _bounds: Bounds<ScaledPixels>) {
         // todo(windows)
     }
 }
diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs
index 57066b0ce64c5e..af968c5a2c1239 100644
--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -3610,7 +3610,9 @@ impl<'a> WindowContext<'a> {
         self.on_next_frame(|cx| {
             if let Some(mut input_handler) = cx.window.platform_window.take_input_handler() {
                 if let Some(bounds) = input_handler.selected_bounds(cx) {
-                    cx.window.platform_window.update_ime_position(bounds);
+                    cx.window
+                        .platform_window
+                        .update_ime_position(bounds.scale(cx.scale_factor()));
                 }
                 cx.window.platform_window.set_input_handler(input_handler);
             }

From e64a86ce9fdf2ee72cf8cc6572295bf3b372b7e1 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Mon, 30 Sep 2024 15:28:46 +0300
Subject: [PATCH 401/762] Fix a typo in the multi buffers documentation
 (#18535)

Closes https://github.com/zed-industries/zed/issues/18533

Release Notes:

- N/A
---
 docs/src/multibuffers.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/src/multibuffers.md b/docs/src/multibuffers.md
index 46bfb1d93f7e41..7d9f4cafc4ab3b 100644
--- a/docs/src/multibuffers.md
+++ b/docs/src/multibuffers.md
@@ -31,7 +31,7 @@ To start a search run the `pane: Toggle Search` command (`cmd-shift-f` on macOS,
 
 ## Diagnostics
 
-If you have a language server installed, the diagnostics pane can show you all errors across your project. You can open it by clicking on the icon in the status bar, or running the `diagnostcs: Deploy` command` ('cmd-shift-m` on macOS, `ctrl-shift-m` on Windows/Linux, or `:clist` in Vim mode).
+If you have a language server installed, the diagnostics pane can show you all errors across your project. You can open it by clicking on the icon in the status bar, or running the `diagnostics: Deploy` command` ('cmd-shift-m` on macOS, `ctrl-shift-m` on Windows/Linux, or `:clist` in Vim mode).
 
 ## Find References
 

From 215bce19748652820e01eecff6a1052586f357ae Mon Sep 17 00:00:00 2001
From: Stanislav Alekseev <43210583+WeetHet@users.noreply.github.com>
Date: Mon, 30 Sep 2024 16:35:36 +0300
Subject: [PATCH 402/762] Make direct direnv loading default (#18536)

I've been running with direct direnv loading for a while now and haven't
experienced any significant issues other than #18473. Making it default
would make direnv integration more reliable and consistent. I've also
updated the docs a bit to ensure that they represent current status of
direnv integration

Release Notes:

- Made direnv integration use direct (`direnv export json`) mode by
default instead of relying on a shell hook, improving consistency and
reliability of direnv detection
---
 assets/settings/default.json           | 10 ++++------
 crates/project/src/project_settings.rs |  5 +----
 docs/src/configuring-zed.md            |  6 ++++--
 3 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index ba95c2cfcdaaa5..f6c498e0278e6a 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -599,13 +599,11 @@
     }
   },
   // Configuration for how direnv configuration should be loaded. May take 2 values:
-  // 1. Load direnv configuration through the shell hook, works for POSIX shells and fish.
-  //      "load_direnv": "shell_hook"
-  // 2. Load direnv configuration using `direnv export json` directly.
-  //    This can help with some shells that otherwise would not detect
-  //    the direnv environment, such as nushell or elvish.
+  // 1. Load direnv configuration using `direnv export json` directly.
   //      "load_direnv": "direct"
-  "load_direnv": "shell_hook",
+  // 2. Load direnv configuration through the shell hook, works for POSIX shells and fish.
+  //      "load_direnv": "shell_hook"
+  "load_direnv": "direct",
   "inline_completions": {
     // A list of globs representing files that inline completions should be disabled for.
     "disabled_globs": [".env"]
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index 706d3afdce45e2..d794563672ed06 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -62,12 +62,9 @@ pub struct NodeBinarySettings {
 #[serde(rename_all = "snake_case")]
 pub enum DirenvSettings {
     /// Load direnv configuration through a shell hook
-    #[default]
     ShellHook,
     /// Load direnv configuration directly using `direnv export json`
-    ///
-    /// Warning: This option is experimental and might cause some inconsistent behavior compared to using the shell hook.
-    /// If it does, please report it to GitHub
+    #[default]
     Direct,
 }
 
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 18d66708ad7fc8..ad6a628ed0880f 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -267,12 +267,14 @@ left and right padding of the central pane from the workspace when the centered
 
 ## Direnv Integration
 
-- Description: Settings for [direnv](https://direnv.net/) integration. Requires `direnv` to be installed. `direnv` integration currently only means that the environment variables set by a `direnv` configuration can be used to detect some language servers in `$PATH` instead of installing them.
+- Description: Settings for [direnv](https://direnv.net/) integration. Requires `direnv` to be installed.
+  `direnv` integration make it possible to use the environment variables set by a `direnv` configuration to detect some language servers in `$PATH` instead of installing them.
+  It also allows for those environment variables to be used in tasks.
 - Setting: `load_direnv`
 - Default:
 
 ```json
-"load_direnv": "shell_hook"
+"load_direnv": "direct"
 ```
 
 **Options**

From 69e698c3be73b6e31605abd317b835f63670172c Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Mon, 30 Sep 2024 15:36:35 +0200
Subject: [PATCH 403/762] terminal: Fix blinking settings & blinking with
 custom shape (#18538)

This is a follow-up to #18530 thanks to this comment here:
https://github.com/zed-industries/zed/pull/18530#issuecomment-2382870564

In short: it fixes the `blinking` setting and the `cursor_shape` setting
as it relates to blinking.

Turns out our `blinking` setting was always the wrong value when using
`terminal_controlled` and the terminal _would_ control the blinking.

Example script to test with:

```bash
echo -e "0 normal \x1b[\x30 q"; sleep 2
echo -e "1 blink block \x1b[\x31 q"; sleep 2
echo -e "2 solid block \x1b[\x32 q"; sleep 2
echo -e "3 blink under \x1b[\x33 q"; sleep 2
echo -e "4 solid under \x1b[\x34 q"; sleep 2
echo -e "5 blink vert \x1b[\x35 q"; sleep 2
echo -e "6 solid vert \x1b[\x36 q"; sleep 2
echo -e "0 normal \x1b[\x30 q"; sleep 2

echo -e "color \x1b]12;#00ff00\x1b\\"; sleep 2
echo -e "reset \x1b]112\x1b\\ \x1b[\x30 q"
```

Before the changes in here, this script would set the cursor shape and
the blinking, but the blinking boolean would always be wrong.

This change here makes sure that it works consistently:

- `terminal.cursor_shape` only controls the *default* shape of the
terminal, not the blinking.
- `terminal.blinking = on` means that it's *always* blinking, regardless
of what terminal programs want
- `terminal.blinking = off` means that it's *never* blinking, regardless
of what terminal programs want
- `terminal.blinking = terminal_controlled (default)` means that it's
blinking depending on what terminal programs want. when a terminal
program resets the cursor to default, it sets it back to
`terminal.cursor_shape` if that is set.

Release Notes:

- Fixed the behavior of `{"terminal": {"blinking":
"[on|off|terminal_controlled]"}` to work correctly and to work correctly
when custom `cursor_shape` is set.
- `terminal.cursor_shape` only controls the *default* shape of the
terminal, not the blinking.
- `terminal.blinking = on` means that it's *always* blinking, regardless
of what terminal programs want
- `terminal.blinking = off` means that it's *never* blinking, regardless
of what terminal programs want
- `terminal.blinking = terminal_controlled (default)` means that it's
blinking depending on what terminal programs want. when a terminal
program resets the cursor to default, it sets it back to
`terminal.cursor_shape` if that is set.

Demo:


https://github.com/user-attachments/assets/b3fbeafd-ad58-41c8-9c07-1f03bc31771f

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/project/src/terminals.rs           |  1 -
 crates/terminal/src/terminal.rs           | 21 ++++++++++-----------
 crates/terminal_view/src/terminal_view.rs | 19 ++++++++++++++-----
 3 files changed, 24 insertions(+), 17 deletions(-)

diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs
index ababb3261b3376..54dd48cf433ff3 100644
--- a/crates/project/src/terminals.rs
+++ b/crates/project/src/terminals.rs
@@ -215,7 +215,6 @@ impl Project {
             spawn_task,
             shell,
             env,
-            Some(settings.blinking),
             settings.cursor_shape.unwrap_or_default(),
             settings.alternate_scroll,
             settings.max_scroll_history_lines,
diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs
index f9767b07d12612..b51308df378845 100644
--- a/crates/terminal/src/terminal.rs
+++ b/crates/terminal/src/terminal.rs
@@ -42,7 +42,7 @@ use serde::{Deserialize, Serialize};
 use settings::Settings;
 use smol::channel::{Receiver, Sender};
 use task::{HideStrategy, Shell, TaskId};
-use terminal_settings::{AlternateScroll, CursorShape, TerminalBlink, TerminalSettings};
+use terminal_settings::{AlternateScroll, CursorShape, TerminalSettings};
 use theme::{ActiveTheme, Theme};
 use util::truncate_and_trailoff;
 
@@ -102,7 +102,7 @@ pub enum Event {
     CloseTerminal,
     Bell,
     Wakeup,
-    BlinkChanged,
+    BlinkChanged(bool),
     SelectionsChanged,
     NewNavigationTarget(Option<MaybeNavigationTarget>),
     Open(MaybeNavigationTarget),
@@ -315,7 +315,6 @@ impl TerminalBuilder {
         task: Option<TaskState>,
         shell: Shell,
         mut env: HashMap<String, String>,
-        blink_settings: Option<TerminalBlink>,
         cursor_shape: CursorShape,
         alternate_scroll: AlternateScroll,
         max_scroll_history_lines: Option<usize>,
@@ -378,16 +377,11 @@ impl TerminalBuilder {
         let (events_tx, events_rx) = unbounded();
         //Set up the terminal...
         let mut term = Term::new(
-            config,
+            config.clone(),
             &TerminalSize::default(),
             ZedListener(events_tx.clone()),
         );
 
-        //Start off blinking if we need to
-        if let Some(TerminalBlink::On) = blink_settings {
-            term.set_private_mode(PrivateMode::Named(NamedPrivateMode::BlinkingCursor));
-        }
-
         //Alacritty defaults to alternate scrolling being on, so we just need to turn it off.
         if let AlternateScroll::Off = alternate_scroll {
             term.unset_private_mode(PrivateMode::Named(NamedPrivateMode::AlternateScroll));
@@ -437,6 +431,7 @@ impl TerminalBuilder {
             pty_tx: Notifier(pty_tx),
             completion_tx,
             term,
+            term_config: config,
             events: VecDeque::with_capacity(10), //Should never get this high.
             last_content: Default::default(),
             last_mouse: None,
@@ -588,6 +583,7 @@ pub struct Terminal {
     pty_tx: Notifier,
     completion_tx: Sender<()>,
     term: Arc<FairMutex<Term<ZedListener>>>,
+    term_config: Config,
     events: VecDeque<InternalEvent>,
     /// This is only used for mouse mode cell change detection
     last_mouse: Option<(AlacPoint, AlacDirection)>,
@@ -672,7 +668,9 @@ impl Terminal {
                 self.write_to_pty(format(self.last_content.size.into()))
             }
             AlacTermEvent::CursorBlinkingChange => {
-                cx.emit(Event::BlinkChanged);
+                let terminal = self.term.lock();
+                let blinking = terminal.cursor_style().blinking;
+                cx.emit(Event::BlinkChanged(blinking));
             }
             AlacTermEvent::Bell => {
                 cx.emit(Event::Bell);
@@ -957,7 +955,8 @@ impl Terminal {
     }
 
     pub fn set_cursor_shape(&mut self, cursor_shape: CursorShape) {
-        self.term.lock().set_cursor_style(Some(cursor_shape.into()));
+        self.term_config.default_cursor_style = cursor_shape.into();
+        self.term.lock().set_options(self.term_config.clone());
     }
 
     pub fn total_lines(&self) -> usize {
diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs
index f7b38e3f5ca3e4..ce65be30c6d4f2 100644
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -104,7 +104,7 @@ pub struct TerminalView {
     context_menu: Option<(View<ContextMenu>, gpui::Point<Pixels>, Subscription)>,
     cursor_shape: CursorShape,
     blink_state: bool,
-    blinking_on: bool,
+    blinking_terminal_enabled: bool,
     blinking_paused: bool,
     blink_epoch: usize,
     can_navigate_to_selected_word: bool,
@@ -184,7 +184,7 @@ impl TerminalView {
             context_menu: None,
             cursor_shape,
             blink_state: true,
-            blinking_on: false,
+            blinking_terminal_enabled: false,
             blinking_paused: false,
             blink_epoch: 0,
             can_navigate_to_selected_word: false,
@@ -434,7 +434,6 @@ impl TerminalView {
     pub fn should_show_cursor(&self, focused: bool, cx: &mut gpui::ViewContext<Self>) -> bool {
         //Don't blink the cursor when not focused, blinking is disabled, or paused
         if !focused
-            || !self.blinking_on
             || self.blinking_paused
             || self
                 .terminal
@@ -450,7 +449,10 @@ impl TerminalView {
             //If the user requested to never blink, don't blink it.
             TerminalBlink::Off => true,
             //If the terminal is controlling it, check terminal mode
-            TerminalBlink::TerminalControlled | TerminalBlink::On => self.blink_state,
+            TerminalBlink::TerminalControlled => {
+                !self.blinking_terminal_enabled || self.blink_state
+            }
+            TerminalBlink::On => self.blink_state,
         }
     }
 
@@ -642,7 +644,14 @@ fn subscribe_for_terminal_events(
                 cx.emit(Event::Wakeup);
             }
 
-            Event::BlinkChanged => this.blinking_on = !this.blinking_on,
+            Event::BlinkChanged(blinking) => {
+                if matches!(
+                    TerminalSettings::get_global(cx).blinking,
+                    TerminalBlink::TerminalControlled
+                ) {
+                    this.blinking_terminal_enabled = *blinking;
+                }
+            }
 
             Event::TitleChanged => {
                 cx.emit(ItemEvent::UpdateTab);

From 053e31994fd5ffc99cd0a59404fb5c4fac4fd3c5 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Mon, 30 Sep 2024 18:33:20 +0200
Subject: [PATCH 404/762] Fine-tune hunk controls block (#18543)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR changes the undo icon and adds a background color so that indent
lines don't bleed through the control block.

<img width="900" alt="Screenshot 2024-09-30 at 5 38 44 PM"
src="https://github.com/user-attachments/assets/4955f0f6-50ce-432f-85b9-1da0172d5e51">

Release Notes:

- N/A
---
 crates/editor/src/hunk_diff.rs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index 4e7a0f05f4a25b..2ccd60c668de7f 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -360,8 +360,11 @@ impl Editor {
 
                     h_flex()
                         .id(cx.block_id)
-                        .w_full()
                         .h(cx.line_height())
+                        .w_full()
+                        .border_t_1()
+                        .border_color(border_color)
+                        .bg(cx.theme().colors().editor_background)
                         .child(
                             div()
                                 .id("gutter-strip")
@@ -381,12 +384,10 @@ impl Editor {
                         )
                         .child(
                             h_flex()
-                                .pl_1p5()
+                                .pl_2()
                                 .pr_6()
                                 .size_full()
                                 .justify_between()
-                                .border_t_1()
-                                .border_color(border_color)
                                 .child(
                                     h_flex()
                                         .gap_1()
@@ -513,7 +514,7 @@ impl Editor {
                                                 }),
                                         )
                                         .child(
-                                            IconButton::new("discard", IconName::RotateCcw)
+                                            IconButton::new("discard", IconName::Undo)
                                                 .shape(IconButtonShape::Square)
                                                 .icon_size(IconSize::Small)
                                                 .tooltip({

From 74cba2407f3c5999ab27597dde1643e7e748db8e Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 30 Sep 2024 16:14:26 -0400
Subject: [PATCH 405/762] ci: Move collab to Dockerfile-collab (#18515)

This makes it possible to have multiple Dockerfiles, each with their own
`.dockerignore`. Previously any docker builds would always include
anything inside `.dockerignore`. I believe this feature may require
`export DOCKER_BUILDKIT=1` but we use that in CI already.
---
 .github/workflows/deploy_collab.yml             | 6 +++++-
 .zed/settings.json                              | 4 ++++
 Dockerfile => Dockerfile-collab                 | 0
 .dockerignore => Dockerfile-collab.dockerignore | 0
 4 files changed, 9 insertions(+), 1 deletion(-)
 rename Dockerfile => Dockerfile-collab (100%)
 rename .dockerignore => Dockerfile-collab.dockerignore (100%)

diff --git a/.github/workflows/deploy_collab.yml b/.github/workflows/deploy_collab.yml
index c4193adcd24349..1e6e6cf2803e20 100644
--- a/.github/workflows/deploy_collab.yml
+++ b/.github/workflows/deploy_collab.yml
@@ -76,7 +76,11 @@ jobs:
           clean: false
 
       - name: Build docker image
-        run: docker build . --build-arg GITHUB_SHA=$GITHUB_SHA --tag registry.digitalocean.com/zed/collab:$GITHUB_SHA
+        run: |
+          docker build -f Dockerfile-collab \
+            --build-arg GITHUB_SHA=$GITHUB_SHA \
+            --tag registry.digitalocean.com/zed/collab:$GITHUB_SHA \
+            .
 
       - name: Publish docker image
         run: docker push registry.digitalocean.com/zed/collab:${GITHUB_SHA}
diff --git a/.zed/settings.json b/.zed/settings.json
index 176fd33a9b966d..41adfdbf591d36 100644
--- a/.zed/settings.json
+++ b/.zed/settings.json
@@ -38,6 +38,10 @@
       }
     }
   },
+  "file_types": {
+    "Dockerfile": ["Dockerfile*[!dockerignore]"],
+    "Git Ignore": ["dockerignore"]
+  },
   "hard_tabs": false,
   "formatter": "auto",
   "remove_trailing_whitespace_on_save": true,
diff --git a/Dockerfile b/Dockerfile-collab
similarity index 100%
rename from Dockerfile
rename to Dockerfile-collab
diff --git a/.dockerignore b/Dockerfile-collab.dockerignore
similarity index 100%
rename from .dockerignore
rename to Dockerfile-collab.dockerignore

From 09424edc3510b3b6004f93f7c7f3c5e173a4c5fa Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 30 Sep 2024 16:17:21 -0400
Subject: [PATCH 406/762] ci: Add script/determine-release-channel (#18476)

- Refactor duplicated inline script from ci.yml to
`script/determine-release-channel`
- Remove references to non-existent '-nightly' release tags

Release Notes:

- N/A
---
 .github/workflows/ci.yml         | 79 ++++----------------------------
 script/bump-zed-patch-version    |  5 +-
 script/determine-release-channel | 32 +++++++++++++
 3 files changed, 43 insertions(+), 73 deletions(-)
 create mode 100755 script/determine-release-channel

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 07e5499d5eb76c..ca0d8bb9100fd8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -192,29 +192,12 @@ jobs:
       - name: Determine version and release channel
         if: ${{ startsWith(github.ref, 'refs/tags/v') }}
         run: |
-          set -eu
-
-          version=$(script/get-crate-version zed)
-          channel=$(cat crates/zed/RELEASE_CHANNEL)
-          echo "Publishing version: ${version} on release channel ${channel}"
-          echo "RELEASE_CHANNEL=${channel}" >> $GITHUB_ENV
-
-          expected_tag_name=""
-          case ${channel} in
-            stable)
-              expected_tag_name="v${version}";;
-            preview)
-              expected_tag_name="v${version}-pre";;
-            nightly)
-              expected_tag_name="v${version}-nightly";;
-            *)
-              echo "can't publish a release on channel ${channel}"
-              exit 1;;
-          esac
-          if [[ $GITHUB_REF_NAME != $expected_tag_name ]]; then
-            echo "invalid release tag ${GITHUB_REF_NAME}. expected ${expected_tag_name}"
-            exit 1
-          fi
+          # This exports RELEASE_CHANNEL into env (GITHUB_ENV)
+          script/determine-release-channel
+
+      - name: Draft release notes
+        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
+        run: |
           mkdir -p target/
           # Ignore any errors that occur while drafting release notes to not fail the build.
           script/draft-release-notes "$version" "$channel" > target/release-notes.md || true
@@ -289,29 +272,8 @@ jobs:
       - name: Determine version and release channel
         if: ${{ startsWith(github.ref, 'refs/tags/v') }}
         run: |
-          set -eu
-
-          version=$(script/get-crate-version zed)
-          channel=$(cat crates/zed/RELEASE_CHANNEL)
-          echo "Publishing version: ${version} on release channel ${channel}"
-          echo "RELEASE_CHANNEL=${channel}" >> $GITHUB_ENV
-
-          expected_tag_name=""
-          case ${channel} in
-            stable)
-              expected_tag_name="v${version}";;
-            preview)
-              expected_tag_name="v${version}-pre";;
-            nightly)
-              expected_tag_name="v${version}-nightly";;
-            *)
-              echo "can't publish a release on channel ${channel}"
-              exit 1;;
-          esac
-          if [[ $GITHUB_REF_NAME != $expected_tag_name ]]; then
-            echo "invalid release tag ${GITHUB_REF_NAME}. expected ${expected_tag_name}"
-            exit 1
-          fi
+          # This exports RELEASE_CHANNEL into env (GITHUB_ENV)
+          script/determine-release-channel
 
       - name: Create Linux .tar.gz bundle
         run: script/bundle-linux
@@ -357,29 +319,8 @@ jobs:
       - name: Determine version and release channel
         if: ${{ startsWith(github.ref, 'refs/tags/v') }}
         run: |
-          set -eu
-
-          version=$(script/get-crate-version zed)
-          channel=$(cat crates/zed/RELEASE_CHANNEL)
-          echo "Publishing version: ${version} on release channel ${channel}"
-          echo "RELEASE_CHANNEL=${channel}" >> $GITHUB_ENV
-
-          expected_tag_name=""
-          case ${channel} in
-            stable)
-              expected_tag_name="v${version}";;
-            preview)
-              expected_tag_name="v${version}-pre";;
-            nightly)
-              expected_tag_name="v${version}-nightly";;
-            *)
-              echo "can't publish a release on channel ${channel}"
-              exit 1;;
-          esac
-          if [[ $GITHUB_REF_NAME != $expected_tag_name ]]; then
-            echo "invalid release tag ${GITHUB_REF_NAME}. expected ${expected_tag_name}"
-            exit 1
-          fi
+          # This exports RELEASE_CHANNEL into env (GITHUB_ENV)
+          script/determine-release-channel
 
       - name: Create and upload Linux .tar.gz bundle
         run: script/bundle-linux
diff --git a/script/bump-zed-patch-version b/script/bump-zed-patch-version
index e00e747aa32dac..b52feff72f1cb4 100755
--- a/script/bump-zed-patch-version
+++ b/script/bump-zed-patch-version
@@ -9,11 +9,8 @@ case $channel in
   preview)
     tag_suffix="-pre"
     ;;
-  nightly)
-    tag_suffix="-nightly"
-    ;;
   *)
-    echo "this must be run on either of stable|preview|nightly release branches" >&2
+    echo "this must be run on either of stable|preview release branches" >&2
     exit 1
     ;;
 esac
diff --git a/script/determine-release-channel b/script/determine-release-channel
new file mode 100755
index 00000000000000..ae49fbf1e5d076
--- /dev/null
+++ b/script/determine-release-channel
@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+if [ -z "${GITHUB_ACTIONS-}" ]; then
+    echo "Error: This script must be run in a GitHub Actions environment"
+    exit 1
+elif [ -z "${GITHUB_REF-}" ]; then
+    # This should be the release tag 'v0.x.x'
+    echo "Error: GITHUB_REF is not set"
+    exit 1
+fi
+
+version=$(script/get-crate-version zed)
+channel=$(cat crates/zed/RELEASE_CHANNEL)
+echo "Publishing version: ${version} on release channel ${channel}"
+echo "RELEASE_CHANNEL=${channel}" >> $GITHUB_ENV
+
+expected_tag_name=""
+case ${channel} in
+stable)
+    expected_tag_name="v${version}";;
+preview)
+    expected_tag_name="v${version}-pre";;
+*)
+    echo "can't publish a release on channel ${channel}"
+    exit 1;;
+esac
+if [[ $GITHUB_REF_NAME != $expected_tag_name ]]; then
+    echo "invalid release tag ${GITHUB_REF_NAME}. expected ${expected_tag_name}"
+    exit 1
+fi

From 432de00e894e6a104fa69e9146081b159de2dc43 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 30 Sep 2024 17:02:19 -0400
Subject: [PATCH 407/762] ci: Use BuildJet Ubuntu 20.04 runners for better
 glibc compatibility (#18442)

Use BuildJet Ubuntu 20.04 runners.
- Linux arm64 unchanged (glibc >= 2.35)
- Linux x64 glibc requirement becomes to >= 2.31 (from glibc >= 2.35).

Note: Ubuntu 20.04 repo cmake (3.16.3) is normally too old to build Zed, but `ubuntu-2004` [includes cmake
3.30.3](https://github.com/actions/runner-images/blob/main/images/ubuntu/Ubuntu2004-Readme.md#tools).
---
 .github/workflows/ci.yml              |  4 +--
 .github/workflows/release_nightly.yml |  4 +--
 docs/src/linux.md                     |  6 ++---
 script/install-mold                   | 37 +++++++++++++++++++++++++++
 script/linux                          | 14 ++++++++--
 5 files changed, 56 insertions(+), 9 deletions(-)
 create mode 100755 script/install-mold

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ca0d8bb9100fd8..ef1570fbf2121a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -254,7 +254,7 @@ jobs:
     timeout-minutes: 60
     name: Create a Linux bundle
     runs-on:
-      - buildjet-16vcpu-ubuntu-2204
+      - buildjet-16vcpu-ubuntu-2004
     if: ${{ startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
     needs: [linux_tests]
     env:
@@ -267,7 +267,7 @@ jobs:
           clean: false
 
       - name: Install Linux dependencies
-        run: ./script/linux
+        run: ./script/linux && ./script/install-mold 2.34.0
 
       - name: Determine version and release channel
         if: ${{ startsWith(github.ref, 'refs/tags/v') }}
diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml
index 4e8a257bdd1bb8..349d14f990fcbf 100644
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -100,7 +100,7 @@ jobs:
     name: Create a Linux *.tar.gz bundle for x86
     if: github.repository_owner == 'zed-industries'
     runs-on:
-      - buildjet-16vcpu-ubuntu-2204
+      - buildjet-16vcpu-ubuntu-2004
     needs: tests
     env:
       DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}
@@ -117,7 +117,7 @@ jobs:
         run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
 
       - name: Install Linux dependencies
-        run: ./script/linux
+        run: ./script/linux && ./script/install-mold 2.34.0
 
       - name: Limit target directory size
         run: script/clear-target-dir-if-larger-than 100
diff --git a/docs/src/linux.md b/docs/src/linux.md
index 17334c325ca309..3bba9c8f93aaae 100644
--- a/docs/src/linux.md
+++ b/docs/src/linux.md
@@ -16,7 +16,7 @@ The Zed installed by the script works best on systems that:
 
 - have a Vulkan compatible GPU available (for example Linux on an M-series macBook)
 - have a system-wide glibc (NixOS and Alpine do not by default)
-  - x86_64 (Intel/AMD): glibc version >= 2.35 (Ubuntu 22 and newer)
+  - x86_64 (Intel/AMD): glibc version >= 2.29 (Ubuntu 20 and newer)
   - aarch64 (ARM): glibc version >= 2.35 (Ubuntu 22 and newer)
 
 Both Nix and Alpine have third-party Zed packages available (though they are currently a few weeks out of date). If you'd like to use our builds they do work if you install a glibc compatibility layer. On NixOS you can try [nix-ld](https://github.com/Mic92/nix-ld), and on Alpine [gcompat](https://wiki.alpinelinux.org/wiki/Running_glibc_programs).
@@ -24,8 +24,8 @@ Both Nix and Alpine have third-party Zed packages available (though they are cur
 You will need to build from source for:
 
 - architectures other than 64-bit Intel or 64-bit ARM (for example a 32-bit or RISC-V machine)
-- Amazon Linux
-- Rocky Linux 9.3
+- Redhat Enterprise Linux 8.x, Rocky Linux 8, AlmaLinux 8, Amazon Linux 2 on all architectures
+- Redhat Enterprise Linux 9.x, Rocky Linux 9.3, AlmaLinux 8, Amazon Linux 2023 on aarch64 (x86_x64 OK)
 
 ## Other ways to install Zed on Linux
 
diff --git a/script/install-mold b/script/install-mold
new file mode 100755
index 00000000000000..1c451b72690614
--- /dev/null
+++ b/script/install-mold
@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+# Install `mold` official binaries from GitHub Releases.
+#
+# Adapted from the official rui314/setup-mold@v1 action to:
+# * use environment variables instead of action inputs
+# * remove make-default support
+# * use curl instead of wget
+# * support doas for sudo
+# * support redhat systems
+# See: https://github.com/rui314/setup-mold/blob/main/action.yml
+
+set -euo pipefail
+
+MOLD_VERSION="${MOLD_VERSION:-${1:-}}"
+if [ "$(uname -s)" != "Linux" ]; then
+    echo "Error: This script is intended for Linux systems only."
+    exit 1
+elif [ -z "$MOLD_VERSION" ]; then
+    echo "Usage: $0 2.34.0"
+    exit 1
+elif [ -e /usr/local/bin/mold ]; then
+    echo "Warning: existing mold found at /usr/local/bin/mold. Skipping installation."
+    exit 0
+fi
+
+if [ "$(whoami)" = root ]; then SUDO=; else SUDO="$(command -v sudo || command -v doas || true)"; fi
+
+MOLD_REPO="${MOLD_REPO:-https://github.com/rui314/mold}"
+MOLD_URL="${MOLD_URL:-$MOLD_REPO}/releases/download/v$MOLD_VERSION/mold-$MOLD_VERSION-$(uname -m)-linux.tar.gz"
+
+echo "Downloading from $MOLD_URL"
+curl --location --show-error --output - --retry 3 --retry-delay 5 "$MOLD_URL" \
+    | $SUDO tar -C /usr/local --strip-components=1 --no-overwrite-dir -xzf -
+
+# Note this binary depends on the system libatomic.so.1 which is usually
+# provided as a dependency of gcc so it should be available on most systems.
diff --git a/script/linux b/script/linux
index eca3bf7f7d2497..189407a5107b86 100755
--- a/script/linux
+++ b/script/linux
@@ -20,19 +20,29 @@ if [[ -n $apt ]]; then
     libwayland-dev
     libxkbcommon-x11-dev
     libssl-dev
-    libstdc++-12-dev
     libzstd-dev
     libvulkan1
     libgit2-dev
     make
     cmake
     clang
-    mold
     jq
     gettext-base
     elfutils
     libsqlite3-dev
   )
+  # Ubuntu 20.04 / Debian Bullseye (including CI for release)
+  if grep -q "bullseye" /etc/debian_version; then
+    deps+=(
+      libstdc++-10-dev
+    )
+  else
+    deps+=(
+      libstdc++-12-dev
+      mold
+    )
+  fi
+
   $maysudo "$apt" update
   $maysudo "$apt" install -y "${deps[@]}"
   exit 0

From 3010dfe038dce73a4d5b809b6d0949e723c76835 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 30 Sep 2024 17:46:21 -0400
Subject: [PATCH 408/762] Support More Linux (#18480)

- Add `script/build-docker`
- Add `script/install-cmake`
- Add `script/install-mold`
- Improve `script/linux`
  - Add missing dependencies: `jq`, `git`, `tar`, `gzip` as required.
  - Add check for mold
  - Fix Redhat 8.x derivatives (RHEL, Centos, Almalinux, Rocky, Oracle, Amazon)
  - Fix perl libs to be Fedora only
  - Install the best `libstdc++` available on apt distros
  - ArchLinux: run `pacman -Syu` to update repos before installing.
  - Should work on Raspbian (untested)

This make it possible to test builds on other distros using docker:
```
./script/build-docker amazonlinux:2023
```
---
 Dockerfile-distros              |  26 +++++++
 Dockerfile-distros.dockerignore |   2 +
 docs/src/development/macos.md   |   6 ++
 script/build-docker             |  25 +++++++
 script/install-cmake            |  77 +++++++++++++++++++++
 script/install-mold             |   2 +-
 script/linux                    | 116 +++++++++++++++++++++++---------
 7 files changed, 220 insertions(+), 34 deletions(-)
 create mode 100644 Dockerfile-distros
 create mode 100644 Dockerfile-distros.dockerignore
 create mode 100755 script/build-docker
 create mode 100755 script/install-cmake

diff --git a/Dockerfile-distros b/Dockerfile-distros
new file mode 100644
index 00000000000000..c8a98d2f7db9bd
--- /dev/null
+++ b/Dockerfile-distros
@@ -0,0 +1,26 @@
+# syntax=docker/dockerfile:1
+
+ARG BASE_IMAGE
+FROM ${BASE_IMAGE}
+WORKDIR /app
+ARG TZ=Etc/UTC \
+    LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    DEBIAN_FRONTEND=noninteractive
+ENV CARGO_TERM_COLOR=always
+
+COPY script/linux script/
+RUN ./script/linux
+COPY script/install-mold script/install-cmake script/
+RUN ./script/install-mold "2.34.0"
+RUN ./script/install-cmake "3.30.4"
+
+COPY . .
+
+# When debugging, make these into individual RUN statements.
+# Cleanup to avoid saving big layers we aren't going to use.
+RUN . "$HOME/.cargo/env" \
+    && cargo fetch \
+    && cargo build \
+    && cargo run -- --help \
+    && cargo clean --quiet
diff --git a/Dockerfile-distros.dockerignore b/Dockerfile-distros.dockerignore
new file mode 100644
index 00000000000000..de70e0d16772e2
--- /dev/null
+++ b/Dockerfile-distros.dockerignore
@@ -0,0 +1,2 @@
+**/target
+**/node_modules
diff --git a/docs/src/development/macos.md b/docs/src/development/macos.md
index 1407b0f610dc68..c5cbf56e15f1a3 100644
--- a/docs/src/development/macos.md
+++ b/docs/src/development/macos.md
@@ -35,6 +35,12 @@ Clone down the [Zed repository](https://github.com/zed-industries/zed).
   brew install cmake
   ```
 
+- (Optional) Install `mold` to speed up link times
+
+  ```sh
+  brew install mold
+  ```
+
 ## Backend Dependencies
 
 If you are developing collaborative features of Zed, you'll need to install the dependencies of zed's `collab` server:
diff --git a/script/build-docker b/script/build-docker
new file mode 100755
index 00000000000000..c5ea294c734200
--- /dev/null
+++ b/script/build-docker
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+# Use a docker BASE_IMAGE to test building Zed.
+# e.g: ./script/bundle-docker ubuntu:20.04
+#
+# Increasing resources available to podman may speed this up:
+# podman machine stop
+# podman machine set --memory 16384 --cpus 8 --disk-size 200
+# podman machine start
+
+set -euo pipefail
+
+BASE_IMAGE=${BASE_IMAGE:-${1:-}}
+if [ -z "$BASE_IMAGE" ]; then
+    echo "Usage: $0 BASE_IMAGE" >&2
+    exit 1
+fi
+
+export DOCKER_BUILDKIT=1
+cd "$(dirname "$0")/.."
+
+podman build . \
+    -f Dockerfile-distros \
+    -t many \
+    --build-arg BASE_IMAGE="$BASE_IMAGE"
diff --git a/script/install-cmake b/script/install-cmake
new file mode 100755
index 00000000000000..71b5aaeeef2ed1
--- /dev/null
+++ b/script/install-cmake
@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+#
+# This script installs an up-to-date version of CMake.
+#
+# For MacOS use Homebrew to install the latest version.
+#
+# For Ubuntu use the official KitWare Apt repository with backports.
+# See: https://apt.kitware.com/
+#
+# For other systems (RHEL 8.x, 9.x, AmazonLinux, SUSE, Fedora, Arch, etc)
+# use the official CMake installer script from KitWare.
+#
+# Note this is similar to how GitHub Actions runners install cmake:
+# https://github.com/actions/runner-images/blob/main/images/ubuntu/scripts/build/install-cmake.sh
+#
+# Upstream:  3.30.4 (2024-09-27)
+
+set -euo pipefail
+
+
+if [[ "$(uname -s)" == "darwin" ]]; then
+  brew --version >/dev/null \
+    || echo "Error: Homebrew is required to install cmake on MacOS." && exit 1
+  echo "Installing cmake via Homebrew (can't pin to old versions)."
+  brew install cmake
+  exit 0
+elif [ "$(uname -s)" != "Linux" ]; then
+  echo "Error: This script is intended for MacOS/Linux systems only."
+  exit 1
+elif [ -z "${1:-}" ]; then
+  echo "Usage: $0 [3.30.4]"
+  exit 1
+fi
+CMAKE_VERSION="${CMAKE_VERSION:-${1:-3.30.4}}"
+
+if [ "$(whoami)" = root ]; then SUDO=; else SUDO="$(command -v sudo || command -v doas || true)"; fi
+
+if cmake --version | grep -q "$CMAKE_VERSION"; then
+  echo "CMake $CMAKE_VERSION is already installed."
+  exit 0
+elif [ -e /usr/local/bin/cmake ]; then
+  echo "Warning: existing cmake found at /usr/local/bin/cmake. Skipping installation."
+  exit 0
+elif [ -e /etc/apt/sources.list.d/kitware.list ]; then
+  echo "Warning: existing KitWare repository found. Skipping installation."
+  exit 0
+elif [ -e /etc/lsb-release ] && grep -qP 'DISTRIB_ID=Ubuntu' /etc/lsb-release; then
+  curl -fsSL https://apt.kitware.com/keys/kitware-archive-latest.asc \
+    | $SUDO gpg --dearmor - \
+    | $SUDO tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
+  echo "deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ $(lsb_release -cs) main" \
+    | $SUDO tee /etc/apt/sources.list.d/kitware.list >/dev/null
+  $SUDO apt-get update
+  $SUDO apt-get install -y kitware-archive-keyring cmake==$CMAKE_VERSION
+else
+  arch="$(uname -m)"
+  if [ "$arch" != "x86_64" ] && [ "$arch" != "aarch64" ]; then
+    echo "Error. Only x86_64 and aarch64 are supported."
+    exit 1
+  fi
+  tempdir=$(mktemp -d)
+  pushd "$tempdir"
+    CMAKE_REPO="https://github.com/Kitware/CMake"
+    CMAKE_INSTALLER="cmake-$CMAKE_VERSION-linux-$arch.sh"
+    curl -fsSL --output cmake-$CMAKE_VERSION-SHA-256.txt \
+      "$CMAKE_REPO/releases/download/v$CMAKE_VERSION/cmake-$CMAKE_VERSION-SHA-256.txt"
+    curl -fsSL --output $CMAKE_INSTALLER \
+      "$CMAKE_REPO/releases/download/v$CMAKE_VERSION/cmake-$CMAKE_VERSION-linux-$arch.sh"
+    # workaround for old versions of sha256sum not having --ignore-missing
+    grep -F "cmake-$CMAKE_VERSION-linux-$arch.sh" "cmake-$CMAKE_VERSION-SHA-256.txt" \
+      | sha256sum -c \
+      | grep -qP "^${CMAKE_INSTALLER}: OK"
+    chmod +x cmake-$CMAKE_VERSION-linux-$arch.sh
+    $SUDO ./cmake-$CMAKE_VERSION-linux-$arch.sh --prefix=/usr/local --skip-license
+  popd
+  rm -rf "$tempdir"
+fi
diff --git a/script/install-mold b/script/install-mold
index 1c451b72690614..fca8d73f21a10d 100755
--- a/script/install-mold
+++ b/script/install-mold
@@ -30,7 +30,7 @@ MOLD_REPO="${MOLD_REPO:-https://github.com/rui314/mold}"
 MOLD_URL="${MOLD_URL:-$MOLD_REPO}/releases/download/v$MOLD_VERSION/mold-$MOLD_VERSION-$(uname -m)-linux.tar.gz"
 
 echo "Downloading from $MOLD_URL"
-curl --location --show-error --output - --retry 3 --retry-delay 5 "$MOLD_URL" \
+curl -fsSL --output - "$MOLD_URL" \
     | $SUDO tar -C /usr/local --strip-components=1 --no-overwrite-dir -xzf -
 
 # Note this binary depends on the system libatomic.so.1 which is usually
diff --git a/script/linux b/script/linux
index 189407a5107b86..540bf063ec92ee 100755
--- a/script/linux
+++ b/script/linux
@@ -1,15 +1,25 @@
 #!/usr/bin/env bash
 
-set -ex
+set -xeuo pipefail
 
-# install the wasm toolchain
-which rustup > /dev/null 2>&1 || curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+# if root or if sudo/unavailable, define an empty variable
+if [ "$(id -u)" -eq 0 ]
+then maysudo=''
+else maysudo="$(command -v sudo || command -v doas || true)"
+fi
 
-# if sudo is not installed, define an empty alias
-maysudo=$(command -v sudo || command -v doas || true)
+function finalize {
+  # after packages install (curl, etc), get the rust toolchain
+  which rustup > /dev/null 2>&1 || curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+  # verify the mold situation
+  if ! command -v mold >/dev/null 2>&1; then
+    echo "Warning: Mold binaries are unavailable on your system." >&2
+    echo "    Builds will be slower without mold. Try: scripts/install-mold" >&2
+  fi
+  echo "Finished installing Linux dependencies with script/linux"
+}
 
-# Ubuntu, Debian, etc.
-# https://packages.ubuntu.com/
+# Ubuntu, Debian, Mint, Kali, Pop!_OS, Raspbian, etc.
 apt=$(command -v apt-get || true)
 if [[ -n $apt ]]; then
   deps=(
@@ -27,58 +37,88 @@ if [[ -n $apt ]]; then
     cmake
     clang
     jq
+    git
+    curl
     gettext-base
     elfutils
     libsqlite3-dev
   )
-  # Ubuntu 20.04 / Debian Bullseye (including CI for release)
-  if grep -q "bullseye" /etc/debian_version; then
-    deps+=(
-      libstdc++-10-dev
-    )
-  else
-    deps+=(
-      libstdc++-12-dev
-      mold
-    )
+  if (grep -qP 'PRETTY_NAME="(.+24\.04)' /etc/os-release); then
+    deps+=( mold libstdc++-14-dev )
+  elif (grep -qP 'PRETTY_NAME="((Debian|Raspbian).+12|.+22\.04)' /etc/os-release); then
+    deps+=( mold libstdc++-12-dev )
+  elif (grep -qP 'PRETTY_NAME="((Debian|Raspbian).+11|.+20\.04)' /etc/os-release); then
+    deps+=( libstdc++-10-dev )
   fi
 
   $maysudo "$apt" update
   $maysudo "$apt" install -y "${deps[@]}"
+  finalize
   exit 0
 fi
 
-# Fedora, CentOS, RHEL, etc.
-# https://packages.fedoraproject.org/
+# Fedora, CentOS, RHEL, Alma, Amazon 2023, Oracle, etc.
 dnf=$(command -v dnf || true)
-if [[ -n $dnf ]]; then
+# Old Redhat (yum only): Amazon Linux 2, Oracle Linux 7, etc.
+yum=$(command -v yum || true)
+
+if [[ -n $dnf ]] || [[ -n $yum ]]; then
+  pkg_cmd="${dnf:-${yum}}"
   deps=(
     gcc
-    g++
     clang
     cmake
-    mold
     alsa-lib-devel
     fontconfig-devel
     wayland-devel
     libxkbcommon-x11-devel
     openssl-devel
     libzstd-devel
-    # Perl dependencies are needed for openssl-sys crate see https://docs.rs/openssl/latest/openssl/
-    perl-FindBin
-    perl-IPC-Cmd
-    perl-File-Compare
-    perl-File-Copy
     vulkan-loader
     sqlite-devel
+    jq
+    git
+    tar
   )
+  # perl used for building openssl-sys crate. See: https://docs.rs/openssl/latest/openssl/
+  if grep -qP '^ID="(fedora)' /etc/os-release; then
+    deps+=(
+      perl-FindBin
+      perl-IPC-Cmd
+      perl-File-Compare
+      perl-File-Copy
+      mold
+    )
+  elif grep grep -qP '^ID="(rhel|rocky|alma|centos|ol)' /etc/os-release; then
+    deps+=( perl-interpreter )
+  fi
 
-  # libxkbcommon-x11-devel is in the crb repo on RHEL and CentOS, not needed for Fedora
-  if ! grep -q "Fedora" /etc/redhat-release; then
-    $maysudo "$dnf" config-manager --set-enabled crb
+  # gcc-c++ is g++ on RHEL8 and 8.x clones
+  if grep -qP '^ID="(rhel|rocky|alma|centos|ol)' /etc/os-release \
+      && grep -qP '^VERSION_ID="8' /etc/os-release; then
+    deps+=( gcc-c++ )
+  else
+    deps+=( g++ )
+  fi
+
+  # libxkbcommon-x11-devel is in a non-default repo on RHEL 8.x/9.x (except on AmazonLinux)
+  if grep -qP '^VERSION_ID="(8|9)' && grep -qP '^ID="(rhel|rocky|centos|alma|ol)' /etc/os-release; then
+    $maysudo dnf install -y 'dnf-command(config-manager)'
+    if grep -qP '^PRETTY_NAME="(AlmaLinux 8|Rocky Linux 8)' /etc/os-release; then
+      $maysudo dnf config-manager --set-enabled powertools
+    elif grep -qP '^PRETTY_NAME="((AlmaLinux|Rocky|CentOS Stream) 9|Red Hat.+(8|9))' /etc/os-release; then
+      $maysudo dnf config-manager --set-enabled crb
+    elif grep -qP '^PRETTY_NAME="Oracle Linux Server 8' /etc/os-release; then
+      $maysudo dnf config-manager --set-enabled ol8_codeready_builder
+    elif grep -qP '^PRETTY_NAME="Oracle Linux Server 9' /etc/os-release; then
+      $maysudo dnf config-manager --set-enabled ol9_codeready_builder
+    else
+      echo "Unexpected distro" && grep 'PRETTY_NAME' /etc/os-release && exit 1
+    fi
   fi
 
-  $maysudo "$dnf" install -y "${deps[@]}"
+  $maysudo $pkg_cmd install -y "${deps[@]}"
+  finalize
   exit 0
 fi
 
@@ -99,10 +139,14 @@ if [[ -n $zyp ]]; then
     openssl-devel
     libzstd-devel
     libvulkan1
-    mold
     sqlite3-devel
+    jq
+    git
+    tar
+    gzip
   )
   $maysudo "$zyp" install -y "${deps[@]}"
+  finalize
   exit 0
 fi
 
@@ -125,8 +169,10 @@ if [[ -n $pacman ]]; then
     mold
     sqlite
     jq
+    git
   )
-  $maysudo "$pacman" -S --needed --noconfirm "${deps[@]}"
+  $maysudo "$pacman" -Syu --needed --noconfirm "${deps[@]}"
+  finalize
   exit 0
 fi
 
@@ -153,6 +199,7 @@ if [[ -n $xbps ]]; then
     sqlite-devel
   )
   $maysudo "$xbps" -Syu "${deps[@]}"
+  finalize
   exit 0
 fi
 
@@ -162,6 +209,7 @@ emerge=$(command -v emerge || true)
 if [[ -n $emerge ]]; then
   deps=(
     app-arch/zstd
+    app-misc/jq
     dev-libs/openssl
     dev-libs/wayland
     dev-util/cmake
@@ -174,7 +222,9 @@ if [[ -n $emerge ]]; then
     dev-db/sqlite
   )
   $maysudo "$emerge" -u "${deps[@]}"
+  finalize
   exit 0
 fi
 
 echo "Unsupported Linux distribution in script/linux"
+exit 1

From eb9fd62a90d9b8825e7280f1e27775f6892c3924 Mon Sep 17 00:00:00 2001
From: Andrey Arutiunian <110744283+andarut@users.noreply.github.com>
Date: Tue, 1 Oct 2024 01:50:30 +0300
Subject: [PATCH 409/762] Fix rendering of markdown tables (#18315)

- Closes: https://github.com/zed-industries/zed/issues/11024

## Release Notes:

- Improved Markdown Preview rendering of tables

## Before:


![image](https://github.com/user-attachments/assets/25f05604-38a9-4bde-901c-6d53a5d9d94d)

<img width="2035" alt="Screenshot 2024-09-25 at 05 47 19"
src="https://github.com/user-attachments/assets/a30c56f5-4793-44c2-8527-294189f9e724">

## Now:


![image](https://github.com/user-attachments/assets/ce06f045-d0db-4b8c-a1fc-2811d35f2683)


<img width="2040" alt="Screenshot 2024-09-25 at 05 47 48"
src="https://github.com/user-attachments/assets/76e5d217-9110-4c5d-9fad-dc63ae0b75f4">

## Note:

I'm not a Rust programmer and this is my first PR in Zed (because i just
want to fix this, so i can view my notes in Markdown in Zed, not slow
Visual Studio Code) - so there may be errors. I'm open for critic a
---
 .../markdown_preview/src/markdown_renderer.rs | 56 ++++++++++++++++---
 1 file changed, 48 insertions(+), 8 deletions(-)

diff --git a/crates/markdown_preview/src/markdown_renderer.rs b/crates/markdown_preview/src/markdown_renderer.rs
index ad169f036b9cec..8bab51b2c3f213 100644
--- a/crates/markdown_preview/src/markdown_renderer.rs
+++ b/crates/markdown_preview/src/markdown_renderer.rs
@@ -6,8 +6,8 @@ use crate::markdown_elements::{
 };
 use gpui::{
     div, px, rems, AbsoluteLength, AnyElement, DefiniteLength, Div, Element, ElementId,
-    HighlightStyle, Hsla, InteractiveText, IntoElement, Keystroke, Modifiers, ParentElement,
-    SharedString, Styled, StyledText, TextStyle, WeakView, WindowContext,
+    HighlightStyle, Hsla, InteractiveText, IntoElement, Keystroke, Length, Modifiers,
+    ParentElement, SharedString, Styled, StyledText, TextStyle, WeakView, WindowContext,
 };
 use settings::Settings;
 use std::{
@@ -16,7 +16,7 @@ use std::{
 };
 use theme::{ActiveTheme, SyntaxTheme, ThemeSettings};
 use ui::{
-    h_flex, v_flex, Checkbox, FluentBuilder, InteractiveElement, LinkPreview, Selection,
+    h_flex, relative, v_flex, Checkbox, FluentBuilder, InteractiveElement, LinkPreview, Selection,
     StatefulInteractiveElement, Tooltip,
 };
 use workspace::Workspace;
@@ -231,12 +231,48 @@ fn render_markdown_list_item(
 }
 
 fn render_markdown_table(parsed: &ParsedMarkdownTable, cx: &mut RenderContext) -> AnyElement {
-    let header = render_markdown_table_row(&parsed.header, &parsed.column_alignments, true, cx);
+    let mut max_lengths: Vec<usize> = vec![0; parsed.header.children.len()];
+
+    for (index, cell) in parsed.header.children.iter().enumerate() {
+        let length = cell.contents.len();
+        max_lengths[index] = length;
+    }
+
+    for row in &parsed.body {
+        for (index, cell) in row.children.iter().enumerate() {
+            let length = cell.contents.len();
+            if length > max_lengths[index] {
+                max_lengths[index] = length;
+            }
+        }
+    }
+
+    let total_max_length: usize = max_lengths.iter().sum();
+    let max_column_widths: Vec<f32> = max_lengths
+        .iter()
+        .map(|&length| length as f32 / total_max_length as f32)
+        .collect();
+
+    let header = render_markdown_table_row(
+        &parsed.header,
+        &parsed.column_alignments,
+        &max_column_widths,
+        true,
+        cx,
+    );
 
     let body: Vec<AnyElement> = parsed
         .body
         .iter()
-        .map(|row| render_markdown_table_row(row, &parsed.column_alignments, false, cx))
+        .map(|row| {
+            render_markdown_table_row(
+                row,
+                &parsed.column_alignments,
+                &max_column_widths,
+                false,
+                cx,
+            )
+        })
         .collect();
 
     cx.with_common_p(v_flex())
@@ -249,14 +285,15 @@ fn render_markdown_table(parsed: &ParsedMarkdownTable, cx: &mut RenderContext) -
 fn render_markdown_table_row(
     parsed: &ParsedMarkdownTableRow,
     alignments: &Vec<ParsedMarkdownTableAlignment>,
+    max_column_widths: &Vec<f32>,
     is_header: bool,
     cx: &mut RenderContext,
 ) -> AnyElement {
     let mut items = vec![];
 
-    for cell in &parsed.children {
+    for (index, cell) in parsed.children.iter().enumerate() {
         let alignment = alignments
-            .get(items.len())
+            .get(index)
             .copied()
             .unwrap_or(ParsedMarkdownTableAlignment::None);
 
@@ -268,8 +305,11 @@ fn render_markdown_table_row(
             ParsedMarkdownTableAlignment::Right => v_flex().items_end(),
         };
 
+        let max_width = max_column_widths.get(index).unwrap_or(&0.0);
+
         let mut cell = container
-            .w_full()
+            .w(Length::Definite(relative(*max_width)))
+            .h_full()
             .child(contents)
             .px_2()
             .py_1()

From 837756198f91e8b33238a0d186d9a4685e4d5b08 Mon Sep 17 00:00:00 2001
From: maan2003 <49202620+maan2003@users.noreply.github.com>
Date: Tue, 1 Oct 2024 04:55:32 +0530
Subject: [PATCH 410/762] linux/wayland: Add support for pasting images
 (#17671)

Release Notes:

- You can now paste images into the Assistant Panel to include them as
context on Linux wayland
---
 crates/gpui/src/platform/linux/platform.rs    |  14 +-
 .../gpui/src/platform/linux/wayland/client.rs |   9 +-
 .../src/platform/linux/wayland/clipboard.rs   | 148 ++++++++++++------
 3 files changed, 106 insertions(+), 65 deletions(-)

diff --git a/crates/gpui/src/platform/linux/platform.rs b/crates/gpui/src/platform/linux/platform.rs
index a0bd6b1d33d176..67f1a43cbe3220 100644
--- a/crates/gpui/src/platform/linux/platform.rs
+++ b/crates/gpui/src/platform/linux/platform.rs
@@ -603,17 +603,11 @@ pub(super) fn get_xkb_compose_state(cx: &xkb::Context) -> Option<xkb::compose::S
     state
 }
 
-pub(super) unsafe fn read_fd(mut fd: FileDescriptor) -> Result<String> {
+pub(super) unsafe fn read_fd(mut fd: FileDescriptor) -> Result<Vec<u8>> {
     let mut file = File::from_raw_fd(fd.as_raw_fd());
-
-    let mut buffer = String::new();
-    file.read_to_string(&mut buffer)?;
-
-    // Normalize the text to unix line endings, otherwise
-    // copying from eg: firefox inserts a lot of blank
-    // lines, and that is super annoying.
-    let result = buffer.replace("\r\n", "\n");
-    Ok(result)
+    let mut buffer = Vec::new();
+    file.read_to_end(&mut buffer)?;
+    Ok(buffer)
 }
 
 impl CursorStyle {
diff --git a/crates/gpui/src/platform/linux/wayland/client.rs b/crates/gpui/src/platform/linux/wayland/client.rs
index ba4971b63af6d2..f7ade828615f4f 100644
--- a/crates/gpui/src/platform/linux/wayland/client.rs
+++ b/crates/gpui/src/platform/linux/wayland/client.rs
@@ -1799,10 +1799,11 @@ impl Dispatch<wl_data_device::WlDataDevice, ()> for WaylandClientStatePtr {
                     let fd = pipe.read;
                     drop(pipe.write);
 
-                    let read_task = state
-                        .common
-                        .background_executor
-                        .spawn(async { unsafe { read_fd(fd) } });
+                    let read_task = state.common.background_executor.spawn(async {
+                        let buffer = unsafe { read_fd(fd)? };
+                        let text = String::from_utf8(buffer)?;
+                        anyhow::Ok(text)
+                    });
 
                     let this = this.clone();
                     state
diff --git a/crates/gpui/src/platform/linux/wayland/clipboard.rs b/crates/gpui/src/platform/linux/wayland/clipboard.rs
index 26b5256bddcd43..b3ec52d20515f9 100644
--- a/crates/gpui/src/platform/linux/wayland/clipboard.rs
+++ b/crates/gpui/src/platform/linux/wayland/clipboard.rs
@@ -6,10 +6,14 @@ use std::{
 
 use calloop::{LoopHandle, PostAction};
 use filedescriptor::Pipe;
+use strum::IntoEnumIterator;
 use wayland_client::{protocol::wl_data_offer::WlDataOffer, Connection};
 use wayland_protocols::wp::primary_selection::zv1::client::zwp_primary_selection_offer_v1::ZwpPrimarySelectionOfferV1;
 
-use crate::{platform::linux::platform::read_fd, ClipboardItem, WaylandClientStatePtr};
+use crate::{
+    hash, platform::linux::platform::read_fd, ClipboardEntry, ClipboardItem, Image, ImageFormat,
+    WaylandClientStatePtr,
+};
 
 pub(crate) const TEXT_MIME_TYPE: &str = "text/plain;charset=utf-8";
 pub(crate) const FILE_LIST_MIME_TYPE: &str = "text/uri-list";
@@ -33,14 +37,30 @@ pub(crate) struct Clipboard {
     current_primary_offer: Option<DataOffer<ZwpPrimarySelectionOfferV1>>,
 }
 
+pub(crate) trait ReceiveData {
+    fn receive_data(&self, mime_type: String, fd: BorrowedFd<'_>);
+}
+
+impl ReceiveData for WlDataOffer {
+    fn receive_data(&self, mime_type: String, fd: BorrowedFd<'_>) {
+        self.receive(mime_type, fd);
+    }
+}
+
+impl ReceiveData for ZwpPrimarySelectionOfferV1 {
+    fn receive_data(&self, mime_type: String, fd: BorrowedFd<'_>) {
+        self.receive(mime_type, fd);
+    }
+}
+
 #[derive(Clone, Debug)]
 /// Wrapper for `WlDataOffer` and `ZwpPrimarySelectionOfferV1`, used to help track mime types.
-pub(crate) struct DataOffer<T> {
+pub(crate) struct DataOffer<T: ReceiveData> {
     pub inner: T,
     mime_types: Vec<String>,
 }
 
-impl<T> DataOffer<T> {
+impl<T: ReceiveData> DataOffer<T> {
     pub fn new(offer: T) -> Self {
         Self {
             inner: offer,
@@ -52,17 +72,71 @@ impl<T> DataOffer<T> {
         self.mime_types.push(mime_type)
     }
 
-    pub fn has_mime_type(&self, mime_type: &str) -> bool {
+    fn has_mime_type(&self, mime_type: &str) -> bool {
         self.mime_types.iter().any(|t| t == mime_type)
     }
 
-    pub fn find_text_mime_type(&self) -> Option<String> {
-        for offered_mime_type in &self.mime_types {
-            if let Some(offer_text_mime_type) = ALLOWED_TEXT_MIME_TYPES
-                .into_iter()
-                .find(|text_mime_type| text_mime_type == offered_mime_type)
-            {
-                return Some(offer_text_mime_type.to_owned());
+    fn read_bytes(&self, connection: &Connection, mime_type: &str) -> Option<Vec<u8>> {
+        let pipe = Pipe::new().unwrap();
+        self.inner.receive_data(mime_type.to_string(), unsafe {
+            BorrowedFd::borrow_raw(pipe.write.as_raw_fd())
+        });
+        let fd = pipe.read;
+        drop(pipe.write);
+
+        connection.flush().unwrap();
+
+        match unsafe { read_fd(fd) } {
+            Ok(bytes) => Some(bytes),
+            Err(err) => {
+                log::error!("error reading clipboard pipe: {err:?}");
+                None
+            }
+        }
+    }
+
+    fn read_text(&self, connection: &Connection) -> Option<ClipboardItem> {
+        let mime_type = self.mime_types.iter().find(|&mime_type| {
+            ALLOWED_TEXT_MIME_TYPES
+                .iter()
+                .any(|&allowed| allowed == mime_type)
+        })?;
+        let bytes = self.read_bytes(connection, mime_type)?;
+        let text_content = match String::from_utf8(bytes) {
+            Ok(content) => content,
+            Err(e) => {
+                log::error!("Failed to convert clipboard content to UTF-8: {}", e);
+                return None;
+            }
+        };
+
+        // Normalize the text to unix line endings, otherwise
+        // copying from eg: firefox inserts a lot of blank
+        // lines, and that is super annoying.
+        let result = text_content.replace("\r\n", "\n");
+        Some(ClipboardItem::new_string(result))
+    }
+
+    fn read_image(&self, connection: &Connection) -> Option<ClipboardItem> {
+        for format in ImageFormat::iter() {
+            let mime_type = match format {
+                ImageFormat::Png => "image/png",
+                ImageFormat::Jpeg => "image/jpeg",
+                ImageFormat::Webp => "image/webp",
+                ImageFormat::Gif => "image/gif",
+                ImageFormat::Svg => "image/svg+xml",
+                ImageFormat::Bmp => "image/bmp",
+                ImageFormat::Tiff => "image/tiff",
+            };
+            if !self.has_mime_type(mime_type) {
+                continue;
+            }
+
+            if let Some(bytes) = self.read_bytes(connection, mime_type) {
+                let id = hash(&bytes);
+                return Some(ClipboardItem {
+                    entries: vec![ClipboardEntry::Image(Image { format, bytes, id })],
+                });
             }
         }
         None
@@ -128,7 +202,7 @@ impl Clipboard {
     }
 
     pub fn read(&mut self) -> Option<ClipboardItem> {
-        let offer = self.current_offer.clone()?;
+        let offer = self.current_offer.as_ref()?;
         if let Some(cached) = self.cached_read.clone() {
             return Some(cached);
         }
@@ -137,30 +211,16 @@ impl Clipboard {
             return self.contents.clone();
         }
 
-        let mime_type = offer.find_text_mime_type()?;
-        let pipe = Pipe::new().unwrap();
-        offer.inner.receive(mime_type, unsafe {
-            BorrowedFd::borrow_raw(pipe.write.as_raw_fd())
-        });
-        let fd = pipe.read;
-        drop(pipe.write);
-
-        self.connection.flush().unwrap();
+        let item = offer
+            .read_text(&self.connection)
+            .or_else(|| offer.read_image(&self.connection))?;
 
-        match unsafe { read_fd(fd) } {
-            Ok(v) => {
-                self.cached_read = Some(ClipboardItem::new_string(v));
-                self.cached_read.clone()
-            }
-            Err(err) => {
-                log::error!("error reading clipboard pipe: {err:?}");
-                None
-            }
-        }
+        self.cached_read = Some(item.clone());
+        Some(item)
     }
 
     pub fn read_primary(&mut self) -> Option<ClipboardItem> {
-        let offer = self.current_primary_offer.clone()?;
+        let offer = self.current_primary_offer.as_ref()?;
         if let Some(cached) = self.cached_primary_read.clone() {
             return Some(cached);
         }
@@ -169,26 +229,12 @@ impl Clipboard {
             return self.primary_contents.clone();
         }
 
-        let mime_type = offer.find_text_mime_type()?;
-        let pipe = Pipe::new().unwrap();
-        offer.inner.receive(mime_type, unsafe {
-            BorrowedFd::borrow_raw(pipe.write.as_raw_fd())
-        });
-        let fd = pipe.read;
-        drop(pipe.write);
-
-        self.connection.flush().unwrap();
+        let item = offer
+            .read_text(&self.connection)
+            .or_else(|| offer.read_image(&self.connection))?;
 
-        match unsafe { read_fd(fd) } {
-            Ok(v) => {
-                self.cached_primary_read = Some(ClipboardItem::new_string(v.clone()));
-                self.cached_primary_read.clone()
-            }
-            Err(err) => {
-                log::error!("error reading clipboard pipe: {err:?}");
-                None
-            }
-        }
+        self.cached_primary_read = Some(item.clone());
+        Some(item)
     }
 
     fn send_internal(&self, fd: OwnedFd, bytes: Vec<u8>) {

From ecb7144b9571d8f99fb0cef19ae2ce554d2862ce Mon Sep 17 00:00:00 2001
From: Junkui Zhang <364772080@qq.com>
Date: Tue, 1 Oct 2024 07:26:20 +0800
Subject: [PATCH 411/762] windows: Fix can not set folder for `FileSaveDialog`
 (#17708)

Closes #17622
Closes #17682

The story here is that `SHCreateItemFromParsingName` dose not accept UNC
path.

Video:



https://github.com/user-attachments/assets/f4f7f671-5ab5-4965-9158-e7a79ac02654



Release Notes:

- N/A
---
 crates/gpui/src/platform/windows/platform.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs
index d9f08c2247adf0..a900d0114bb234 100644
--- a/crates/gpui/src/platform/windows/platform.rs
+++ b/crates/gpui/src/platform/windows/platform.rs
@@ -664,10 +664,11 @@ fn file_save_dialog(directory: PathBuf) -> Result<Option<PathBuf>> {
     let dialog: IFileSaveDialog = unsafe { CoCreateInstance(&FileSaveDialog, None, CLSCTX_ALL)? };
     if !directory.to_string_lossy().is_empty() {
         if let Some(full_path) = directory.canonicalize().log_err() {
-            let full_path = full_path.to_string_lossy().to_string();
-            if !full_path.is_empty() {
+            let full_path = full_path.to_string_lossy();
+            let full_path_str = full_path.trim_start_matches("\\\\?\\");
+            if !full_path_str.is_empty() {
                 let path_item: IShellItem =
-                    unsafe { SHCreateItemFromParsingName(&HSTRING::from(&full_path), None)? };
+                    unsafe { SHCreateItemFromParsingName(&HSTRING::from(full_path_str), None)? };
                 unsafe { dialog.SetFolder(&path_item).log_err() };
             }
         }

From 77506afd8314a8b300971b4ac444955bad654652 Mon Sep 17 00:00:00 2001
From: Junkui Zhang <364772080@qq.com>
Date: Tue, 1 Oct 2024 07:29:23 +0800
Subject: [PATCH 412/762] windows: Implement copy/paste images (#17852)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

**Clipboard Behavior on Windows Under This PR:**

| User Action | Zed’s Behavior |
| ------------------- |
-------------------------------------------------- |
| Paste PNG | Worked |
| Paste JPEG | Worked |
| Paste WebP | Worked, but not in the way you expect (see Issue section
below) |
| Paste GIF | Partially worked (see Issue section below) |
| Paste SVG | Partially worked (see Issue section below) |
| Paste BMP | Worked, but not in the way you expect (see Issue section
below) |
| Paste TIFF | Worked, but not in the way you expect (see Issue section
below) |
| Paste Files         | Worked, same behavior as macOS              |
| Copy image in Zed | Not tested, as I couldn’t find a way to copy
images |

---

**Differences Between the Windows and macOS Clipboard**

The clipboard functionality on Windows differs significantly from macOS.
On macOS, there can be multiple items in the clipboard, whereas, on
Windows, the clipboard holds only a single item. You can retrieve
different formats from the clipboard, but they are all just different
representations of the same item.

For example, when you copy a JPG image from Microsoft Word, the
clipboard will contain data in several formats:

- Microsoft Office proprietary data
- JPG format data
- PNG format data
- SVG format data

Please note that these formats all represent the same image, just in
different formats. This is due to compatibility concerns on Windows, as
various applications support different formats. Ideally, multiple
formats should be placed on the clipboard to support more software.
However, in general, supporting PNG will cover 99% of software, like
Chrome, which only supports PNG and BMP formats.

Additionally, since the clipboard on Windows only contains a single
item, special handling is required when copying multiple objects, such
as text and images. For instance, if you copy both text and an image
simultaneously in Microsoft Word, Microsoft places the following data on
the clipboard:

- Microsoft Office proprietary data containing a lot of content such as
text fonts, sizes, italics, positioning, image size, content, etc.
- RTF data representing the above content in RTF format
- HTML data representing the content in HTML format
- Plain text data

Therefore, for the current `ClipboardItem` implementation, if there are
multiple `ClipboardEntry` objects to be placed on the clipboard, RTF or
HTML formats are required. This PR does not support this scenario, and
only supports copying or pasting a single item from the clipboard.

---

**Known Issues**

- **WebP, BMP, TIFF**: These formats are not explicitly supported in
this PR. However, as mentioned earlier, in most cases, there are
corresponding PNG format data on the clipboard. This PR retrieves data
via PNG format, so users copying images in these formats from other
sources will still see the images displayed correctly.

- **GIF**: In this PR, GIFs are displayed, but for GIF images with
multiple frames, the image will not animate and will freeze on a single
frame. Since I observed the same behavior on macOS, I believe this is
not an issue with this PR.

- **SVG**: In this PR, only the top-left corner of the SVG image is
displayed. Again, I observed the same behavior on macOS, so I believe
this issue is not specific to this PR.

---

I hope this provides a clearer understanding. Any feedback or
suggestions on how to improve this are welcome.

Release Notes:

- N/A
---
 crates/gpui/src/platform/windows.rs           |   2 +
 crates/gpui/src/platform/windows/clipboard.rs | 366 ++++++++++++++++++
 crates/gpui/src/platform/windows/platform.rs  | 140 +------
 crates/gpui/src/platform/windows/window.rs    |  23 +-
 crates/gpui/src/platform/windows/wrapper.rs   |  34 +-
 5 files changed, 408 insertions(+), 157 deletions(-)
 create mode 100644 crates/gpui/src/platform/windows/clipboard.rs

diff --git a/crates/gpui/src/platform/windows.rs b/crates/gpui/src/platform/windows.rs
index aa484eccdc29c1..84cf107c70516d 100644
--- a/crates/gpui/src/platform/windows.rs
+++ b/crates/gpui/src/platform/windows.rs
@@ -1,3 +1,4 @@
+mod clipboard;
 mod direct_write;
 mod dispatcher;
 mod display;
@@ -8,6 +9,7 @@ mod util;
 mod window;
 mod wrapper;
 
+pub(crate) use clipboard::*;
 pub(crate) use direct_write::*;
 pub(crate) use dispatcher::*;
 pub(crate) use display::*;
diff --git a/crates/gpui/src/platform/windows/clipboard.rs b/crates/gpui/src/platform/windows/clipboard.rs
new file mode 100644
index 00000000000000..7e607b6a8c7751
--- /dev/null
+++ b/crates/gpui/src/platform/windows/clipboard.rs
@@ -0,0 +1,366 @@
+use std::sync::LazyLock;
+
+use anyhow::Result;
+use collections::{FxHashMap, FxHashSet};
+use itertools::Itertools;
+use util::ResultExt;
+use windows::Win32::{
+    Foundation::HANDLE,
+    System::{
+        DataExchange::{
+            CloseClipboard, CountClipboardFormats, EmptyClipboard, EnumClipboardFormats,
+            GetClipboardData, GetClipboardFormatNameW, IsClipboardFormatAvailable, OpenClipboard,
+            RegisterClipboardFormatW, SetClipboardData,
+        },
+        Memory::{GlobalAlloc, GlobalLock, GlobalUnlock, GMEM_MOVEABLE},
+        Ole::{CF_HDROP, CF_UNICODETEXT},
+    },
+    UI::Shell::{DragQueryFileW, HDROP},
+};
+use windows_core::PCWSTR;
+
+use crate::{
+    hash, ClipboardEntry, ClipboardItem, ClipboardString, Image, ImageFormat, SmartGlobal,
+};
+
+// https://learn.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-dragqueryfilew
+const DRAGDROP_GET_FILES_COUNT: u32 = 0xFFFFFFFF;
+
+// Clipboard formats
+static CLIPBOARD_HASH_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("GPUI internal text hash")));
+static CLIPBOARD_METADATA_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("GPUI internal metadata")));
+static CLIPBOARD_SVG_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("image/svg+xml")));
+static CLIPBOARD_GIF_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("GIF")));
+static CLIPBOARD_PNG_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("PNG")));
+static CLIPBOARD_JPG_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("JFIF")));
+
+// Helper maps and sets
+static FORMATS_MAP: LazyLock<FxHashMap<u32, ClipboardFormatType>> = LazyLock::new(|| {
+    let mut formats_map = FxHashMap::default();
+    formats_map.insert(CF_UNICODETEXT.0 as u32, ClipboardFormatType::Text);
+    formats_map.insert(*CLIPBOARD_PNG_FORMAT, ClipboardFormatType::Image);
+    formats_map.insert(*CLIPBOARD_GIF_FORMAT, ClipboardFormatType::Image);
+    formats_map.insert(*CLIPBOARD_JPG_FORMAT, ClipboardFormatType::Image);
+    formats_map.insert(*CLIPBOARD_SVG_FORMAT, ClipboardFormatType::Image);
+    formats_map.insert(CF_HDROP.0 as u32, ClipboardFormatType::Files);
+    formats_map
+});
+static FORMATS_SET: LazyLock<FxHashSet<u32>> = LazyLock::new(|| {
+    let mut formats_map = FxHashSet::default();
+    formats_map.insert(CF_UNICODETEXT.0 as u32);
+    formats_map.insert(*CLIPBOARD_PNG_FORMAT);
+    formats_map.insert(*CLIPBOARD_GIF_FORMAT);
+    formats_map.insert(*CLIPBOARD_JPG_FORMAT);
+    formats_map.insert(*CLIPBOARD_SVG_FORMAT);
+    formats_map.insert(CF_HDROP.0 as u32);
+    formats_map
+});
+static IMAGE_FORMATS_MAP: LazyLock<FxHashMap<u32, ImageFormat>> = LazyLock::new(|| {
+    let mut formats_map = FxHashMap::default();
+    formats_map.insert(*CLIPBOARD_PNG_FORMAT, ImageFormat::Png);
+    formats_map.insert(*CLIPBOARD_GIF_FORMAT, ImageFormat::Gif);
+    formats_map.insert(*CLIPBOARD_JPG_FORMAT, ImageFormat::Jpeg);
+    formats_map.insert(*CLIPBOARD_SVG_FORMAT, ImageFormat::Svg);
+    formats_map
+});
+
+#[derive(Debug, Clone, Copy)]
+enum ClipboardFormatType {
+    Text,
+    Image,
+    Files,
+}
+
+pub(crate) fn write_to_clipboard(item: ClipboardItem) {
+    write_to_clipboard_inner(item).log_err();
+    unsafe { CloseClipboard().log_err() };
+}
+
+pub(crate) fn read_from_clipboard() -> Option<ClipboardItem> {
+    let result = read_from_clipboard_inner();
+    unsafe { CloseClipboard().log_err() };
+    result
+}
+
+pub(crate) fn with_file_names<F>(hdrop: HDROP, mut f: F)
+where
+    F: FnMut(String),
+{
+    let file_count = unsafe { DragQueryFileW(hdrop, DRAGDROP_GET_FILES_COUNT, None) };
+    for file_index in 0..file_count {
+        let filename_length = unsafe { DragQueryFileW(hdrop, file_index, None) } as usize;
+        let mut buffer = vec![0u16; filename_length + 1];
+        let ret = unsafe { DragQueryFileW(hdrop, file_index, Some(buffer.as_mut_slice())) };
+        if ret == 0 {
+            log::error!("unable to read file name");
+            continue;
+        }
+        if let Some(file_name) = String::from_utf16(&buffer[0..filename_length]).log_err() {
+            f(file_name);
+        }
+    }
+}
+
+fn register_clipboard_format(format: PCWSTR) -> u32 {
+    let ret = unsafe { RegisterClipboardFormatW(format) };
+    if ret == 0 {
+        panic!(
+            "Error when registering clipboard format: {}",
+            std::io::Error::last_os_error()
+        );
+    }
+    ret
+}
+
+#[inline]
+fn format_to_type(item_format: u32) -> &'static ClipboardFormatType {
+    FORMATS_MAP.get(&item_format).unwrap()
+}
+
+// Currently, we only write the first item.
+fn write_to_clipboard_inner(item: ClipboardItem) -> Result<()> {
+    unsafe {
+        OpenClipboard(None)?;
+        EmptyClipboard()?;
+    }
+    match item.entries().first() {
+        Some(entry) => match entry {
+            ClipboardEntry::String(string) => {
+                write_string_to_clipboard(string)?;
+            }
+            ClipboardEntry::Image(image) => {
+                write_image_to_clipboard(image)?;
+            }
+        },
+        None => {
+            // Writing an empty list of entries just clears the clipboard.
+        }
+    }
+    Ok(())
+}
+
+fn write_string_to_clipboard(item: &ClipboardString) -> Result<()> {
+    let encode_wide = item.text.encode_utf16().chain(Some(0)).collect_vec();
+    set_data_to_clipboard(&encode_wide, CF_UNICODETEXT.0 as u32)?;
+
+    if let Some(metadata) = item.metadata.as_ref() {
+        let hash_result = {
+            let hash = ClipboardString::text_hash(&item.text);
+            hash.to_ne_bytes()
+        };
+        let encode_wide =
+            unsafe { std::slice::from_raw_parts(hash_result.as_ptr().cast::<u16>(), 4) };
+        set_data_to_clipboard(encode_wide, *CLIPBOARD_HASH_FORMAT)?;
+
+        let metadata_wide = metadata.encode_utf16().chain(Some(0)).collect_vec();
+        set_data_to_clipboard(&metadata_wide, *CLIPBOARD_METADATA_FORMAT)?;
+    }
+    Ok(())
+}
+
+fn set_data_to_clipboard<T>(data: &[T], format: u32) -> Result<()> {
+    unsafe {
+        let global = GlobalAlloc(GMEM_MOVEABLE, std::mem::size_of_val(data))?;
+        let handle = GlobalLock(global);
+        std::ptr::copy_nonoverlapping(data.as_ptr(), handle as _, data.len());
+        let _ = GlobalUnlock(global);
+        SetClipboardData(format, HANDLE(global.0))?;
+    }
+    Ok(())
+}
+
+// Here writing PNG to the clipboard to better support other apps. For more info, please ref to
+// the PR.
+fn write_image_to_clipboard(item: &Image) -> Result<()> {
+    match item.format {
+        ImageFormat::Svg => set_data_to_clipboard(item.bytes(), *CLIPBOARD_SVG_FORMAT)?,
+        ImageFormat::Gif => {
+            set_data_to_clipboard(item.bytes(), *CLIPBOARD_GIF_FORMAT)?;
+            let png_bytes = convert_image_to_png_format(item.bytes(), ImageFormat::Gif)?;
+            set_data_to_clipboard(&png_bytes, *CLIPBOARD_PNG_FORMAT)?;
+        }
+        ImageFormat::Png => {
+            set_data_to_clipboard(item.bytes(), *CLIPBOARD_PNG_FORMAT)?;
+            let png_bytes = convert_image_to_png_format(item.bytes(), ImageFormat::Png)?;
+            set_data_to_clipboard(&png_bytes, *CLIPBOARD_PNG_FORMAT)?;
+        }
+        ImageFormat::Jpeg => {
+            set_data_to_clipboard(item.bytes(), *CLIPBOARD_JPG_FORMAT)?;
+            let png_bytes = convert_image_to_png_format(item.bytes(), ImageFormat::Jpeg)?;
+            set_data_to_clipboard(&png_bytes, *CLIPBOARD_PNG_FORMAT)?;
+        }
+        other => {
+            log::warn!(
+                "Clipboard unsupported image format: {:?}, convert to PNG instead.",
+                item.format
+            );
+            let png_bytes = convert_image_to_png_format(item.bytes(), other)?;
+            set_data_to_clipboard(&png_bytes, *CLIPBOARD_PNG_FORMAT)?;
+        }
+    }
+    Ok(())
+}
+
+fn convert_image_to_png_format(bytes: &[u8], image_format: ImageFormat) -> Result<Vec<u8>> {
+    let image = image::load_from_memory_with_format(bytes, image_format.into())?;
+    let mut output_buf = Vec::new();
+    image.write_to(
+        &mut std::io::Cursor::new(&mut output_buf),
+        image::ImageFormat::Png,
+    )?;
+    Ok(output_buf)
+}
+
+fn read_from_clipboard_inner() -> Option<ClipboardItem> {
+    unsafe { OpenClipboard(None) }.log_err()?;
+    with_best_match_format(|item_format| match format_to_type(item_format) {
+        ClipboardFormatType::Text => read_string_from_clipboard(),
+        ClipboardFormatType::Image => read_image_from_clipboard(item_format),
+        ClipboardFormatType::Files => read_files_from_clipboard(),
+    })
+}
+
+// Here, we enumerate all formats on the clipboard and find the first one that we can process.
+// The reason we don't use `GetPriorityClipboardFormat` is that it sometimes returns the
+// wrong format.
+// For instance, when copying a JPEG image from  Microsoft Word, there may be several formats
+// on the clipboard: Jpeg, Png, Svg.
+// If we use `GetPriorityClipboardFormat`, it will return Svg, which is not what we want.
+fn with_best_match_format<F>(f: F) -> Option<ClipboardItem>
+where
+    F: Fn(u32) -> Option<ClipboardEntry>,
+{
+    let count = unsafe { CountClipboardFormats() };
+    let mut clipboard_format = 0;
+    for _ in 0..count {
+        clipboard_format = unsafe { EnumClipboardFormats(clipboard_format) };
+        let Some(item_format) = FORMATS_SET.get(&clipboard_format) else {
+            continue;
+        };
+        if let Some(entry) = f(*item_format) {
+            return Some(ClipboardItem {
+                entries: vec![entry],
+            });
+        }
+    }
+    // log the formats that we don't support yet.
+    {
+        clipboard_format = 0;
+        for _ in 0..count {
+            clipboard_format = unsafe { EnumClipboardFormats(clipboard_format) };
+            let mut buffer = [0u16; 64];
+            unsafe { GetClipboardFormatNameW(clipboard_format, &mut buffer) };
+            let format_name = String::from_utf16_lossy(&buffer);
+            log::warn!(
+                "Try to paste with unsupported clipboard format: {}, {}.",
+                clipboard_format,
+                format_name
+            );
+        }
+    }
+    None
+}
+
+fn read_string_from_clipboard() -> Option<ClipboardEntry> {
+    let text = {
+        let global = SmartGlobal::from_raw_ptr(
+            unsafe { GetClipboardData(CF_UNICODETEXT.0 as u32).log_err() }?.0,
+        );
+        let text = PCWSTR(global.lock() as *const u16);
+        String::from_utf16_lossy(unsafe { text.as_wide() })
+    };
+    let Some(hash) = read_hash_from_clipboard() else {
+        return Some(ClipboardEntry::String(ClipboardString::new(text)));
+    };
+    let Some(metadata) = read_metadata_from_clipboard() else {
+        return Some(ClipboardEntry::String(ClipboardString::new(text)));
+    };
+    if hash == ClipboardString::text_hash(&text) {
+        Some(ClipboardEntry::String(ClipboardString {
+            text,
+            metadata: Some(metadata),
+        }))
+    } else {
+        Some(ClipboardEntry::String(ClipboardString::new(text)))
+    }
+}
+
+fn read_hash_from_clipboard() -> Option<u64> {
+    if unsafe { IsClipboardFormatAvailable(*CLIPBOARD_HASH_FORMAT).is_err() } {
+        return None;
+    }
+    let global =
+        SmartGlobal::from_raw_ptr(unsafe { GetClipboardData(*CLIPBOARD_HASH_FORMAT).log_err() }?.0);
+    let raw_ptr = global.lock() as *const u16;
+    let hash_bytes: [u8; 8] = unsafe {
+        std::slice::from_raw_parts(raw_ptr.cast::<u8>(), 8)
+            .to_vec()
+            .try_into()
+            .log_err()
+    }?;
+    Some(u64::from_ne_bytes(hash_bytes))
+}
+
+fn read_metadata_from_clipboard() -> Option<String> {
+    unsafe { IsClipboardFormatAvailable(*CLIPBOARD_METADATA_FORMAT).log_err()? };
+    let global = SmartGlobal::from_raw_ptr(
+        unsafe { GetClipboardData(*CLIPBOARD_METADATA_FORMAT).log_err() }?.0,
+    );
+    let text = PCWSTR(global.lock() as *const u16);
+    Some(String::from_utf16_lossy(unsafe { text.as_wide() }))
+}
+
+fn read_image_from_clipboard(format: u32) -> Option<ClipboardEntry> {
+    let image_format = format_number_to_image_format(format)?;
+    read_image_for_type(format, *image_format)
+}
+
+#[inline]
+fn format_number_to_image_format(format_number: u32) -> Option<&'static ImageFormat> {
+    IMAGE_FORMATS_MAP.get(&format_number)
+}
+
+fn read_image_for_type(format_number: u32, format: ImageFormat) -> Option<ClipboardEntry> {
+    let global = SmartGlobal::from_raw_ptr(unsafe { GetClipboardData(format_number).log_err() }?.0);
+    let image_ptr = global.lock();
+    let iamge_size = global.size();
+    let bytes =
+        unsafe { std::slice::from_raw_parts(image_ptr as *mut u8 as _, iamge_size).to_vec() };
+    let id = hash(&bytes);
+    Some(ClipboardEntry::Image(Image { format, bytes, id }))
+}
+
+fn read_files_from_clipboard() -> Option<ClipboardEntry> {
+    let global =
+        SmartGlobal::from_raw_ptr(unsafe { GetClipboardData(CF_HDROP.0 as u32).log_err() }?.0);
+    let hdrop = HDROP(global.lock());
+    let mut filenames = String::new();
+    with_file_names(hdrop, |file_name| {
+        filenames.push_str(&file_name);
+    });
+    Some(ClipboardEntry::String(ClipboardString {
+        text: filenames,
+        metadata: None,
+    }))
+}
+
+impl From<ImageFormat> for image::ImageFormat {
+    fn from(value: ImageFormat) -> Self {
+        match value {
+            ImageFormat::Png => image::ImageFormat::Png,
+            ImageFormat::Jpeg => image::ImageFormat::Jpeg,
+            ImageFormat::Webp => image::ImageFormat::WebP,
+            ImageFormat::Gif => image::ImageFormat::Gif,
+            // ImageFormat::Svg => todo!(),
+            ImageFormat::Bmp => image::ImageFormat::Bmp,
+            ImageFormat::Tiff => image::ImageFormat::Tiff,
+            _ => unreachable!(),
+        }
+    }
+}
diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs
index a900d0114bb234..30e7c402d26d85 100644
--- a/crates/gpui/src/platform/windows/platform.rs
+++ b/crates/gpui/src/platform/windows/platform.rs
@@ -17,24 +17,12 @@ use windows::{
     core::*,
     Win32::{
         Foundation::*,
-        Globalization::u_memcpy,
         Graphics::{
             Gdi::*,
             Imaging::{CLSID_WICImagingFactory, IWICImagingFactory},
         },
         Security::Credentials::*,
-        System::{
-            Com::*,
-            DataExchange::{
-                CloseClipboard, EmptyClipboard, GetClipboardData, OpenClipboard,
-                RegisterClipboardFormatW, SetClipboardData,
-            },
-            LibraryLoader::*,
-            Memory::{GlobalAlloc, GlobalLock, GlobalUnlock, GMEM_MOVEABLE},
-            Ole::*,
-            SystemInformation::*,
-            Threading::*,
-        },
+        System::{Com::*, LibraryLoader::*, Ole::*, SystemInformation::*, Threading::*},
         UI::{Input::KeyboardAndMouse::*, Shell::*, WindowsAndMessaging::*},
     },
     UI::ViewManagement::UISettings,
@@ -52,8 +40,6 @@ pub(crate) struct WindowsPlatform {
     background_executor: BackgroundExecutor,
     foreground_executor: ForegroundExecutor,
     text_system: Arc<DirectWriteTextSystem>,
-    clipboard_hash_format: u32,
-    clipboard_metadata_format: u32,
     windows_version: WindowsVersion,
     bitmap_factory: ManuallyDrop<IWICImagingFactory>,
     validation_number: usize,
@@ -108,9 +94,6 @@ impl WindowsPlatform {
         let icon = load_icon().unwrap_or_default();
         let state = RefCell::new(WindowsPlatformState::new());
         let raw_window_handles = RwLock::new(SmallVec::new());
-        let clipboard_hash_format = register_clipboard_format(CLIPBOARD_HASH_FORMAT).unwrap();
-        let clipboard_metadata_format =
-            register_clipboard_format(CLIPBOARD_METADATA_FORMAT).unwrap();
         let windows_version = WindowsVersion::new().expect("Error retrieve windows version");
         let validation_number = rand::random::<usize>();
 
@@ -123,8 +106,6 @@ impl WindowsPlatform {
             background_executor,
             foreground_executor,
             text_system,
-            clipboard_hash_format,
-            clipboard_metadata_format,
             windows_version,
             bitmap_factory,
             validation_number,
@@ -487,15 +468,11 @@ impl Platform for WindowsPlatform {
     }
 
     fn write_to_clipboard(&self, item: ClipboardItem) {
-        write_to_clipboard(
-            item,
-            self.clipboard_hash_format,
-            self.clipboard_metadata_format,
-        );
+        write_to_clipboard(item);
     }
 
     fn read_from_clipboard(&self) -> Option<ClipboardItem> {
-        read_from_clipboard(self.clipboard_hash_format, self.clipboard_metadata_format)
+        read_from_clipboard()
     }
 
     fn write_credentials(&self, url: &str, username: &str, password: &[u8]) -> Task<Result<()>> {
@@ -725,117 +702,6 @@ fn should_auto_hide_scrollbars() -> Result<bool> {
     Ok(ui_settings.AutoHideScrollBars()?)
 }
 
-fn register_clipboard_format(format: PCWSTR) -> Result<u32> {
-    let ret = unsafe { RegisterClipboardFormatW(format) };
-    if ret == 0 {
-        Err(anyhow::anyhow!(
-            "Error when registering clipboard format: {}",
-            std::io::Error::last_os_error()
-        ))
-    } else {
-        Ok(ret)
-    }
-}
-
-fn write_to_clipboard(item: ClipboardItem, hash_format: u32, metadata_format: u32) {
-    write_to_clipboard_inner(item, hash_format, metadata_format).log_err();
-    unsafe { CloseClipboard().log_err() };
-}
-
-fn write_to_clipboard_inner(
-    item: ClipboardItem,
-    hash_format: u32,
-    metadata_format: u32,
-) -> Result<()> {
-    unsafe {
-        OpenClipboard(None)?;
-        EmptyClipboard()?;
-        let encode_wide = item
-            .text()
-            .unwrap_or_default()
-            .encode_utf16()
-            .chain(Some(0))
-            .collect_vec();
-        set_data_to_clipboard(&encode_wide, CF_UNICODETEXT.0 as u32)?;
-
-        if let Some((metadata, text)) = item.metadata().zip(item.text()) {
-            let hash_result = {
-                let hash = ClipboardString::text_hash(&text);
-                hash.to_ne_bytes()
-            };
-            let encode_wide = std::slice::from_raw_parts(hash_result.as_ptr().cast::<u16>(), 4);
-            set_data_to_clipboard(encode_wide, hash_format)?;
-
-            let metadata_wide = metadata.encode_utf16().chain(Some(0)).collect_vec();
-            set_data_to_clipboard(&metadata_wide, metadata_format)?;
-        }
-    }
-    Ok(())
-}
-
-fn set_data_to_clipboard(data: &[u16], format: u32) -> Result<()> {
-    unsafe {
-        let global = GlobalAlloc(GMEM_MOVEABLE, data.len() * 2)?;
-        let handle = GlobalLock(global);
-        u_memcpy(handle as _, data.as_ptr(), data.len() as _);
-        let _ = GlobalUnlock(global);
-        SetClipboardData(format, HANDLE(global.0))?;
-    }
-    Ok(())
-}
-
-fn read_from_clipboard(hash_format: u32, metadata_format: u32) -> Option<ClipboardItem> {
-    let result = read_from_clipboard_inner(hash_format, metadata_format).log_err();
-    unsafe { CloseClipboard().log_err() };
-    result
-}
-
-fn read_from_clipboard_inner(hash_format: u32, metadata_format: u32) -> Result<ClipboardItem> {
-    unsafe {
-        OpenClipboard(None)?;
-        let text = {
-            let handle = GetClipboardData(CF_UNICODETEXT.0 as u32)?;
-            let text = PCWSTR(handle.0 as *const u16);
-            String::from_utf16_lossy(text.as_wide())
-        };
-        let Some(hash) = read_hash_from_clipboard(hash_format) else {
-            return Ok(ClipboardItem::new_string(text));
-        };
-        let Some(metadata) = read_metadata_from_clipboard(metadata_format) else {
-            return Ok(ClipboardItem::new_string(text));
-        };
-        if hash == ClipboardString::text_hash(&text) {
-            Ok(ClipboardItem::new_string_with_metadata(text, metadata))
-        } else {
-            Ok(ClipboardItem::new_string(text))
-        }
-    }
-}
-
-fn read_hash_from_clipboard(hash_format: u32) -> Option<u64> {
-    unsafe {
-        let handle = GetClipboardData(hash_format).log_err()?;
-        let raw_ptr = handle.0 as *const u16;
-        let hash_bytes: [u8; 8] = std::slice::from_raw_parts(raw_ptr.cast::<u8>(), 8)
-            .to_vec()
-            .try_into()
-            .log_err()?;
-        Some(u64::from_ne_bytes(hash_bytes))
-    }
-}
-
-fn read_metadata_from_clipboard(metadata_format: u32) -> Option<String> {
-    unsafe {
-        let handle = GetClipboardData(metadata_format).log_err()?;
-        let text = PCWSTR(handle.0 as *const u16);
-        Some(String::from_utf16_lossy(text.as_wide()))
-    }
-}
-
-// clipboard
-pub const CLIPBOARD_HASH_FORMAT: PCWSTR = windows::core::w!("zed-text-hash");
-pub const CLIPBOARD_METADATA_FORMAT: PCWSTR = windows::core::w!("zed-metadata");
-
 #[cfg(test)]
 mod tests {
     use crate::{ClipboardItem, Platform, WindowsPlatform};
diff --git a/crates/gpui/src/platform/windows/window.rs b/crates/gpui/src/platform/windows/window.rs
index d5ea3be6cac5e6..b212a03a981481 100644
--- a/crates/gpui/src/platform/windows/window.rs
+++ b/crates/gpui/src/platform/windows/window.rs
@@ -735,23 +735,11 @@ impl IDropTarget_Impl for WindowsDragDropHandler_Impl {
                 }
                 let hdrop = idata.u.hGlobal.0 as *mut HDROP;
                 let mut paths = SmallVec::<[PathBuf; 2]>::new();
-                let file_count = DragQueryFileW(*hdrop, DRAGDROP_GET_FILES_COUNT, None);
-                for file_index in 0..file_count {
-                    let filename_length = DragQueryFileW(*hdrop, file_index, None) as usize;
-                    let mut buffer = vec![0u16; filename_length + 1];
-                    let ret = DragQueryFileW(*hdrop, file_index, Some(buffer.as_mut_slice()));
-                    if ret == 0 {
-                        log::error!("unable to read file name");
-                        continue;
+                with_file_names(*hdrop, |file_name| {
+                    if let Some(path) = PathBuf::from_str(&file_name).log_err() {
+                        paths.push(path);
                     }
-                    if let Some(file_name) =
-                        String::from_utf16(&buffer[0..filename_length]).log_err()
-                    {
-                        if let Some(path) = PathBuf::from_str(&file_name).log_err() {
-                            paths.push(path);
-                        }
-                    }
-                }
+                });
                 ReleaseStgMedium(&mut idata);
                 let mut cursor_position = POINT { x: pt.x, y: pt.y };
                 ScreenToClient(self.0.hwnd, &mut cursor_position)
@@ -1069,9 +1057,6 @@ fn calculate_client_rect(
     }
 }
 
-// https://learn.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-dragqueryfilew
-const DRAGDROP_GET_FILES_COUNT: u32 = 0xFFFFFFFF;
-
 mod windows_renderer {
     use std::{num::NonZeroIsize, sync::Arc};
 
diff --git a/crates/gpui/src/platform/windows/wrapper.rs b/crates/gpui/src/platform/windows/wrapper.rs
index 6015dffdab2997..e6e645e61aebdf 100644
--- a/crates/gpui/src/platform/windows/wrapper.rs
+++ b/crates/gpui/src/platform/windows/wrapper.rs
@@ -1,6 +1,11 @@
 use std::ops::Deref;
 
-use windows::Win32::{Foundation::HANDLE, UI::WindowsAndMessaging::HCURSOR};
+use util::ResultExt;
+use windows::Win32::{
+    Foundation::{HANDLE, HGLOBAL},
+    System::Memory::{GlobalLock, GlobalSize, GlobalUnlock},
+    UI::WindowsAndMessaging::HCURSOR,
+};
 
 #[derive(Debug, Clone, Copy)]
 pub(crate) struct SafeHandle {
@@ -45,3 +50,30 @@ impl Deref for SafeCursor {
         &self.raw
     }
 }
+
+#[derive(Debug, Clone)]
+pub(crate) struct SmartGlobal {
+    raw: HGLOBAL,
+}
+
+impl SmartGlobal {
+    pub(crate) fn from_raw_ptr(ptr: *mut std::ffi::c_void) -> Self {
+        Self { raw: HGLOBAL(ptr) }
+    }
+
+    pub(crate) fn lock(&self) -> *mut std::ffi::c_void {
+        unsafe { GlobalLock(self.raw) }
+    }
+
+    pub(crate) fn size(&self) -> usize {
+        unsafe { GlobalSize(self.raw) }
+    }
+}
+
+impl Drop for SmartGlobal {
+    fn drop(&mut self) {
+        unsafe {
+            GlobalUnlock(self.raw).log_err();
+        }
+    }
+}

From 938a0679c004be4ae2b6c1e897de75e4b4e7aa24 Mon Sep 17 00:00:00 2001
From: Jason Lee <huacnlee@gmail.com>
Date: Tue, 1 Oct 2024 07:39:19 +0800
Subject: [PATCH 413/762] gpui: Fix img element to auto size when only have
 width or height (#17994)

Release Notes:

- N/A

---

We may only want to set the height of an image to limit the size and
make the width adaptive.

In HTML, we will only set width or height, and the other side will adapt
and maintain the original image ratio.

I changed this because I had a logo image that only to be limited in
height, and then I found that setting the height of the `img` alone
would not display correctly.

I also tried to set `ObjectFit` in this Demo, but it seems that none of
them can achieve the same effect as "After".

## Before
<img width="809" alt="before 2024-09-18 164029"
src="https://github.com/user-attachments/assets/7ba559ed-e53b-43e6-a072-93c8ba5b14ee">

## After
<img width="749" alt="after 2024-09-18 172003"
src="https://github.com/user-attachments/assets/51ee2eba-76b3-400a-abbf-de0e9c4021e2">
---
 crates/gpui/examples/image/image.rs | 54 +++++++++++++++++++++--------
 crates/gpui/src/elements/img.rs     | 36 +++++++++++++------
 2 files changed, 65 insertions(+), 25 deletions(-)

diff --git a/crates/gpui/examples/image/image.rs b/crates/gpui/examples/image/image.rs
index 157dbdf70f1afc..24a94bf746ec47 100644
--- a/crates/gpui/examples/image/image.rs
+++ b/crates/gpui/examples/image/image.rs
@@ -69,25 +69,51 @@ struct ImageShowcase {
 impl Render for ImageShowcase {
     fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
         div()
-            .flex()
-            .flex_row()
             .size_full()
+            .flex()
+            .flex_col()
             .justify_center()
             .items_center()
             .gap_8()
             .bg(rgb(0xFFFFFF))
-            .child(ImageContainer::new(
-                "Image loaded from a local file",
-                self.local_resource.clone(),
-            ))
-            .child(ImageContainer::new(
-                "Image loaded from a remote resource",
-                self.remote_resource.clone(),
-            ))
-            .child(ImageContainer::new(
-                "Image loaded from an asset",
-                self.asset_resource.clone(),
-            ))
+            .child(
+                div()
+                    .flex()
+                    .flex_row()
+                    .justify_center()
+                    .items_center()
+                    .gap_8()
+                    .child(ImageContainer::new(
+                        "Image loaded from a local file",
+                        self.local_resource.clone(),
+                    ))
+                    .child(ImageContainer::new(
+                        "Image loaded from a remote resource",
+                        self.remote_resource.clone(),
+                    ))
+                    .child(ImageContainer::new(
+                        "Image loaded from an asset",
+                        self.asset_resource.clone(),
+                    )),
+            )
+            .child(
+                div()
+                    .flex()
+                    .flex_row()
+                    .gap_8()
+                    .child(
+                        div()
+                            .flex_col()
+                            .child("Auto Width")
+                            .child(img("https://picsum.photos/800/400").h(px(180.))),
+                    )
+                    .child(
+                        div()
+                            .flex_col()
+                            .child("Auto Height")
+                            .child(img("https://picsum.photos/480/640").w(px(180.))),
+                    ),
+            )
     }
 }
 
diff --git a/crates/gpui/src/elements/img.rs b/crates/gpui/src/elements/img.rs
index 63236d5309f145..58ee639265ec1a 100644
--- a/crates/gpui/src/elements/img.rs
+++ b/crates/gpui/src/elements/img.rs
@@ -1,7 +1,7 @@
 use crate::{
     px, AbsoluteLength, AppContext, Asset, Bounds, DefiniteLength, Element, ElementId,
     GlobalElementId, Hitbox, Image, InteractiveElement, Interactivity, IntoElement, LayoutId,
-    Length, ObjectFit, Pixels, RenderImage, SharedString, SharedUri, Size, StyleRefinement, Styled,
+    Length, ObjectFit, Pixels, RenderImage, SharedString, SharedUri, StyleRefinement, Styled,
     SvgSize, UriOrPath, WindowContext,
 };
 use futures::{AsyncReadExt, Future};
@@ -187,16 +187,30 @@ impl Element for Img {
 
                         let image_size = data.size(frame_index);
 
-                        if let (Length::Auto, Length::Auto) = (style.size.width, style.size.height)
-                        {
-                            style.size = Size {
-                                width: Length::Definite(DefiniteLength::Absolute(
-                                    AbsoluteLength::Pixels(px(image_size.width.0 as f32)),
-                                )),
-                                height: Length::Definite(DefiniteLength::Absolute(
-                                    AbsoluteLength::Pixels(px(image_size.height.0 as f32)),
-                                )),
-                            }
+                        if let Length::Auto = style.size.width {
+                            style.size.width = match style.size.height {
+                                Length::Definite(DefiniteLength::Absolute(
+                                    AbsoluteLength::Pixels(height),
+                                )) => Length::Definite(
+                                    px(image_size.width.0 as f32 * height.0
+                                        / image_size.height.0 as f32)
+                                    .into(),
+                                ),
+                                _ => Length::Definite(px(image_size.width.0 as f32).into()),
+                            };
+                        }
+
+                        if let Length::Auto = style.size.height {
+                            style.size.height = match style.size.width {
+                                Length::Definite(DefiniteLength::Absolute(
+                                    AbsoluteLength::Pixels(width),
+                                )) => Length::Definite(
+                                    px(image_size.height.0 as f32 * width.0
+                                        / image_size.width.0 as f32)
+                                    .into(),
+                                ),
+                                _ => Length::Definite(px(image_size.height.0 as f32).into()),
+                            };
                         }
 
                         if global_id.is_some() && data.frame_count() > 1 {

From a752bbcee83f9cf853082e91c693f7bde197eb0f Mon Sep 17 00:00:00 2001
From: Patrick MARIE <mycroft@users.noreply.github.com>
Date: Tue, 1 Oct 2024 01:51:05 +0200
Subject: [PATCH 414/762] Fix linux double click (#18504)

Closes #17573

Release Notes:

- Check that double clicks on Linux are triggered by same button.
---
 crates/gpui/src/platform/linux/wayland/client.rs |  7 +++++++
 crates/gpui/src/platform/linux/x11/client.rs     | 10 ++++++++--
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/crates/gpui/src/platform/linux/wayland/client.rs b/crates/gpui/src/platform/linux/wayland/client.rs
index f7ade828615f4f..4b7816a73ac36c 100644
--- a/crates/gpui/src/platform/linux/wayland/client.rs
+++ b/crates/gpui/src/platform/linux/wayland/client.rs
@@ -236,6 +236,7 @@ pub struct DragState {
 }
 
 pub struct ClickState {
+    last_mouse_button: Option<MouseButton>,
     last_click: Instant,
     last_location: Point<Pixels>,
     current_count: usize,
@@ -535,6 +536,7 @@ impl WaylandClient {
             },
             click: ClickState {
                 last_click: Instant::now(),
+                last_mouse_button: None,
                 last_location: Point::default(),
                 current_count: 0,
             },
@@ -1524,6 +1526,10 @@ impl Dispatch<wl_pointer::WlPointer, ()> for WaylandClientStatePtr {
                         let click_elapsed = state.click.last_click.elapsed();
 
                         if click_elapsed < DOUBLE_CLICK_INTERVAL
+                            && state
+                                .click
+                                .last_mouse_button
+                                .is_some_and(|prev_button| prev_button == button)
                             && is_within_click_distance(
                                 state.click.last_location,
                                 state.mouse_location.unwrap(),
@@ -1535,6 +1541,7 @@ impl Dispatch<wl_pointer::WlPointer, ()> for WaylandClientStatePtr {
                         }
 
                         state.click.last_click = Instant::now();
+                        state.click.last_mouse_button = Some(button);
                         state.click.last_location = state.mouse_location.unwrap();
 
                         state.button_pressed = Some(button);
diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs
index 7f5342a50360eb..5339cc95fd1b11 100644
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -37,8 +37,8 @@ use crate::platform::linux::LinuxClient;
 use crate::platform::{LinuxCommon, PlatformWindow};
 use crate::{
     modifiers_from_xinput_info, point, px, AnyWindowHandle, Bounds, ClipboardItem, CursorStyle,
-    DisplayId, FileDropEvent, Keystroke, Modifiers, ModifiersChangedEvent, Pixels, Platform,
-    PlatformDisplay, PlatformInput, Point, ScaledPixels, ScrollDelta, Size, TouchPhase,
+    DisplayId, FileDropEvent, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton, Pixels,
+    Platform, PlatformDisplay, PlatformInput, Point, ScaledPixels, ScrollDelta, Size, TouchPhase,
     WindowParams, X11Window,
 };
 
@@ -122,6 +122,7 @@ pub struct X11ClientState {
     pub(crate) event_loop: Option<calloop::EventLoop<'static, X11Client>>,
 
     pub(crate) last_click: Instant,
+    pub(crate) last_mouse_button: Option<MouseButton>,
     pub(crate) last_location: Point<Pixels>,
     pub(crate) current_count: usize,
 
@@ -404,6 +405,7 @@ impl X11Client {
             loop_handle: handle,
             common,
             last_click: Instant::now(),
+            last_mouse_button: None,
             last_location: Point::new(px(0.0), px(0.0)),
             current_count: 0,
             scale_factor,
@@ -952,6 +954,9 @@ impl X11Client {
                     let click_elapsed = state.last_click.elapsed();
 
                     if click_elapsed < DOUBLE_CLICK_INTERVAL
+                        && state
+                            .last_mouse_button
+                            .is_some_and(|prev_button| prev_button == button)
                         && is_within_click_distance(state.last_location, position)
                     {
                         state.current_count += 1;
@@ -960,6 +965,7 @@ impl X11Client {
                     }
 
                     state.last_click = Instant::now();
+                    state.last_mouse_button = Some(button);
                     state.last_location = position;
                     let current_count = state.current_count;
 

From 1d2172aba8c7718d36d363e8d4e7f8b1a3ad1cec Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 30 Sep 2024 21:07:10 -0400
Subject: [PATCH 415/762] docs: Correct glibc requirements (#18554)

---
 docs/src/linux.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/src/linux.md b/docs/src/linux.md
index 3bba9c8f93aaae..33d12d0a8ca02f 100644
--- a/docs/src/linux.md
+++ b/docs/src/linux.md
@@ -16,7 +16,7 @@ The Zed installed by the script works best on systems that:
 
 - have a Vulkan compatible GPU available (for example Linux on an M-series macBook)
 - have a system-wide glibc (NixOS and Alpine do not by default)
-  - x86_64 (Intel/AMD): glibc version >= 2.29 (Ubuntu 20 and newer)
+  - x86_64 (Intel/AMD): glibc version >= 2.31 (Ubuntu 20 and newer)
   - aarch64 (ARM): glibc version >= 2.35 (Ubuntu 22 and newer)
 
 Both Nix and Alpine have third-party Zed packages available (though they are currently a few weeks out of date). If you'd like to use our builds they do work if you install a glibc compatibility layer. On NixOS you can try [nix-ld](https://github.com/Mic92/nix-ld), and on Alpine [gcompat](https://wiki.alpinelinux.org/wiki/Running_glibc_programs).

From 39be9e5949483e8964322d9878e7d5cb794872cb Mon Sep 17 00:00:00 2001
From: Jason Lee <huacnlee@gmail.com>
Date: Tue, 1 Oct 2024 09:25:02 +0800
Subject: [PATCH 416/762] gpui: Fix `show: false` support on Windows to create
 an invisible window (#18161)

Release Notes:

- N/A
-
The `show` of WindowOptions is valid on macOS but not on Windows, this
changes to fix it to support create an invisible window.

```bash
cargo run -p gpui --example window
```

## Before



https://github.com/user-attachments/assets/4157bdaa-39a7-44df-bbdc-30b00e9c61e9


## After



https://github.com/user-attachments/assets/d48fa524-0caa-4f87-932d-01d7a468c488


https://github.com/user-attachments/assets/dd052f15-c8db-4a2a-a6af-a7c0ffecca84
---
 crates/gpui/examples/window.rs             | 168 +++++++++++++++++++++
 crates/gpui/src/platform/mac/window.rs     |   2 +-
 crates/gpui/src/platform/windows/window.rs |  13 +-
 3 files changed, 180 insertions(+), 3 deletions(-)
 create mode 100644 crates/gpui/examples/window.rs

diff --git a/crates/gpui/examples/window.rs b/crates/gpui/examples/window.rs
new file mode 100644
index 00000000000000..0f0d4287da723f
--- /dev/null
+++ b/crates/gpui/examples/window.rs
@@ -0,0 +1,168 @@
+use gpui::*;
+use prelude::FluentBuilder as _;
+
+struct SubWindow {
+    custom_titlebar: bool,
+}
+
+fn button(text: &str, on_click: impl Fn(&mut WindowContext) + 'static) -> impl IntoElement {
+    div()
+        .id(SharedString::from(text.to_string()))
+        .flex_none()
+        .px_2()
+        .bg(rgb(0xf7f7f7))
+        .active(|this| this.opacity(0.85))
+        .border_1()
+        .border_color(rgb(0xe0e0e0))
+        .rounded_md()
+        .cursor_pointer()
+        .child(text.to_string())
+        .on_click(move |_, cx| on_click(cx))
+}
+
+impl Render for SubWindow {
+    fn render(&mut self, _: &mut ViewContext<Self>) -> impl IntoElement {
+        div()
+            .flex()
+            .flex_col()
+            .bg(rgb(0xffffff))
+            .size_full()
+            .gap_2()
+            .when(self.custom_titlebar, |cx| {
+                cx.child(
+                    div()
+                        .flex()
+                        .h(px(32.))
+                        .px_4()
+                        .bg(gpui::blue())
+                        .text_color(gpui::white())
+                        .w_full()
+                        .child(
+                            div()
+                                .flex()
+                                .items_center()
+                                .justify_center()
+                                .size_full()
+                                .child("Custom Titlebar"),
+                        ),
+                )
+            })
+            .child(
+                div()
+                    .p_8()
+                    .gap_2()
+                    .child("SubWindow")
+                    .child(button("Close", |cx| {
+                        cx.remove_window();
+                    })),
+            )
+    }
+}
+
+struct WindowDemo {}
+
+impl Render for WindowDemo {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let window_bounds =
+            WindowBounds::Windowed(Bounds::centered(None, size(px(300.0), px(300.0)), cx));
+
+        div()
+            .p_4()
+            .flex()
+            .flex_wrap()
+            .bg(rgb(0xffffff))
+            .size_full()
+            .justify_center()
+            .items_center()
+            .gap_2()
+            .child(button("Normal", move |cx| {
+                cx.open_window(
+                    WindowOptions {
+                        window_bounds: Some(window_bounds),
+                        ..Default::default()
+                    },
+                    |cx| {
+                        cx.new_view(|_cx| SubWindow {
+                            custom_titlebar: false,
+                        })
+                    },
+                )
+                .unwrap();
+            }))
+            .child(button("Popup", move |cx| {
+                cx.open_window(
+                    WindowOptions {
+                        window_bounds: Some(window_bounds),
+                        kind: WindowKind::PopUp,
+                        ..Default::default()
+                    },
+                    |cx| {
+                        cx.new_view(|_cx| SubWindow {
+                            custom_titlebar: false,
+                        })
+                    },
+                )
+                .unwrap();
+            }))
+            .child(button("Custom Titlebar", move |cx| {
+                cx.open_window(
+                    WindowOptions {
+                        titlebar: None,
+                        window_bounds: Some(window_bounds),
+                        ..Default::default()
+                    },
+                    |cx| {
+                        cx.new_view(|_cx| SubWindow {
+                            custom_titlebar: true,
+                        })
+                    },
+                )
+                .unwrap();
+            }))
+            .child(button("Invisible", move |cx| {
+                cx.open_window(
+                    WindowOptions {
+                        show: false,
+                        window_bounds: Some(window_bounds),
+                        ..Default::default()
+                    },
+                    |cx| {
+                        cx.new_view(|_cx| SubWindow {
+                            custom_titlebar: false,
+                        })
+                    },
+                )
+                .unwrap();
+            }))
+            .child(button("Unmovable", move |cx| {
+                cx.open_window(
+                    WindowOptions {
+                        is_movable: false,
+                        titlebar: None,
+                        window_bounds: Some(window_bounds),
+                        ..Default::default()
+                    },
+                    |cx| {
+                        cx.new_view(|_cx| SubWindow {
+                            custom_titlebar: false,
+                        })
+                    },
+                )
+                .unwrap();
+            }))
+    }
+}
+
+fn main() {
+    App::new().run(|cx: &mut AppContext| {
+        let bounds = Bounds::centered(None, size(px(800.0), px(600.0)), cx);
+        cx.open_window(
+            WindowOptions {
+                window_bounds: Some(WindowBounds::Windowed(bounds)),
+                ..Default::default()
+            },
+            |cx| cx.new_view(|_cx| WindowDemo {}),
+        )
+        .unwrap();
+    });
+}
diff --git a/crates/gpui/src/platform/mac/window.rs b/crates/gpui/src/platform/mac/window.rs
index 885c3565ccc899..5f9ee43dec48f7 100644
--- a/crates/gpui/src/platform/mac/window.rs
+++ b/crates/gpui/src/platform/mac/window.rs
@@ -707,7 +707,7 @@ impl MacWindow {
                 }
             }
 
-            if focus {
+            if focus && show {
                 native_window.makeKeyAndOrderFront_(nil);
             } else if show {
                 native_window.orderFront_(nil);
diff --git a/crates/gpui/src/platform/windows/window.rs b/crates/gpui/src/platform/windows/window.rs
index b212a03a981481..d7b9a469b7d4e5 100644
--- a/crates/gpui/src/platform/windows/window.rs
+++ b/crates/gpui/src/platform/windows/window.rs
@@ -287,7 +287,7 @@ impl WindowsWindow {
                 .map(|title| title.as_ref())
                 .unwrap_or(""),
         );
-        let (dwexstyle, dwstyle) = if params.kind == WindowKind::PopUp {
+        let (dwexstyle, mut dwstyle) = if params.kind == WindowKind::PopUp {
             (WS_EX_TOOLWINDOW, WINDOW_STYLE(0x0))
         } else {
             (
@@ -295,6 +295,10 @@ impl WindowsWindow {
                 WS_THICKFRAME | WS_SYSMENU | WS_MAXIMIZEBOX | WS_MINIMIZEBOX,
             )
         };
+        if !params.show {
+            dwstyle |= WS_MINIMIZE;
+        }
+
         let hinstance = get_module_handle();
         let display = if let Some(display_id) = params.display_id {
             // if we obtain a display_id, then this ID must be valid.
@@ -357,7 +361,12 @@ impl WindowsWindow {
             drop(lock);
             SetWindowPlacement(raw_hwnd, &placement)?;
         }
-        unsafe { ShowWindow(raw_hwnd, SW_SHOW).ok()? };
+
+        if params.show {
+            unsafe { ShowWindow(raw_hwnd, SW_SHOW).ok()? };
+        } else {
+            unsafe { ShowWindow(raw_hwnd, SW_HIDE).ok()? };
+        }
 
         Ok(Self(state_ptr))
     }

From 8d795ff882ec6ee6eb40346ee4fbcba88e6e6b6d Mon Sep 17 00:00:00 2001
From: Alvaro Parker <64918109+AlvaroParker@users.noreply.github.com>
Date: Tue, 1 Oct 2024 03:04:35 -0300
Subject: [PATCH 417/762] Fix file watching for symlinks (#17609)

Closes #17605

Watches for target paths if file watched is a symlink in Linux.
This will check if the generated `notify::Event` has any paths matching
the `root_path` and if the file is a symlink it will also check if the
path matches the `target_root_path` (the path that the symlink is
pointing to)

Release Notes:

- Added file watching for symlinks
---
 crates/fs/src/fs.rs | 84 +++++++++++++++++++++++++++++----------------
 1 file changed, 54 insertions(+), 30 deletions(-)

diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rs
index b649831fd2de69..7064448e168298 100644
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -587,38 +587,54 @@ impl Fs for RealFs {
         let pending_paths: Arc<Mutex<Vec<PathEvent>>> = Default::default();
         let root_path = path.to_path_buf();
 
-        watcher::global(|g| {
-            let tx = tx.clone();
-            let pending_paths = pending_paths.clone();
-            g.add(move |event: &notify::Event| {
-                let kind = match event.kind {
-                    EventKind::Create(_) => Some(PathEventKind::Created),
-                    EventKind::Modify(_) => Some(PathEventKind::Changed),
-                    EventKind::Remove(_) => Some(PathEventKind::Removed),
-                    _ => None,
-                };
-                let mut paths = event
-                    .paths
-                    .iter()
-                    .filter_map(|path| {
-                        path.starts_with(&root_path).then(|| PathEvent {
-                            path: path.clone(),
-                            kind,
+        // Check if root path is a symlink
+        let target_path = self.read_link(&path).await.ok();
+
+        watcher::global({
+            let target_path = target_path.clone();
+            |g| {
+                let tx = tx.clone();
+                let pending_paths = pending_paths.clone();
+                g.add(move |event: &notify::Event| {
+                    let kind = match event.kind {
+                        EventKind::Create(_) => Some(PathEventKind::Created),
+                        EventKind::Modify(_) => Some(PathEventKind::Changed),
+                        EventKind::Remove(_) => Some(PathEventKind::Removed),
+                        _ => None,
+                    };
+                    let mut paths = event
+                        .paths
+                        .iter()
+                        .filter_map(|path| {
+                            if let Some(target) = target_path.clone() {
+                                if path.starts_with(target) {
+                                    return Some(PathEvent {
+                                        path: path.clone(),
+                                        kind,
+                                    });
+                                }
+                            } else if path.starts_with(&root_path) {
+                                return Some(PathEvent {
+                                    path: path.clone(),
+                                    kind,
+                                });
+                            }
+                            None
                         })
-                    })
-                    .collect::<Vec<_>>();
-
-                if !paths.is_empty() {
-                    paths.sort();
-                    let mut pending_paths = pending_paths.lock();
-                    if pending_paths.is_empty() {
-                        tx.try_send(()).ok();
+                        .collect::<Vec<_>>();
+
+                    if !paths.is_empty() {
+                        paths.sort();
+                        let mut pending_paths = pending_paths.lock();
+                        if pending_paths.is_empty() {
+                            tx.try_send(()).ok();
+                        }
+                        util::extend_sorted(&mut *pending_paths, paths, usize::MAX, |a, b| {
+                            a.path.cmp(&b.path)
+                        });
                     }
-                    util::extend_sorted(&mut *pending_paths, paths, usize::MAX, |a, b| {
-                        a.path.cmp(&b.path)
-                    });
-                }
-            })
+                })
+            }
         })
         .log_err();
 
@@ -626,6 +642,14 @@ impl Fs for RealFs {
 
         watcher.add(path).ok(); // Ignore "file doesn't exist error" and rely on parent watcher.
 
+        // Check if path is a symlink and follow the target parent
+        if let Some(target) = target_path {
+            watcher.add(&target).ok();
+            if let Some(parent) = target.parent() {
+                watcher.add(parent).log_err();
+            }
+        }
+
         // watch the parent dir so we can tell when settings.json is created
         if let Some(parent) = path.parent() {
             watcher.add(parent).log_err();

From 72be8c5d145d0f7554fd7cb8d3ee3c6c4e99423d Mon Sep 17 00:00:00 2001
From: Jason Lee <huacnlee@gmail.com>
Date: Tue, 1 Oct 2024 14:20:24 +0800
Subject: [PATCH 418/762] gpui: Fix `hide`, `activate` method on Windows to
 hide/show application (#18164)

Release Notes:

- N/A

Continue #18161 to fix `cx.hide`, `cx.activate` method on Windows to
hide/show application.

## After


https://github.com/user-attachments/assets/fe0070f9-7844-4c2a-b859-3e22ee4b8d22

---------

Co-authored-by: Mikayla Maki <mikayla@zed.dev>
---
 crates/gpui/examples/window.rs               | 12 ++++++++++
 crates/gpui/src/platform/windows/platform.rs | 24 ++++++++++++++++----
 2 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/crates/gpui/examples/window.rs b/crates/gpui/examples/window.rs
index 0f0d4287da723f..78a47782c956a8 100644
--- a/crates/gpui/examples/window.rs
+++ b/crates/gpui/examples/window.rs
@@ -150,6 +150,18 @@ impl Render for WindowDemo {
                 )
                 .unwrap();
             }))
+            .child(button("Hide Application", |cx| {
+                cx.hide();
+
+                // Restore the application after 3 seconds
+                cx.spawn(|mut cx| async move {
+                    Timer::after(std::time::Duration::from_secs(3)).await;
+                    cx.update(|cx| {
+                        cx.activate(false);
+                    })
+                })
+                .detach();
+            }))
     }
 }
 
diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs
index 30e7c402d26d85..7f6677973b2fbd 100644
--- a/crates/gpui/src/platform/windows/platform.rs
+++ b/crates/gpui/src/platform/windows/platform.rs
@@ -33,6 +33,8 @@ use crate::*;
 pub(crate) struct WindowsPlatform {
     state: RefCell<WindowsPlatformState>,
     raw_window_handles: RwLock<SmallVec<[HWND; 4]>>,
+    // The window handles that are hided by `hide` method.
+    hidden_windows: RwLock<SmallVec<[HWND; 4]>>,
     // The below members will never change throughout the entire lifecycle of the app.
     icon: HICON,
     main_receiver: flume::Receiver<Runnable>,
@@ -100,6 +102,7 @@ impl WindowsPlatform {
         Self {
             state,
             raw_window_handles,
+            hidden_windows: RwLock::new(SmallVec::new()),
             icon,
             main_receiver,
             dispatch_event,
@@ -295,12 +298,25 @@ impl Platform for WindowsPlatform {
         }
     }
 
-    // todo(windows)
-    fn activate(&self, _ignoring_other_apps: bool) {}
+    fn activate(&self, _ignoring_other_apps: bool) {
+        let mut state = self.hidden_windows.write();
+        state.iter().for_each(|handle| unsafe {
+            ShowWindow(*handle, SW_SHOW).ok().log_err();
+        });
+        state.clear();
+    }
 
-    // todo(windows)
     fn hide(&self) {
-        unimplemented!()
+        let mut state = self.hidden_windows.write();
+        self.raw_window_handles
+            .read()
+            .iter()
+            .for_each(|handle| unsafe {
+                if IsWindowVisible(*handle).as_bool() {
+                    state.push(*handle);
+                    ShowWindow(*handle, SW_HIDE).ok().log_err();
+                }
+            });
     }
 
     // todo(windows)

From 527c9097f848feef78cfb6cfd36d32eb048e6bb5 Mon Sep 17 00:00:00 2001
From: Michael Sloan <mgsloan@gmail.com>
Date: Tue, 1 Oct 2024 01:14:40 -0600
Subject: [PATCH 419/762] linux: Various X11 scroll improvements (#18484)

Closes  #14089, #14416, #15970, #17230, #18485

Release Notes:

- Fixed some cases where Linux X11 mouse scrolling doesn't work at all
(#14089, ##15970, #17230)
- Fixed handling of switching between Linux X11 devices used for
scrolling (#14416, #18485)

Change details:

Also includes the commit from PR #18317 so I don't have to deal with
merge conflicts.

* Now uses valuator info from slave pointers rather than master. This
hopefully fixes remaining cases where scrolling is fully
broken. https://github.com/zed-industries/zed/issues/14089,
https://github.com/zed-industries/zed/issues/15970,
https://github.com/zed-industries/zed/issues/17230

* Per-device recording of "last scroll position" used to calculate
deltas. This meant that swithing scroll devices would cause a sudden
jump of scroll position, often to the beginning or end of the
file (https://github.com/zed-industries/zed/issues/14416).

* Re-queries device metadata when devices change, so that newly
plugged in devices will work, and re-use of device-ids don't use old
metadata with a new device.

* xinput 2 documentation describes support for multiple master
devices. I believe this implementation will support that, since now it
just uses `DeviceInfo` from slave devices. The concept of master
devices is only used in registering for events.

* Uses popcount+bit masking to resolve axis indexes, instead of
iterating bit indices.

---------

Co-authored-by: Thorsten Ball <mrnugget@gmail.com>
---
 crates/gpui/src/platform/linux/platform.rs    |   2 +-
 .../gpui/src/platform/linux/wayland/client.rs |   8 +-
 crates/gpui/src/platform/linux/x11/client.rs  | 406 ++++++++++++------
 crates/gpui/src/platform/linux/x11/event.rs   | 116 ++++-
 crates/gpui/src/platform/linux/x11/window.rs  |  19 +-
 5 files changed, 408 insertions(+), 143 deletions(-)

diff --git a/crates/gpui/src/platform/linux/platform.rs b/crates/gpui/src/platform/linux/platform.rs
index 67f1a43cbe3220..6e09badb493a64 100644
--- a/crates/gpui/src/platform/linux/platform.rs
+++ b/crates/gpui/src/platform/linux/platform.rs
@@ -45,7 +45,7 @@ use crate::{
 
 use super::x11::X11Client;
 
-pub(crate) const SCROLL_LINES: f64 = 3.0;
+pub(crate) const SCROLL_LINES: f32 = 3.0;
 
 // Values match the defaults on GTK.
 // Taken from https://github.com/GNOME/gtk/blob/main/gtk/gtksettings.c#L320
diff --git a/crates/gpui/src/platform/linux/wayland/client.rs b/crates/gpui/src/platform/linux/wayland/client.rs
index 4b7816a73ac36c..f0015a7e5820bd 100644
--- a/crates/gpui/src/platform/linux/wayland/client.rs
+++ b/crates/gpui/src/platform/linux/wayland/client.rs
@@ -1634,10 +1634,10 @@ impl Dispatch<wl_pointer::WlPointer, ()> for WaylandClientStatePtr {
                 let scroll_delta = state.discrete_scroll_delta.get_or_insert(point(0.0, 0.0));
                 match axis {
                     wl_pointer::Axis::VerticalScroll => {
-                        scroll_delta.y += discrete as f32 * axis_modifier * SCROLL_LINES as f32;
+                        scroll_delta.y += discrete as f32 * axis_modifier * SCROLL_LINES;
                     }
                     wl_pointer::Axis::HorizontalScroll => {
-                        scroll_delta.x += discrete as f32 * axis_modifier * SCROLL_LINES as f32;
+                        scroll_delta.x += discrete as f32 * axis_modifier * SCROLL_LINES;
                     }
                     _ => unreachable!(),
                 }
@@ -1662,10 +1662,10 @@ impl Dispatch<wl_pointer::WlPointer, ()> for WaylandClientStatePtr {
                 let wheel_percent = value120 as f32 / 120.0;
                 match axis {
                     wl_pointer::Axis::VerticalScroll => {
-                        scroll_delta.y += wheel_percent * axis_modifier * SCROLL_LINES as f32;
+                        scroll_delta.y += wheel_percent * axis_modifier * SCROLL_LINES;
                     }
                     wl_pointer::Axis::HorizontalScroll => {
-                        scroll_delta.x += wheel_percent * axis_modifier * SCROLL_LINES as f32;
+                        scroll_delta.x += wheel_percent * axis_modifier * SCROLL_LINES;
                     }
                     _ => unreachable!(),
                 }
diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs
index 5339cc95fd1b11..459f2045bb732a 100644
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -1,6 +1,6 @@
 use core::str;
 use std::cell::RefCell;
-use std::collections::HashSet;
+use std::collections::{BTreeMap, HashSet};
 use std::ops::Deref;
 use std::path::PathBuf;
 use std::rc::{Rc, Weak};
@@ -42,7 +42,10 @@ use crate::{
     WindowParams, X11Window,
 };
 
-use super::{button_of_key, modifiers_from_state, pressed_button_from_mask};
+use super::{
+    button_or_scroll_from_event_detail, get_valuator_axis_index, modifiers_from_state,
+    pressed_button_from_mask, ButtonOrScroll, ScrollDirection,
+};
 use super::{X11Display, X11WindowStatePtr, XcbAtoms};
 use super::{XimCallbackEvent, XimHandler};
 use crate::platform::linux::platform::{DOUBLE_CLICK_INTERVAL, SCROLL_LINES};
@@ -51,7 +54,15 @@ use crate::platform::linux::{
     get_xkb_compose_state, is_within_click_distance, open_uri_internal, reveal_path_internal,
 };
 
-pub(super) const XINPUT_MASTER_DEVICE: u16 = 1;
+/// Value for DeviceId parameters which selects all devices.
+pub(crate) const XINPUT_ALL_DEVICES: xinput::DeviceId = 0;
+
+/// Value for DeviceId parameters which selects all device groups. Events that
+/// occur within the group are emitted by the group itself.
+///
+/// In XInput 2's interface, these are referred to as "master devices", but that
+/// terminology is both archaic and unclear.
+pub(crate) const XINPUT_ALL_DEVICE_GROUPS: xinput::DeviceId = 1;
 
 pub(crate) struct WindowRef {
     window: X11WindowStatePtr,
@@ -117,6 +128,26 @@ pub struct Xdnd {
     position: Point<Pixels>,
 }
 
+#[derive(Debug)]
+struct PointerDeviceState {
+    horizontal: ScrollAxisState,
+    vertical: ScrollAxisState,
+}
+
+#[derive(Debug, Default)]
+struct ScrollAxisState {
+    /// Valuator number for looking up this axis's scroll value.
+    valuator_number: Option<u16>,
+    /// Conversion factor from scroll units to lines.
+    multiplier: f32,
+    /// Last scroll value for calculating scroll delta.
+    ///
+    /// This gets set to `None` whenever it might be invalid - when devices change or when window focus changes.
+    /// The logic errs on the side of invalidating this, since the consequence is just skipping the delta of one scroll event.
+    /// The consequence of not invalidating it can be large invalid deltas, which are much more user visible.
+    scroll_value: Option<f32>,
+}
+
 pub struct X11ClientState {
     pub(crate) loop_handle: LoopHandle<'static, X11Client>,
     pub(crate) event_loop: Option<calloop::EventLoop<'static, X11Client>>,
@@ -152,9 +183,7 @@ pub struct X11ClientState {
     pub(crate) cursor_styles: HashMap<xproto::Window, CursorStyle>,
     pub(crate) cursor_cache: HashMap<CursorStyle, xproto::Cursor>,
 
-    pub(crate) scroll_class_data: Vec<xinput::DeviceClassDataScroll>,
-    pub(crate) scroll_x: Option<f32>,
-    pub(crate) scroll_y: Option<f32>,
+    pointer_device_states: BTreeMap<xinput::DeviceId, PointerDeviceState>,
 
     pub(crate) common: LinuxCommon,
     pub(crate) clipboard: x11_clipboard::Clipboard,
@@ -266,31 +295,21 @@ impl X11Client {
             .prefetch_extension_information(xinput::X11_EXTENSION_NAME)
             .unwrap();
 
+        // Announce to X server that XInput up to 2.1 is supported. To increase this to 2.2 and
+        // beyond, support for touch events would need to be added.
         let xinput_version = xcb_connection
-            .xinput_xi_query_version(2, 0)
+            .xinput_xi_query_version(2, 1)
             .unwrap()
             .reply()
             .unwrap();
+        // XInput 1.x is not supported.
         assert!(
             xinput_version.major_version >= 2,
-            "XInput Extension v2 not supported."
+            "XInput version >= 2 required."
         );
 
-        let master_device_query = xcb_connection
-            .xinput_xi_query_device(XINPUT_MASTER_DEVICE)
-            .unwrap()
-            .reply()
-            .unwrap();
-        let scroll_class_data = master_device_query
-            .infos
-            .iter()
-            .find(|info| info.type_ == xinput::DeviceType::MASTER_POINTER)
-            .unwrap()
-            .classes
-            .iter()
-            .filter_map(|class| class.data.as_scroll())
-            .map(|class| *class)
-            .collect::<Vec<_>>();
+        let pointer_device_states =
+            get_new_pointer_device_states(&xcb_connection, &BTreeMap::new());
 
         let atoms = XcbAtoms::new(&xcb_connection).unwrap().reply().unwrap();
 
@@ -434,9 +453,7 @@ impl X11Client {
             cursor_styles: HashMap::default(),
             cursor_cache: HashMap::default(),
 
-            scroll_class_data,
-            scroll_x: None,
-            scroll_y: None,
+            pointer_device_states,
 
             clipboard,
             clipboard_item: None,
@@ -950,35 +967,56 @@ impl X11Client {
                     window.handle_ime_commit(text);
                     state = self.0.borrow_mut();
                 }
-                if let Some(button) = button_of_key(event.detail.try_into().unwrap()) {
-                    let click_elapsed = state.last_click.elapsed();
-
-                    if click_elapsed < DOUBLE_CLICK_INTERVAL
-                        && state
-                            .last_mouse_button
-                            .is_some_and(|prev_button| prev_button == button)
-                        && is_within_click_distance(state.last_location, position)
-                    {
-                        state.current_count += 1;
-                    } else {
-                        state.current_count = 1;
-                    }
-
-                    state.last_click = Instant::now();
-                    state.last_mouse_button = Some(button);
-                    state.last_location = position;
-                    let current_count = state.current_count;
+                match button_or_scroll_from_event_detail(event.detail) {
+                    Some(ButtonOrScroll::Button(button)) => {
+                        let click_elapsed = state.last_click.elapsed();
+                        if click_elapsed < DOUBLE_CLICK_INTERVAL
+                            && state
+                                .last_mouse_button
+                                .is_some_and(|prev_button| prev_button == button)
+                            && is_within_click_distance(state.last_location, position)
+                        {
+                            state.current_count += 1;
+                        } else {
+                            state.current_count = 1;
+                        }
 
-                    drop(state);
-                    window.handle_input(PlatformInput::MouseDown(crate::MouseDownEvent {
-                        button,
-                        position,
-                        modifiers,
-                        click_count: current_count,
-                        first_mouse: false,
-                    }));
-                } else {
-                    log::warn!("Unknown button press: {event:?}");
+                        state.last_click = Instant::now();
+                        state.last_mouse_button = Some(button);
+                        state.last_location = position;
+                        let current_count = state.current_count;
+
+                        drop(state);
+                        window.handle_input(PlatformInput::MouseDown(crate::MouseDownEvent {
+                            button,
+                            position,
+                            modifiers,
+                            click_count: current_count,
+                            first_mouse: false,
+                        }));
+                    }
+                    Some(ButtonOrScroll::Scroll(direction)) => {
+                        drop(state);
+                        // Emulated scroll button presses are sent simultaneously with smooth scrolling XinputMotion events.
+                        // Since handling those events does the scrolling, they are skipped here.
+                        if !event
+                            .flags
+                            .contains(xinput::PointerEventFlags::POINTER_EMULATED)
+                        {
+                            let scroll_delta = match direction {
+                                ScrollDirection::Up => Point::new(0.0, SCROLL_LINES),
+                                ScrollDirection::Down => Point::new(0.0, -SCROLL_LINES),
+                                ScrollDirection::Left => Point::new(SCROLL_LINES, 0.0),
+                                ScrollDirection::Right => Point::new(-SCROLL_LINES, 0.0),
+                            };
+                            window.handle_input(PlatformInput::ScrollWheel(
+                                make_scroll_wheel_event(position, scroll_delta, modifiers),
+                            ));
+                        }
+                    }
+                    None => {
+                        log::error!("Unknown x11 button: {}", event.detail);
+                    }
                 }
             }
             Event::XinputButtonRelease(event) => {
@@ -991,15 +1029,19 @@ impl X11Client {
                     px(event.event_x as f32 / u16::MAX as f32 / state.scale_factor),
                     px(event.event_y as f32 / u16::MAX as f32 / state.scale_factor),
                 );
-                if let Some(button) = button_of_key(event.detail.try_into().unwrap()) {
-                    let click_count = state.current_count;
-                    drop(state);
-                    window.handle_input(PlatformInput::MouseUp(crate::MouseUpEvent {
-                        button,
-                        position,
-                        modifiers,
-                        click_count,
-                    }));
+                match button_or_scroll_from_event_detail(event.detail) {
+                    Some(ButtonOrScroll::Button(button)) => {
+                        let click_count = state.current_count;
+                        drop(state);
+                        window.handle_input(PlatformInput::MouseUp(crate::MouseUpEvent {
+                            button,
+                            position,
+                            modifiers,
+                            click_count,
+                        }));
+                    }
+                    Some(ButtonOrScroll::Scroll(_)) => {}
+                    None => {}
                 }
             }
             Event::XinputMotion(event) => {
@@ -1014,12 +1056,6 @@ impl X11Client {
                 state.modifiers = modifiers;
                 drop(state);
 
-                let axisvalues = event
-                    .axisvalues
-                    .iter()
-                    .map(|axisvalue| fp3232_to_f32(*axisvalue))
-                    .collect::<Vec<_>>();
-
                 if event.valuator_mask[0] & 3 != 0 {
                     window.handle_input(PlatformInput::MouseMove(crate::MouseMoveEvent {
                         position,
@@ -1028,64 +1064,17 @@ impl X11Client {
                     }));
                 }
 
-                let mut valuator_idx = 0;
-                let scroll_class_data = self.0.borrow().scroll_class_data.clone();
-                for shift in 0..32 {
-                    if (event.valuator_mask[0] >> shift) & 1 == 0 {
-                        continue;
-                    }
-
-                    for scroll_class in &scroll_class_data {
-                        if scroll_class.scroll_type == xinput::ScrollType::HORIZONTAL
-                            && scroll_class.number == shift
-                        {
-                            let new_scroll = axisvalues[valuator_idx]
-                                / fp3232_to_f32(scroll_class.increment)
-                                * SCROLL_LINES as f32;
-                            let old_scroll = self.0.borrow().scroll_x;
-                            self.0.borrow_mut().scroll_x = Some(new_scroll);
-
-                            if let Some(old_scroll) = old_scroll {
-                                let delta_scroll = old_scroll - new_scroll;
-                                window.handle_input(PlatformInput::ScrollWheel(
-                                    crate::ScrollWheelEvent {
-                                        position,
-                                        delta: ScrollDelta::Lines(Point::new(delta_scroll, 0.0)),
-                                        modifiers,
-                                        touch_phase: TouchPhase::default(),
-                                    },
-                                ));
-                            }
-                        } else if scroll_class.scroll_type == xinput::ScrollType::VERTICAL
-                            && scroll_class.number == shift
-                        {
-                            // the `increment` is the valuator delta equivalent to one positive unit of scrolling. Here that means SCROLL_LINES lines.
-                            let new_scroll = axisvalues[valuator_idx]
-                                / fp3232_to_f32(scroll_class.increment)
-                                * SCROLL_LINES as f32;
-                            let old_scroll = self.0.borrow().scroll_y;
-                            self.0.borrow_mut().scroll_y = Some(new_scroll);
-
-                            if let Some(old_scroll) = old_scroll {
-                                let delta_scroll = old_scroll - new_scroll;
-                                let (x, y) = if !modifiers.shift {
-                                    (0.0, delta_scroll)
-                                } else {
-                                    (delta_scroll, 0.0)
-                                };
-                                window.handle_input(PlatformInput::ScrollWheel(
-                                    crate::ScrollWheelEvent {
-                                        position,
-                                        delta: ScrollDelta::Lines(Point::new(x, y)),
-                                        modifiers,
-                                        touch_phase: TouchPhase::default(),
-                                    },
-                                ));
-                            }
-                        }
+                state = self.0.borrow_mut();
+                if let Some(mut pointer) = state.pointer_device_states.get_mut(&event.sourceid) {
+                    let scroll_delta = get_scroll_delta_and_update_state(&mut pointer, &event);
+                    drop(state);
+                    if let Some(scroll_delta) = scroll_delta {
+                        window.handle_input(PlatformInput::ScrollWheel(make_scroll_wheel_event(
+                            position,
+                            scroll_delta,
+                            modifiers,
+                        )));
                     }
-
-                    valuator_idx += 1;
                 }
             }
             Event::XinputEnter(event) if event.mode == xinput::NotifyMode::NORMAL => {
@@ -1095,10 +1084,10 @@ impl X11Client {
                 state.mouse_focused_window = Some(event.event);
             }
             Event::XinputLeave(event) if event.mode == xinput::NotifyMode::NORMAL => {
-                self.0.borrow_mut().scroll_x = None; // Set last scroll to `None` so that a large delta isn't created if scrolling is done outside the window (the valuator is global)
-                self.0.borrow_mut().scroll_y = None;
-
                 let mut state = self.0.borrow_mut();
+
+                // Set last scroll values to `None` so that a large delta isn't created if scrolling is done outside the window (the valuator is global)
+                reset_all_pointer_device_scroll_positions(&mut state.pointer_device_states);
                 state.mouse_focused_window = None;
                 let pressed_button = pressed_button_from_mask(event.buttons[0]);
                 let position = point(
@@ -1117,6 +1106,26 @@ impl X11Client {
                 }));
                 window.set_hovered(false);
             }
+            Event::XinputHierarchy(event) => {
+                let mut state = self.0.borrow_mut();
+                // Temporarily use `state.pointer_device_states` to only store pointers that still have valid scroll values.
+                // Any change to a device invalidates its scroll values.
+                for info in event.infos {
+                    if is_pointer_device(info.type_) {
+                        state.pointer_device_states.remove(&info.deviceid);
+                    }
+                }
+                state.pointer_device_states = get_new_pointer_device_states(
+                    &state.xcb_connection,
+                    &state.pointer_device_states,
+                );
+            }
+            Event::XinputDeviceChanged(event) => {
+                let mut state = self.0.borrow_mut();
+                if let Some(mut pointer) = state.pointer_device_states.get_mut(&event.sourceid) {
+                    reset_pointer_device_scroll_positions(&mut pointer);
+                }
+            }
             _ => {}
         };
 
@@ -1742,3 +1751,142 @@ fn xdnd_send_status(
         .send_event(false, target, EventMask::default(), message)
         .unwrap();
 }
+
+/// Recomputes `pointer_device_states` by querying all pointer devices.
+/// When a device is present in `scroll_values_to_preserve`, its value for `ScrollAxisState.scroll_value` is used.
+fn get_new_pointer_device_states(
+    xcb_connection: &XCBConnection,
+    scroll_values_to_preserve: &BTreeMap<xinput::DeviceId, PointerDeviceState>,
+) -> BTreeMap<xinput::DeviceId, PointerDeviceState> {
+    let devices_query_result = xcb_connection
+        .xinput_xi_query_device(XINPUT_ALL_DEVICES)
+        .unwrap()
+        .reply()
+        .unwrap();
+
+    let mut pointer_device_states = BTreeMap::new();
+    pointer_device_states.extend(
+        devices_query_result
+            .infos
+            .iter()
+            .filter(|info| is_pointer_device(info.type_))
+            .filter_map(|info| {
+                let scroll_data = info
+                    .classes
+                    .iter()
+                    .filter_map(|class| class.data.as_scroll())
+                    .map(|class| *class)
+                    .rev()
+                    .collect::<Vec<_>>();
+                let old_state = scroll_values_to_preserve.get(&info.deviceid);
+                let old_horizontal = old_state.map(|state| &state.horizontal);
+                let old_vertical = old_state.map(|state| &state.vertical);
+                let horizontal = scroll_data
+                    .iter()
+                    .find(|data| data.scroll_type == xinput::ScrollType::HORIZONTAL)
+                    .map(|data| scroll_data_to_axis_state(data, old_horizontal));
+                let vertical = scroll_data
+                    .iter()
+                    .find(|data| data.scroll_type == xinput::ScrollType::VERTICAL)
+                    .map(|data| scroll_data_to_axis_state(data, old_vertical));
+                if horizontal.is_none() && vertical.is_none() {
+                    None
+                } else {
+                    Some((
+                        info.deviceid,
+                        PointerDeviceState {
+                            horizontal: horizontal.unwrap_or_else(Default::default),
+                            vertical: vertical.unwrap_or_else(Default::default),
+                        },
+                    ))
+                }
+            }),
+    );
+    if pointer_device_states.is_empty() {
+        log::error!("Found no xinput mouse pointers.");
+    }
+    return pointer_device_states;
+}
+
+/// Returns true if the device is a pointer device. Does not include pointer device groups.
+fn is_pointer_device(type_: xinput::DeviceType) -> bool {
+    type_ == xinput::DeviceType::SLAVE_POINTER
+}
+
+fn scroll_data_to_axis_state(
+    data: &xinput::DeviceClassDataScroll,
+    old_axis_state_with_valid_scroll_value: Option<&ScrollAxisState>,
+) -> ScrollAxisState {
+    ScrollAxisState {
+        valuator_number: Some(data.number),
+        multiplier: SCROLL_LINES / fp3232_to_f32(data.increment),
+        scroll_value: old_axis_state_with_valid_scroll_value.and_then(|state| state.scroll_value),
+    }
+}
+
+fn reset_all_pointer_device_scroll_positions(
+    pointer_device_states: &mut BTreeMap<xinput::DeviceId, PointerDeviceState>,
+) {
+    pointer_device_states
+        .iter_mut()
+        .for_each(|(_, device_state)| reset_pointer_device_scroll_positions(device_state));
+}
+
+fn reset_pointer_device_scroll_positions(pointer: &mut PointerDeviceState) {
+    pointer.horizontal.scroll_value = None;
+    pointer.vertical.scroll_value = None;
+}
+
+/// Returns the scroll delta for a smooth scrolling motion event, or `None` if no scroll data is present.
+fn get_scroll_delta_and_update_state(
+    pointer: &mut PointerDeviceState,
+    event: &xinput::MotionEvent,
+) -> Option<Point<f32>> {
+    let delta_x = get_axis_scroll_delta_and_update_state(event, &mut pointer.horizontal);
+    let delta_y = get_axis_scroll_delta_and_update_state(event, &mut pointer.vertical);
+    if delta_x.is_some() || delta_y.is_some() {
+        Some(Point::new(delta_x.unwrap_or(0.0), delta_y.unwrap_or(0.0)))
+    } else {
+        None
+    }
+}
+
+fn get_axis_scroll_delta_and_update_state(
+    event: &xinput::MotionEvent,
+    axis: &mut ScrollAxisState,
+) -> Option<f32> {
+    let axis_index = get_valuator_axis_index(&event.valuator_mask, axis.valuator_number?)?;
+    if let Some(axis_value) = event.axisvalues.get(axis_index) {
+        let new_scroll = fp3232_to_f32(*axis_value);
+        let delta_scroll = axis
+            .scroll_value
+            .map(|old_scroll| (old_scroll - new_scroll) * axis.multiplier);
+        axis.scroll_value = Some(new_scroll);
+        delta_scroll
+    } else {
+        log::error!("Encountered invalid XInput valuator_mask, scrolling may not work properly.");
+        None
+    }
+}
+
+fn make_scroll_wheel_event(
+    position: Point<Pixels>,
+    scroll_delta: Point<f32>,
+    modifiers: Modifiers,
+) -> crate::ScrollWheelEvent {
+    // When shift is held down, vertical scrolling turns into horizontal scrolling.
+    let delta = if modifiers.shift {
+        Point {
+            x: scroll_delta.y,
+            y: 0.0,
+        }
+    } else {
+        scroll_delta
+    };
+    crate::ScrollWheelEvent {
+        position,
+        delta: ScrollDelta::Lines(delta),
+        modifiers,
+        touch_phase: TouchPhase::default(),
+    }
+}
diff --git a/crates/gpui/src/platform/linux/x11/event.rs b/crates/gpui/src/platform/linux/x11/event.rs
index 18ec392fc657ef..cd4cef24a33f33 100644
--- a/crates/gpui/src/platform/linux/x11/event.rs
+++ b/crates/gpui/src/platform/linux/x11/event.rs
@@ -5,13 +5,29 @@ use x11rb::protocol::{
 
 use crate::{Modifiers, MouseButton, NavigationDirection};
 
-pub(crate) fn button_of_key(detail: xproto::Button) -> Option<MouseButton> {
+pub(crate) enum ButtonOrScroll {
+    Button(MouseButton),
+    Scroll(ScrollDirection),
+}
+
+pub(crate) enum ScrollDirection {
+    Up,
+    Down,
+    Left,
+    Right,
+}
+
+pub(crate) fn button_or_scroll_from_event_detail(detail: u32) -> Option<ButtonOrScroll> {
     Some(match detail {
-        1 => MouseButton::Left,
-        2 => MouseButton::Middle,
-        3 => MouseButton::Right,
-        8 => MouseButton::Navigate(NavigationDirection::Back),
-        9 => MouseButton::Navigate(NavigationDirection::Forward),
+        1 => ButtonOrScroll::Button(MouseButton::Left),
+        2 => ButtonOrScroll::Button(MouseButton::Middle),
+        3 => ButtonOrScroll::Button(MouseButton::Right),
+        4 => ButtonOrScroll::Scroll(ScrollDirection::Up),
+        5 => ButtonOrScroll::Scroll(ScrollDirection::Down),
+        6 => ButtonOrScroll::Scroll(ScrollDirection::Left),
+        7 => ButtonOrScroll::Scroll(ScrollDirection::Right),
+        8 => ButtonOrScroll::Button(MouseButton::Navigate(NavigationDirection::Back)),
+        9 => ButtonOrScroll::Button(MouseButton::Navigate(NavigationDirection::Forward)),
         _ => return None,
     })
 }
@@ -48,3 +64,91 @@ pub(crate) fn pressed_button_from_mask(button_mask: u32) -> Option<MouseButton>
         return None;
     })
 }
+
+pub(crate) fn get_valuator_axis_index(
+    valuator_mask: &Vec<u32>,
+    valuator_number: u16,
+) -> Option<usize> {
+    // XInput valuator masks have a 1 at the bit indexes corresponding to each
+    // valuator present in this event's axisvalues. Axisvalues is ordered from
+    // lowest valuator number to highest, so counting bits before the 1 bit for
+    // this valuator yields the index in axisvalues.
+    if bit_is_set_in_vec(&valuator_mask, valuator_number) {
+        Some(popcount_upto_bit_index(&valuator_mask, valuator_number) as usize)
+    } else {
+        None
+    }
+}
+
+/// Returns the number of 1 bits in `bit_vec` for all bits where `i < bit_index`.
+fn popcount_upto_bit_index(bit_vec: &Vec<u32>, bit_index: u16) -> u32 {
+    let array_index = bit_index as usize / 32;
+    let popcount: u32 = bit_vec
+        .get(array_index)
+        .map_or(0, |bits| keep_bits_upto(*bits, bit_index % 32).count_ones());
+    if array_index == 0 {
+        popcount
+    } else {
+        // Valuator numbers over 32 probably never occur for scroll position, but may as well
+        // support it.
+        let leading_popcount: u32 = bit_vec
+            .iter()
+            .take(array_index)
+            .map(|bits| bits.count_ones())
+            .sum();
+        popcount + leading_popcount
+    }
+}
+
+fn bit_is_set_in_vec(bit_vec: &Vec<u32>, bit_index: u16) -> bool {
+    let array_index = bit_index as usize / 32;
+    bit_vec
+        .get(array_index)
+        .map_or(false, |bits| bit_is_set(*bits, bit_index % 32))
+}
+
+fn bit_is_set(bits: u32, bit_index: u16) -> bool {
+    bits & (1 << bit_index) != 0
+}
+
+/// Sets every bit with `i >= bit_index` to 0.
+fn keep_bits_upto(bits: u32, bit_index: u16) -> u32 {
+    if bit_index == 0 {
+        0
+    } else if bit_index >= 32 {
+        u32::MAX
+    } else {
+        bits & ((1 << bit_index) - 1)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_valuator_axis_index() {
+        assert!(get_valuator_axis_index(&vec![0b11], 0) == Some(0));
+        assert!(get_valuator_axis_index(&vec![0b11], 1) == Some(1));
+        assert!(get_valuator_axis_index(&vec![0b11], 2) == None);
+
+        assert!(get_valuator_axis_index(&vec![0b100], 0) == None);
+        assert!(get_valuator_axis_index(&vec![0b100], 1) == None);
+        assert!(get_valuator_axis_index(&vec![0b100], 2) == Some(0));
+        assert!(get_valuator_axis_index(&vec![0b100], 3) == None);
+
+        assert!(get_valuator_axis_index(&vec![0b1010, 0], 0) == None);
+        assert!(get_valuator_axis_index(&vec![0b1010, 0], 1) == Some(0));
+        assert!(get_valuator_axis_index(&vec![0b1010, 0], 2) == None);
+        assert!(get_valuator_axis_index(&vec![0b1010, 0], 3) == Some(1));
+
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 0) == None);
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 1) == Some(0));
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 2) == None);
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 3) == Some(1));
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 32) == Some(2));
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 33) == None);
+
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b101], 34) == Some(3));
+    }
+}
diff --git a/crates/gpui/src/platform/linux/x11/window.rs b/crates/gpui/src/platform/linux/x11/window.rs
index 62b895d01f426c..2884c7ea91a51d 100644
--- a/crates/gpui/src/platform/linux/x11/window.rs
+++ b/crates/gpui/src/platform/linux/x11/window.rs
@@ -29,7 +29,7 @@ use std::{
     sync::Arc,
 };
 
-use super::{X11Display, XINPUT_MASTER_DEVICE};
+use super::{X11Display, XINPUT_ALL_DEVICES, XINPUT_ALL_DEVICE_GROUPS};
 x11rb::atom_manager! {
     pub XcbAtoms: AtomsCookie {
         XA_ATOM,
@@ -475,7 +475,7 @@ impl X11WindowState {
             .xinput_xi_select_events(
                 x_window,
                 &[xinput::EventMask {
-                    deviceid: XINPUT_MASTER_DEVICE,
+                    deviceid: XINPUT_ALL_DEVICE_GROUPS,
                     mask: vec![
                         xinput::XIEventMask::MOTION
                             | xinput::XIEventMask::BUTTON_PRESS
@@ -487,6 +487,19 @@ impl X11WindowState {
             )
             .unwrap();
 
+        xcb_connection
+            .xinput_xi_select_events(
+                x_window,
+                &[xinput::EventMask {
+                    deviceid: XINPUT_ALL_DEVICES,
+                    mask: vec![
+                        xinput::XIEventMask::HIERARCHY,
+                        xinput::XIEventMask::DEVICE_CHANGED,
+                    ],
+                }],
+            )
+            .unwrap();
+
         xcb_connection.flush().unwrap();
 
         let raw = RawWindow {
@@ -1253,7 +1266,7 @@ impl PlatformWindow for X11Window {
             self.0.x_window,
             state.atoms._GTK_SHOW_WINDOW_MENU,
             [
-                XINPUT_MASTER_DEVICE as u32,
+                XINPUT_ALL_DEVICE_GROUPS as u32,
                 coords.dst_x as u32,
                 coords.dst_y as u32,
                 0,

From 7ce8797d78794f5a53e7a7d113e4c14a65e6297f Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 1 Oct 2024 12:16:44 +0200
Subject: [PATCH 420/762] ssh remoting: Add infrastructure to handle reconnects
 (#18572)

This restructures the code in `remote` so that it's easier to replace
the current SSH connection with a new one in case of
disconnects/reconnects.

Right now, it successfully reconnects, BUT we're still missing the big
piece on the server-side: keeping the server process alive and
reconnecting to the same process that keeps the project-state.

Release Notes:

- N/A

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 .../remote_editing_collaboration_tests.rs     |   4 +-
 crates/collab/src/tests/test_server.rs        |   4 +-
 crates/project/src/project.rs                 |  83 +-
 crates/project/src/terminals.rs               |   8 +-
 crates/recent_projects/src/ssh_connections.rs |   6 +-
 crates/remote/src/remote.rs                   |   2 +-
 crates/remote/src/ssh_session.rs              | 826 +++++++++++-------
 crates/remote_server/src/headless_project.rs  |   4 +-
 crates/remote_server/src/main.rs              |   5 +-
 .../remote_server/src/remote_editing_tests.rs |  11 +-
 crates/workspace/src/workspace.rs             |   4 +-
 11 files changed, 559 insertions(+), 398 deletions(-)

diff --git a/crates/collab/src/tests/remote_editing_collaboration_tests.rs b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
index a9cc32c1dd3a67..7de50511ea2766 100644
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -4,7 +4,7 @@ use fs::{FakeFs, Fs as _};
 use gpui::{Context as _, TestAppContext};
 use language::language_settings::all_language_settings;
 use project::ProjectPath;
-use remote::SshSession;
+use remote::SshRemoteClient;
 use remote_server::HeadlessProject;
 use serde_json::json;
 use std::{path::Path, sync::Arc};
@@ -24,7 +24,7 @@ async fn test_sharing_an_ssh_remote_project(
         .await;
 
     // Set up project on remote FS
-    let (client_ssh, server_ssh) = SshSession::fake(cx_a, server_cx);
+    let (client_ssh, server_ssh) = SshRemoteClient::fake(cx_a, server_cx);
     let remote_fs = FakeFs::new(server_cx.executor());
     remote_fs
         .insert_tree(
diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs
index 5ff4a720741bc8..5e7d935c364382 100644
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -25,7 +25,7 @@ use node_runtime::NodeRuntime;
 use notifications::NotificationStore;
 use parking_lot::Mutex;
 use project::{Project, WorktreeId};
-use remote::SshSession;
+use remote::SshRemoteClient;
 use rpc::{
     proto::{self, ChannelRole},
     RECEIVE_TIMEOUT,
@@ -835,7 +835,7 @@ impl TestClient {
     pub async fn build_ssh_project(
         &self,
         root_path: impl AsRef<Path>,
-        ssh: Arc<SshSession>,
+        ssh: Arc<SshRemoteClient>,
         cx: &mut TestAppContext,
     ) -> (Model<Project>, WorktreeId) {
         let project = cx.update(|cx| {
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index b91250e6b2c4a3..dadbd394bbf9b5 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -54,7 +54,7 @@ use parking_lot::{Mutex, RwLock};
 use paths::{local_tasks_file_relative_path, local_vscode_tasks_file_relative_path};
 pub use prettier_store::PrettierStore;
 use project_settings::{ProjectSettings, SettingsObserver, SettingsObserverEvent};
-use remote::SshSession;
+use remote::SshRemoteClient;
 use rpc::{proto::SSH_PROJECT_ID, AnyProtoClient, ErrorCode};
 use search::{SearchInputKind, SearchQuery, SearchResult};
 use search_history::SearchHistory;
@@ -138,7 +138,7 @@ pub struct Project {
     join_project_response_message_id: u32,
     user_store: Model<UserStore>,
     fs: Arc<dyn Fs>,
-    ssh_session: Option<Arc<SshSession>>,
+    ssh_client: Option<Arc<SshRemoteClient>>,
     client_state: ProjectClientState,
     collaborators: HashMap<proto::PeerId, Collaborator>,
     client_subscriptions: Vec<client::Subscription>,
@@ -643,7 +643,7 @@ impl Project {
                 user_store,
                 settings_observer,
                 fs,
-                ssh_session: None,
+                ssh_client: None,
                 buffers_needing_diff: Default::default(),
                 git_diff_debouncer: DebouncedDelay::new(),
                 terminals: Terminals {
@@ -664,7 +664,7 @@ impl Project {
     }
 
     pub fn ssh(
-        ssh: Arc<SshSession>,
+        ssh: Arc<SshRemoteClient>,
         client: Arc<Client>,
         node: NodeRuntime,
         user_store: Model<UserStore>,
@@ -682,14 +682,14 @@ impl Project {
                 SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
 
             let worktree_store =
-                cx.new_model(|_| WorktreeStore::remote(false, ssh.clone().into(), 0, None));
+                cx.new_model(|_| WorktreeStore::remote(false, ssh.to_proto_client(), 0, None));
             cx.subscribe(&worktree_store, Self::on_worktree_store_event)
                 .detach();
 
             let buffer_store = cx.new_model(|cx| {
                 BufferStore::remote(
                     worktree_store.clone(),
-                    ssh.clone().into(),
+                    ssh.to_proto_client(),
                     SSH_PROJECT_ID,
                     cx,
                 )
@@ -698,7 +698,7 @@ impl Project {
                 .detach();
 
             let settings_observer = cx.new_model(|cx| {
-                SettingsObserver::new_ssh(ssh.clone().into(), worktree_store.clone(), cx)
+                SettingsObserver::new_ssh(ssh.to_proto_client(), worktree_store.clone(), cx)
             });
             cx.subscribe(&settings_observer, Self::on_settings_observer_event)
                 .detach();
@@ -709,7 +709,7 @@ impl Project {
                     buffer_store.clone(),
                     worktree_store.clone(),
                     languages.clone(),
-                    ssh.clone().into(),
+                    ssh.to_proto_client(),
                     SSH_PROJECT_ID,
                     cx,
                 )
@@ -733,7 +733,7 @@ impl Project {
                 user_store,
                 settings_observer,
                 fs,
-                ssh_session: Some(ssh.clone()),
+                ssh_client: Some(ssh.clone()),
                 buffers_needing_diff: Default::default(),
                 git_diff_debouncer: DebouncedDelay::new(),
                 terminals: Terminals {
@@ -751,7 +751,7 @@ impl Project {
                 search_excluded_history: Self::new_search_history(),
             };
 
-            let client: AnyProtoClient = ssh.clone().into();
+            let client: AnyProtoClient = ssh.to_proto_client();
 
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &cx.handle());
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.buffer_store);
@@ -907,7 +907,7 @@ impl Project {
                 user_store: user_store.clone(),
                 snippets,
                 fs,
-                ssh_session: None,
+                ssh_client: None,
                 settings_observer: settings_observer.clone(),
                 client_subscriptions: Default::default(),
                 _subscriptions: vec![cx.on_release(Self::release)],
@@ -1230,7 +1230,7 @@ impl Project {
         match self.client_state {
             ProjectClientState::Remote { replica_id, .. } => replica_id,
             _ => {
-                if self.ssh_session.is_some() {
+                if self.ssh_client.is_some() {
                     1
                 } else {
                     0
@@ -1638,7 +1638,7 @@ impl Project {
     pub fn is_local(&self) -> bool {
         match &self.client_state {
             ProjectClientState::Local | ProjectClientState::Shared { .. } => {
-                self.ssh_session.is_none()
+                self.ssh_client.is_none()
             }
             ProjectClientState::Remote { .. } => false,
         }
@@ -1647,7 +1647,7 @@ impl Project {
     pub fn is_via_ssh(&self) -> bool {
         match &self.client_state {
             ProjectClientState::Local | ProjectClientState::Shared { .. } => {
-                self.ssh_session.is_some()
+                self.ssh_client.is_some()
             }
             ProjectClientState::Remote { .. } => false,
         }
@@ -1933,8 +1933,9 @@ impl Project {
             }
             BufferStoreEvent::BufferChangedFilePath { .. } => {}
             BufferStoreEvent::BufferDropped(buffer_id) => {
-                if let Some(ref ssh_session) = self.ssh_session {
-                    ssh_session
+                if let Some(ref ssh_client) = self.ssh_client {
+                    ssh_client
+                        .to_proto_client()
                         .send(proto::CloseBuffer {
                             project_id: 0,
                             buffer_id: buffer_id.to_proto(),
@@ -2139,13 +2140,14 @@ impl Project {
             } => {
                 let operation = language::proto::serialize_operation(operation);
 
-                if let Some(ssh) = &self.ssh_session {
-                    ssh.send(proto::UpdateBuffer {
-                        project_id: 0,
-                        buffer_id: buffer_id.to_proto(),
-                        operations: vec![operation.clone()],
-                    })
-                    .ok();
+                if let Some(ssh) = &self.ssh_client {
+                    ssh.to_proto_client()
+                        .send(proto::UpdateBuffer {
+                            project_id: 0,
+                            buffer_id: buffer_id.to_proto(),
+                            operations: vec![operation.clone()],
+                        })
+                        .ok();
                 }
 
                 self.enqueue_buffer_ordered_message(BufferOrderedMessage::Operation {
@@ -2825,14 +2827,13 @@ impl Project {
     ) -> Receiver<Model<Buffer>> {
         let (tx, rx) = smol::channel::unbounded();
 
-        let (client, remote_id): (AnyProtoClient, _) =
-            if let Some(ssh_session) = self.ssh_session.clone() {
-                (ssh_session.into(), 0)
-            } else if let Some(remote_id) = self.remote_id() {
-                (self.client.clone().into(), remote_id)
-            } else {
-                return rx;
-            };
+        let (client, remote_id): (AnyProtoClient, _) = if let Some(ssh_client) = &self.ssh_client {
+            (ssh_client.to_proto_client(), 0)
+        } else if let Some(remote_id) = self.remote_id() {
+            (self.client.clone().into(), remote_id)
+        } else {
+            return rx;
+        };
 
         let request = client.request(proto::FindSearchCandidates {
             project_id: remote_id,
@@ -2961,11 +2962,13 @@ impl Project {
 
                     exists.then(|| ResolvedPath::AbsPath(expanded))
                 })
-            } else if let Some(ssh_session) = self.ssh_session.as_ref() {
-                let request = ssh_session.request(proto::CheckFileExists {
-                    project_id: SSH_PROJECT_ID,
-                    path: path.to_string(),
-                });
+            } else if let Some(ssh_client) = self.ssh_client.as_ref() {
+                let request = ssh_client
+                    .to_proto_client()
+                    .request(proto::CheckFileExists {
+                        project_id: SSH_PROJECT_ID,
+                        path: path.to_string(),
+                    });
                 cx.background_executor().spawn(async move {
                     let response = request.await.log_err()?;
                     if response.exists {
@@ -3035,13 +3038,13 @@ impl Project {
     ) -> Task<Result<Vec<PathBuf>>> {
         if self.is_local() {
             DirectoryLister::Local(self.fs.clone()).list_directory(query, cx)
-        } else if let Some(session) = self.ssh_session.as_ref() {
+        } else if let Some(session) = self.ssh_client.as_ref() {
             let request = proto::ListRemoteDirectory {
                 dev_server_id: SSH_PROJECT_ID,
                 path: query,
             };
 
-            let response = session.request(request);
+            let response = session.to_proto_client().request(request);
             cx.background_executor().spawn(async move {
                 let response = response.await?;
                 Ok(response.entries.into_iter().map(PathBuf::from).collect())
@@ -3465,11 +3468,11 @@ impl Project {
         cx: AsyncAppContext,
     ) -> Result<proto::Ack> {
         let buffer_store = this.read_with(&cx, |this, cx| {
-            if let Some(ssh) = &this.ssh_session {
+            if let Some(ssh) = &this.ssh_client {
                 let mut payload = envelope.payload.clone();
                 payload.project_id = 0;
                 cx.background_executor()
-                    .spawn(ssh.request(payload))
+                    .spawn(ssh.to_proto_client().request(payload))
                     .detach_and_log_err(cx);
             }
             this.buffer_store.clone()
diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs
index 54dd48cf433ff3..7175b75e22a323 100644
--- a/crates/project/src/terminals.rs
+++ b/crates/project/src/terminals.rs
@@ -67,8 +67,12 @@ impl Project {
     }
 
     fn ssh_command(&self, cx: &AppContext) -> Option<SshCommand> {
-        if let Some(ssh_session) = self.ssh_session.as_ref() {
-            return Some(SshCommand::Direct(ssh_session.ssh_args()));
+        if let Some(args) = self
+            .ssh_client
+            .as_ref()
+            .and_then(|session| session.ssh_args())
+        {
+            return Some(SshCommand::Direct(args));
         }
 
         let dev_server_project_id = self.dev_server_project_id()?;
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index dd30f15f267fc7..d0fffc031f0bff 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -11,7 +11,7 @@ use gpui::{
     Transformation, View,
 };
 use release_channel::{AppVersion, ReleaseChannel};
-use remote::{SshConnectionOptions, SshPlatform, SshSession};
+use remote::{SshConnectionOptions, SshPlatform, SshRemoteClient};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
@@ -376,12 +376,12 @@ pub fn connect_over_ssh(
     connection_options: SshConnectionOptions,
     ui: View<SshPrompt>,
     cx: &mut WindowContext,
-) -> Task<Result<Arc<SshSession>>> {
+) -> Task<Result<Arc<SshRemoteClient>>> {
     let window = cx.window_handle();
     let known_password = connection_options.password.clone();
 
     cx.spawn(|mut cx| async move {
-        remote::SshSession::client(
+        remote::SshRemoteClient::new(
             connection_options,
             Arc::new(SshClientDelegate {
                 window,
diff --git a/crates/remote/src/remote.rs b/crates/remote/src/remote.rs
index 23f798c1914dbf..c3d9e8f9cc125e 100644
--- a/crates/remote/src/remote.rs
+++ b/crates/remote/src/remote.rs
@@ -2,4 +2,4 @@ pub mod json_log;
 pub mod protocol;
 pub mod ssh_session;
 
-pub use ssh_session::{SshClientDelegate, SshConnectionOptions, SshPlatform, SshSession};
+pub use ssh_session::{SshClientDelegate, SshConnectionOptions, SshPlatform, SshRemoteClient};
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 915595fd9d2957..fe1e42fe966309 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -7,19 +7,23 @@ use crate::{
 use anyhow::{anyhow, Context as _, Result};
 use collections::HashMap;
 use futures::{
-    channel::{mpsc, oneshot},
+    channel::{
+        mpsc::{self, UnboundedReceiver, UnboundedSender},
+        oneshot,
+    },
     future::BoxFuture,
-    select_biased, AsyncReadExt as _, AsyncWriteExt as _, Future, FutureExt as _, StreamExt as _,
+    select_biased, AsyncReadExt as _, AsyncWriteExt as _, Future, FutureExt as _, SinkExt,
+    StreamExt as _,
 };
 use gpui::{AppContext, AsyncAppContext, Model, SemanticVersion, Task};
 use parking_lot::Mutex;
 use rpc::{
     proto::{self, build_typed_envelope, Envelope, EnvelopedMessage, PeerId, RequestMessage},
-    EntityMessageSubscriber, ProtoClient, ProtoMessageHandlerSet, RpcError,
+    AnyProtoClient, EntityMessageSubscriber, ProtoClient, ProtoMessageHandlerSet, RpcError,
 };
 use smol::{
     fs,
-    process::{self, Stdio},
+    process::{self, Child, Stdio},
 };
 use std::{
     any::TypeId,
@@ -44,22 +48,6 @@ pub struct SshSocket {
     socket_path: PathBuf,
 }
 
-pub struct SshSession {
-    next_message_id: AtomicU32,
-    response_channels: ResponseChannels, // Lock
-    outgoing_tx: mpsc::UnboundedSender<Envelope>,
-    spawn_process_tx: mpsc::UnboundedSender<SpawnRequest>,
-    client_socket: Option<SshSocket>,
-    state: Mutex<ProtoMessageHandlerSet>, // Lock
-    _io_task: Option<Task<Result<()>>>,
-}
-
-struct SshClientState {
-    socket: SshSocket,
-    master_process: process::Child,
-    _temp_dir: TempDir,
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SshConnectionOptions {
     pub host: String,
@@ -105,18 +93,13 @@ impl SshConnectionOptions {
     }
 }
 
-struct SpawnRequest {
-    command: String,
-    process_tx: oneshot::Sender<process::Child>,
-}
-
 #[derive(Copy, Clone, Debug)]
 pub struct SshPlatform {
     pub os: &'static str,
     pub arch: &'static str,
 }
 
-pub trait SshClientDelegate {
+pub trait SshClientDelegate: Send + Sync {
     fn ask_password(
         &self,
         prompt: String,
@@ -132,48 +115,249 @@ pub trait SshClientDelegate {
     fn set_error(&self, error_message: String, cx: &mut AsyncAppContext);
 }
 
-type ResponseChannels = Mutex<HashMap<MessageId, oneshot::Sender<(Envelope, oneshot::Sender<()>)>>>;
+impl SshSocket {
+    fn ssh_command<S: AsRef<OsStr>>(&self, program: S) -> process::Command {
+        let mut command = process::Command::new("ssh");
+        self.ssh_options(&mut command)
+            .arg(self.connection_options.ssh_url())
+            .arg(program);
+        command
+    }
+
+    fn ssh_options<'a>(&self, command: &'a mut process::Command) -> &'a mut process::Command {
+        command
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .args(["-o", "ControlMaster=no", "-o"])
+            .arg(format!("ControlPath={}", self.socket_path.display()))
+    }
+
+    fn ssh_args(&self) -> Vec<String> {
+        vec![
+            "-o".to_string(),
+            "ControlMaster=no".to_string(),
+            "-o".to_string(),
+            format!("ControlPath={}", self.socket_path.display()),
+            self.connection_options.ssh_url(),
+        ]
+    }
+}
 
-impl SshSession {
-    pub async fn client(
+async fn run_cmd(command: &mut process::Command) -> Result<String> {
+    let output = command.output().await?;
+    if output.status.success() {
+        Ok(String::from_utf8_lossy(&output.stdout).to_string())
+    } else {
+        Err(anyhow!(
+            "failed to run command: {}",
+            String::from_utf8_lossy(&output.stderr)
+        ))
+    }
+}
+#[cfg(unix)]
+async fn read_with_timeout(
+    stdout: &mut process::ChildStdout,
+    timeout: std::time::Duration,
+    output: &mut Vec<u8>,
+) -> Result<(), std::io::Error> {
+    smol::future::or(
+        async {
+            stdout.read_to_end(output).await?;
+            Ok::<_, std::io::Error>(())
+        },
+        async {
+            smol::Timer::after(timeout).await;
+
+            Err(std::io::Error::new(
+                std::io::ErrorKind::TimedOut,
+                "Read operation timed out",
+            ))
+        },
+    )
+    .await
+}
+
+struct ChannelForwarder {
+    quit_tx: UnboundedSender<()>,
+    forwarding_task: Task<(UnboundedSender<Envelope>, UnboundedReceiver<Envelope>)>,
+}
+
+impl ChannelForwarder {
+    fn new(
+        mut incoming_tx: UnboundedSender<Envelope>,
+        mut outgoing_rx: UnboundedReceiver<Envelope>,
+        cx: &mut AsyncAppContext,
+    ) -> (Self, UnboundedSender<Envelope>, UnboundedReceiver<Envelope>) {
+        let (quit_tx, mut quit_rx) = mpsc::unbounded::<()>();
+
+        let (proxy_incoming_tx, mut proxy_incoming_rx) = mpsc::unbounded::<Envelope>();
+        let (mut proxy_outgoing_tx, proxy_outgoing_rx) = mpsc::unbounded::<Envelope>();
+
+        let forwarding_task = cx.background_executor().spawn(async move {
+            loop {
+                select_biased! {
+                    _ = quit_rx.next().fuse() => {
+                        break;
+                    },
+                    incoming_envelope = proxy_incoming_rx.next().fuse() => {
+                        if let Some(envelope) = incoming_envelope {
+                            if incoming_tx.send(envelope).await.is_err() {
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+                    outgoing_envelope = outgoing_rx.next().fuse() => {
+                        if let Some(envelope) = outgoing_envelope {
+                            if proxy_outgoing_tx.send(envelope).await.is_err() {
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            (incoming_tx, outgoing_rx)
+        });
+
+        (
+            Self {
+                forwarding_task,
+                quit_tx,
+            },
+            proxy_incoming_tx,
+            proxy_outgoing_rx,
+        )
+    }
+
+    async fn into_channels(mut self) -> (UnboundedSender<Envelope>, UnboundedReceiver<Envelope>) {
+        let _ = self.quit_tx.send(()).await;
+        self.forwarding_task.await
+    }
+}
+
+struct SshRemoteClientState {
+    ssh_connection: SshRemoteConnection,
+    delegate: Arc<dyn SshClientDelegate>,
+    forwarder: ChannelForwarder,
+    _multiplex_task: Task<Result<()>>,
+}
+
+pub struct SshRemoteClient {
+    client: Arc<ChannelClient>,
+    inner_state: Arc<Mutex<Option<SshRemoteClientState>>>,
+}
+
+impl SshRemoteClient {
+    pub async fn new(
         connection_options: SshConnectionOptions,
         delegate: Arc<dyn SshClientDelegate>,
         cx: &mut AsyncAppContext,
     ) -> Result<Arc<Self>> {
-        let client_state = SshClientState::new(connection_options, delegate.clone(), cx).await?;
+        let (outgoing_tx, outgoing_rx) = mpsc::unbounded::<Envelope>();
+        let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();
 
-        let platform = client_state.query_platform().await?;
-        let (local_binary_path, version) = delegate.get_server_binary(platform, cx).await??;
-        let remote_binary_path = delegate.remote_server_binary_path(cx)?;
-        client_state
-            .ensure_server_binary(
-                &delegate,
-                &local_binary_path,
-                &remote_binary_path,
-                version,
+        let client = cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx))?;
+        let this = Arc::new(Self {
+            client,
+            inner_state: Arc::new(Mutex::new(None)),
+        });
+
+        let inner_state = {
+            let (proxy, proxy_incoming_tx, proxy_outgoing_rx) =
+                ChannelForwarder::new(incoming_tx, outgoing_rx, cx);
+
+            let (ssh_connection, ssh_process) =
+                Self::establish_connection(connection_options.clone(), delegate.clone(), cx)
+                    .await?;
+
+            let multiplex_task = Self::multiplex(
+                this.clone(),
+                ssh_process,
+                proxy_incoming_tx,
+                proxy_outgoing_rx,
                 cx,
-            )
-            .await?;
+            );
 
-        let (spawn_process_tx, mut spawn_process_rx) = mpsc::unbounded::<SpawnRequest>();
-        let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded::<Envelope>();
-        let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();
+            SshRemoteClientState {
+                ssh_connection,
+                delegate,
+                forwarder: proxy,
+                _multiplex_task: multiplex_task,
+            }
+        };
 
-        let socket = client_state.socket.clone();
-        run_cmd(socket.ssh_command(&remote_binary_path).arg("version")).await?;
+        this.inner_state.lock().replace(inner_state);
 
-        let mut remote_server_child = socket
-            .ssh_command(format!(
-                "RUST_LOG={} RUST_BACKTRACE={} {:?} run",
-                std::env::var("RUST_LOG").unwrap_or_default(),
-                std::env::var("RUST_BACKTRACE").unwrap_or_default(),
-                remote_binary_path,
-            ))
-            .spawn()
-            .context("failed to spawn remote server")?;
-        let mut child_stderr = remote_server_child.stderr.take().unwrap();
-        let mut child_stdout = remote_server_child.stdout.take().unwrap();
-        let mut child_stdin = remote_server_child.stdin.take().unwrap();
+        Ok(this)
+    }
+
+    fn reconnect(this: Arc<Self>, cx: &mut AsyncAppContext) -> Result<()> {
+        let Some(state) = this.inner_state.lock().take() else {
+            return Err(anyhow!("reconnect is already in progress"));
+        };
+
+        let SshRemoteClientState {
+            mut ssh_connection,
+            delegate,
+            forwarder: proxy,
+            _multiplex_task,
+        } = state;
+        drop(_multiplex_task);
+
+        cx.spawn(|mut cx| async move {
+            let (incoming_tx, outgoing_rx) = proxy.into_channels().await;
+
+            ssh_connection.master_process.kill()?;
+            ssh_connection
+                .master_process
+                .status()
+                .await
+                .context("Failed to kill ssh process")?;
+
+            let connection_options = ssh_connection.socket.connection_options.clone();
+
+            let (ssh_connection, ssh_process) =
+                Self::establish_connection(connection_options, delegate.clone(), &mut cx).await?;
+
+            let (proxy, proxy_incoming_tx, proxy_outgoing_rx) =
+                ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
+
+            let inner_state = SshRemoteClientState {
+                ssh_connection,
+                delegate,
+                forwarder: proxy,
+                _multiplex_task: Self::multiplex(
+                    this.clone(),
+                    ssh_process,
+                    proxy_incoming_tx,
+                    proxy_outgoing_rx,
+                    &mut cx,
+                ),
+            };
+            this.inner_state.lock().replace(inner_state);
+
+            anyhow::Ok(())
+        })
+        .detach();
+
+        anyhow::Ok(())
+    }
+
+    fn multiplex(
+        this: Arc<Self>,
+        mut ssh_process: Child,
+        incoming_tx: UnboundedSender<Envelope>,
+        mut outgoing_rx: UnboundedReceiver<Envelope>,
+        cx: &mut AsyncAppContext,
+    ) -> Task<Result<()>> {
+        let mut child_stderr = ssh_process.stderr.take().unwrap();
+        let mut child_stdout = ssh_process.stdout.take().unwrap();
+        let mut child_stdin = ssh_process.stdin.take().unwrap();
 
         let io_task = cx.background_executor().spawn(async move {
             let mut stdin_buffer = Vec::new();
@@ -194,27 +378,15 @@ impl SshSession {
                         write_message(&mut child_stdin, &mut stdin_buffer, outgoing).await?;
                     }
 
-                    request = spawn_process_rx.next().fuse() => {
-                        let Some(request) = request else {
-                            return Ok(());
-                        };
-
-                        log::info!("spawn process: {:?}", request.command);
-                        let child = client_state.socket
-                            .ssh_command(&request.command)
-                            .spawn()
-                            .context("failed to create channel")?;
-                        request.process_tx.send(child).ok();
-                    }
-
                     result = child_stdout.read(&mut stdout_buffer).fuse() => {
                         match result {
                             Ok(0) => {
                                 child_stdin.close().await?;
                                 outgoing_rx.close();
-                                let status = remote_server_child.status().await?;
+                                let status = ssh_process.status().await?;
                                 if !status.success() {
-                                    log::error!("channel exited with status: {status:?}");
+                                    log::error!("ssh process exited with status: {status:?}");
+                                    return Err(anyhow!("ssh process exited with non-zero status code: {:?}", status.code()));
                                 }
                                 return Ok(());
                             }
@@ -267,239 +439,112 @@ impl SshSession {
             }
         });
 
-        cx.update(|cx| {
-            Self::new(
-                incoming_rx,
-                outgoing_tx,
-                spawn_process_tx,
-                Some(socket),
-                Some(io_task),
-                cx,
-            )
-        })
-    }
+        cx.spawn(|mut cx| async move {
+            let result = io_task.await;
 
-    pub fn server(
-        incoming_rx: mpsc::UnboundedReceiver<Envelope>,
-        outgoing_tx: mpsc::UnboundedSender<Envelope>,
-        cx: &AppContext,
-    ) -> Arc<SshSession> {
-        let (tx, _rx) = mpsc::unbounded();
-        Self::new(incoming_rx, outgoing_tx, tx, None, None, cx)
-    }
-
-    #[cfg(any(test, feature = "test-support"))]
-    pub fn fake(
-        client_cx: &mut gpui::TestAppContext,
-        server_cx: &mut gpui::TestAppContext,
-    ) -> (Arc<Self>, Arc<Self>) {
-        let (server_to_client_tx, server_to_client_rx) = mpsc::unbounded();
-        let (client_to_server_tx, client_to_server_rx) = mpsc::unbounded();
-        let (tx, _rx) = mpsc::unbounded();
-        (
-            client_cx.update(|cx| {
-                Self::new(
-                    server_to_client_rx,
-                    client_to_server_tx,
-                    tx.clone(),
-                    None, // todo()
-                    None,
-                    cx,
-                )
-            }),
-            server_cx.update(|cx| {
-                Self::new(
-                    client_to_server_rx,
-                    server_to_client_tx,
-                    tx.clone(),
-                    None,
-                    None,
-                    cx,
-                )
-            }),
-        )
-    }
-
-    fn new(
-        mut incoming_rx: mpsc::UnboundedReceiver<Envelope>,
-        outgoing_tx: mpsc::UnboundedSender<Envelope>,
-        spawn_process_tx: mpsc::UnboundedSender<SpawnRequest>,
-        client_socket: Option<SshSocket>,
-        io_task: Option<Task<Result<()>>>,
-        cx: &AppContext,
-    ) -> Arc<SshSession> {
-        let this = Arc::new(Self {
-            next_message_id: AtomicU32::new(0),
-            response_channels: ResponseChannels::default(),
-            outgoing_tx,
-            spawn_process_tx,
-            client_socket,
-            state: Default::default(),
-            _io_task: io_task,
-        });
-
-        cx.spawn(|cx| {
-            let this = Arc::downgrade(&this);
-            async move {
-                let peer_id = PeerId { owner_id: 0, id: 0 };
-                while let Some(incoming) = incoming_rx.next().await {
-                    let Some(this) = this.upgrade() else {
-                        return anyhow::Ok(());
-                    };
-
-                    if let Some(request_id) = incoming.responding_to {
-                        let request_id = MessageId(request_id);
-                        let sender = this.response_channels.lock().remove(&request_id);
-                        if let Some(sender) = sender {
-                            let (tx, rx) = oneshot::channel();
-                            if incoming.payload.is_some() {
-                                sender.send((incoming, tx)).ok();
-                            }
-                            rx.await.ok();
-                        }
-                    } else if let Some(envelope) =
-                        build_typed_envelope(peer_id, Instant::now(), incoming)
-                    {
-                        let type_name = envelope.payload_type_name();
-                        if let Some(future) = ProtoMessageHandlerSet::handle_message(
-                            &this.state,
-                            envelope,
-                            this.clone().into(),
-                            cx.clone(),
-                        ) {
-                            log::debug!("ssh message received. name:{type_name}");
-                            match future.await {
-                                Ok(_) => {
-                                    log::debug!("ssh message handled. name:{type_name}");
-                                }
-                                Err(error) => {
-                                    log::error!(
-                                        "error handling message. type:{type_name}, error:{error}",
-                                    );
-                                }
-                            }
-                        } else {
-                            log::error!("unhandled ssh message name:{type_name}");
-                        }
-                    }
-                }
-                anyhow::Ok(())
+            if let Err(error) = result {
+                log::warn!("ssh io task died with error: {:?}. reconnecting...", error);
+                Self::reconnect(this, &mut cx).ok();
             }
-        })
-        .detach();
-
-        this
-    }
 
-    pub fn request<T: RequestMessage>(
-        &self,
-        payload: T,
-    ) -> impl 'static + Future<Output = Result<T::Response>> {
-        log::debug!("ssh request start. name:{}", T::NAME);
-        let response = self.request_dynamic(payload.into_envelope(0, None, None), T::NAME);
-        async move {
-            let response = response.await?;
-            log::debug!("ssh request finish. name:{}", T::NAME);
-            T::Response::from_envelope(response)
-                .ok_or_else(|| anyhow!("received a response of the wrong type"))
-        }
-    }
-
-    pub fn send<T: EnvelopedMessage>(&self, payload: T) -> Result<()> {
-        log::debug!("ssh send name:{}", T::NAME);
-        self.send_dynamic(payload.into_envelope(0, None, None))
+            Ok(())
+        })
     }
 
-    pub fn request_dynamic(
-        &self,
-        mut envelope: proto::Envelope,
-        type_name: &'static str,
-    ) -> impl 'static + Future<Output = Result<proto::Envelope>> {
-        envelope.id = self.next_message_id.fetch_add(1, SeqCst);
-        let (tx, rx) = oneshot::channel();
-        let mut response_channels_lock = self.response_channels.lock();
-        response_channels_lock.insert(MessageId(envelope.id), tx);
-        drop(response_channels_lock);
-        let result = self.outgoing_tx.unbounded_send(envelope);
-        async move {
-            if let Err(error) = &result {
-                log::error!("failed to send message: {}", error);
-                return Err(anyhow!("failed to send message: {}", error));
-            }
-
-            let response = rx.await.context("connection lost")?.0;
-            if let Some(proto::envelope::Payload::Error(error)) = &response.payload {
-                return Err(RpcError::from_proto(error, type_name));
-            }
-            Ok(response)
-        }
-    }
+    async fn establish_connection(
+        connection_options: SshConnectionOptions,
+        delegate: Arc<dyn SshClientDelegate>,
+        cx: &mut AsyncAppContext,
+    ) -> Result<(SshRemoteConnection, Child)> {
+        let ssh_connection =
+            SshRemoteConnection::new(connection_options, delegate.clone(), cx).await?;
 
-    pub fn send_dynamic(&self, mut envelope: proto::Envelope) -> Result<()> {
-        envelope.id = self.next_message_id.fetch_add(1, SeqCst);
-        self.outgoing_tx.unbounded_send(envelope)?;
-        Ok(())
-    }
+        let platform = ssh_connection.query_platform().await?;
+        let (local_binary_path, version) = delegate.get_server_binary(platform, cx).await??;
+        let remote_binary_path = delegate.remote_server_binary_path(cx)?;
+        ssh_connection
+            .ensure_server_binary(
+                &delegate,
+                &local_binary_path,
+                &remote_binary_path,
+                version,
+                cx,
+            )
+            .await?;
 
-    pub fn subscribe_to_entity<E: 'static>(&self, remote_id: u64, entity: &Model<E>) {
-        let id = (TypeId::of::<E>(), remote_id);
+        let socket = ssh_connection.socket.clone();
+        run_cmd(socket.ssh_command(&remote_binary_path).arg("version")).await?;
 
-        let mut state = self.state.lock();
-        if state.entities_by_type_and_remote_id.contains_key(&id) {
-            panic!("already subscribed to entity");
-        }
+        let ssh_process = socket
+            .ssh_command(format!(
+                "RUST_LOG={} RUST_BACKTRACE={} {:?} run",
+                std::env::var("RUST_LOG").unwrap_or_default(),
+                std::env::var("RUST_BACKTRACE").unwrap_or_default(),
+                remote_binary_path,
+            ))
+            .spawn()
+            .context("failed to spawn remote server")?;
 
-        state.entities_by_type_and_remote_id.insert(
-            id,
-            EntityMessageSubscriber::Entity {
-                handle: entity.downgrade().into(),
-            },
-        );
+        Ok((ssh_connection, ssh_process))
     }
 
-    pub async fn spawn_process(&self, command: String) -> process::Child {
-        let (process_tx, process_rx) = oneshot::channel();
-        self.spawn_process_tx
-            .unbounded_send(SpawnRequest {
-                command,
-                process_tx,
-            })
-            .ok();
-        process_rx.await.unwrap()
+    pub fn subscribe_to_entity<E: 'static>(&self, remote_id: u64, entity: &Model<E>) {
+        self.client.subscribe_to_entity(remote_id, entity);
     }
 
-    pub fn ssh_args(&self) -> Vec<String> {
-        self.client_socket.as_ref().unwrap().ssh_args()
+    pub fn ssh_args(&self) -> Option<Vec<String>> {
+        let state = self.inner_state.lock();
+        state
+            .as_ref()
+            .map(|state| state.ssh_connection.socket.ssh_args())
     }
-}
 
-impl ProtoClient for SshSession {
-    fn request(
-        &self,
-        envelope: proto::Envelope,
-        request_type: &'static str,
-    ) -> BoxFuture<'static, Result<proto::Envelope>> {
-        self.request_dynamic(envelope, request_type).boxed()
+    pub fn to_proto_client(&self) -> AnyProtoClient {
+        self.client.clone().into()
     }
 
-    fn send(&self, envelope: proto::Envelope, _message_type: &'static str) -> Result<()> {
-        self.send_dynamic(envelope)
-    }
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn fake(
+        client_cx: &mut gpui::TestAppContext,
+        server_cx: &mut gpui::TestAppContext,
+    ) -> (Arc<Self>, Arc<ChannelClient>) {
+        let (server_to_client_tx, server_to_client_rx) = mpsc::unbounded();
+        let (client_to_server_tx, client_to_server_rx) = mpsc::unbounded();
 
-    fn send_response(&self, envelope: Envelope, _message_type: &'static str) -> anyhow::Result<()> {
-        self.send_dynamic(envelope)
+        (
+            client_cx.update(|cx| {
+                let client = ChannelClient::new(server_to_client_rx, client_to_server_tx, cx);
+                Arc::new(Self {
+                    client,
+                    inner_state: Arc::new(Mutex::new(None)),
+                })
+            }),
+            server_cx.update(|cx| ChannelClient::new(client_to_server_rx, server_to_client_tx, cx)),
+        )
     }
+}
 
-    fn message_handler_set(&self) -> &Mutex<ProtoMessageHandlerSet> {
-        &self.state
+impl From<SshRemoteClient> for AnyProtoClient {
+    fn from(client: SshRemoteClient) -> Self {
+        AnyProtoClient::new(client.client.clone())
     }
+}
 
-    fn is_via_collab(&self) -> bool {
-        false
+struct SshRemoteConnection {
+    socket: SshSocket,
+    master_process: process::Child,
+    _temp_dir: TempDir,
+}
+
+impl Drop for SshRemoteConnection {
+    fn drop(&mut self) {
+        if let Err(error) = self.master_process.kill() {
+            log::error!("failed to kill SSH master process: {}", error);
+        }
     }
 }
 
-impl SshClientState {
+impl SshRemoteConnection {
     #[cfg(not(unix))]
     async fn new(
         _connection_options: SshConnectionOptions,
@@ -740,74 +785,181 @@ impl SshClientState {
     }
 }
 
-#[cfg(unix)]
-async fn read_with_timeout(
-    stdout: &mut process::ChildStdout,
-    timeout: std::time::Duration,
-    output: &mut Vec<u8>,
-) -> Result<(), std::io::Error> {
-    smol::future::or(
-        async {
-            stdout.read_to_end(output).await?;
-            Ok::<_, std::io::Error>(())
-        },
-        async {
-            smol::Timer::after(timeout).await;
+type ResponseChannels = Mutex<HashMap<MessageId, oneshot::Sender<(Envelope, oneshot::Sender<()>)>>>;
 
-            Err(std::io::Error::new(
-                std::io::ErrorKind::TimedOut,
-                "Read operation timed out",
-            ))
-        },
-    )
-    .await
+pub struct ChannelClient {
+    next_message_id: AtomicU32,
+    outgoing_tx: mpsc::UnboundedSender<Envelope>,
+    response_channels: ResponseChannels,             // Lock
+    message_handlers: Mutex<ProtoMessageHandlerSet>, // Lock
 }
 
-impl Drop for SshClientState {
-    fn drop(&mut self) {
-        if let Err(error) = self.master_process.kill() {
-            log::error!("failed to kill SSH master process: {}", error);
+impl ChannelClient {
+    pub fn new(
+        incoming_rx: mpsc::UnboundedReceiver<Envelope>,
+        outgoing_tx: mpsc::UnboundedSender<Envelope>,
+        cx: &AppContext,
+    ) -> Arc<Self> {
+        let this = Arc::new(Self {
+            outgoing_tx,
+            next_message_id: AtomicU32::new(0),
+            response_channels: ResponseChannels::default(),
+            message_handlers: Default::default(),
+        });
+
+        Self::start_handling_messages(this.clone(), incoming_rx, cx);
+
+        this
+    }
+
+    fn start_handling_messages(
+        this: Arc<Self>,
+        mut incoming_rx: mpsc::UnboundedReceiver<Envelope>,
+        cx: &AppContext,
+    ) {
+        cx.spawn(|cx| {
+            let this = Arc::downgrade(&this);
+            async move {
+                let peer_id = PeerId { owner_id: 0, id: 0 };
+                while let Some(incoming) = incoming_rx.next().await {
+                    let Some(this) = this.upgrade() else {
+                        return anyhow::Ok(());
+                    };
+
+                    if let Some(request_id) = incoming.responding_to {
+                        let request_id = MessageId(request_id);
+                        let sender = this.response_channels.lock().remove(&request_id);
+                        if let Some(sender) = sender {
+                            let (tx, rx) = oneshot::channel();
+                            if incoming.payload.is_some() {
+                                sender.send((incoming, tx)).ok();
+                            }
+                            rx.await.ok();
+                        }
+                    } else if let Some(envelope) =
+                        build_typed_envelope(peer_id, Instant::now(), incoming)
+                    {
+                        let type_name = envelope.payload_type_name();
+                        if let Some(future) = ProtoMessageHandlerSet::handle_message(
+                            &this.message_handlers,
+                            envelope,
+                            this.clone().into(),
+                            cx.clone(),
+                        ) {
+                            log::debug!("ssh message received. name:{type_name}");
+                            match future.await {
+                                Ok(_) => {
+                                    log::debug!("ssh message handled. name:{type_name}");
+                                }
+                                Err(error) => {
+                                    log::error!(
+                                        "error handling message. type:{type_name}, error:{error}",
+                                    );
+                                }
+                            }
+                        } else {
+                            log::error!("unhandled ssh message name:{type_name}");
+                        }
+                    }
+                }
+                anyhow::Ok(())
+            }
+        })
+        .detach();
+    }
+
+    pub fn subscribe_to_entity<E: 'static>(&self, remote_id: u64, entity: &Model<E>) {
+        let id = (TypeId::of::<E>(), remote_id);
+
+        let mut message_handlers = self.message_handlers.lock();
+        if message_handlers
+            .entities_by_type_and_remote_id
+            .contains_key(&id)
+        {
+            panic!("already subscribed to entity");
         }
+
+        message_handlers.entities_by_type_and_remote_id.insert(
+            id,
+            EntityMessageSubscriber::Entity {
+                handle: entity.downgrade().into(),
+            },
+        );
     }
-}
 
-impl SshSocket {
-    fn ssh_command<S: AsRef<OsStr>>(&self, program: S) -> process::Command {
-        let mut command = process::Command::new("ssh");
-        self.ssh_options(&mut command)
-            .arg(self.connection_options.ssh_url())
-            .arg(program);
-        command
+    pub fn request<T: RequestMessage>(
+        &self,
+        payload: T,
+    ) -> impl 'static + Future<Output = Result<T::Response>> {
+        log::debug!("ssh request start. name:{}", T::NAME);
+        let response = self.request_dynamic(payload.into_envelope(0, None, None), T::NAME);
+        async move {
+            let response = response.await?;
+            log::debug!("ssh request finish. name:{}", T::NAME);
+            T::Response::from_envelope(response)
+                .ok_or_else(|| anyhow!("received a response of the wrong type"))
+        }
     }
 
-    fn ssh_options<'a>(&self, command: &'a mut process::Command) -> &'a mut process::Command {
-        command
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .args(["-o", "ControlMaster=no", "-o"])
-            .arg(format!("ControlPath={}", self.socket_path.display()))
+    pub fn send<T: EnvelopedMessage>(&self, payload: T) -> Result<()> {
+        log::debug!("ssh send name:{}", T::NAME);
+        self.send_dynamic(payload.into_envelope(0, None, None))
     }
 
-    fn ssh_args(&self) -> Vec<String> {
-        vec![
-            "-o".to_string(),
-            "ControlMaster=no".to_string(),
-            "-o".to_string(),
-            format!("ControlPath={}", self.socket_path.display()),
-            self.connection_options.ssh_url(),
-        ]
+    pub fn request_dynamic(
+        &self,
+        mut envelope: proto::Envelope,
+        type_name: &'static str,
+    ) -> impl 'static + Future<Output = Result<proto::Envelope>> {
+        envelope.id = self.next_message_id.fetch_add(1, SeqCst);
+        let (tx, rx) = oneshot::channel();
+        let mut response_channels_lock = self.response_channels.lock();
+        response_channels_lock.insert(MessageId(envelope.id), tx);
+        drop(response_channels_lock);
+        let result = self.outgoing_tx.unbounded_send(envelope);
+        async move {
+            if let Err(error) = &result {
+                log::error!("failed to send message: {}", error);
+                return Err(anyhow!("failed to send message: {}", error));
+            }
+
+            let response = rx.await.context("connection lost")?.0;
+            if let Some(proto::envelope::Payload::Error(error)) = &response.payload {
+                return Err(RpcError::from_proto(error, type_name));
+            }
+            Ok(response)
+        }
+    }
+
+    pub fn send_dynamic(&self, mut envelope: proto::Envelope) -> Result<()> {
+        envelope.id = self.next_message_id.fetch_add(1, SeqCst);
+        self.outgoing_tx.unbounded_send(envelope)?;
+        Ok(())
     }
 }
 
-async fn run_cmd(command: &mut process::Command) -> Result<String> {
-    let output = command.output().await?;
-    if output.status.success() {
-        Ok(String::from_utf8_lossy(&output.stdout).to_string())
-    } else {
-        Err(anyhow!(
-            "failed to run command: {}",
-            String::from_utf8_lossy(&output.stderr)
-        ))
+impl ProtoClient for ChannelClient {
+    fn request(
+        &self,
+        envelope: proto::Envelope,
+        request_type: &'static str,
+    ) -> BoxFuture<'static, Result<proto::Envelope>> {
+        self.request_dynamic(envelope, request_type).boxed()
+    }
+
+    fn send(&self, envelope: proto::Envelope, _message_type: &'static str) -> Result<()> {
+        self.send_dynamic(envelope)
+    }
+
+    fn send_response(&self, envelope: Envelope, _message_type: &'static str) -> anyhow::Result<()> {
+        self.send_dynamic(envelope)
+    }
+
+    fn message_handler_set(&self) -> &Mutex<ProtoMessageHandlerSet> {
+        &self.message_handlers
+    }
+
+    fn is_via_collab(&self) -> bool {
+        false
     }
 }
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 4b13938d8ca2f5..39540b04e04cb8 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -10,7 +10,7 @@ use project::{
     worktree_store::WorktreeStore,
     LspStore, LspStoreEvent, PrettierStore, ProjectPath, WorktreeId,
 };
-use remote::SshSession;
+use remote::ssh_session::ChannelClient;
 use rpc::{
     proto::{self, SSH_PEER_ID, SSH_PROJECT_ID},
     AnyProtoClient, TypedEnvelope,
@@ -41,7 +41,7 @@ impl HeadlessProject {
         project::Project::init_settings(cx);
     }
 
-    pub fn new(session: Arc<SshSession>, fs: Arc<dyn Fs>, cx: &mut ModelContext<Self>) -> Self {
+    pub fn new(session: Arc<ChannelClient>, fs: Arc<dyn Fs>, cx: &mut ModelContext<Self>) -> Self {
         let languages = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
 
         let node_runtime = NodeRuntime::unavailable();
diff --git a/crates/remote_server/src/main.rs b/crates/remote_server/src/main.rs
index 908a0a89b6273b..73b8a91da1876f 100644
--- a/crates/remote_server/src/main.rs
+++ b/crates/remote_server/src/main.rs
@@ -6,7 +6,6 @@ use gpui::Context as _;
 use remote::{
     json_log::LogRecord,
     protocol::{read_message, write_message},
-    SshSession,
 };
 use remote_server::HeadlessProject;
 use smol::{io::AsyncWriteExt, stream::StreamExt as _, Async};
@@ -24,6 +23,8 @@ fn main() {
 
 #[cfg(not(windows))]
 fn main() {
+    use remote::ssh_session::ChannelClient;
+
     env_logger::builder()
         .format(|buf, record| {
             serde_json::to_writer(&mut *buf, &LogRecord::new(record))?;
@@ -55,7 +56,7 @@ fn main() {
         let mut stdin = Async::new(io::stdin()).unwrap();
         let mut stdout = Async::new(io::stdout()).unwrap();
 
-        let session = SshSession::server(incoming_rx, outgoing_tx, cx);
+        let session = ChannelClient::new(incoming_rx, outgoing_tx, cx);
         let project = cx.new_model(|cx| {
             HeadlessProject::new(
                 session.clone(),
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 892063942754c1..960b7c248c0e26 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -15,7 +15,7 @@ use project::{
     search::{SearchQuery, SearchResult},
     Project, ProjectPath,
 };
-use remote::SshSession;
+use remote::SshRemoteClient;
 use serde_json::json;
 use settings::{Settings, SettingsLocation, SettingsStore};
 use smol::stream::StreamExt;
@@ -616,7 +616,7 @@ async fn init_test(
     cx: &mut TestAppContext,
     server_cx: &mut TestAppContext,
 ) -> (Model<Project>, Model<HeadlessProject>, Arc<FakeFs>) {
-    let (client_ssh, server_ssh) = SshSession::fake(cx, server_cx);
+    let (ssh_remote_client, ssh_server_client) = SshRemoteClient::fake(cx, server_cx);
     init_logger();
 
     let fs = FakeFs::new(server_cx.executor());
@@ -642,8 +642,9 @@ async fn init_test(
     );
 
     server_cx.update(HeadlessProject::init);
-    let headless = server_cx.new_model(|cx| HeadlessProject::new(server_ssh, fs.clone(), cx));
-    let project = build_project(client_ssh, cx);
+    let headless =
+        server_cx.new_model(|cx| HeadlessProject::new(ssh_server_client, fs.clone(), cx));
+    let project = build_project(ssh_remote_client, cx);
 
     project
         .update(cx, {
@@ -654,7 +655,7 @@ async fn init_test(
     (project, headless, fs)
 }
 
-fn build_project(ssh: Arc<SshSession>, cx: &mut TestAppContext) -> Model<Project> {
+fn build_project(ssh: Arc<SshRemoteClient>, cx: &mut TestAppContext) -> Model<Project> {
     cx.update(|cx| {
         let settings_store = SettingsStore::test(cx);
         cx.set_global(settings_store);
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index cec913851f04df..b668a5802c3b14 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -61,7 +61,7 @@ use postage::stream::Stream;
 use project::{
     DirectoryLister, Project, ProjectEntryId, ProjectPath, ResolvedPath, Worktree, WorktreeId,
 };
-use remote::{SshConnectionOptions, SshSession};
+use remote::{SshConnectionOptions, SshRemoteClient};
 use serde::Deserialize;
 use session::AppSession;
 use settings::{InvalidSettingsError, Settings};
@@ -5514,7 +5514,7 @@ pub fn join_hosted_project(
 pub fn open_ssh_project(
     window: WindowHandle<Workspace>,
     connection_options: SshConnectionOptions,
-    session: Arc<SshSession>,
+    session: Arc<SshRemoteClient>,
     app_state: Arc<AppState>,
     paths: Vec<PathBuf>,
     cx: &mut AppContext,

From 6336248c1a90d23f08678bf6d30fd84bc1638625 Mon Sep 17 00:00:00 2001
From: Junkui Zhang <364772080@qq.com>
Date: Tue, 1 Oct 2024 18:58:40 +0800
Subject: [PATCH 421/762] windows: Revert "Fix `hide`, `activate` method on
 Windows to hide/show application" (#18571)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR reverts the changes introduced via #18164. As shown in the video
below, once you `hide` the app, there is essentially no way to bring it
back. I must emphasize that the window logic on Windows is entirely
different from macOS. On macOS, when you `hide` an app, its icon always
remains visible in the dock, and you can always bring the hidden app
back by clicking that icon. However, on Windows, there is no such
mechanism—the app is literally hidden.

I think the `hide` feature should be macOS-only.



https://github.com/user-attachments/assets/65c8a007-eedb-4444-9499-787b50f2d1e9



Release Notes:

- N/A
---
 crates/gpui/src/platform/windows/platform.rs | 24 ++------------------
 1 file changed, 2 insertions(+), 22 deletions(-)

diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs
index 7f6677973b2fbd..e90b2c6ef1bedc 100644
--- a/crates/gpui/src/platform/windows/platform.rs
+++ b/crates/gpui/src/platform/windows/platform.rs
@@ -33,8 +33,6 @@ use crate::*;
 pub(crate) struct WindowsPlatform {
     state: RefCell<WindowsPlatformState>,
     raw_window_handles: RwLock<SmallVec<[HWND; 4]>>,
-    // The window handles that are hided by `hide` method.
-    hidden_windows: RwLock<SmallVec<[HWND; 4]>>,
     // The below members will never change throughout the entire lifecycle of the app.
     icon: HICON,
     main_receiver: flume::Receiver<Runnable>,
@@ -102,7 +100,6 @@ impl WindowsPlatform {
         Self {
             state,
             raw_window_handles,
-            hidden_windows: RwLock::new(SmallVec::new()),
             icon,
             main_receiver,
             dispatch_event,
@@ -298,26 +295,9 @@ impl Platform for WindowsPlatform {
         }
     }
 
-    fn activate(&self, _ignoring_other_apps: bool) {
-        let mut state = self.hidden_windows.write();
-        state.iter().for_each(|handle| unsafe {
-            ShowWindow(*handle, SW_SHOW).ok().log_err();
-        });
-        state.clear();
-    }
+    fn activate(&self, _ignoring_other_apps: bool) {}
 
-    fn hide(&self) {
-        let mut state = self.hidden_windows.write();
-        self.raw_window_handles
-            .read()
-            .iter()
-            .for_each(|handle| unsafe {
-                if IsWindowVisible(*handle).as_bool() {
-                    state.push(*handle);
-                    ShowWindow(*handle, SW_HIDE).ok().log_err();
-                }
-            });
-    }
+    fn hide(&self) {}
 
     // todo(windows)
     fn hide_other_apps(&self) {

From 1be24f77396aaade46739218e70cb059491aaedf Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 1 Oct 2024 09:31:03 -0400
Subject: [PATCH 422/762] Rename proto language to Proto (#18559)

All the other languages are capitalized. Proto should be too.
---
 crates/languages/src/proto/config.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/languages/src/proto/config.toml b/crates/languages/src/proto/config.toml
index b8bccfd39b6a39..6d25c23da5dfaa 100644
--- a/crates/languages/src/proto/config.toml
+++ b/crates/languages/src/proto/config.toml
@@ -1,4 +1,4 @@
-name = "proto"
+name = "Proto"
 grammar = "proto"
 path_suffixes = ["proto"]
 line_comments = ["// "]

From 68d6177d370defa04be8f989240ab9e8a8e8c79f Mon Sep 17 00:00:00 2001
From: pantheraleo-7 <159872817+pantheraleo-7@users.noreply.github.com>
Date: Tue, 1 Oct 2024 20:39:34 +0530
Subject: [PATCH 423/762] docs: Correct typo in `configuring-zed.md` (#18580)

Release Notes:

- N/A
---
 docs/src/configuring-zed.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index ad6a628ed0880f..1e531f7c744d18 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -1736,7 +1736,7 @@ See Buffer Font Features
 
 ## Terminal: Detect Virtual Environments {#terminal-detect_venv}
 
-- Description: Activate the [Python Virtual Environment](https://docs.python.org/3/library/venv.html), if one is found, in the terminal's working directory (as resolved by the working_directory and automatically activating the virtual environemtn
+- Description: Activate the [Python Virtual Environment](https://docs.python.org/3/library/venv.html), if one is found, in the terminal's working directory (as resolved by the working_directory and automatically activating the virtual environment.
 - Setting: `detect_venv`
 - Default:
 

From 051627c4493b5f5446cb3957576be89899b1d386 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Tue, 1 Oct 2024 18:32:16 +0300
Subject: [PATCH 424/762] Project panel horizontal scrollbar (#18513)

<img width="389" alt="image"
src="https://github.com/user-attachments/assets/c6718c6e-0fe1-40ed-b3db-7d576c4d98c8">


https://github.com/user-attachments/assets/734f1f52-70d9-4308-b1fc-36c7cfd4dd76

Closes https://github.com/zed-industries/zed/issues/7001
Closes https://github.com/zed-industries/zed/issues/4427
Part of https://github.com/zed-industries/zed/issues/15324
Part of https://github.com/zed-industries/zed/issues/14551

* Adjusts a `UniformList` to have a horizontal sizing behavior: the old
mode forced all items to have the size of the list exactly.
A new mode (with corresponding `ListItems` having `overflow_x` enabled)
lays out the uniform list elements with width of its widest element,
setting the same width to the list itself too.

* Using the new behavior, adds a new scrollbar into the project panel
and enhances its file name editor to scroll it during editing of long
file names

* Also restyles the scrollbar a bit, making it narrower and removing its
background

* Changes the project_panel.scrollbar.show settings to accept `null` and
be `null` by default, to inherit `editor`'s scrollbar settings. All
editor scrollbar settings are supported now.

Release Notes:

- Added a horizontal scrollbar to project panel
([#7001](https://github.com/zed-industries/zed/issues/7001))
([#4427](https://github.com/zed-industries/zed/issues/4427))

---------

Co-authored-by: Piotr Osiewicz <piotr@zed.dev>
---
 assets/settings/default.json                  |  14 +-
 crates/editor/src/editor.rs                   |   2 +-
 crates/gpui/src/elements/div.rs               |  19 +-
 crates/gpui/src/elements/list.rs              |  10 +
 crates/gpui/src/elements/uniform_list.rs      |  96 ++++-
 crates/gpui/src/style.rs                      |   3 +
 crates/language/src/language_settings.rs      |   2 +-
 crates/project_panel/src/project_panel.rs     | 335 +++++++++++++++---
 .../src/project_panel_settings.rs             |  22 +-
 crates/project_panel/src/scrollbar.rs         | 192 +++++++---
 crates/ui/src/components/list/list_item.rs    |  15 +-
 docs/src/configuring-zed.md                   |   6 +-
 12 files changed, 567 insertions(+), 149 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index f6c498e0278e6a..133ff9451d027b 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -356,9 +356,19 @@
     /// Scrollbar-related settings
     "scrollbar": {
       /// When to show the scrollbar in the project panel.
+      /// This setting can take four values:
       ///
-      /// Default: always
-      "show": "always"
+      /// 1. null (default): Inherit editor settings
+      /// 2. Show the scrollbar if there's important information or
+      ///    follow the system's configured behavior (default):
+      ///   "auto"
+      /// 3. Match the system's configured behavior:
+      ///    "system"
+      /// 4. Always show the scrollbar:
+      ///    "always"
+      /// 5. Never show the scrollbar:
+      ///    "never"
+      "show": null
     }
   },
   "outline_panel": {
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index d1ca70f705ce56..61a47d7f631fd8 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -61,7 +61,7 @@ use debounced_delay::DebouncedDelay;
 use display_map::*;
 pub use display_map::{DisplayPoint, FoldPlaceholder};
 pub use editor_settings::{
-    CurrentLineHighlight, EditorSettings, ScrollBeyondLastLine, SearchSettings,
+    CurrentLineHighlight, EditorSettings, ScrollBeyondLastLine, SearchSettings, ShowScrollbar,
 };
 pub use editor_settings_controls::*;
 use element::LineWithInvisibles;
diff --git a/crates/gpui/src/elements/div.rs b/crates/gpui/src/elements/div.rs
index 4e92f7f82c4cb4..284e574627631f 100644
--- a/crates/gpui/src/elements/div.rs
+++ b/crates/gpui/src/elements/div.rs
@@ -2057,6 +2057,7 @@ impl Interactivity {
     fn paint_scroll_listener(&self, hitbox: &Hitbox, style: &Style, cx: &mut WindowContext) {
         if let Some(scroll_offset) = self.scroll_offset.clone() {
             let overflow = style.overflow;
+            let allow_concurrent_scroll = style.allow_concurrent_scroll;
             let line_height = cx.line_height();
             let hitbox = hitbox.clone();
             cx.on_mouse_event(move |event: &ScrollWheelEvent, phase, cx| {
@@ -2065,27 +2066,31 @@ impl Interactivity {
                     let old_scroll_offset = *scroll_offset;
                     let delta = event.delta.pixel_delta(line_height);
 
+                    let mut delta_x = Pixels::ZERO;
                     if overflow.x == Overflow::Scroll {
-                        let mut delta_x = Pixels::ZERO;
                         if !delta.x.is_zero() {
                             delta_x = delta.x;
                         } else if overflow.y != Overflow::Scroll {
                             delta_x = delta.y;
                         }
-
-                        scroll_offset.x += delta_x;
                     }
-
+                    let mut delta_y = Pixels::ZERO;
                     if overflow.y == Overflow::Scroll {
-                        let mut delta_y = Pixels::ZERO;
                         if !delta.y.is_zero() {
                             delta_y = delta.y;
                         } else if overflow.x != Overflow::Scroll {
                             delta_y = delta.x;
                         }
-
-                        scroll_offset.y += delta_y;
                     }
+                    if !allow_concurrent_scroll && !delta_x.is_zero() && !delta_y.is_zero() {
+                        if delta_x.abs() > delta_y.abs() {
+                            delta_y = Pixels::ZERO;
+                        } else {
+                            delta_x = Pixels::ZERO;
+                        }
+                    }
+                    scroll_offset.y += delta_y;
+                    scroll_offset.x += delta_x;
 
                     cx.stop_propagation();
                     if *scroll_offset != old_scroll_offset {
diff --git a/crates/gpui/src/elements/list.rs b/crates/gpui/src/elements/list.rs
index 6ac6d2a9bf8d7d..d77c91e6552d31 100644
--- a/crates/gpui/src/elements/list.rs
+++ b/crates/gpui/src/elements/list.rs
@@ -89,6 +89,16 @@ pub enum ListSizingBehavior {
     Auto,
 }
 
+/// The horizontal sizing behavior to apply during layout.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ListHorizontalSizingBehavior {
+    /// List items' width can never exceed the width of the list.
+    #[default]
+    FitList,
+    /// List items' width may go over the width of the list, if any item is wider.
+    Unconstrained,
+}
+
 struct LayoutItemsResponse {
     max_item_width: Pixels,
     scroll_top: ListOffset,
diff --git a/crates/gpui/src/elements/uniform_list.rs b/crates/gpui/src/elements/uniform_list.rs
index 4dc2f5335deddd..54297d1214f3f9 100644
--- a/crates/gpui/src/elements/uniform_list.rs
+++ b/crates/gpui/src/elements/uniform_list.rs
@@ -5,8 +5,8 @@
 //! elements with uniform height.
 
 use crate::{
-    point, px, size, AnyElement, AvailableSpace, Bounds, ContentMask, Element, ElementId,
-    GlobalElementId, Hitbox, InteractiveElement, Interactivity, IntoElement, LayoutId,
+    point, size, AnyElement, AvailableSpace, Bounds, ContentMask, Element, ElementId,
+    GlobalElementId, Hitbox, InteractiveElement, Interactivity, IntoElement, IsZero, LayoutId,
     ListSizingBehavior, Pixels, Render, ScrollHandle, Size, StyleRefinement, Styled, View,
     ViewContext, WindowContext,
 };
@@ -14,6 +14,8 @@ use smallvec::SmallVec;
 use std::{cell::RefCell, cmp, ops::Range, rc::Rc};
 use taffy::style::Overflow;
 
+use super::ListHorizontalSizingBehavior;
+
 /// uniform_list provides lazy rendering for a set of items that are of uniform height.
 /// When rendered into a container with overflow-y: hidden and a fixed (or max) height,
 /// uniform_list will only render the visible subset of items.
@@ -57,6 +59,7 @@ where
         },
         scroll_handle: None,
         sizing_behavior: ListSizingBehavior::default(),
+        horizontal_sizing_behavior: ListHorizontalSizingBehavior::default(),
     }
 }
 
@@ -69,11 +72,11 @@ pub struct UniformList {
     interactivity: Interactivity,
     scroll_handle: Option<UniformListScrollHandle>,
     sizing_behavior: ListSizingBehavior,
+    horizontal_sizing_behavior: ListHorizontalSizingBehavior,
 }
 
 /// Frame state used by the [UniformList].
 pub struct UniformListFrameState {
-    item_size: Size<Pixels>,
     items: SmallVec<[AnyElement; 32]>,
 }
 
@@ -87,7 +90,18 @@ pub struct UniformListScrollHandle(pub Rc<RefCell<UniformListScrollState>>);
 pub struct UniformListScrollState {
     pub base_handle: ScrollHandle,
     pub deferred_scroll_to_item: Option<usize>,
-    pub last_item_height: Option<Pixels>,
+    /// Size of the item, captured during last layout.
+    pub last_item_size: Option<ItemSize>,
+}
+
+#[derive(Copy, Clone, Debug, Default)]
+/// The size of the item and its contents.
+pub struct ItemSize {
+    /// The size of the item.
+    pub item: Size<Pixels>,
+    /// The size of the item's contents, which may be larger than the item itself,
+    /// if the item was bounded by a parent element.
+    pub contents: Size<Pixels>,
 }
 
 impl UniformListScrollHandle {
@@ -96,7 +110,7 @@ impl UniformListScrollHandle {
         Self(Rc::new(RefCell::new(UniformListScrollState {
             base_handle: ScrollHandle::new(),
             deferred_scroll_to_item: None,
-            last_item_height: None,
+            last_item_size: None,
         })))
     }
 
@@ -170,7 +184,6 @@ impl Element for UniformList {
         (
             layout_id,
             UniformListFrameState {
-                item_size,
                 items: SmallVec::new(),
             },
         )
@@ -193,17 +206,30 @@ impl Element for UniformList {
                 - point(border.right + padding.right, border.bottom + padding.bottom),
         );
 
+        let can_scroll_horizontally = matches!(
+            self.horizontal_sizing_behavior,
+            ListHorizontalSizingBehavior::Unconstrained
+        );
+
+        let longest_item_size = self.measure_item(None, cx);
+        let content_width = if can_scroll_horizontally {
+            padded_bounds.size.width.max(longest_item_size.width)
+        } else {
+            padded_bounds.size.width
+        };
         let content_size = Size {
-            width: padded_bounds.size.width,
-            height: frame_state.item_size.height * self.item_count + padding.top + padding.bottom,
+            width: content_width,
+            height: longest_item_size.height * self.item_count + padding.top + padding.bottom,
         };
 
         let shared_scroll_offset = self.interactivity.scroll_offset.clone().unwrap();
-
-        let item_height = self.measure_item(Some(padded_bounds.size.width), cx).height;
+        let item_height = longest_item_size.height;
         let shared_scroll_to_item = self.scroll_handle.as_mut().and_then(|handle| {
             let mut handle = handle.0.borrow_mut();
-            handle.last_item_height = Some(item_height);
+            handle.last_item_size = Some(ItemSize {
+                item: padded_bounds.size,
+                contents: content_size,
+            });
             handle.deferred_scroll_to_item.take()
         });
 
@@ -228,12 +254,19 @@ impl Element for UniformList {
                 if self.item_count > 0 {
                     let content_height =
                         item_height * self.item_count + padding.top + padding.bottom;
-                    let min_scroll_offset = padded_bounds.size.height - content_height;
-                    let is_scrolled = scroll_offset.y != px(0.);
+                    let is_scrolled_vertically = !scroll_offset.y.is_zero();
+                    let min_vertical_scroll_offset = padded_bounds.size.height - content_height;
+                    if is_scrolled_vertically && scroll_offset.y < min_vertical_scroll_offset {
+                        shared_scroll_offset.borrow_mut().y = min_vertical_scroll_offset;
+                        scroll_offset.y = min_vertical_scroll_offset;
+                    }
 
-                    if is_scrolled && scroll_offset.y < min_scroll_offset {
-                        shared_scroll_offset.borrow_mut().y = min_scroll_offset;
-                        scroll_offset.y = min_scroll_offset;
+                    let content_width = content_size.width + padding.left + padding.right;
+                    let is_scrolled_horizontally =
+                        can_scroll_horizontally && !scroll_offset.x.is_zero();
+                    if is_scrolled_horizontally && content_width <= padded_bounds.size.width {
+                        shared_scroll_offset.borrow_mut().x = Pixels::ZERO;
+                        scroll_offset.x = Pixels::ZERO;
                     }
 
                     if let Some(ix) = shared_scroll_to_item {
@@ -263,9 +296,17 @@ impl Element for UniformList {
                     cx.with_content_mask(Some(content_mask), |cx| {
                         for (mut item, ix) in items.into_iter().zip(visible_range) {
                             let item_origin = padded_bounds.origin
-                                + point(px(0.), item_height * ix + scroll_offset.y + padding.top);
+                                + point(
+                                    scroll_offset.x + padding.left,
+                                    item_height * ix + scroll_offset.y + padding.top,
+                                );
+                            let available_width = if can_scroll_horizontally {
+                                padded_bounds.size.width + scroll_offset.x.abs()
+                            } else {
+                                padded_bounds.size.width
+                            };
                             let available_space = size(
-                                AvailableSpace::Definite(padded_bounds.size.width),
+                                AvailableSpace::Definite(available_width),
                                 AvailableSpace::Definite(item_height),
                             );
                             item.layout_as_root(available_space, cx);
@@ -318,6 +359,25 @@ impl UniformList {
         self
     }
 
+    /// Sets the horizontal sizing behavior, controlling the way list items laid out horizontally.
+    /// With [`ListHorizontalSizingBehavior::Unconstrained`] behavior, every item and the list itself will
+    /// have the size of the widest item and lay out pushing the `end_slot` to the right end.
+    pub fn with_horizontal_sizing_behavior(
+        mut self,
+        behavior: ListHorizontalSizingBehavior,
+    ) -> Self {
+        self.horizontal_sizing_behavior = behavior;
+        match behavior {
+            ListHorizontalSizingBehavior::FitList => {
+                self.interactivity.base_style.overflow.x = None;
+            }
+            ListHorizontalSizingBehavior::Unconstrained => {
+                self.interactivity.base_style.overflow.x = Some(Overflow::Scroll);
+            }
+        }
+        self
+    }
+
     fn measure_item(&self, list_width: Option<Pixels>, cx: &mut WindowContext) -> Size<Pixels> {
         if self.item_count == 0 {
             return Size::default();
diff --git a/crates/gpui/src/style.rs b/crates/gpui/src/style.rs
index c3148fcfa8b4bd..455a2e162d563e 100644
--- a/crates/gpui/src/style.rs
+++ b/crates/gpui/src/style.rs
@@ -156,6 +156,8 @@ pub struct Style {
     pub overflow: Point<Overflow>,
     /// How much space (in points) should be reserved for the scrollbars of `Overflow::Scroll` and `Overflow::Auto` nodes.
     pub scrollbar_width: f32,
+    /// Whether both x and y axis should be scrollable at the same time.
+    pub allow_concurrent_scroll: bool,
 
     // Position properties
     /// What should the `position` value of this struct use as a base offset?
@@ -667,6 +669,7 @@ impl Default for Style {
                 x: Overflow::Visible,
                 y: Overflow::Visible,
             },
+            allow_concurrent_scroll: false,
             scrollbar_width: 0.0,
             position: Position::Relative,
             inset: Edges::auto(),
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index d610ab09865ce3..de37e52290bf46 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -381,7 +381,7 @@ pub struct FeaturesContent {
 pub enum SoftWrap {
     /// Prefer a single line generally, unless an overly long line is encountered.
     None,
-    /// Deprecated: use None instead. Left to avoid breakin existing users' configs.
+    /// Deprecated: use None instead. Left to avoid breaking existing users' configs.
     /// Prefer a single line generally, unless an overly long line is encountered.
     PreferLine,
     /// Soft wrap lines that exceed the editor width.
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 6958bfb3318e23..53b274ee6fa964 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -8,20 +8,22 @@ use db::kvp::KEY_VALUE_STORE;
 use editor::{
     items::entry_git_aware_label_color,
     scroll::{Autoscroll, ScrollbarAutoHide},
-    Editor,
+    Editor, EditorEvent, EditorSettings, ShowScrollbar,
 };
 use file_icons::FileIcons;
 
-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, Context as _, Result};
 use collections::{hash_map, BTreeSet, HashMap};
+use core::f32;
 use git::repository::GitFileStatus;
 use gpui::{
     actions, anchored, deferred, div, impl_actions, px, uniform_list, Action, AnyElement,
     AppContext, AssetSource, AsyncWindowContext, ClipboardItem, DismissEvent, Div, DragMoveEvent,
-    EventEmitter, ExternalPaths, FocusHandle, FocusableView, InteractiveElement, KeyContext,
-    ListSizingBehavior, Model, MouseButton, MouseDownEvent, ParentElement, Pixels, Point,
-    PromptLevel, Render, Stateful, Styled, Subscription, Task, UniformListScrollHandle, View,
-    ViewContext, VisualContext as _, WeakView, WindowContext,
+    Entity, EventEmitter, ExternalPaths, FocusHandle, FocusableView, InteractiveElement,
+    KeyContext, ListHorizontalSizingBehavior, ListSizingBehavior, Model, MouseButton,
+    MouseDownEvent, ParentElement, Pixels, Point, PromptLevel, Render, Stateful, Styled,
+    Subscription, Task, UniformListScrollHandle, View, ViewContext, VisualContext as _, WeakView,
+    WindowContext,
 };
 use indexmap::IndexMap;
 use menu::{Confirm, SelectFirst, SelectLast, SelectNext, SelectPrev};
@@ -29,7 +31,7 @@ use project::{
     relativize_path, Entry, EntryKind, Fs, Project, ProjectEntryId, ProjectPath, Worktree,
     WorktreeId,
 };
-use project_panel_settings::{ProjectPanelDockPosition, ProjectPanelSettings, ShowScrollbar};
+use project_panel_settings::{ProjectPanelDockPosition, ProjectPanelSettings};
 use serde::{Deserialize, Serialize};
 use std::{
     cell::{Cell, OnceCell},
@@ -80,8 +82,10 @@ pub struct ProjectPanel {
     width: Option<Pixels>,
     pending_serialization: Task<Option<()>>,
     show_scrollbar: bool,
-    scrollbar_drag_thumb_offset: Rc<Cell<Option<f32>>>,
+    vertical_scrollbar_drag_thumb_offset: Rc<Cell<Option<f32>>>,
+    horizontal_scrollbar_drag_thumb_offset: Rc<Cell<Option<f32>>>,
     hide_scrollbar_task: Option<Task<()>>,
+    max_width_item_index: Option<usize>,
 }
 
 #[derive(Clone, Debug)]
@@ -90,6 +94,8 @@ struct EditState {
     entry_id: ProjectEntryId,
     is_new_entry: bool,
     is_dir: bool,
+    is_symlink: bool,
+    depth: usize,
     processing_filename: Option<String>,
 }
 
@@ -254,23 +260,26 @@ impl ProjectPanel {
 
             let filename_editor = cx.new_view(Editor::single_line);
 
-            cx.subscribe(&filename_editor, |this, _, event, cx| match event {
-                editor::EditorEvent::BufferEdited
-                | editor::EditorEvent::SelectionsChanged { .. } => {
-                    this.autoscroll(cx);
-                }
-                editor::EditorEvent::Blurred => {
-                    if this
-                        .edit_state
-                        .as_ref()
-                        .map_or(false, |state| state.processing_filename.is_none())
-                    {
-                        this.edit_state = None;
-                        this.update_visible_entries(None, cx);
+            cx.subscribe(
+                &filename_editor,
+                |project_panel, _, editor_event, cx| match editor_event {
+                    EditorEvent::BufferEdited | EditorEvent::SelectionsChanged { .. } => {
+                        project_panel.autoscroll(cx);
                     }
-                }
-                _ => {}
-            })
+                    EditorEvent::Blurred => {
+                        if project_panel
+                            .edit_state
+                            .as_ref()
+                            .map_or(false, |state| state.processing_filename.is_none())
+                        {
+                            project_panel.edit_state = None;
+                            project_panel.update_visible_entries(None, cx);
+                            cx.notify();
+                        }
+                    }
+                    _ => {}
+                },
+            )
             .detach();
 
             cx.observe_global::<FileIcons>(|_, cx| {
@@ -311,7 +320,9 @@ impl ProjectPanel {
                 pending_serialization: Task::ready(None),
                 show_scrollbar: !Self::should_autohide_scrollbar(cx),
                 hide_scrollbar_task: None,
-                scrollbar_drag_thumb_offset: Default::default(),
+                vertical_scrollbar_drag_thumb_offset: Default::default(),
+                horizontal_scrollbar_drag_thumb_offset: Default::default(),
+                max_width_item_index: None,
             };
             this.update_visible_entries(None, cx);
 
@@ -827,7 +838,7 @@ impl ProjectPanel {
         Some(cx.spawn(|project_panel, mut cx| async move {
             let new_entry = edit_task.await;
             project_panel.update(&mut cx, |project_panel, cx| {
-                project_panel.edit_state.take();
+                project_panel.edit_state = None;
                 cx.notify();
             })?;
 
@@ -970,6 +981,8 @@ impl ProjectPanel {
                 is_new_entry: true,
                 is_dir,
                 processing_filename: None,
+                is_symlink: false,
+                depth: 0,
             });
             self.filename_editor.update(cx, |editor, cx| {
                 editor.clear(cx);
@@ -992,6 +1005,7 @@ impl ProjectPanel {
             leaf_entry_id
         }
     }
+
     fn rename(&mut self, _: &Rename, cx: &mut ViewContext<Self>) {
         if let Some(SelectedEntry {
             worktree_id,
@@ -1007,6 +1021,8 @@ impl ProjectPanel {
                         is_new_entry: false,
                         is_dir: entry.is_dir(),
                         processing_filename: None,
+                        is_symlink: entry.is_symlink,
+                        depth: 0,
                     });
                     let file_name = entry
                         .path
@@ -1750,6 +1766,7 @@ impl ProjectPanel {
 
         let old_ancestors = std::mem::take(&mut self.ancestors);
         self.visible_entries.clear();
+        let mut max_width_item = None;
         for worktree in project.visible_worktrees(cx) {
             let snapshot = worktree.read(cx).snapshot();
             let worktree_id = snapshot.id();
@@ -1805,6 +1822,12 @@ impl ProjectPanel {
                         .get(&entry.id)
                         .map(|ancestor| ancestor.current_ancestor_depth)
                         .unwrap_or_default();
+                    if let Some(edit_state) = &mut self.edit_state {
+                        if edit_state.entry_id == entry.id {
+                            edit_state.is_symlink = entry.is_symlink;
+                            edit_state.depth = depth;
+                        }
+                    }
                     let mut ancestors = std::mem::take(&mut auto_folded_ancestors);
                     if ancestors.len() > 1 {
                         ancestors.reverse();
@@ -1837,6 +1860,78 @@ impl ProjectPanel {
                         is_fifo: entry.is_fifo,
                     });
                 }
+                let worktree_abs_path = worktree.read(cx).abs_path();
+                let (depth, path) = if Some(entry) == worktree.read(cx).root_entry() {
+                    let Some(path_name) = worktree_abs_path
+                        .file_name()
+                        .with_context(|| {
+                            format!("Worktree abs path has no file name, root entry: {entry:?}")
+                        })
+                        .log_err()
+                    else {
+                        continue;
+                    };
+                    let path = Arc::from(Path::new(path_name));
+                    let depth = 0;
+                    (depth, path)
+                } else if entry.is_file() {
+                    let Some(path_name) = entry
+                        .path
+                        .file_name()
+                        .with_context(|| format!("Non-root entry has no file name: {entry:?}"))
+                        .log_err()
+                    else {
+                        continue;
+                    };
+                    let path = Arc::from(Path::new(path_name));
+                    let depth = entry.path.ancestors().count() - 1;
+                    (depth, path)
+                } else {
+                    let path = self
+                        .ancestors
+                        .get(&entry.id)
+                        .and_then(|ancestors| {
+                            let outermost_ancestor = ancestors.ancestors.last()?;
+                            let root_folded_entry = worktree
+                                .read(cx)
+                                .entry_for_id(*outermost_ancestor)?
+                                .path
+                                .as_ref();
+                            entry
+                                .path
+                                .strip_prefix(root_folded_entry)
+                                .ok()
+                                .and_then(|suffix| {
+                                    let full_path = Path::new(root_folded_entry.file_name()?);
+                                    Some(Arc::<Path>::from(full_path.join(suffix)))
+                                })
+                        })
+                        .unwrap_or_else(|| entry.path.clone());
+                    let depth = path
+                        .strip_prefix(worktree_abs_path)
+                        .map(|suffix| suffix.components().count())
+                        .unwrap_or_default();
+                    (depth, path)
+                };
+                let width_estimate = item_width_estimate(
+                    depth,
+                    path.to_string_lossy().chars().count(),
+                    entry.is_symlink,
+                );
+
+                match max_width_item.as_mut() {
+                    Some((id, worktree_id, width)) => {
+                        if *width < width_estimate {
+                            *id = entry.id;
+                            *worktree_id = worktree.read(cx).id();
+                            *width = width_estimate;
+                        }
+                    }
+                    None => {
+                        max_width_item = Some((entry.id, worktree.read(cx).id(), width_estimate))
+                    }
+                }
+
                 if expanded_dir_ids.binary_search(&entry.id).is_err()
                     && entry_iter.advance_to_sibling()
                 {
@@ -1851,6 +1946,22 @@ impl ProjectPanel {
                 .push((worktree_id, visible_worktree_entries, OnceCell::new()));
         }
 
+        if let Some((project_entry_id, worktree_id, _)) = max_width_item {
+            let mut visited_worktrees_length = 0;
+            let index = self.visible_entries.iter().find_map(|(id, entries, _)| {
+                if worktree_id == *id {
+                    entries
+                        .iter()
+                        .position(|entry| entry.id == project_entry_id)
+                } else {
+                    visited_worktrees_length += entries.len();
+                    None
+                }
+            });
+            if let Some(index) = index {
+                self.max_width_item_index = Some(visited_worktrees_length + index);
+            }
+        }
         if let Some((worktree_id, entry_id)) = new_selected_entry {
             self.selection = Some(SelectedEntry {
                 worktree_id,
@@ -2474,7 +2585,8 @@ impl ProjectPanel {
                             cx.stop_propagation();
                             this.deploy_context_menu(event.position, entry_id, cx);
                         },
-                    )),
+                    ))
+                    .overflow_x(),
             )
             .border_1()
             .border_r_2()
@@ -2498,22 +2610,19 @@ impl ProjectPanel {
             )
     }
 
-    fn render_scrollbar(
-        &self,
-        items_count: usize,
-        cx: &mut ViewContext<Self>,
-    ) -> Option<Stateful<Div>> {
-        let settings = ProjectPanelSettings::get_global(cx);
-        if settings.scrollbar.show == ShowScrollbar::Never {
+    fn render_vertical_scrollbar(&self, cx: &mut ViewContext<Self>) -> Option<Stateful<Div>> {
+        if !Self::should_show_scrollbar(cx) {
             return None;
         }
         let scroll_handle = self.scroll_handle.0.borrow();
-
-        let height = scroll_handle
-            .last_item_height
-            .filter(|_| self.show_scrollbar || self.scrollbar_drag_thumb_offset.get().is_some())?;
-
-        let total_list_length = height.0 as f64 * items_count as f64;
+        let total_list_length = scroll_handle
+            .last_item_size
+            .filter(|_| {
+                self.show_scrollbar || self.vertical_scrollbar_drag_thumb_offset.get().is_some()
+            })?
+            .contents
+            .height
+            .0 as f64;
         let current_offset = scroll_handle.base_handle.offset().y.0.min(0.).abs() as f64;
         let mut percentage = current_offset / total_list_length;
         let end_offset = (current_offset + scroll_handle.base_handle.bounds().size.height.0 as f64)
@@ -2536,7 +2645,7 @@ impl ProjectPanel {
         Some(
             div()
                 .occlude()
-                .id("project-panel-scroll")
+                .id("project-panel-vertical-scroll")
                 .on_mouse_move(cx.listener(|_, _, cx| {
                     cx.notify();
                     cx.stop_propagation()
@@ -2550,7 +2659,7 @@ impl ProjectPanel {
                 .on_mouse_up(
                     MouseButton::Left,
                     cx.listener(|this, _, cx| {
-                        if this.scrollbar_drag_thumb_offset.get().is_none()
+                        if this.vertical_scrollbar_drag_thumb_offset.get().is_none()
                             && !this.focus_handle.contains_focused(cx)
                         {
                             this.hide_scrollbar(cx);
@@ -2565,21 +2674,101 @@ impl ProjectPanel {
                 }))
                 .h_full()
                 .absolute()
-                .right_0()
-                .top_0()
-                .bottom_0()
+                .right_1()
+                .top_1()
+                .bottom_1()
                 .w(px(12.))
                 .cursor_default()
-                .child(ProjectPanelScrollbar::new(
+                .child(ProjectPanelScrollbar::vertical(
                     percentage as f32..end_offset as f32,
                     self.scroll_handle.clone(),
-                    self.scrollbar_drag_thumb_offset.clone(),
-                    cx.view().clone().into(),
-                    items_count,
+                    self.vertical_scrollbar_drag_thumb_offset.clone(),
+                    cx.view().entity_id(),
                 )),
         )
     }
 
+    fn render_horizontal_scrollbar(&self, cx: &mut ViewContext<Self>) -> Option<Stateful<Div>> {
+        if !Self::should_show_scrollbar(cx) {
+            return None;
+        }
+        let scroll_handle = self.scroll_handle.0.borrow();
+        let longest_item_width = scroll_handle
+            .last_item_size
+            .filter(|_| {
+                self.show_scrollbar || self.horizontal_scrollbar_drag_thumb_offset.get().is_some()
+            })
+            .filter(|size| size.contents.width > size.item.width)?
+            .contents
+            .width
+            .0 as f64;
+        let current_offset = scroll_handle.base_handle.offset().x.0.min(0.).abs() as f64;
+        let mut percentage = current_offset / longest_item_width;
+        let end_offset = (current_offset + scroll_handle.base_handle.bounds().size.width.0 as f64)
+            / longest_item_width;
+        // Uniform scroll handle might briefly report an offset greater than the length of a list;
+        // in such case we'll adjust the starting offset as well to keep the scrollbar thumb length stable.
+        let overshoot = (end_offset - 1.).clamp(0., 1.);
+        if overshoot > 0. {
+            percentage -= overshoot;
+        }
+        const MINIMUM_SCROLLBAR_PERCENTAGE_WIDTH: f64 = 0.005;
+        if percentage + MINIMUM_SCROLLBAR_PERCENTAGE_WIDTH > 1.0 || end_offset > longest_item_width
+        {
+            return None;
+        }
+        if longest_item_width < scroll_handle.base_handle.bounds().size.width.0 as f64 {
+            return None;
+        }
+        let end_offset = end_offset.clamp(percentage + MINIMUM_SCROLLBAR_PERCENTAGE_WIDTH, 1.);
+        Some(
+            div()
+                .occlude()
+                .id("project-panel-horizontal-scroll")
+                .on_mouse_move(cx.listener(|_, _, cx| {
+                    cx.notify();
+                    cx.stop_propagation()
+                }))
+                .on_hover(|_, cx| {
+                    cx.stop_propagation();
+                })
+                .on_any_mouse_down(|_, cx| {
+                    cx.stop_propagation();
+                })
+                .on_mouse_up(
+                    MouseButton::Left,
+                    cx.listener(|this, _, cx| {
+                        if this.horizontal_scrollbar_drag_thumb_offset.get().is_none()
+                            && !this.focus_handle.contains_focused(cx)
+                        {
+                            this.hide_scrollbar(cx);
+                            cx.notify();
+                        }
+
+                        cx.stop_propagation();
+                    }),
+                )
+                .on_scroll_wheel(cx.listener(|_, _, cx| {
+                    cx.notify();
+                }))
+                .w_full()
+                .absolute()
+                .right_1()
+                .left_1()
+                .bottom_1()
+                .h(px(12.))
+                .cursor_default()
+                .when(self.width.is_some(), |this| {
+                    this.child(ProjectPanelScrollbar::horizontal(
+                        percentage as f32..end_offset as f32,
+                        self.scroll_handle.clone(),
+                        self.horizontal_scrollbar_drag_thumb_offset.clone(),
+                        cx.view().entity_id(),
+                    ))
+                }),
+        )
+    }
+
     fn dispatch_context(&self, cx: &ViewContext<Self>) -> KeyContext {
         let mut dispatch_context = KeyContext::new_with_defaults();
         dispatch_context.add("ProjectPanel");
@@ -2595,9 +2784,32 @@ impl ProjectPanel {
         dispatch_context
     }
 
+    fn should_show_scrollbar(cx: &AppContext) -> bool {
+        let show = ProjectPanelSettings::get_global(cx)
+            .scrollbar
+            .show
+            .unwrap_or_else(|| EditorSettings::get_global(cx).scrollbar.show);
+        match show {
+            ShowScrollbar::Auto => true,
+            ShowScrollbar::System => true,
+            ShowScrollbar::Always => true,
+            ShowScrollbar::Never => false,
+        }
+    }
+
     fn should_autohide_scrollbar(cx: &AppContext) -> bool {
-        cx.try_global::<ScrollbarAutoHide>()
-            .map_or_else(|| cx.should_auto_hide_scrollbars(), |autohide| autohide.0)
+        let show = ProjectPanelSettings::get_global(cx)
+            .scrollbar
+            .show
+            .unwrap_or_else(|| EditorSettings::get_global(cx).scrollbar.show);
+        match show {
+            ShowScrollbar::Auto => true,
+            ShowScrollbar::System => cx
+                .try_global::<ScrollbarAutoHide>()
+                .map_or_else(|| cx.should_auto_hide_scrollbars(), |autohide| autohide.0),
+            ShowScrollbar::Always => false,
+            ShowScrollbar::Never => true,
+        }
     }
 
     fn hide_scrollbar(&mut self, cx: &mut ViewContext<Self>) {
@@ -2623,7 +2835,7 @@ impl ProjectPanel {
         project: Model<Project>,
         entry_id: ProjectEntryId,
         skip_ignored: bool,
-        cx: &mut ViewContext<'_, ProjectPanel>,
+        cx: &mut ViewContext<'_, Self>,
     ) {
         if let Some(worktree) = project.read(cx).worktree_for_entry(entry_id, cx) {
             let worktree = worktree.read(cx);
@@ -2645,13 +2857,22 @@ impl ProjectPanel {
     }
 }
 
+fn item_width_estimate(depth: usize, item_text_chars: usize, is_symlink: bool) -> usize {
+    const ICON_SIZE_FACTOR: usize = 2;
+    let mut item_width = depth * ICON_SIZE_FACTOR + item_text_chars;
+    if is_symlink {
+        item_width += ICON_SIZE_FACTOR;
+    }
+    item_width
+}
+
 impl Render for ProjectPanel {
     fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> impl IntoElement {
         let has_worktree = !self.visible_entries.is_empty();
         let project = self.project.read(cx);
 
         if has_worktree {
-            let items_count = self
+            let item_count = self
                 .visible_entries
                 .iter()
                 .map(|(_, worktree_entries, _)| worktree_entries.len())
@@ -2742,7 +2963,7 @@ impl Render for ProjectPanel {
                 )
                 .track_focus(&self.focus_handle)
                 .child(
-                    uniform_list(cx.view().clone(), "entries", items_count, {
+                    uniform_list(cx.view().clone(), "entries", item_count, {
                         |this, range, cx| {
                             let mut items = Vec::with_capacity(range.end - range.start);
                             this.for_each_visible_entry(range, cx, |id, details, cx| {
@@ -2753,9 +2974,12 @@ impl Render for ProjectPanel {
                     })
                     .size_full()
                     .with_sizing_behavior(ListSizingBehavior::Infer)
+                    .with_horizontal_sizing_behavior(ListHorizontalSizingBehavior::Unconstrained)
+                    .with_width_from_item(self.max_width_item_index)
                     .track_scroll(self.scroll_handle.clone()),
                 )
-                .children(self.render_scrollbar(items_count, cx))
+                .children(self.render_vertical_scrollbar(cx))
+                .children(self.render_horizontal_scrollbar(cx))
                 .children(self.context_menu.as_ref().map(|(menu, position, _)| {
                     deferred(
                         anchored()
@@ -2934,6 +3158,7 @@ mod tests {
     use serde_json::json;
     use settings::SettingsStore;
     use std::path::{Path, PathBuf};
+    use ui::Context;
     use workspace::{
         item::{Item, ProjectItem},
         register_project_item, AppState,
diff --git a/crates/project_panel/src/project_panel_settings.rs b/crates/project_panel/src/project_panel_settings.rs
index 4d73ae92456da9..0114b3968d4db5 100644
--- a/crates/project_panel/src/project_panel_settings.rs
+++ b/crates/project_panel/src/project_panel_settings.rs
@@ -1,3 +1,4 @@
+use editor::ShowScrollbar;
 use gpui::Pixels;
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
@@ -24,33 +25,20 @@ pub struct ProjectPanelSettings {
     pub scrollbar: ScrollbarSettings,
 }
 
-/// When to show the scrollbar in the project panel.
-///
-/// Default: always
-#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum ShowScrollbar {
-    #[default]
-    /// Always show the scrollbar.
-    Always,
-    /// Never show the scrollbar.
-    Never,
-}
-
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 pub struct ScrollbarSettings {
     /// When to show the scrollbar in the project panel.
     ///
-    /// Default: always
-    pub show: ShowScrollbar,
+    /// Default: inherits editor scrollbar settings
+    pub show: Option<ShowScrollbar>,
 }
 
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 pub struct ScrollbarSettingsContent {
     /// When to show the scrollbar in the project panel.
     ///
-    /// Default: always
-    pub show: Option<ShowScrollbar>,
+    /// Default: inherits editor scrollbar settings
+    pub show: Option<Option<ShowScrollbar>>,
 }
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema, Debug)]
diff --git a/crates/project_panel/src/scrollbar.rs b/crates/project_panel/src/scrollbar.rs
index 0da9db7cb794f0..cb7b15386c2070 100644
--- a/crates/project_panel/src/scrollbar.rs
+++ b/crates/project_panel/src/scrollbar.rs
@@ -1,34 +1,54 @@
 use std::{cell::Cell, ops::Range, rc::Rc};
 
 use gpui::{
-    point, AnyView, Bounds, ContentMask, Hitbox, MouseDownEvent, MouseMoveEvent, MouseUpEvent,
-    ScrollWheelEvent, Style, UniformListScrollHandle,
+    point, quad, Bounds, ContentMask, Corners, Edges, EntityId, Hitbox, Hsla, MouseDownEvent,
+    MouseMoveEvent, MouseUpEvent, ScrollWheelEvent, Style, UniformListScrollHandle,
 };
 use ui::{prelude::*, px, relative, IntoElement};
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum ScrollbarKind {
+    Horizontal,
+    Vertical,
+}
+
 pub(crate) struct ProjectPanelScrollbar {
     thumb: Range<f32>,
     scroll: UniformListScrollHandle,
     // If Some(), there's an active drag, offset by percentage from the top of thumb.
     scrollbar_drag_state: Rc<Cell<Option<f32>>>,
-    item_count: usize,
-    view: AnyView,
+    kind: ScrollbarKind,
+    parent_id: EntityId,
 }
 
 impl ProjectPanelScrollbar {
-    pub(crate) fn new(
+    pub(crate) fn vertical(
         thumb: Range<f32>,
         scroll: UniformListScrollHandle,
         scrollbar_drag_state: Rc<Cell<Option<f32>>>,
-        view: AnyView,
-        item_count: usize,
+        parent_id: EntityId,
     ) -> Self {
         Self {
             thumb,
             scroll,
             scrollbar_drag_state,
-            item_count,
-            view,
+            kind: ScrollbarKind::Vertical,
+            parent_id,
+        }
+    }
+
+    pub(crate) fn horizontal(
+        thumb: Range<f32>,
+        scroll: UniformListScrollHandle,
+        scrollbar_drag_state: Rc<Cell<Option<f32>>>,
+        parent_id: EntityId,
+    ) -> Self {
+        Self {
+            thumb,
+            scroll,
+            scrollbar_drag_state,
+            kind: ScrollbarKind::Horizontal,
+            parent_id,
         }
     }
 }
@@ -50,8 +70,14 @@ impl gpui::Element for ProjectPanelScrollbar {
         let mut style = Style::default();
         style.flex_grow = 1.;
         style.flex_shrink = 1.;
-        style.size.width = px(12.).into();
-        style.size.height = relative(1.).into();
+        if self.kind == ScrollbarKind::Vertical {
+            style.size.width = px(12.).into();
+            style.size.height = relative(1.).into();
+        } else {
+            style.size.width = relative(1.).into();
+            style.size.height = px(12.).into();
+        }
+
         (cx.request_layout(style, None), ())
     }
 
@@ -77,25 +103,65 @@ impl gpui::Element for ProjectPanelScrollbar {
     ) {
         cx.with_content_mask(Some(ContentMask { bounds }), |cx| {
             let colors = cx.theme().colors();
-            let scrollbar_background = colors.scrollbar_track_background;
             let thumb_background = colors.scrollbar_thumb_background;
-            cx.paint_quad(gpui::fill(bounds, scrollbar_background));
-
-            let thumb_offset = self.thumb.start * bounds.size.height;
-            let thumb_end = self.thumb.end * bounds.size.height;
+            let is_vertical = self.kind == ScrollbarKind::Vertical;
+            let extra_padding = px(5.0);
+            let padded_bounds = if is_vertical {
+                Bounds::from_corners(
+                    bounds.origin + point(Pixels::ZERO, extra_padding),
+                    bounds.lower_right() - point(Pixels::ZERO, extra_padding * 3),
+                )
+            } else {
+                Bounds::from_corners(
+                    bounds.origin + point(extra_padding, Pixels::ZERO),
+                    bounds.lower_right() - point(extra_padding * 3, Pixels::ZERO),
+                )
+            };
 
-            let thumb_percentage_size = self.thumb.end - self.thumb.start;
-            let thumb_bounds = {
-                let thumb_upper_left = point(bounds.origin.x, bounds.origin.y + thumb_offset);
+            let mut thumb_bounds = if is_vertical {
+                let thumb_offset = self.thumb.start * padded_bounds.size.height;
+                let thumb_end = self.thumb.end * padded_bounds.size.height;
+                let thumb_upper_left = point(
+                    padded_bounds.origin.x,
+                    padded_bounds.origin.y + thumb_offset,
+                );
                 let thumb_lower_right = point(
-                    bounds.origin.x + bounds.size.width,
-                    bounds.origin.y + thumb_end,
+                    padded_bounds.origin.x + padded_bounds.size.width,
+                    padded_bounds.origin.y + thumb_end,
                 );
                 Bounds::from_corners(thumb_upper_left, thumb_lower_right)
+            } else {
+                let thumb_offset = self.thumb.start * padded_bounds.size.width;
+                let thumb_end = self.thumb.end * padded_bounds.size.width;
+                let thumb_upper_left = point(
+                    padded_bounds.origin.x + thumb_offset,
+                    padded_bounds.origin.y,
+                );
+                let thumb_lower_right = point(
+                    padded_bounds.origin.x + thumb_end,
+                    padded_bounds.origin.y + padded_bounds.size.height,
+                );
+                Bounds::from_corners(thumb_upper_left, thumb_lower_right)
+            };
+            let corners = if is_vertical {
+                thumb_bounds.size.width /= 1.5;
+                Corners::all(thumb_bounds.size.width / 2.0)
+            } else {
+                thumb_bounds.size.height /= 1.5;
+                Corners::all(thumb_bounds.size.height / 2.0)
             };
-            cx.paint_quad(gpui::fill(thumb_bounds, thumb_background));
+            cx.paint_quad(quad(
+                thumb_bounds,
+                corners,
+                thumb_background,
+                Edges::default(),
+                Hsla::transparent_black(),
+            ));
+
             let scroll = self.scroll.clone();
-            let item_count = self.item_count;
+            let kind = self.kind;
+            let thumb_percentage_size = self.thumb.end - self.thumb.start;
+
             cx.on_mouse_event({
                 let scroll = self.scroll.clone();
                 let is_dragging = self.scrollbar_drag_state.clone();
@@ -103,20 +169,37 @@ impl gpui::Element for ProjectPanelScrollbar {
                     if phase.bubble() && bounds.contains(&event.position) {
                         if !thumb_bounds.contains(&event.position) {
                             let scroll = scroll.0.borrow();
-                            if let Some(last_height) = scroll.last_item_height {
-                                let max_offset = item_count as f32 * last_height;
-                                let percentage =
-                                    (event.position.y - bounds.origin.y) / bounds.size.height;
-
-                                let percentage = percentage.min(1. - thumb_percentage_size);
-                                scroll
-                                    .base_handle
-                                    .set_offset(point(px(0.), -max_offset * percentage));
+                            if let Some(item_size) = scroll.last_item_size {
+                                match kind {
+                                    ScrollbarKind::Horizontal => {
+                                        let percentage = (event.position.x - bounds.origin.x)
+                                            / bounds.size.width;
+                                        let max_offset = item_size.contents.width;
+                                        let percentage = percentage.min(1. - thumb_percentage_size);
+                                        scroll.base_handle.set_offset(point(
+                                            -max_offset * percentage,
+                                            scroll.base_handle.offset().y,
+                                        ));
+                                    }
+                                    ScrollbarKind::Vertical => {
+                                        let percentage = (event.position.y - bounds.origin.y)
+                                            / bounds.size.height;
+                                        let max_offset = item_size.contents.height;
+                                        let percentage = percentage.min(1. - thumb_percentage_size);
+                                        scroll.base_handle.set_offset(point(
+                                            scroll.base_handle.offset().x,
+                                            -max_offset * percentage,
+                                        ));
+                                    }
+                                }
                             }
                         } else {
-                            let thumb_top_offset =
-                                (event.position.y - thumb_bounds.origin.y) / bounds.size.height;
-                            is_dragging.set(Some(thumb_top_offset));
+                            let thumb_offset = if is_vertical {
+                                (event.position.y - thumb_bounds.origin.y) / bounds.size.height
+                            } else {
+                                (event.position.x - thumb_bounds.origin.x) / bounds.size.width
+                            };
+                            is_dragging.set(Some(thumb_offset));
                         }
                     }
                 }
@@ -127,6 +210,7 @@ impl gpui::Element for ProjectPanelScrollbar {
                     if phase.bubble() && bounds.contains(&event.position) {
                         let scroll = scroll.0.borrow_mut();
                         let current_offset = scroll.base_handle.offset();
+
                         scroll
                             .base_handle
                             .set_offset(current_offset + event.delta.pixel_delta(cx.line_height()));
@@ -134,19 +218,39 @@ impl gpui::Element for ProjectPanelScrollbar {
                 }
             });
             let drag_state = self.scrollbar_drag_state.clone();
-            let view_id = self.view.entity_id();
+            let view_id = self.parent_id;
+            let kind = self.kind;
             cx.on_mouse_event(move |event: &MouseMoveEvent, _, cx| {
                 if let Some(drag_state) = drag_state.get().filter(|_| event.dragging()) {
                     let scroll = scroll.0.borrow();
-                    if let Some(last_height) = scroll.last_item_height {
-                        let max_offset = item_count as f32 * last_height;
-                        let percentage =
-                            (event.position.y - bounds.origin.y) / bounds.size.height - drag_state;
+                    if let Some(item_size) = scroll.last_item_size {
+                        match kind {
+                            ScrollbarKind::Horizontal => {
+                                let max_offset = item_size.contents.width;
+                                let percentage = (event.position.x - bounds.origin.x)
+                                    / bounds.size.width
+                                    - drag_state;
+
+                                let percentage = percentage.min(1. - thumb_percentage_size);
+                                scroll.base_handle.set_offset(point(
+                                    -max_offset * percentage,
+                                    scroll.base_handle.offset().y,
+                                ));
+                            }
+                            ScrollbarKind::Vertical => {
+                                let max_offset = item_size.contents.height;
+                                let percentage = (event.position.y - bounds.origin.y)
+                                    / bounds.size.height
+                                    - drag_state;
+
+                                let percentage = percentage.min(1. - thumb_percentage_size);
+                                scroll.base_handle.set_offset(point(
+                                    scroll.base_handle.offset().x,
+                                    -max_offset * percentage,
+                                ));
+                            }
+                        };
 
-                        let percentage = percentage.min(1. - thumb_percentage_size);
-                        scroll
-                            .base_handle
-                            .set_offset(point(px(0.), -max_offset * percentage));
                         cx.notify(view_id);
                     }
                 } else {
diff --git a/crates/ui/src/components/list/list_item.rs b/crates/ui/src/components/list/list_item.rs
index e1c90894fdd3d2..e13fb8ef265ebf 100644
--- a/crates/ui/src/components/list/list_item.rs
+++ b/crates/ui/src/components/list/list_item.rs
@@ -36,6 +36,7 @@ pub struct ListItem {
     on_secondary_mouse_down: Option<Box<dyn Fn(&MouseDownEvent, &mut WindowContext) + 'static>>,
     children: SmallVec<[AnyElement; 2]>,
     selectable: bool,
+    overflow_x: bool,
 }
 
 impl ListItem {
@@ -58,6 +59,7 @@ impl ListItem {
             tooltip: None,
             children: SmallVec::new(),
             selectable: true,
+            overflow_x: false,
         }
     }
 
@@ -131,6 +133,11 @@ impl ListItem {
         self.end_hover_slot = end_hover_slot.into().map(IntoElement::into_any_element);
         self
     }
+
+    pub fn overflow_x(mut self) -> Self {
+        self.overflow_x = true;
+        self
+    }
 }
 
 impl Disableable for ListItem {
@@ -239,7 +246,13 @@ impl RenderOnce for ListItem {
                             .flex_shrink_0()
                             .flex_basis(relative(0.25))
                             .gap(Spacing::Small.rems(cx))
-                            .overflow_hidden()
+                            .map(|list_content| {
+                                if self.overflow_x {
+                                    list_content
+                                } else {
+                                    list_content.overflow_hidden()
+                                }
+                            })
                             .children(self.start_slot)
                             .children(self.children),
                     )
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 1e531f7c744d18..fbd5fa53cfbd84 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -1954,7 +1954,7 @@ Run the `theme selector: toggle` action in the command palette to see a current
     "auto_reveal_entries": true,
     "auto_fold_dirs": true,
     "scrollbar": {
-      "show": "always"
+      "show": null
     }
   }
 }
@@ -2074,13 +2074,13 @@ Run the `theme selector: toggle` action in the command palette to see a current
 
 ### Scrollbar
 
-- Description: Scrollbar related settings. Possible values: "always", "never".
+- Description: Scrollbar related settings. Possible values: null, "auto", "system", "always", "never". Inherits editor settings when absent, see its description for more details.
 - Setting: `scrollbar`
 - Default:
 
 ```json
 "scrollbar": {
-    "show": "always"
+    "show": null
 }
 ```
 

From 280b8a89ea132f225b249ce743839c0cab96b05b Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 1 Oct 2024 12:40:18 -0400
Subject: [PATCH 425/762] editor: Allow opening excerpts from proposed changes
 editor (#18591)

This PR adds the ability to open excerpts in the base buffer from the
proposed changes editor.

Release Notes:

- N/A
---
 crates/editor/src/proposed_changes_editor.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/crates/editor/src/proposed_changes_editor.rs b/crates/editor/src/proposed_changes_editor.rs
index ec0c05d88382c0..a791e87e62053f 100644
--- a/crates/editor/src/proposed_changes_editor.rs
+++ b/crates/editor/src/proposed_changes_editor.rs
@@ -11,7 +11,7 @@ use text::ToOffset;
 use ui::prelude::*;
 use workspace::{
     searchable::SearchableItemHandle, Item, ItemHandle as _, ToolbarItemEvent, ToolbarItemLocation,
-    ToolbarItemView,
+    ToolbarItemView, Workspace,
 };
 
 pub struct ProposedChangesEditor {
@@ -159,6 +159,11 @@ impl Item for ProposedChangesEditor {
             None
         }
     }
+
+    fn added_to_workspace(&mut self, workspace: &mut Workspace, cx: &mut ViewContext<Self>) {
+        self.editor
+            .update(cx, |editor, cx| editor.added_to_workspace(workspace, cx));
+    }
 }
 
 impl ProposedChangesEditorToolbar {

From eb962b7bfc15dd77c702cfcbf7dc32585e89749a Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 1 Oct 2024 13:05:50 -0400
Subject: [PATCH 426/762] editor: Include proposed changes editor in navigation
 history (#18593)

This PR makes it so the proposed changes editor works with the workspace
navigation history.

This allows for easily navigating back to the proposed changes editor
after opening one of the excerpts into the base buffer.

Release Notes:

- N/A
---
 crates/editor/src/proposed_changes_editor.rs | 22 +++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/crates/editor/src/proposed_changes_editor.rs b/crates/editor/src/proposed_changes_editor.rs
index a791e87e62053f..0666346e487764 100644
--- a/crates/editor/src/proposed_changes_editor.rs
+++ b/crates/editor/src/proposed_changes_editor.rs
@@ -161,8 +161,28 @@ impl Item for ProposedChangesEditor {
     }
 
     fn added_to_workspace(&mut self, workspace: &mut Workspace, cx: &mut ViewContext<Self>) {
+        self.editor.update(cx, |editor, cx| {
+            Item::added_to_workspace(editor, workspace, cx)
+        });
+    }
+
+    fn deactivated(&mut self, cx: &mut ViewContext<Self>) {
+        self.editor.update(cx, Item::deactivated);
+    }
+
+    fn navigate(&mut self, data: Box<dyn std::any::Any>, cx: &mut ViewContext<Self>) -> bool {
         self.editor
-            .update(cx, |editor, cx| editor.added_to_workspace(workspace, cx));
+            .update(cx, |editor, cx| Item::navigate(editor, data, cx))
+    }
+
+    fn set_nav_history(
+        &mut self,
+        nav_history: workspace::ItemNavHistory,
+        cx: &mut ViewContext<Self>,
+    ) {
+        self.editor.update(cx, |editor, cx| {
+            Item::set_nav_history(editor, nav_history, cx)
+        });
     }
 }
 

From d14e36b3231071d2da7492bc89e12b6f964fee3a Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Tue, 1 Oct 2024 11:07:52 -0600
Subject: [PATCH 427/762] Add an apply button to hunks in proposed changes
 editor (#18592)

Release Notes:

- N/A

---------

Co-authored-by: Antonio <antonio@zed.dev>
Co-authored-by: Nathan <nathan@zed.dev>
---
 crates/editor/src/actions.rs                 |   1 +
 crates/editor/src/editor.rs                  |  14 +
 crates/editor/src/element.rs                 |   1 +
 crates/editor/src/hunk_diff.rs               | 272 +++++++++++--------
 crates/editor/src/proposed_changes_editor.rs |  52 ++--
 crates/language/src/buffer.rs                |  55 ++--
 crates/language/src/buffer_tests.rs          |  16 +-
 7 files changed, 248 insertions(+), 163 deletions(-)

diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs
index b5935782580ba3..502b70361b4f8e 100644
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -193,6 +193,7 @@ gpui::actions!(
         AcceptPartialInlineCompletion,
         AddSelectionAbove,
         AddSelectionBelow,
+        ApplyDiffHunk,
         Backspace,
         Cancel,
         CancelLanguageServerWork,
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 61a47d7f631fd8..b43433e3f41e6e 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -6205,6 +6205,20 @@ impl Editor {
         }
     }
 
+    fn apply_selected_diff_hunks(&mut self, _: &ApplyDiffHunk, cx: &mut ViewContext<Self>) {
+        let snapshot = self.buffer.read(cx).snapshot(cx);
+        let hunks = hunks_for_selections(&snapshot, &self.selections.disjoint_anchors());
+        self.transact(cx, |editor, cx| {
+            for hunk in hunks {
+                if let Some(buffer) = editor.buffer.read(cx).buffer(hunk.buffer_id) {
+                    buffer.update(cx, |buffer, cx| {
+                        buffer.merge_into_base(Some(hunk.buffer_range.to_offset(buffer)), cx);
+                    });
+                }
+            }
+        });
+    }
+
     pub fn open_active_item_in_terminal(&mut self, _: &OpenInTerminal, cx: &mut ViewContext<Self>) {
         if let Some(working_directory) = self.active_excerpt(cx).and_then(|(_, buffer, _)| {
             let project_path = buffer.read(cx).project_path(cx)?;
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 98a5ff7f4dff50..8a0735354720d1 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -436,6 +436,7 @@ impl EditorElement {
         register_action(view, cx, Editor::accept_inline_completion);
         register_action(view, cx, Editor::revert_file);
         register_action(view, cx, Editor::revert_selected_hunks);
+        register_action(view, cx, Editor::apply_selected_diff_hunks);
         register_action(view, cx, Editor::open_active_item_in_terminal)
     }
 
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index 2ccd60c668de7f..c8caa30b59c49c 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -14,9 +14,9 @@ use ui::{
 use util::RangeExt;
 
 use crate::{
-    editor_settings::CurrentLineHighlight, hunk_status, hunks_for_selections, BlockDisposition,
-    BlockProperties, BlockStyle, CustomBlockId, DiffRowHighlight, DisplayRow, DisplaySnapshot,
-    Editor, EditorElement, ExpandAllHunkDiffs, GoToHunk, GoToPrevHunk, RevertFile,
+    editor_settings::CurrentLineHighlight, hunk_status, hunks_for_selections, ApplyDiffHunk,
+    BlockDisposition, BlockProperties, BlockStyle, CustomBlockId, DiffRowHighlight, DisplayRow,
+    DisplaySnapshot, Editor, EditorElement, ExpandAllHunkDiffs, GoToHunk, GoToPrevHunk, RevertFile,
     RevertSelectedHunks, ToDisplayPoint, ToggleHunkDiff,
 };
 
@@ -238,19 +238,14 @@ impl Editor {
         cx: &mut ViewContext<'_, Editor>,
     ) -> Option<()> {
         let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
-        let multi_buffer_row_range = hunk
-            .multi_buffer_range
-            .start
-            .to_point(&multi_buffer_snapshot)
-            ..hunk.multi_buffer_range.end.to_point(&multi_buffer_snapshot);
-        let hunk_start = hunk.multi_buffer_range.start;
-        let hunk_end = hunk.multi_buffer_range.end;
+        let hunk_range = hunk.multi_buffer_range.clone();
+        let hunk_point_range = hunk_range.to_point(&multi_buffer_snapshot);
 
         let buffer = self.buffer().clone();
         let snapshot = self.snapshot(cx);
         let (diff_base_buffer, deleted_text_lines) = buffer.update(cx, |buffer, cx| {
-            let hunk = buffer_diff_hunk(&snapshot.buffer_snapshot, multi_buffer_row_range.clone())?;
-            let mut buffer_ranges = buffer.range_to_buffer_ranges(multi_buffer_row_range, cx);
+            let hunk = buffer_diff_hunk(&snapshot.buffer_snapshot, hunk_point_range.clone())?;
+            let mut buffer_ranges = buffer.range_to_buffer_ranges(hunk_point_range, cx);
             if buffer_ranges.len() == 1 {
                 let (buffer, _, _) = buffer_ranges.pop()?;
                 let diff_base_buffer = diff_base_buffer
@@ -275,7 +270,7 @@ impl Editor {
             probe
                 .hunk_range
                 .start
-                .cmp(&hunk_start, &multi_buffer_snapshot)
+                .cmp(&hunk_range.start, &multi_buffer_snapshot)
         }) {
             Ok(_already_present) => return None,
             Err(ix) => ix,
@@ -295,7 +290,7 @@ impl Editor {
             }
             DiffHunkStatus::Added => {
                 self.highlight_rows::<DiffRowHighlight>(
-                    hunk_start..hunk_end,
+                    hunk_range.clone(),
                     added_hunk_color(cx),
                     false,
                     cx,
@@ -304,7 +299,7 @@ impl Editor {
             }
             DiffHunkStatus::Modified => {
                 self.highlight_rows::<DiffRowHighlight>(
-                    hunk_start..hunk_end,
+                    hunk_range.clone(),
                     added_hunk_color(cx),
                     false,
                     cx,
@@ -323,7 +318,7 @@ impl Editor {
             block_insert_index,
             ExpandedHunk {
                 blocks,
-                hunk_range: hunk_start..hunk_end,
+                hunk_range,
                 status: hunk.status,
                 folded: false,
                 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
@@ -333,11 +328,47 @@ impl Editor {
         Some(())
     }
 
+    fn apply_changes_in_range(
+        &mut self,
+        range: Range<Anchor>,
+        cx: &mut ViewContext<'_, Editor>,
+    ) -> Option<()> {
+        let (buffer, range, _) = self
+            .buffer
+            .read(cx)
+            .range_to_buffer_ranges(range, cx)
+            .into_iter()
+            .next()?;
+
+        buffer.update(cx, |branch_buffer, cx| {
+            branch_buffer.merge_into_base(Some(range), cx);
+        });
+
+        None
+    }
+
+    pub(crate) fn apply_all_changes(&self, cx: &mut ViewContext<Self>) {
+        let buffers = self.buffer.read(cx).all_buffers();
+        for branch_buffer in buffers {
+            branch_buffer.update(cx, |branch_buffer, cx| {
+                branch_buffer.merge_into_base(None, cx);
+            });
+        }
+    }
+
     fn hunk_header_block(
         &self,
         hunk: &HoveredHunk,
         cx: &mut ViewContext<'_, Editor>,
     ) -> BlockProperties<Anchor> {
+        let is_branch_buffer = self
+            .buffer
+            .read(cx)
+            .point_to_buffer_offset(hunk.multi_buffer_range.start, cx)
+            .map_or(false, |(buffer, _, _)| {
+                buffer.read(cx).diff_base_buffer().is_some()
+            });
+
         let border_color = cx.theme().colors().border_variant;
         let gutter_color = match hunk.status {
             DiffHunkStatus::Added => cx.theme().status().created,
@@ -388,6 +419,10 @@ impl Editor {
                                 .pr_6()
                                 .size_full()
                                 .justify_between()
+                                .border_t_1()
+                                .pl_6()
+                                .pr_6()
+                                .border_color(border_color)
                                 .child(
                                     h_flex()
                                         .gap_1()
@@ -411,43 +446,10 @@ impl Editor {
                                                     let hunk = hunk.clone();
                                                     move |_event, cx| {
                                                         editor.update(cx, |editor, cx| {
-                                                            let snapshot = editor.snapshot(cx);
-                                                            let position = hunk
-                                                                .multi_buffer_range
-                                                                .end
-                                                                .to_point(
-                                                                    &snapshot.buffer_snapshot,
-                                                                );
-                                                            if let Some(hunk) = editor
-                                                                .go_to_hunk_after_position(
-                                                                    &snapshot, position, cx,
-                                                                )
-                                                            {
-                                                                let multi_buffer_start = snapshot
-                                                                    .buffer_snapshot
-                                                                    .anchor_before(Point::new(
-                                                                        hunk.row_range.start.0,
-                                                                        0,
-                                                                    ));
-                                                                let multi_buffer_end = snapshot
-                                                                    .buffer_snapshot
-                                                                    .anchor_after(Point::new(
-                                                                        hunk.row_range.end.0,
-                                                                        0,
-                                                                    ));
-                                                                editor.expand_diff_hunk(
-                                                                    None,
-                                                                    &HoveredHunk {
-                                                                        multi_buffer_range:
-                                                                            multi_buffer_start
-                                                                                ..multi_buffer_end,
-                                                                        status: hunk_status(&hunk),
-                                                                        diff_base_byte_range: hunk
-                                                                            .diff_base_byte_range,
-                                                                    },
-                                                                    cx,
-                                                                );
-                                                            }
+                                                            editor.go_to_subsequent_hunk(
+                                                                hunk.multi_buffer_range.end,
+                                                                cx,
+                                                            );
                                                         });
                                                     }
                                                 }),
@@ -472,43 +474,10 @@ impl Editor {
                                                     let hunk = hunk.clone();
                                                     move |_event, cx| {
                                                         editor.update(cx, |editor, cx| {
-                                                            let snapshot = editor.snapshot(cx);
-                                                            let position = hunk
-                                                                .multi_buffer_range
-                                                                .start
-                                                                .to_point(
-                                                                    &snapshot.buffer_snapshot,
-                                                                );
-                                                            let hunk = editor
-                                                                .go_to_hunk_before_position(
-                                                                    &snapshot, position, cx,
-                                                                );
-                                                            if let Some(hunk) = hunk {
-                                                                let multi_buffer_start = snapshot
-                                                                    .buffer_snapshot
-                                                                    .anchor_before(Point::new(
-                                                                        hunk.row_range.start.0,
-                                                                        0,
-                                                                    ));
-                                                                let multi_buffer_end = snapshot
-                                                                    .buffer_snapshot
-                                                                    .anchor_after(Point::new(
-                                                                        hunk.row_range.end.0,
-                                                                        0,
-                                                                    ));
-                                                                editor.expand_diff_hunk(
-                                                                    None,
-                                                                    &HoveredHunk {
-                                                                        multi_buffer_range:
-                                                                            multi_buffer_start
-                                                                                ..multi_buffer_end,
-                                                                        status: hunk_status(&hunk),
-                                                                        diff_base_byte_range: hunk
-                                                                            .diff_base_byte_range,
-                                                                    },
-                                                                    cx,
-                                                                );
-                                                            }
+                                                            editor.go_to_preceding_hunk(
+                                                                hunk.multi_buffer_range.start,
+                                                                cx,
+                                                            );
                                                         });
                                                     }
                                                 }),
@@ -558,6 +527,36 @@ impl Editor {
                                                     }
                                                 }),
                                         )
+                                        .when(is_branch_buffer, |this| {
+                                            this.child(
+                                                IconButton::new("apply", IconName::Check)
+                                                    .shape(IconButtonShape::Square)
+                                                    .icon_size(IconSize::Small)
+                                                    .tooltip({
+                                                        let focus_handle = editor.focus_handle(cx);
+                                                        move |cx| {
+                                                            Tooltip::for_action_in(
+                                                                "Apply Hunk",
+                                                                &ApplyDiffHunk,
+                                                                &focus_handle,
+                                                                cx,
+                                                            )
+                                                        }
+                                                    })
+                                                    .on_click({
+                                                        let editor = editor.clone();
+                                                        let hunk = hunk.clone();
+                                                        move |_event, cx| {
+                                                            editor.update(cx, |editor, cx| {
+                                                                editor.apply_changes_in_range(
+                                                                    hunk.multi_buffer_range.clone(),
+                                                                    cx,
+                                                                );
+                                                            });
+                                                        }
+                                                    }),
+                                            )
+                                        })
                                         .child({
                                             let focus = editor.focus_handle(cx);
                                             PopoverMenu::new("hunk-controls-dropdown")
@@ -597,31 +596,29 @@ impl Editor {
                                         }),
                                 )
                                 .child(
-                                    div().child(
-                                        IconButton::new("collapse", IconName::Close)
-                                            .shape(IconButtonShape::Square)
-                                            .icon_size(IconSize::Small)
-                                            .tooltip({
-                                                let focus_handle = editor.focus_handle(cx);
-                                                move |cx| {
-                                                    Tooltip::for_action_in(
-                                                        "Collapse Hunk",
-                                                        &ToggleHunkDiff,
-                                                        &focus_handle,
-                                                        cx,
-                                                    )
-                                                }
-                                            })
-                                            .on_click({
-                                                let editor = editor.clone();
-                                                let hunk = hunk.clone();
-                                                move |_event, cx| {
-                                                    editor.update(cx, |editor, cx| {
-                                                        editor.toggle_hovered_hunk(&hunk, cx);
-                                                    });
-                                                }
-                                            }),
-                                    ),
+                                    IconButton::new("collapse", IconName::Close)
+                                        .shape(IconButtonShape::Square)
+                                        .icon_size(IconSize::Small)
+                                        .tooltip({
+                                            let focus_handle = editor.focus_handle(cx);
+                                            move |cx| {
+                                                Tooltip::for_action_in(
+                                                    "Collapse Hunk",
+                                                    &ToggleHunkDiff,
+                                                    &focus_handle,
+                                                    cx,
+                                                )
+                                            }
+                                        })
+                                        .on_click({
+                                            let editor = editor.clone();
+                                            let hunk = hunk.clone();
+                                            move |_event, cx| {
+                                                editor.update(cx, |editor, cx| {
+                                                    editor.toggle_hovered_hunk(&hunk, cx);
+                                                });
+                                            }
+                                        }),
                                 ),
                         )
                         .into_any_element()
@@ -876,6 +873,51 @@ impl Editor {
             }
         })
     }
+
+    fn go_to_subsequent_hunk(&mut self, position: Anchor, cx: &mut ViewContext<Self>) {
+        let snapshot = self.snapshot(cx);
+        let position = position.to_point(&snapshot.buffer_snapshot);
+        if let Some(hunk) = self.go_to_hunk_after_position(&snapshot, position, cx) {
+            let multi_buffer_start = snapshot
+                .buffer_snapshot
+                .anchor_before(Point::new(hunk.row_range.start.0, 0));
+            let multi_buffer_end = snapshot
+                .buffer_snapshot
+                .anchor_after(Point::new(hunk.row_range.end.0, 0));
+            self.expand_diff_hunk(
+                None,
+                &HoveredHunk {
+                    multi_buffer_range: multi_buffer_start..multi_buffer_end,
+                    status: hunk_status(&hunk),
+                    diff_base_byte_range: hunk.diff_base_byte_range,
+                },
+                cx,
+            );
+        }
+    }
+
+    fn go_to_preceding_hunk(&mut self, position: Anchor, cx: &mut ViewContext<Self>) {
+        let snapshot = self.snapshot(cx);
+        let position = position.to_point(&snapshot.buffer_snapshot);
+        let hunk = self.go_to_hunk_before_position(&snapshot, position, cx);
+        if let Some(hunk) = hunk {
+            let multi_buffer_start = snapshot
+                .buffer_snapshot
+                .anchor_before(Point::new(hunk.row_range.start.0, 0));
+            let multi_buffer_end = snapshot
+                .buffer_snapshot
+                .anchor_after(Point::new(hunk.row_range.end.0, 0));
+            self.expand_diff_hunk(
+                None,
+                &HoveredHunk {
+                    multi_buffer_range: multi_buffer_start..multi_buffer_end,
+                    status: hunk_status(&hunk),
+                    diff_base_byte_range: hunk.diff_base_byte_range,
+                },
+                cx,
+            );
+        }
+    }
 }
 
 fn to_diff_hunk(
diff --git a/crates/editor/src/proposed_changes_editor.rs b/crates/editor/src/proposed_changes_editor.rs
index 0666346e487764..62e37bc677f5fc 100644
--- a/crates/editor/src/proposed_changes_editor.rs
+++ b/crates/editor/src/proposed_changes_editor.rs
@@ -18,7 +18,7 @@ pub struct ProposedChangesEditor {
     editor: View<Editor>,
     _subscriptions: Vec<Subscription>,
     _recalculate_diffs_task: Task<Option<()>>,
-    recalculate_diffs_tx: mpsc::UnboundedSender<Model<Buffer>>,
+    recalculate_diffs_tx: mpsc::UnboundedSender<RecalculateDiff>,
 }
 
 pub struct ProposedChangesBuffer<T> {
@@ -30,6 +30,11 @@ pub struct ProposedChangesEditorToolbar {
     current_editor: Option<View<ProposedChangesEditor>>,
 }
 
+struct RecalculateDiff {
+    buffer: Model<Buffer>,
+    debounce: bool,
+}
+
 impl ProposedChangesEditor {
     pub fn new<T: ToOffset>(
         buffers: Vec<ProposedChangesBuffer<T>>,
@@ -63,16 +68,18 @@ impl ProposedChangesEditor {
             recalculate_diffs_tx,
             _recalculate_diffs_task: cx.spawn(|_, mut cx| async move {
                 let mut buffers_to_diff = HashSet::default();
-                while let Some(buffer) = recalculate_diffs_rx.next().await {
-                    buffers_to_diff.insert(buffer);
+                while let Some(mut recalculate_diff) = recalculate_diffs_rx.next().await {
+                    buffers_to_diff.insert(recalculate_diff.buffer);
 
-                    loop {
+                    while recalculate_diff.debounce {
                         cx.background_executor()
                             .timer(Duration::from_millis(250))
                             .await;
                         let mut had_further_changes = false;
-                        while let Ok(next_buffer) = recalculate_diffs_rx.try_next() {
-                            buffers_to_diff.insert(next_buffer?);
+                        while let Ok(next_recalculate_diff) = recalculate_diffs_rx.try_next() {
+                            let next_recalculate_diff = next_recalculate_diff?;
+                            recalculate_diff.debounce &= next_recalculate_diff.debounce;
+                            buffers_to_diff.insert(next_recalculate_diff.buffer);
                             had_further_changes = true;
                         }
                         if !had_further_changes {
@@ -99,19 +106,24 @@ impl ProposedChangesEditor {
         event: &BufferEvent,
         _cx: &mut ViewContext<Self>,
     ) {
-        if let BufferEvent::Edited = event {
-            self.recalculate_diffs_tx.unbounded_send(buffer).ok();
-        }
-    }
-
-    fn apply_all_changes(&self, cx: &mut ViewContext<Self>) {
-        let buffers = self.editor.read(cx).buffer.read(cx).all_buffers();
-        for branch_buffer in buffers {
-            if let Some(base_buffer) = branch_buffer.read(cx).diff_base_buffer() {
-                base_buffer.update(cx, |base_buffer, cx| {
-                    base_buffer.merge(&branch_buffer, None, cx)
-                });
+        match event {
+            BufferEvent::Operation { .. } => {
+                self.recalculate_diffs_tx
+                    .unbounded_send(RecalculateDiff {
+                        buffer,
+                        debounce: true,
+                    })
+                    .ok();
+            }
+            BufferEvent::DiffBaseChanged => {
+                self.recalculate_diffs_tx
+                    .unbounded_send(RecalculateDiff {
+                        buffer,
+                        debounce: false,
+                    })
+                    .ok();
             }
+            _ => (),
         }
     }
 }
@@ -208,7 +220,9 @@ impl Render for ProposedChangesEditorToolbar {
         Button::new("apply-changes", "Apply All").on_click(move |_, cx| {
             if let Some(editor) = &editor {
                 editor.update(cx, |editor, cx| {
-                    editor.apply_all_changes(cx);
+                    editor.editor.update(cx, |editor, cx| {
+                        editor.apply_all_changes(cx);
+                    })
                 });
             }
         })
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 7abc9b8dba146a..8afc4d389db7f5 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -62,7 +62,7 @@ pub use text::{
 use theme::SyntaxTheme;
 #[cfg(any(test, feature = "test-support"))]
 use util::RandomCharIter;
-use util::RangeExt;
+use util::{debug_panic, RangeExt};
 
 #[cfg(any(test, feature = "test-support"))]
 pub use {tree_sitter_rust, tree_sitter_typescript};
@@ -823,40 +823,41 @@ impl Buffer {
         })
     }
 
-    /// Applies all of the changes in `branch` buffer that intersect the given `range`
-    /// to this buffer.
-    pub fn merge(
-        &mut self,
-        branch: &Model<Self>,
-        range: Option<Range<Anchor>>,
-        cx: &mut ModelContext<Self>,
-    ) {
-        let edits = branch.read_with(cx, |branch, _| {
-            branch
-                .edits_since_in_range::<usize>(
-                    &self.version,
-                    range.unwrap_or(Anchor::MIN..Anchor::MAX),
-                )
-                .map(|edit| {
-                    (
-                        edit.old,
-                        branch.text_for_range(edit.new).collect::<String>(),
-                    )
+    /// Applies all of the changes in this buffer that intersect the given `range`
+    /// to its base buffer. This buffer must be a branch buffer to call this method.
+    pub fn merge_into_base(&mut self, range: Option<Range<usize>>, cx: &mut ModelContext<Self>) {
+        let Some(base_buffer) = self.diff_base_buffer() else {
+            debug_panic!("not a branch buffer");
+            return;
+        };
+
+        base_buffer.update(cx, |base_buffer, cx| {
+            let edits = self
+                .edits_since::<usize>(&base_buffer.version)
+                .filter_map(|edit| {
+                    if range
+                        .as_ref()
+                        .map_or(true, |range| range.overlaps(&edit.new))
+                    {
+                        Some((edit.old, self.text_for_range(edit.new).collect::<String>()))
+                    } else {
+                        None
+                    }
                 })
-                .collect::<Vec<_>>()
-        });
-        let operation = self.edit(edits, None, cx);
+                .collect::<Vec<_>>();
+
+            let operation = base_buffer.edit(edits, None, cx);
 
-        // Prevent this operation from being reapplied to the branch.
-        branch.update(cx, |branch, cx| {
+            // Prevent this operation from being reapplied to the branch.
             if let Some(BufferDiffBase::PastBufferVersion {
                 operations_to_ignore,
                 ..
-            }) = &mut branch.diff_base
+            }) = &mut self.diff_base
             {
                 operations_to_ignore.extend(operation);
             }
-            cx.emit(BufferEvent::Edited)
+
+            cx.emit(BufferEvent::DiffBaseChanged);
         });
     }
 
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index 49cc31067b93ae..da53d5a7637b99 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -2471,8 +2471,8 @@ fn test_branch_and_merge(cx: &mut TestAppContext) {
     });
 
     // Merging the branch applies all of its changes to the base.
-    base_buffer.update(cx, |base_buffer, cx| {
-        base_buffer.merge(&branch_buffer, None, cx);
+    branch_buffer.update(cx, |branch_buffer, cx| {
+        branch_buffer.merge_into_base(None, cx);
     });
 
     branch_buffer.update(cx, |branch_buffer, cx| {
@@ -2484,6 +2484,18 @@ fn test_branch_and_merge(cx: &mut TestAppContext) {
     });
 }
 
+#[gpui::test]
+fn test_merge_into_base(cx: &mut AppContext) {
+    init_settings(cx, |_| {});
+    let base = cx.new_model(|cx| Buffer::local("abcdefghijk", cx));
+    let branch = base.update(cx, |buffer, cx| buffer.branch(cx));
+    branch.update(cx, |branch, cx| {
+        branch.edit([(0..3, "ABC"), (7..9, "HI")], None, cx);
+        branch.merge_into_base(Some(5..8), cx);
+    });
+    assert_eq!(base.read(cx).text(), "abcdefgHIjk");
+}
+
 fn start_recalculating_diff(buffer: &Model<Buffer>, cx: &mut TestAppContext) {
     buffer
         .update(cx, |buffer, cx| buffer.recalculate_diff(cx).unwrap())

From 9b148f3dcc5e4281bfadd515efd817bcdbf21bc3 Mon Sep 17 00:00:00 2001
From: Junkui Zhang <364772080@qq.com>
Date: Wed, 2 Oct 2024 01:32:31 +0800
Subject: [PATCH 428/762] Limit the value can be set for font weight (#18594)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes #18531



This PR limits the range of values that can be set for `FontWeight`.
Since any value less than 1.0 or greater than 999.9 causes Zed to crash
on Windows, I’ve restricted `FontWeight` to this range.

I could apply this constraint only on Windows, but considering the
documentation at https://zed.dev/docs/configuring-zed#buffer-font-weight
indicates that `FontWeight` should be between 100 and 900, I thought it
might be a good idea to apply this restriction in the settings.


Release Notes:

- Changed `ui_font_weight` and `buffer_font_weight` settings to require
values to be between `100` and `950` (inclusive).

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 crates/theme/src/settings.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/crates/theme/src/settings.rs b/crates/theme/src/settings.rs
index 7fa9a870de559b..86383cec8ea079 100644
--- a/crates/theme/src/settings.rs
+++ b/crates/theme/src/settings.rs
@@ -520,6 +520,10 @@ pub fn reset_ui_font_size(cx: &mut AppContext) {
     }
 }
 
+fn clamp_font_weight(weight: f32) -> FontWeight {
+    FontWeight(weight.clamp(100., 950.))
+}
+
 impl settings::Settings for ThemeSettings {
     const KEY: Option<&'static str> = None;
 
@@ -579,7 +583,7 @@ impl settings::Settings for ThemeSettings {
                 this.buffer_font.fallbacks = Some(FontFallbacks::from_fonts(value));
             }
             if let Some(value) = value.buffer_font_weight {
-                this.buffer_font.weight = FontWeight(value);
+                this.buffer_font.weight = clamp_font_weight(value);
             }
 
             if let Some(value) = value.ui_font_family.clone() {
@@ -592,7 +596,7 @@ impl settings::Settings for ThemeSettings {
                 this.ui_font.fallbacks = Some(FontFallbacks::from_fonts(value));
             }
             if let Some(value) = value.ui_font_weight {
-                this.ui_font.weight = FontWeight(value);
+                this.ui_font.weight = clamp_font_weight(value);
             }
 
             if let Some(value) = &value.theme {

From 7dcb0de28cb3abf482b81e2821332cf234891cda Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Tue, 1 Oct 2024 12:58:12 -0600
Subject: [PATCH 429/762] Keep all hunks expanded in proposed change editor
 (#18598)

Also, fix visual bug when pressing escape with a non-empty selection in
a deleted text block.

Release Notes:

- N/A

Co-authored-by: Antonio <antonio@zed.dev>
---
 crates/editor/src/editor.rs                  |   2 +-
 crates/editor/src/hunk_diff.rs               | 440 +++++++++++--------
 crates/editor/src/proposed_changes_editor.rs |   7 +-
 3 files changed, 259 insertions(+), 190 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index b43433e3f41e6e..54a1318bdfe52c 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -3059,7 +3059,7 @@ impl Editor {
     }
 
     pub fn cancel(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
-        if self.clear_clicked_diff_hunks(cx) {
+        if self.clear_expanded_diff_hunks(cx) {
             cx.notify();
             return;
         }
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index c8caa30b59c49c..ff3451fc9216b0 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -32,6 +32,7 @@ pub(super) struct ExpandedHunks {
     pub(crate) hunks: Vec<ExpandedHunk>,
     diff_base: HashMap<BufferId, DiffBaseBuffer>,
     hunk_update_tasks: HashMap<Option<BufferId>, Task<()>>,
+    expand_all: bool,
 }
 
 #[derive(Debug, Clone)]
@@ -72,6 +73,10 @@ impl ExpandedHunks {
 }
 
 impl Editor {
+    pub fn set_expand_all_diff_hunks(&mut self) {
+        self.expanded_hunks.expand_all = true;
+    }
+
     pub(super) fn toggle_hovered_hunk(
         &mut self,
         hovered_hunk: &HoveredHunk,
@@ -133,6 +138,10 @@ impl Editor {
         hunks_to_toggle: Vec<MultiBufferDiffHunk>,
         cx: &mut ViewContext<Self>,
     ) {
+        if self.expanded_hunks.expand_all {
+            return;
+        }
+
         let previous_toggle_task = self.expanded_hunks.hunk_update_tasks.remove(&None);
         let new_toggle_task = cx.spawn(move |editor, mut cx| async move {
             if let Some(task) = previous_toggle_task {
@@ -426,62 +435,64 @@ impl Editor {
                                 .child(
                                     h_flex()
                                         .gap_1()
-                                        .child(
-                                            IconButton::new("next-hunk", IconName::ArrowDown)
-                                                .shape(IconButtonShape::Square)
-                                                .icon_size(IconSize::Small)
-                                                .tooltip({
-                                                    let focus_handle = editor.focus_handle(cx);
-                                                    move |cx| {
-                                                        Tooltip::for_action_in(
-                                                            "Next Hunk",
-                                                            &GoToHunk,
-                                                            &focus_handle,
-                                                            cx,
-                                                        )
-                                                    }
-                                                })
-                                                .on_click({
-                                                    let editor = editor.clone();
-                                                    let hunk = hunk.clone();
-                                                    move |_event, cx| {
-                                                        editor.update(cx, |editor, cx| {
-                                                            editor.go_to_subsequent_hunk(
-                                                                hunk.multi_buffer_range.end,
+                                        .when(!is_branch_buffer, |row| {
+                                            row.child(
+                                                IconButton::new("next-hunk", IconName::ArrowDown)
+                                                    .shape(IconButtonShape::Square)
+                                                    .icon_size(IconSize::Small)
+                                                    .tooltip({
+                                                        let focus_handle = editor.focus_handle(cx);
+                                                        move |cx| {
+                                                            Tooltip::for_action_in(
+                                                                "Next Hunk",
+                                                                &GoToHunk,
+                                                                &focus_handle,
                                                                 cx,
-                                                            );
-                                                        });
-                                                    }
-                                                }),
-                                        )
-                                        .child(
-                                            IconButton::new("prev-hunk", IconName::ArrowUp)
-                                                .shape(IconButtonShape::Square)
-                                                .icon_size(IconSize::Small)
-                                                .tooltip({
-                                                    let focus_handle = editor.focus_handle(cx);
-                                                    move |cx| {
-                                                        Tooltip::for_action_in(
-                                                            "Previous Hunk",
-                                                            &GoToPrevHunk,
-                                                            &focus_handle,
-                                                            cx,
-                                                        )
-                                                    }
-                                                })
-                                                .on_click({
-                                                    let editor = editor.clone();
-                                                    let hunk = hunk.clone();
-                                                    move |_event, cx| {
-                                                        editor.update(cx, |editor, cx| {
-                                                            editor.go_to_preceding_hunk(
-                                                                hunk.multi_buffer_range.start,
+                                                            )
+                                                        }
+                                                    })
+                                                    .on_click({
+                                                        let editor = editor.clone();
+                                                        let hunk = hunk.clone();
+                                                        move |_event, cx| {
+                                                            editor.update(cx, |editor, cx| {
+                                                                editor.go_to_subsequent_hunk(
+                                                                    hunk.multi_buffer_range.end,
+                                                                    cx,
+                                                                );
+                                                            });
+                                                        }
+                                                    }),
+                                            )
+                                            .child(
+                                                IconButton::new("prev-hunk", IconName::ArrowUp)
+                                                    .shape(IconButtonShape::Square)
+                                                    .icon_size(IconSize::Small)
+                                                    .tooltip({
+                                                        let focus_handle = editor.focus_handle(cx);
+                                                        move |cx| {
+                                                            Tooltip::for_action_in(
+                                                                "Previous Hunk",
+                                                                &GoToPrevHunk,
+                                                                &focus_handle,
                                                                 cx,
-                                                            );
-                                                        });
-                                                    }
-                                                }),
-                                        )
+                                                            )
+                                                        }
+                                                    })
+                                                    .on_click({
+                                                        let editor = editor.clone();
+                                                        let hunk = hunk.clone();
+                                                        move |_event, cx| {
+                                                            editor.update(cx, |editor, cx| {
+                                                                editor.go_to_preceding_hunk(
+                                                                    hunk.multi_buffer_range.start,
+                                                                    cx,
+                                                                );
+                                                            });
+                                                        }
+                                                    }),
+                                            )
+                                        })
                                         .child(
                                             IconButton::new("discard", IconName::Undo)
                                                 .shape(IconButtonShape::Square)
@@ -527,99 +538,115 @@ impl Editor {
                                                     }
                                                 }),
                                         )
-                                        .when(is_branch_buffer, |this| {
-                                            this.child(
-                                                IconButton::new("apply", IconName::Check)
-                                                    .shape(IconButtonShape::Square)
-                                                    .icon_size(IconSize::Small)
-                                                    .tooltip({
-                                                        let focus_handle = editor.focus_handle(cx);
-                                                        move |cx| {
-                                                            Tooltip::for_action_in(
-                                                                "Apply Hunk",
-                                                                &ApplyDiffHunk,
-                                                                &focus_handle,
-                                                                cx,
-                                                            )
-                                                        }
-                                                    })
-                                                    .on_click({
-                                                        let editor = editor.clone();
-                                                        let hunk = hunk.clone();
-                                                        move |_event, cx| {
-                                                            editor.update(cx, |editor, cx| {
-                                                                editor.apply_changes_in_range(
-                                                                    hunk.multi_buffer_range.clone(),
+                                        .map(|this| {
+                                            if is_branch_buffer {
+                                                this.child(
+                                                    IconButton::new("apply", IconName::Check)
+                                                        .shape(IconButtonShape::Square)
+                                                        .icon_size(IconSize::Small)
+                                                        .tooltip({
+                                                            let focus_handle =
+                                                                editor.focus_handle(cx);
+                                                            move |cx| {
+                                                                Tooltip::for_action_in(
+                                                                    "Apply Hunk",
+                                                                    &ApplyDiffHunk,
+                                                                    &focus_handle,
                                                                     cx,
-                                                                );
-                                                            });
-                                                        }
-                                                    }),
-                                            )
-                                        })
-                                        .child({
-                                            let focus = editor.focus_handle(cx);
-                                            PopoverMenu::new("hunk-controls-dropdown")
-                                                .trigger(
-                                                    IconButton::new(
-                                                        "toggle_editor_selections_icon",
-                                                        IconName::EllipsisVertical,
-                                                    )
-                                                    .shape(IconButtonShape::Square)
-                                                    .icon_size(IconSize::Small)
-                                                    .style(ButtonStyle::Subtle)
-                                                    .selected(
-                                                        hunk_controls_menu_handle.is_deployed(),
-                                                    )
-                                                    .when(
-                                                        !hunk_controls_menu_handle.is_deployed(),
-                                                        |this| {
-                                                            this.tooltip(|cx| {
-                                                                Tooltip::text("Hunk Controls", cx)
-                                                            })
-                                                        },
-                                                    ),
+                                                                )
+                                                            }
+                                                        })
+                                                        .on_click({
+                                                            let editor = editor.clone();
+                                                            let hunk = hunk.clone();
+                                                            move |_event, cx| {
+                                                                editor.update(cx, |editor, cx| {
+                                                                    editor.apply_changes_in_range(
+                                                                        hunk.multi_buffer_range
+                                                                            .clone(),
+                                                                        cx,
+                                                                    );
+                                                                });
+                                                            }
+                                                        }),
                                                 )
-                                                .anchor(AnchorCorner::TopRight)
-                                                .with_handle(hunk_controls_menu_handle)
-                                                .menu(move |cx| {
-                                                    let focus = focus.clone();
-                                                    let menu =
-                                                        ContextMenu::build(cx, move |menu, _| {
-                                                            menu.context(focus.clone()).action(
-                                                                "Discard All",
-                                                                RevertFile.boxed_clone(),
+                                            } else {
+                                                this.child({
+                                                    let focus = editor.focus_handle(cx);
+                                                    PopoverMenu::new("hunk-controls-dropdown")
+                                                        .trigger(
+                                                            IconButton::new(
+                                                                "toggle_editor_selections_icon",
+                                                                IconName::EllipsisVertical,
                                                             )
-                                                        });
-                                                    Some(menu)
+                                                            .shape(IconButtonShape::Square)
+                                                            .icon_size(IconSize::Small)
+                                                            .style(ButtonStyle::Subtle)
+                                                            .selected(
+                                                                hunk_controls_menu_handle
+                                                                    .is_deployed(),
+                                                            )
+                                                            .when(
+                                                                !hunk_controls_menu_handle
+                                                                    .is_deployed(),
+                                                                |this| {
+                                                                    this.tooltip(|cx| {
+                                                                        Tooltip::text(
+                                                                            "Hunk Controls",
+                                                                            cx,
+                                                                        )
+                                                                    })
+                                                                },
+                                                            ),
+                                                        )
+                                                        .anchor(AnchorCorner::TopRight)
+                                                        .with_handle(hunk_controls_menu_handle)
+                                                        .menu(move |cx| {
+                                                            let focus = focus.clone();
+                                                            let menu = ContextMenu::build(
+                                                                cx,
+                                                                move |menu, _| {
+                                                                    menu.context(focus.clone())
+                                                                        .action(
+                                                                            "Discard All",
+                                                                            RevertFile
+                                                                                .boxed_clone(),
+                                                                        )
+                                                                },
+                                                            );
+                                                            Some(menu)
+                                                        })
                                                 })
-                                        }),
-                                )
-                                .child(
-                                    IconButton::new("collapse", IconName::Close)
-                                        .shape(IconButtonShape::Square)
-                                        .icon_size(IconSize::Small)
-                                        .tooltip({
-                                            let focus_handle = editor.focus_handle(cx);
-                                            move |cx| {
-                                                Tooltip::for_action_in(
-                                                    "Collapse Hunk",
-                                                    &ToggleHunkDiff,
-                                                    &focus_handle,
-                                                    cx,
-                                                )
-                                            }
-                                        })
-                                        .on_click({
-                                            let editor = editor.clone();
-                                            let hunk = hunk.clone();
-                                            move |_event, cx| {
-                                                editor.update(cx, |editor, cx| {
-                                                    editor.toggle_hovered_hunk(&hunk, cx);
-                                                });
                                             }
                                         }),
-                                ),
+                                )
+                                .when(!is_branch_buffer, |div| {
+                                    div.child(
+                                        IconButton::new("collapse", IconName::Close)
+                                            .shape(IconButtonShape::Square)
+                                            .icon_size(IconSize::Small)
+                                            .tooltip({
+                                                let focus_handle = editor.focus_handle(cx);
+                                                move |cx| {
+                                                    Tooltip::for_action_in(
+                                                        "Collapse Hunk",
+                                                        &ToggleHunkDiff,
+                                                        &focus_handle,
+                                                        cx,
+                                                    )
+                                                }
+                                            })
+                                            .on_click({
+                                                let editor = editor.clone();
+                                                let hunk = hunk.clone();
+                                                move |_event, cx| {
+                                                    editor.update(cx, |editor, cx| {
+                                                        editor.toggle_hovered_hunk(&hunk, cx);
+                                                    });
+                                                }
+                                            }),
+                                    )
+                                }),
                         )
                         .into_any_element()
                 }
@@ -694,7 +721,10 @@ impl Editor {
         }
     }
 
-    pub(super) fn clear_clicked_diff_hunks(&mut self, cx: &mut ViewContext<'_, Editor>) -> bool {
+    pub(super) fn clear_expanded_diff_hunks(&mut self, cx: &mut ViewContext<'_, Editor>) -> bool {
+        if self.expanded_hunks.expand_all {
+            return false;
+        }
         self.expanded_hunks.hunk_update_tasks.clear();
         self.clear_row_highlights::<DiffRowHighlight>();
         let to_remove = self
@@ -798,33 +828,43 @@ impl Editor {
                                         status,
                                     } => {
                                         let hunk_display_range = display_row_range;
+
                                         if expanded_hunk_display_range.start
                                             > hunk_display_range.end
                                         {
                                             recalculated_hunks.next();
-                                            continue;
-                                        } else if expanded_hunk_display_range.end
-                                            < hunk_display_range.start
-                                        {
-                                            break;
-                                        } else {
-                                            if !expanded_hunk.folded
-                                                && expanded_hunk_display_range == hunk_display_range
-                                                && expanded_hunk.status == hunk_status(buffer_hunk)
-                                                && expanded_hunk.diff_base_byte_range
-                                                    == buffer_hunk.diff_base_byte_range
-                                            {
-                                                recalculated_hunks.next();
-                                                retain = true;
-                                            } else {
+                                            if editor.expanded_hunks.expand_all {
                                                 hunks_to_reexpand.push(HoveredHunk {
                                                     status,
                                                     multi_buffer_range,
                                                     diff_base_byte_range,
                                                 });
                                             }
+                                            continue;
+                                        }
+
+                                        if expanded_hunk_display_range.end
+                                            < hunk_display_range.start
+                                        {
                                             break;
                                         }
+
+                                        if !expanded_hunk.folded
+                                            && expanded_hunk_display_range == hunk_display_range
+                                            && expanded_hunk.status == hunk_status(buffer_hunk)
+                                            && expanded_hunk.diff_base_byte_range
+                                                == buffer_hunk.diff_base_byte_range
+                                        {
+                                            recalculated_hunks.next();
+                                            retain = true;
+                                        } else {
+                                            hunks_to_reexpand.push(HoveredHunk {
+                                                status,
+                                                multi_buffer_range,
+                                                diff_base_byte_range,
+                                            });
+                                        }
+                                        break;
                                     }
                                 }
                             }
@@ -836,6 +876,26 @@ impl Editor {
                         retain
                     });
 
+                    if editor.expanded_hunks.expand_all {
+                        for hunk in recalculated_hunks {
+                            match diff_hunk_to_display(&hunk, &snapshot) {
+                                DisplayDiffHunk::Folded { .. } => {}
+                                DisplayDiffHunk::Unfolded {
+                                    diff_base_byte_range,
+                                    multi_buffer_range,
+                                    status,
+                                    ..
+                                } => {
+                                    hunks_to_reexpand.push(HoveredHunk {
+                                        status,
+                                        multi_buffer_range,
+                                        diff_base_byte_range,
+                                    });
+                                }
+                            }
+                        }
+                    }
+
                     editor.remove_highlighted_rows::<DiffRowHighlight>(highlights_to_remove, cx);
                     editor.remove_blocks(blocks_to_remove, None, cx);
 
@@ -1000,13 +1060,15 @@ fn editor_with_deleted_text(
         editor.scroll_manager.set_forbid_vertical_scroll(true);
         editor.set_read_only(true);
         editor.set_show_inline_completions(Some(false), cx);
-        editor.highlight_rows::<DiffRowHighlight>(
+
+        enum DeletedBlockRowHighlight {}
+        editor.highlight_rows::<DeletedBlockRowHighlight>(
             Anchor::min()..Anchor::max(),
             deleted_color,
             false,
             cx,
         );
-        editor.set_current_line_highlight(Some(CurrentLineHighlight::None));
+        editor.set_current_line_highlight(Some(CurrentLineHighlight::None)); //
         editor
             ._subscriptions
             .extend([cx.on_blur(&editor.focus_handle, |editor, cx| {
@@ -1015,37 +1077,41 @@ fn editor_with_deleted_text(
                 });
             })]);
 
-        let parent_editor_for_reverts = parent_editor.clone();
         let original_multi_buffer_range = hunk.multi_buffer_range.clone();
         let diff_base_range = hunk.diff_base_byte_range.clone();
         editor
-            .register_action::<RevertSelectedHunks>(move |_, cx| {
-                parent_editor_for_reverts
-                    .update(cx, |editor, cx| {
-                        let Some((buffer, original_text)) =
-                            editor.buffer().update(cx, |buffer, cx| {
-                                let (_, buffer, _) = buffer
-                                    .excerpt_containing(original_multi_buffer_range.start, cx)?;
-                                let original_text =
-                                    buffer.read(cx).diff_base()?.slice(diff_base_range.clone());
-                                Some((buffer, Arc::from(original_text.to_string())))
-                            })
-                        else {
-                            return;
-                        };
-                        buffer.update(cx, |buffer, cx| {
-                            buffer.edit(
-                                Some((
-                                    original_multi_buffer_range.start.text_anchor
-                                        ..original_multi_buffer_range.end.text_anchor,
-                                    original_text,
-                                )),
-                                None,
-                                cx,
-                            )
-                        });
-                    })
-                    .ok();
+            .register_action::<RevertSelectedHunks>({
+                let parent_editor = parent_editor.clone();
+                move |_, cx| {
+                    parent_editor
+                        .update(cx, |editor, cx| {
+                            let Some((buffer, original_text)) =
+                                editor.buffer().update(cx, |buffer, cx| {
+                                    let (_, buffer, _) = buffer.excerpt_containing(
+                                        original_multi_buffer_range.start,
+                                        cx,
+                                    )?;
+                                    let original_text =
+                                        buffer.read(cx).diff_base()?.slice(diff_base_range.clone());
+                                    Some((buffer, Arc::from(original_text.to_string())))
+                                })
+                            else {
+                                return;
+                            };
+                            buffer.update(cx, |buffer, cx| {
+                                buffer.edit(
+                                    Some((
+                                        original_multi_buffer_range.start.text_anchor
+                                            ..original_multi_buffer_range.end.text_anchor,
+                                        original_text,
+                                    )),
+                                    None,
+                                    cx,
+                                )
+                            });
+                        })
+                        .ok();
+                }
             })
             .detach();
         let hunk = hunk.clone();
diff --git a/crates/editor/src/proposed_changes_editor.rs b/crates/editor/src/proposed_changes_editor.rs
index 62e37bc677f5fc..8c8aa710a2f72c 100644
--- a/crates/editor/src/proposed_changes_editor.rs
+++ b/crates/editor/src/proposed_changes_editor.rs
@@ -63,8 +63,11 @@ impl ProposedChangesEditor {
         let (recalculate_diffs_tx, mut recalculate_diffs_rx) = mpsc::unbounded();
 
         Self {
-            editor: cx
-                .new_view(|cx| Editor::for_multibuffer(multibuffer.clone(), project, true, cx)),
+            editor: cx.new_view(|cx| {
+                let mut editor = Editor::for_multibuffer(multibuffer.clone(), project, true, cx);
+                editor.set_expand_all_diff_hunks();
+                editor
+            }),
             recalculate_diffs_tx,
             _recalculate_diffs_task: cx.spawn(|_, mut cx| async move {
                 let mut buffers_to_diff = HashSet::default();

From 563a1dcbab67b58a6c9cf10fe4dea35d862376d1 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Tue, 1 Oct 2024 12:58:21 -0600
Subject: [PATCH 430/762] Fix panic when opening proposed changes editor with
 reversed ranges (#18599)

Closes https://github.com/zed-industries/zed/issues/18589

Release Notes:

- N/A

Co-authored-by: Antonio <antonio@zed.dev>
---
 crates/editor/src/editor.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 54a1318bdfe52c..ddc7de4e41a464 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -12257,12 +12257,9 @@ impl Editor {
         let buffer = self.buffer.read(cx);
         let mut new_selections_by_buffer = HashMap::default();
         for selection in self.selections.all::<usize>(cx) {
-            for (buffer, mut range, _) in
+            for (buffer, range, _) in
                 buffer.range_to_buffer_ranges(selection.start..selection.end, cx)
             {
-                if selection.reversed {
-                    mem::swap(&mut range.start, &mut range.end);
-                }
                 let mut range = range.to_point(buffer.read(cx));
                 range.start.column = 0;
                 range.end.column = buffer.read(cx).line_len(range.end.row);

From e80cbab93f0b30ce6619f9b37636410bc8caab5d Mon Sep 17 00:00:00 2001
From: Roman Zipp <ich@ich.wtf>
Date: Wed, 2 Oct 2024 13:03:23 +0200
Subject: [PATCH 431/762] Fix docs `format_on_save` value is not a boolean
 (#18619)

Fixed [Configuring
Languages](https://zed.dev/docs/configuring-languages) docs using
boolean value for `format_on_save` option although it accepts string
values of `"on"` or `"off"`

Details:

The documentation on [configuring
languages](https://zed.dev/docs/configuring-languages) states the use of
boolean values for the `format_on_save` option although the
[configuration
reference](https://zed.dev/docs/configuring-zed#format-on-save) only
allows the usage of string values `"on"` or `"off"`. In fact using
boolean values will not work and won't translate to `on` or `off`

Release Notes:

- N/A
---
 docs/src/configuring-languages.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/src/configuring-languages.md b/docs/src/configuring-languages.md
index 65e9f822b94786..fc6de9efeab630 100644
--- a/docs/src/configuring-languages.md
+++ b/docs/src/configuring-languages.md
@@ -33,7 +33,7 @@ Here's an example of language-specific settings:
   "Python": {
     "tab_size": 4,
     "formatter": "language_server",
-    "format_on_save": true
+    "format_on_save": "on"
   },
   "JavaScript": {
     "tab_size": 2,
@@ -209,11 +209,11 @@ Zed supports both built-in and external formatters. Configure formatters globall
         "arguments": ["--stdin-filepath", "{buffer_path}"]
       }
     },
-    "format_on_save": true
+    "format_on_save": "on"
   },
   "Rust": {
     "formatter": "language_server",
-    "format_on_save": true
+    "format_on_save": "on"
   }
 }
 ```
@@ -225,7 +225,7 @@ To disable formatting for a specific language:
 ```json
 "languages": {
   "Markdown": {
-    "format_on_save": false
+    "format_on_save": "off"
   }
 }
 ```
@@ -276,7 +276,7 @@ Zed allows you to run both formatting and linting on save. Here's an example tha
     "code_actions_on_format": {
       "source.fixAll.eslint": true
     },
-    "format_on_save": true
+    "format_on_save": "on"
   }
 }
 ```

From b3cdd2ccff82d0a3d2e33171e22838402f8f3f79 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Wed, 2 Oct 2024 13:21:19 +0200
Subject: [PATCH 432/762] ssh remoting: Fix ssh process not being cleaned up
 when connection is closed (#18623)

We introduced a memory leak in #18572, which meant that `Drop` was never
called on `SshRemoteConnection`, meaning that the ssh process kept
running

Co-Authored-by: Thorsten <thorsten@zed.dev>

Release Notes:

- N/A

---------

Co-authored-by: Thorsten <thorsten@zed.dev>
---
 crates/remote/src/ssh_session.rs | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index fe1e42fe966309..6bca9938baac71 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -31,7 +31,7 @@ use std::{
     path::{Path, PathBuf},
     sync::{
         atomic::{AtomicU32, Ordering::SeqCst},
-        Arc,
+        Arc, Weak,
     },
     time::Instant,
 };
@@ -244,12 +244,12 @@ struct SshRemoteClientState {
     ssh_connection: SshRemoteConnection,
     delegate: Arc<dyn SshClientDelegate>,
     forwarder: ChannelForwarder,
-    _multiplex_task: Task<Result<()>>,
+    multiplex_task: Task<Result<()>>,
 }
 
 pub struct SshRemoteClient {
     client: Arc<ChannelClient>,
-    inner_state: Arc<Mutex<Option<SshRemoteClientState>>>,
+    inner_state: Mutex<Option<SshRemoteClientState>>,
 }
 
 impl SshRemoteClient {
@@ -264,7 +264,7 @@ impl SshRemoteClient {
         let client = cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx))?;
         let this = Arc::new(Self {
             client,
-            inner_state: Arc::new(Mutex::new(None)),
+            inner_state: Mutex::new(None),
         });
 
         let inner_state = {
@@ -276,7 +276,7 @@ impl SshRemoteClient {
                     .await?;
 
             let multiplex_task = Self::multiplex(
-                this.clone(),
+                Arc::downgrade(&this),
                 ssh_process,
                 proxy_incoming_tx,
                 proxy_outgoing_rx,
@@ -287,7 +287,7 @@ impl SshRemoteClient {
                 ssh_connection,
                 delegate,
                 forwarder: proxy,
-                _multiplex_task: multiplex_task,
+                multiplex_task,
             }
         };
 
@@ -305,9 +305,9 @@ impl SshRemoteClient {
             mut ssh_connection,
             delegate,
             forwarder: proxy,
-            _multiplex_task,
+            multiplex_task,
         } = state;
-        drop(_multiplex_task);
+        drop(multiplex_task);
 
         cx.spawn(|mut cx| async move {
             let (incoming_tx, outgoing_rx) = proxy.into_channels().await;
@@ -331,8 +331,8 @@ impl SshRemoteClient {
                 ssh_connection,
                 delegate,
                 forwarder: proxy,
-                _multiplex_task: Self::multiplex(
-                    this.clone(),
+                multiplex_task: Self::multiplex(
+                    Arc::downgrade(&this),
                     ssh_process,
                     proxy_incoming_tx,
                     proxy_outgoing_rx,
@@ -349,7 +349,7 @@ impl SshRemoteClient {
     }
 
     fn multiplex(
-        this: Arc<Self>,
+        this: Weak<Self>,
         mut ssh_process: Child,
         incoming_tx: UnboundedSender<Envelope>,
         mut outgoing_rx: UnboundedReceiver<Envelope>,
@@ -444,7 +444,9 @@ impl SshRemoteClient {
 
             if let Err(error) = result {
                 log::warn!("ssh io task died with error: {:?}. reconnecting...", error);
-                Self::reconnect(this, &mut cx).ok();
+                if let Some(this) = this.upgrade() {
+                    Self::reconnect(this, &mut cx).ok();
+                }
             }
 
             Ok(())
@@ -516,7 +518,7 @@ impl SshRemoteClient {
                 let client = ChannelClient::new(server_to_client_rx, client_to_server_tx, cx);
                 Arc::new(Self {
                     client,
-                    inner_state: Arc::new(Mutex::new(None)),
+                    inner_state: Mutex::new(None),
                 })
             }),
             server_cx.update(|cx| ChannelClient::new(client_to_server_rx, server_to_client_tx, cx)),

From 0ee1d7ab2634521e11cb7f221074b0287763359d Mon Sep 17 00:00:00 2001
From: loczek <30776250+loczek@users.noreply.github.com>
Date: Wed, 2 Oct 2024 13:27:16 +0200
Subject: [PATCH 433/762] Add snippet commands (#18453)

Closes #17860
Closes #15403

Release Notes:

- Added `snippets: configure snippets` command to create and modify
snippets
- Added `snippets: open folder` command for opening the
`~/.config/zed/snippets` directory


https://github.com/user-attachments/assets/fd9e664c-44b1-49bf-87a8-42b9e516f12f
---
 Cargo.lock                            |  15 ++
 Cargo.toml                            |   2 +
 crates/snippets_ui/Cargo.toml         |  22 +++
 crates/snippets_ui/LICENSE-GPL        |   1 +
 crates/snippets_ui/src/snippets_ui.rs | 226 ++++++++++++++++++++++++++
 crates/zed/Cargo.toml                 |   1 +
 crates/zed/src/main.rs                |   1 +
 7 files changed, 268 insertions(+)
 create mode 100644 crates/snippets_ui/Cargo.toml
 create mode 120000 crates/snippets_ui/LICENSE-GPL
 create mode 100644 crates/snippets_ui/src/snippets_ui.rs

diff --git a/Cargo.lock b/Cargo.lock
index 123141d188e0eb..7c92ef0f5257c7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10500,6 +10500,20 @@ dependencies = [
  "util",
 ]
 
+[[package]]
+name = "snippets_ui"
+version = "0.1.0"
+dependencies = [
+ "fuzzy",
+ "gpui",
+ "language",
+ "paths",
+ "picker",
+ "ui",
+ "util",
+ "workspace",
+]
+
 [[package]]
 name = "socket2"
 version = "0.4.10"
@@ -14468,6 +14482,7 @@ dependencies = [
  "simplelog",
  "smol",
  "snippet_provider",
+ "snippets_ui",
  "supermaven",
  "sysinfo",
  "tab_switcher",
diff --git a/Cargo.toml b/Cargo.toml
index c72fec020fe678..1ef14dae70c202 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -99,6 +99,7 @@ members = [
     "crates/settings_ui",
     "crates/snippet",
     "crates/snippet_provider",
+    "crates/snippets_ui",
     "crates/sqlez",
     "crates/sqlez_macros",
     "crates/story",
@@ -275,6 +276,7 @@ settings = { path = "crates/settings" }
 settings_ui = { path = "crates/settings_ui" }
 snippet = { path = "crates/snippet" }
 snippet_provider = { path = "crates/snippet_provider" }
+snippets_ui = { path = "crates/snippets_ui" }
 sqlez = { path = "crates/sqlez" }
 sqlez_macros = { path = "crates/sqlez_macros" }
 story = { path = "crates/story" }
diff --git a/crates/snippets_ui/Cargo.toml b/crates/snippets_ui/Cargo.toml
new file mode 100644
index 00000000000000..da9eff4ae55bad
--- /dev/null
+++ b/crates/snippets_ui/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "snippets_ui"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/snippets_ui.rs"
+
+[dependencies]
+fuzzy.workspace = true
+gpui.workspace = true
+language.workspace = true
+paths.workspace = true
+picker.workspace = true
+ui.workspace = true
+util.workspace = true
+workspace.workspace = true
diff --git a/crates/snippets_ui/LICENSE-GPL b/crates/snippets_ui/LICENSE-GPL
new file mode 120000
index 00000000000000..89e542f750cd38
--- /dev/null
+++ b/crates/snippets_ui/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
\ No newline at end of file
diff --git a/crates/snippets_ui/src/snippets_ui.rs b/crates/snippets_ui/src/snippets_ui.rs
new file mode 100644
index 00000000000000..c8ab6febdaa076
--- /dev/null
+++ b/crates/snippets_ui/src/snippets_ui.rs
@@ -0,0 +1,226 @@
+use fuzzy::{match_strings, StringMatch, StringMatchCandidate};
+use gpui::{
+    actions, AppContext, DismissEvent, EventEmitter, FocusableView, ParentElement, Render, Styled,
+    View, ViewContext, VisualContext, WeakView,
+};
+use language::LanguageRegistry;
+use paths::config_dir;
+use picker::{Picker, PickerDelegate};
+use std::{borrow::Borrow, fs, sync::Arc};
+use ui::{prelude::*, HighlightedLabel, ListItem, ListItemSpacing, WindowContext};
+use util::ResultExt;
+use workspace::{notifications::NotifyResultExt, ModalView, Workspace};
+
+actions!(snippets, [ConfigureSnippets, OpenFolder]);
+
+pub fn init(cx: &mut AppContext) {
+    cx.observe_new_views(register).detach();
+}
+
+fn register(workspace: &mut Workspace, _: &mut ViewContext<Workspace>) {
+    workspace.register_action(configure_snippets);
+    workspace.register_action(open_folder);
+}
+
+fn configure_snippets(
+    workspace: &mut Workspace,
+    _: &ConfigureSnippets,
+    cx: &mut ViewContext<Workspace>,
+) {
+    let language_registry = workspace.app_state().languages.clone();
+    let workspace_handle = workspace.weak_handle();
+
+    workspace.toggle_modal(cx, move |cx| {
+        ScopeSelector::new(language_registry, workspace_handle, cx)
+    });
+}
+
+fn open_folder(workspace: &mut Workspace, _: &OpenFolder, cx: &mut ViewContext<Workspace>) {
+    fs::create_dir_all(config_dir().join("snippets")).notify_err(workspace, cx);
+    cx.open_with_system(config_dir().join("snippets").borrow());
+}
+
+pub struct ScopeSelector {
+    picker: View<Picker<ScopeSelectorDelegate>>,
+}
+
+impl ScopeSelector {
+    fn new(
+        language_registry: Arc<LanguageRegistry>,
+        workspace: WeakView<Workspace>,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
+        let delegate =
+            ScopeSelectorDelegate::new(workspace, cx.view().downgrade(), language_registry);
+
+        let picker = cx.new_view(|cx| Picker::uniform_list(delegate, cx));
+
+        Self { picker }
+    }
+}
+
+impl ModalView for ScopeSelector {}
+
+impl EventEmitter<DismissEvent> for ScopeSelector {}
+
+impl FocusableView for ScopeSelector {
+    fn focus_handle(&self, cx: &AppContext) -> gpui::FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl Render for ScopeSelector {
+    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+        v_flex().w(rems(34.)).child(self.picker.clone())
+    }
+}
+
+pub struct ScopeSelectorDelegate {
+    workspace: WeakView<Workspace>,
+    scope_selector: WeakView<ScopeSelector>,
+    language_registry: Arc<LanguageRegistry>,
+    candidates: Vec<StringMatchCandidate>,
+    matches: Vec<StringMatch>,
+    selected_index: usize,
+}
+
+impl ScopeSelectorDelegate {
+    fn new(
+        workspace: WeakView<Workspace>,
+        scope_selector: WeakView<ScopeSelector>,
+        language_registry: Arc<LanguageRegistry>,
+    ) -> Self {
+        let candidates = Vec::from(["Global".to_string()]).into_iter();
+        let languages = language_registry.language_names().into_iter();
+
+        let candidates = candidates
+            .chain(languages)
+            .enumerate()
+            .map(|(candidate_id, name)| StringMatchCandidate::new(candidate_id, name))
+            .collect::<Vec<_>>();
+
+        Self {
+            workspace,
+            scope_selector,
+            language_registry,
+            candidates,
+            matches: vec![],
+            selected_index: 0,
+        }
+    }
+}
+
+impl PickerDelegate for ScopeSelectorDelegate {
+    type ListItem = ListItem;
+
+    fn placeholder_text(&self, _: &mut WindowContext) -> Arc<str> {
+        "Select snippet scope...".into()
+    }
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn confirm(&mut self, _: bool, cx: &mut ViewContext<Picker<Self>>) {
+        if let Some(mat) = self.matches.get(self.selected_index) {
+            let scope_name = self.candidates[mat.candidate_id].string.clone();
+            let language = self.language_registry.language_for_name(&scope_name);
+
+            if let Some(workspace) = self.workspace.upgrade() {
+                cx.spawn(|_, mut cx| async move {
+                    let scope = match scope_name.as_str() {
+                        "Global" => "snippets".to_string(),
+                        _ => language.await?.lsp_id(),
+                    };
+
+                    workspace.update(&mut cx, |workspace, cx| {
+                        workspace
+                            .open_abs_path(
+                                config_dir().join("snippets").join(scope + ".json"),
+                                false,
+                                cx,
+                            )
+                            .detach();
+                    })
+                })
+                .detach_and_log_err(cx);
+            };
+        }
+        self.dismissed(cx);
+    }
+
+    fn dismissed(&mut self, cx: &mut ViewContext<Picker<Self>>) {
+        self.scope_selector
+            .update(cx, |_, cx| cx.emit(DismissEvent))
+            .log_err();
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(&mut self, ix: usize, _: &mut ViewContext<Picker<Self>>) {
+        self.selected_index = ix;
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        cx: &mut ViewContext<Picker<Self>>,
+    ) -> gpui::Task<()> {
+        let background = cx.background_executor().clone();
+        let candidates = self.candidates.clone();
+        cx.spawn(|this, mut cx| async move {
+            let matches = if query.is_empty() {
+                candidates
+                    .into_iter()
+                    .enumerate()
+                    .map(|(index, candidate)| StringMatch {
+                        candidate_id: index,
+                        string: candidate.string,
+                        positions: Vec::new(),
+                        score: 0.0,
+                    })
+                    .collect()
+            } else {
+                match_strings(
+                    &candidates,
+                    &query,
+                    false,
+                    100,
+                    &Default::default(),
+                    background,
+                )
+                .await
+            };
+
+            this.update(&mut cx, |this, cx| {
+                let delegate = &mut this.delegate;
+                delegate.matches = matches;
+                delegate.selected_index = delegate
+                    .selected_index
+                    .min(delegate.matches.len().saturating_sub(1));
+                cx.notify();
+            })
+            .log_err();
+        })
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _: &mut ViewContext<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let mat = &self.matches[ix];
+        let label = mat.string.clone();
+
+        Some(
+            ListItem::new(ix)
+                .inset(true)
+                .spacing(ListItemSpacing::Sparse)
+                .selected(selected)
+                .child(HighlightedLabel::new(label, mat.positions.clone())),
+        )
+    }
+}
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index 5422f8b29aa98d..775a59e475cb47 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -96,6 +96,7 @@ shellexpand.workspace = true
 simplelog.workspace = true
 smol.workspace = true
 snippet_provider.workspace = true
+snippets_ui.workspace = true
 supermaven.workspace = true
 sysinfo.workspace = true
 tab_switcher.workspace = true
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 186805d12cd01d..06f1d926aea37d 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -256,6 +256,7 @@ fn init_ui(
     project_panel::init(Assets, cx);
     outline_panel::init(Assets, cx);
     tasks_ui::init(cx);
+    snippets_ui::init(cx);
     channel::init(&app_state.client.clone(), app_state.user_store.clone(), cx);
     search::init(cx);
     vim::init(cx);

From fd94c2b3fd5ceac67ff852d1781b4c707f5ed487 Mon Sep 17 00:00:00 2001
From: Patrick <39161540+patrickJramos@users.noreply.github.com>
Date: Wed, 2 Oct 2024 08:44:42 -0300
Subject: [PATCH 434/762] Keep tab position when closing tabs (#18168)

- Closes #18036

Release Notes:

- N/A
---
 crates/workspace/src/pane.rs | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index 82300690e7dbe1..3e228b7b1602b3 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -1407,17 +1407,13 @@ impl Pane {
             self.pinned_tab_count -= 1;
         }
         if item_index == self.active_item_index {
-            let index_to_activate = self
-                .activation_history
-                .pop()
-                .and_then(|last_activated_item| {
-                    self.items.iter().enumerate().find_map(|(index, item)| {
-                        (item.item_id() == last_activated_item.entity_id).then_some(index)
-                    })
-                })
-                // We didn't have a valid activation history entry, so fallback
-                // to activating the item to the left
-                .unwrap_or_else(|| item_index.min(self.items.len()).saturating_sub(1));
+            self.activation_history.pop();
+
+            let index_to_activate = if item_index + 1 < self.items.len() {
+                item_index + 1
+            } else {
+                item_index.saturating_sub(1)
+            };
 
             let should_activate = activate_pane || self.has_focus(cx);
             if self.items.len() == 1 && should_activate {
@@ -3320,7 +3316,7 @@ mod tests {
         .unwrap()
         .await
         .unwrap();
-        assert_item_labels(&pane, ["A", "B*", "C", "D"], cx);
+        assert_item_labels(&pane, ["A", "B", "C*", "D"], cx);
 
         pane.update(cx, |pane, cx| pane.activate_item(3, false, false, cx));
         assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
@@ -3331,7 +3327,7 @@ mod tests {
         .unwrap()
         .await
         .unwrap();
-        assert_item_labels(&pane, ["A", "B*", "C"], cx);
+        assert_item_labels(&pane, ["A", "B", "C*"], cx);
 
         pane.update(cx, |pane, cx| {
             pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
@@ -3339,7 +3335,7 @@ mod tests {
         .unwrap()
         .await
         .unwrap();
-        assert_item_labels(&pane, ["A", "C*"], cx);
+        assert_item_labels(&pane, ["A", "B*"], cx);
 
         pane.update(cx, |pane, cx| {
             pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)

From e01bc6765db7352559d20d3b0f18b124dc4707d8 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Wed, 2 Oct 2024 13:45:07 +0200
Subject: [PATCH 435/762] editor: Fix "Reveal in File Manager" not working with
 multibuffers (#18626)

Additionally, mark context menu entry as disabled when the action would
fail (untitled buffer, collab sessions).

Supersedes #18584

Release Notes:

- Fixed "Reveal in Finder/File Manager", "Copy Path", "Copy Relative
Path" and "Copy file location" actions not working with multibuffers.
---
 crates/editor/src/editor.rs             | 40 ++++++++++++-------------
 crates/editor/src/mouse_context_menu.rs | 18 +++++++----
 2 files changed, 33 insertions(+), 25 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index ddc7de4e41a464..525a94f2582ab1 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -11257,30 +11257,32 @@ impl Editor {
         None
     }
 
+    fn target_file<'a>(&self, cx: &'a AppContext) -> Option<&'a dyn language::LocalFile> {
+        self.active_excerpt(cx)?
+            .1
+            .read(cx)
+            .file()
+            .and_then(|f| f.as_local())
+    }
+
     pub fn reveal_in_finder(&mut self, _: &RevealInFileManager, cx: &mut ViewContext<Self>) {
-        if let Some(buffer) = self.buffer().read(cx).as_singleton() {
-            if let Some(file) = buffer.read(cx).file().and_then(|f| f.as_local()) {
-                cx.reveal_path(&file.abs_path(cx));
-            }
+        if let Some(target) = self.target_file(cx) {
+            cx.reveal_path(&target.abs_path(cx));
         }
     }
 
     pub fn copy_path(&mut self, _: &CopyPath, cx: &mut ViewContext<Self>) {
-        if let Some(buffer) = self.buffer().read(cx).as_singleton() {
-            if let Some(file) = buffer.read(cx).file().and_then(|f| f.as_local()) {
-                if let Some(path) = file.abs_path(cx).to_str() {
-                    cx.write_to_clipboard(ClipboardItem::new_string(path.to_string()));
-                }
+        if let Some(file) = self.target_file(cx) {
+            if let Some(path) = file.abs_path(cx).to_str() {
+                cx.write_to_clipboard(ClipboardItem::new_string(path.to_string()));
             }
         }
     }
 
     pub fn copy_relative_path(&mut self, _: &CopyRelativePath, cx: &mut ViewContext<Self>) {
-        if let Some(buffer) = self.buffer().read(cx).as_singleton() {
-            if let Some(file) = buffer.read(cx).file().and_then(|f| f.as_local()) {
-                if let Some(path) = file.path().to_str() {
-                    cx.write_to_clipboard(ClipboardItem::new_string(path.to_string()));
-                }
+        if let Some(file) = self.target_file(cx) {
+            if let Some(path) = file.path().to_str() {
+                cx.write_to_clipboard(ClipboardItem::new_string(path.to_string()));
             }
         }
     }
@@ -11491,12 +11493,10 @@ impl Editor {
     }
 
     pub fn copy_file_location(&mut self, _: &CopyFileLocation, cx: &mut ViewContext<Self>) {
-        if let Some(buffer) = self.buffer().read(cx).as_singleton() {
-            if let Some(file) = buffer.read(cx).file().and_then(|f| f.as_local()) {
-                if let Some(path) = file.path().to_str() {
-                    let selection = self.selections.newest::<Point>(cx).start.row + 1;
-                    cx.write_to_clipboard(ClipboardItem::new_string(format!("{path}:{selection}")));
-                }
+        if let Some(file) = self.target_file(cx) {
+            if let Some(path) = file.path().to_str() {
+                let selection = self.selections.newest::<Point>(cx).start.row + 1;
+                cx.write_to_clipboard(ClipboardItem::new_string(format!("{path}:{selection}")));
             }
         }
     }
diff --git a/crates/editor/src/mouse_context_menu.rs b/crates/editor/src/mouse_context_menu.rs
index 239d7955a056b4..936d95dccbf8c2 100644
--- a/crates/editor/src/mouse_context_menu.rs
+++ b/crates/editor/src/mouse_context_menu.rs
@@ -158,6 +158,12 @@ pub fn deploy_context_menu(
         }
 
         let focus = cx.focused();
+        let has_reveal_target = editor.target_file(cx).is_some();
+        let reveal_in_finder_label = if cfg!(target_os = "macos") {
+            "Reveal in Finder"
+        } else {
+            "Reveal in File Manager"
+        };
         ui::ContextMenu::build(cx, |menu, _cx| {
             let builder = menu
                 .on_blur_subscription(Subscription::new(|| {}))
@@ -180,11 +186,13 @@ pub fn deploy_context_menu(
                 .action("Copy", Box::new(Copy))
                 .action("Paste", Box::new(Paste))
                 .separator()
-                .when(cfg!(target_os = "macos"), |builder| {
-                    builder.action("Reveal in Finder", Box::new(RevealInFileManager))
-                })
-                .when(cfg!(not(target_os = "macos")), |builder| {
-                    builder.action("Reveal in File Manager", Box::new(RevealInFileManager))
+                .map(|builder| {
+                    if has_reveal_target {
+                        builder.action(reveal_in_finder_label, Box::new(RevealInFileManager))
+                    } else {
+                        builder
+                            .disabled_action(reveal_in_finder_label, Box::new(RevealInFileManager))
+                    }
                 })
                 .action("Open in Terminal", Box::new(OpenInTerminal))
                 .action("Copy Permalink", Box::new(CopyPermalinkToLine));

From 82d3fcdf4b97566357633801df047027240aa286 Mon Sep 17 00:00:00 2001
From: Roy Williams <roy@anthropic.com>
Date: Wed, 2 Oct 2024 09:29:11 -0400
Subject: [PATCH 436/762] Tweak assistant prompt to only fix diagnostic issues
 when requested to do so (#18596)

Release Notes:

- Assistant: Make the model less likely to incorporate diagnostic
information when not requested to fix any issues.

![CleanShot 2024-10-01 at 13 44
08](https://github.com/user-attachments/assets/f0e9a132-6cac-4dc6-889f-467e59ec8bbc)
---
 assets/prompts/content_prompt.hbs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/assets/prompts/content_prompt.hbs b/assets/prompts/content_prompt.hbs
index e944e230f56f9b..c029f84b24c36e 100644
--- a/assets/prompts/content_prompt.hbs
+++ b/assets/prompts/content_prompt.hbs
@@ -50,6 +50,9 @@ And here's the section to rewrite based on that prompt again for reference:
 
 {{#if diagnostic_errors}}
 {{#each diagnostic_errors}}
+
+Below are the diagnostic errors visible to the user.  If the user requests problems to be fixed, use this information, but do not try to fix these errors if the user hasn't asked you to.
+
 <diagnostic_error>
     <line_number>{{line_number}}</line_number>
     <error_message>{{error_message}}</error_message>

From 8a18c94f33fc36c89016c8f606a20632ce63b472 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 2 Oct 2024 15:35:50 +0200
Subject: [PATCH 437/762] Make slash command descriptions consistent (#18595)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR adds a description constant in most of the slash command files
so that both the editor _and_ footer pickers use the same string. In
terms of copywriting, I did some tweaking to reduce the longer ones a
bit. Also standardized them all to use sentence case, as opposed to each
instance using a different convention. The editor picker needs more
work, though, given the arguments and descriptions are being cut at the
moment. This should happen in a follow-up!

<img width="900" alt="Screenshot 2024-10-01 at 7 25 19 PM"
src="https://github.com/user-attachments/assets/e8759eff-0de9-4a4d-a026-366d85507b3c">

---

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 crates/assistant/src/slash_command/auto_command.rs        | 4 ++--
 crates/assistant/src/slash_command/delta_command.rs       | 4 ++--
 crates/assistant/src/slash_command/diagnostics_command.rs | 2 +-
 crates/assistant/src/slash_command/fetch_command.rs       | 4 ++--
 crates/assistant/src/slash_command/file_command.rs        | 4 ++--
 crates/assistant/src/slash_command/now_command.rs         | 4 ++--
 crates/assistant/src/slash_command/project_command.rs     | 4 ++--
 crates/assistant/src/slash_command/prompt_command.rs      | 4 ++--
 crates/assistant/src/slash_command/search_command.rs      | 4 ++--
 crates/assistant/src/slash_command/symbols_command.rs     | 4 ++--
 crates/assistant/src/slash_command/tab_command.rs         | 4 ++--
 crates/assistant/src/slash_command/terminal_command.rs    | 4 ++--
 crates/assistant/src/slash_command/workflow_command.rs    | 4 ++--
 crates/assistant/src/slash_command_picker.rs              | 6 ++++--
 14 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/crates/assistant/src/slash_command/auto_command.rs b/crates/assistant/src/slash_command/auto_command.rs
index 14cee296820989..14bbb7c8412b41 100644
--- a/crates/assistant/src/slash_command/auto_command.rs
+++ b/crates/assistant/src/slash_command/auto_command.rs
@@ -31,11 +31,11 @@ impl SlashCommand for AutoCommand {
     }
 
     fn description(&self) -> String {
-        "Automatically infer what context to add, based on your prompt".into()
+        "Automatically infer what context to add".into()
     }
 
     fn menu_text(&self) -> String {
-        "Automatically Infer Context".into()
+        self.description()
     }
 
     fn label(&self, cx: &AppContext) -> CodeLabel {
diff --git a/crates/assistant/src/slash_command/delta_command.rs b/crates/assistant/src/slash_command/delta_command.rs
index 6a66ad3f09aa9a..6f697ecbb9bcba 100644
--- a/crates/assistant/src/slash_command/delta_command.rs
+++ b/crates/assistant/src/slash_command/delta_command.rs
@@ -19,11 +19,11 @@ impl SlashCommand for DeltaSlashCommand {
     }
 
     fn description(&self) -> String {
-        "re-insert changed files".into()
+        "Re-insert changed files".into()
     }
 
     fn menu_text(&self) -> String {
-        "Re-insert Changed Files".into()
+        self.description()
     }
 
     fn requires_argument(&self) -> bool {
diff --git a/crates/assistant/src/slash_command/diagnostics_command.rs b/crates/assistant/src/slash_command/diagnostics_command.rs
index 3f79c016750318..146a4e5d366dd3 100644
--- a/crates/assistant/src/slash_command/diagnostics_command.rs
+++ b/crates/assistant/src/slash_command/diagnostics_command.rs
@@ -95,7 +95,7 @@ impl SlashCommand for DiagnosticsSlashCommand {
     }
 
     fn menu_text(&self) -> String {
-        "Insert Diagnostics".into()
+        self.description()
     }
 
     fn requires_argument(&self) -> bool {
diff --git a/crates/assistant/src/slash_command/fetch_command.rs b/crates/assistant/src/slash_command/fetch_command.rs
index 23d3c884a8ec28..3a01bb645a36bb 100644
--- a/crates/assistant/src/slash_command/fetch_command.rs
+++ b/crates/assistant/src/slash_command/fetch_command.rs
@@ -104,11 +104,11 @@ impl SlashCommand for FetchSlashCommand {
     }
 
     fn description(&self) -> String {
-        "insert URL contents".into()
+        "Insert fetched URL contents".into()
     }
 
     fn menu_text(&self) -> String {
-        "Insert fetched URL contents".into()
+        self.description()
     }
 
     fn requires_argument(&self) -> bool {
diff --git a/crates/assistant/src/slash_command/file_command.rs b/crates/assistant/src/slash_command/file_command.rs
index 260c6b0e2a0840..6da56d064178ad 100644
--- a/crates/assistant/src/slash_command/file_command.rs
+++ b/crates/assistant/src/slash_command/file_command.rs
@@ -110,11 +110,11 @@ impl SlashCommand for FileSlashCommand {
     }
 
     fn description(&self) -> String {
-        "insert file".into()
+        "Insert file".into()
     }
 
     fn menu_text(&self) -> String {
-        "Insert File".into()
+        self.description()
     }
 
     fn requires_argument(&self) -> bool {
diff --git a/crates/assistant/src/slash_command/now_command.rs b/crates/assistant/src/slash_command/now_command.rs
index eb0ca926f015b6..221ba05cafc623 100644
--- a/crates/assistant/src/slash_command/now_command.rs
+++ b/crates/assistant/src/slash_command/now_command.rs
@@ -19,11 +19,11 @@ impl SlashCommand for NowSlashCommand {
     }
 
     fn description(&self) -> String {
-        "insert the current date and time".into()
+        "Insert current date and time".into()
     }
 
     fn menu_text(&self) -> String {
-        "Insert Current Date and Time".into()
+        self.description()
     }
 
     fn requires_argument(&self) -> bool {
diff --git a/crates/assistant/src/slash_command/project_command.rs b/crates/assistant/src/slash_command/project_command.rs
index 197e91d91addac..58fef8f338771d 100644
--- a/crates/assistant/src/slash_command/project_command.rs
+++ b/crates/assistant/src/slash_command/project_command.rs
@@ -47,11 +47,11 @@ impl SlashCommand for ProjectSlashCommand {
     }
 
     fn description(&self) -> String {
-        "Generate semantic searches based on the current context".into()
+        "Generate a semantic search based on context".into()
     }
 
     fn menu_text(&self) -> String {
-        "Project Context".into()
+        self.description()
     }
 
     fn requires_argument(&self) -> bool {
diff --git a/crates/assistant/src/slash_command/prompt_command.rs b/crates/assistant/src/slash_command/prompt_command.rs
index effbcc0f90ce87..978c6d7504caeb 100644
--- a/crates/assistant/src/slash_command/prompt_command.rs
+++ b/crates/assistant/src/slash_command/prompt_command.rs
@@ -16,11 +16,11 @@ impl SlashCommand for PromptSlashCommand {
     }
 
     fn description(&self) -> String {
-        "insert prompt from library".into()
+        "Insert prompt from library".into()
     }
 
     fn menu_text(&self) -> String {
-        "Insert Prompt from Library".into()
+        self.description()
     }
 
     fn requires_argument(&self) -> bool {
diff --git a/crates/assistant/src/slash_command/search_command.rs b/crates/assistant/src/slash_command/search_command.rs
index f0f3ee3d25c660..c7183e95bbc853 100644
--- a/crates/assistant/src/slash_command/search_command.rs
+++ b/crates/assistant/src/slash_command/search_command.rs
@@ -34,11 +34,11 @@ impl SlashCommand for SearchSlashCommand {
     }
 
     fn description(&self) -> String {
-        "semantic search".into()
+        "Search your project semantically".into()
     }
 
     fn menu_text(&self) -> String {
-        "Semantic Search".into()
+        self.description()
     }
 
     fn requires_argument(&self) -> bool {
diff --git a/crates/assistant/src/slash_command/symbols_command.rs b/crates/assistant/src/slash_command/symbols_command.rs
index 1cf8536c0dbfe7..887b57ba9956c7 100644
--- a/crates/assistant/src/slash_command/symbols_command.rs
+++ b/crates/assistant/src/slash_command/symbols_command.rs
@@ -17,11 +17,11 @@ impl SlashCommand for OutlineSlashCommand {
     }
 
     fn description(&self) -> String {
-        "insert symbols for active tab".into()
+        "Insert symbols for active tab".into()
     }
 
     fn menu_text(&self) -> String {
-        "Insert Symbols for Active Tab".into()
+        self.description()
     }
 
     fn complete_argument(
diff --git a/crates/assistant/src/slash_command/tab_command.rs b/crates/assistant/src/slash_command/tab_command.rs
index bdf8450d43be81..0bff4730d8e5c8 100644
--- a/crates/assistant/src/slash_command/tab_command.rs
+++ b/crates/assistant/src/slash_command/tab_command.rs
@@ -24,11 +24,11 @@ impl SlashCommand for TabSlashCommand {
     }
 
     fn description(&self) -> String {
-        "insert open tabs (active tab by default)".to_owned()
+        "Insert open tabs (active tab by default)".to_owned()
     }
 
     fn menu_text(&self) -> String {
-        "Insert Open Tabs".to_owned()
+        self.description()
     }
 
     fn requires_argument(&self) -> bool {
diff --git a/crates/assistant/src/slash_command/terminal_command.rs b/crates/assistant/src/slash_command/terminal_command.rs
index 1d0293c235d442..1d4959fb199572 100644
--- a/crates/assistant/src/slash_command/terminal_command.rs
+++ b/crates/assistant/src/slash_command/terminal_command.rs
@@ -29,11 +29,11 @@ impl SlashCommand for TerminalSlashCommand {
     }
 
     fn description(&self) -> String {
-        "insert terminal output".into()
+        "Insert terminal output".into()
     }
 
     fn menu_text(&self) -> String {
-        "Insert Terminal Output".into()
+        self.description()
     }
 
     fn requires_argument(&self) -> bool {
diff --git a/crates/assistant/src/slash_command/workflow_command.rs b/crates/assistant/src/slash_command/workflow_command.rs
index c66dd9bebff144..071b4feaf436e3 100644
--- a/crates/assistant/src/slash_command/workflow_command.rs
+++ b/crates/assistant/src/slash_command/workflow_command.rs
@@ -29,11 +29,11 @@ impl SlashCommand for WorkflowSlashCommand {
     }
 
     fn description(&self) -> String {
-        "insert a prompt that opts into the edit workflow".into()
+        "Insert prompt to opt into the edit workflow".into()
     }
 
     fn menu_text(&self) -> String {
-        "Insert Workflow Prompt".into()
+        self.description()
     }
 
     fn requires_argument(&self) -> bool {
diff --git a/crates/assistant/src/slash_command_picker.rs b/crates/assistant/src/slash_command_picker.rs
index 4b57dcfb3306c5..58023848b0e508 100644
--- a/crates/assistant/src/slash_command_picker.rs
+++ b/crates/assistant/src/slash_command_picker.rs
@@ -184,7 +184,7 @@ impl PickerDelegate for SlashCommandDelegate {
                         h_flex()
                             .group(format!("command-entry-label-{ix}"))
                             .w_full()
-                            .min_w(px(220.))
+                            .min_w(px(250.))
                             .child(
                                 v_flex()
                                     .child(
@@ -203,7 +203,9 @@ impl PickerDelegate for SlashCommandDelegate {
                                                     div()
                                                         .font_buffer(cx)
                                                         .child(
-                                                            Label::new(args).size(LabelSize::Small),
+                                                            Label::new(args)
+                                                                .size(LabelSize::Small)
+                                                                .color(Color::Muted),
                                                         )
                                                         .visible_on_hover(format!(
                                                             "command-entry-label-{ix}"

From 21336eb12491e3b505437c8d3fa99e7aaf64460f Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 2 Oct 2024 10:10:53 -0400
Subject: [PATCH 438/762] docs: Add note about forking the extensions repo to a
 personal GitHub account (#18631)

This PR adds a note to the docs encouraging folks to fork the
`zed-industries/extensions` repo to a personal GitHub account rather
than a GitHub organization, as this makes life easier for everyone.

Release Notes:

- N/A
---
 docs/src/extensions/developing-extensions.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docs/src/extensions/developing-extensions.md b/docs/src/extensions/developing-extensions.md
index c1330a4c49eef4..503d253fc33bb3 100644
--- a/docs/src/extensions/developing-extensions.md
+++ b/docs/src/extensions/developing-extensions.md
@@ -86,6 +86,8 @@ If you already have a published extension with the same name installed, your dev
 
 To publish an extension, open a PR to [the `zed-industries/extensions` repo](https://github.com/zed-industries/extensions).
 
+> Note: It is very helpful if you fork the `zed-industries/extensions` repo to a personal GitHub account instead of a GitHub organization, as this allows Zed staff to push any needed changes to your PR to expedite the publishing process.
+
 In your PR, do the following:
 
 1. Add your extension as a Git submodule within the `extensions/` directory

From cfd61f933773ff152d3520cba84f6ac69453c7bf Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 2 Oct 2024 10:38:23 -0400
Subject: [PATCH 439/762] Clean up formatting in `Cargo.toml` (#18632)

This PR cleans up some formatting in some `Cargo.toml` files.

Release Notes:

- N/A
---
 crates/languages/Cargo.toml | 35 +++++++++++++++++------------------
 crates/util/Cargo.toml      |  8 ++++----
 crates/worktree/Cargo.toml  |  8 ++++----
 crates/zed/Cargo.toml       |  2 +-
 4 files changed, 26 insertions(+), 27 deletions(-)

diff --git a/crates/languages/Cargo.toml b/crates/languages/Cargo.toml
index 5cb5455dd168d6..19842efac20cf7 100644
--- a/crates/languages/Cargo.toml
+++ b/crates/languages/Cargo.toml
@@ -46,6 +46,7 @@ lsp.workspace = true
 node_runtime.workspace = true
 paths.workspace = true
 project.workspace = true
+protols-tree-sitter-proto = { workspace = true, optional = true }
 regex.workspace = true
 rope.workspace = true
 rust-embed.workspace = true
@@ -55,26 +56,24 @@ settings.workspace = true
 smol.workspace = true
 task.workspace = true
 toml.workspace = true
+tree-sitter = { workspace = true, optional = true }
+tree-sitter-bash = { workspace = true, optional = true }
+tree-sitter-c = { workspace = true, optional = true }
+tree-sitter-cpp = { workspace = true, optional = true }
+tree-sitter-css = { workspace = true, optional = true }
+tree-sitter-go = { workspace = true, optional = true }
+tree-sitter-go-mod = { workspace = true, optional = true }
+tree-sitter-gowork = { workspace = true, optional = true }
+tree-sitter-jsdoc = { workspace = true, optional = true }
+tree-sitter-json = { workspace = true, optional = true }
+tree-sitter-md = { workspace = true, optional = true }
+tree-sitter-python = { workspace = true, optional = true }
+tree-sitter-regex = { workspace = true, optional = true }
+tree-sitter-rust = { workspace = true, optional = true }
+tree-sitter-typescript = { workspace = true, optional = true }
+tree-sitter-yaml = { workspace = true, optional = true }
 util.workspace = true
 
-tree-sitter-bash = {workspace = true, optional = true}
-tree-sitter-c = {workspace = true, optional = true}
-tree-sitter-cpp = {workspace = true, optional = true}
-tree-sitter-css = {workspace = true, optional = true}
-tree-sitter-go = {workspace = true, optional = true}
-tree-sitter-go-mod = {workspace = true, optional = true}
-tree-sitter-gowork = {workspace = true, optional = true}
-tree-sitter-jsdoc = {workspace = true, optional = true}
-tree-sitter-json = {workspace = true, optional = true}
-tree-sitter-md = {workspace = true, optional = true}
-protols-tree-sitter-proto = {workspace = true, optional = true}
-tree-sitter-python = {workspace = true, optional = true}
-tree-sitter-regex = {workspace = true, optional = true}
-tree-sitter-rust = {workspace = true, optional = true}
-tree-sitter-typescript = {workspace = true, optional = true}
-tree-sitter-yaml = {workspace = true, optional = true}
-tree-sitter = {workspace = true, optional = true}
-
 [dev-dependencies]
 text.workspace = true
 theme = { workspace = true, features = ["test-support"] }
diff --git a/crates/util/Cargo.toml b/crates/util/Cargo.toml
index 6257ffd64269f4..58c4686bf90522 100644
--- a/crates/util/Cargo.toml
+++ b/crates/util/Cargo.toml
@@ -17,19 +17,19 @@ test-support = ["tempfile", "git2", "rand"]
 
 [dependencies]
 anyhow.workspace = true
+async-fs.workspace = true
 collections.workspace = true
 dirs.workspace = true
+futures-lite.workspace = true
 futures.workspace = true
 git2 = { workspace = true, optional = true }
 globset.workspace = true
 log.workspace = true
-rand = {workspace = true, optional = true}
+rand = { workspace = true, optional = true }
 regex.workspace = true
 rust-embed.workspace = true
 serde.workspace = true
 serde_json.workspace = true
-async-fs.workspace = true
-futures-lite.workspace = true
 take-until = "0.2.0"
 tempfile = { workspace = true, optional = true }
 unicase.workspace = true
@@ -39,5 +39,5 @@ tendril = "0.4.3"
 
 [dev-dependencies]
 git2.workspace = true
-tempfile.workspace = true
 rand.workspace = true
+tempfile.workspace = true
diff --git a/crates/worktree/Cargo.toml b/crates/worktree/Cargo.toml
index 1186c988adb17c..41221d7b6e8186 100644
--- a/crates/worktree/Cargo.toml
+++ b/crates/worktree/Cargo.toml
@@ -48,12 +48,12 @@ text.workspace = true
 util.workspace = true
 
 [dev-dependencies]
-clock = {workspace = true, features = ["test-support"]}
+clock = { workspace = true, features = ["test-support"] }
 collections = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
 git2.workspace = true
-gpui = {workspace = true, features = ["test-support"]}
+gpui = { workspace = true, features = ["test-support"] }
 http_client.workspace = true
-rand.workspace = true
-settings = {workspace = true, features = ["test-support"]}
 pretty_assertions.workspace = true
+rand.workspace = true
+settings = { workspace = true, features = ["test-support"] }
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index 775a59e475cb47..04e2be7ed02666 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -63,7 +63,7 @@ language.workspace = true
 language_model.workspace = true
 language_selector.workspace = true
 language_tools.workspace = true
-languages = {workspace = true, features = ["load-grammars"] }
+languages = { workspace = true, features = ["load-grammars"] }
 libc.workspace = true
 log.workspace = true
 markdown_preview.workspace = true

From 028d7a624f24a143858b316bee7edc69911918ee Mon Sep 17 00:00:00 2001
From: Joseph T Lyons <JosephTLyons@gmail.com>
Date: Wed, 2 Oct 2024 11:03:57 -0400
Subject: [PATCH 440/762] v0.157.x dev

---
 Cargo.lock            | 2 +-
 crates/zed/Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7c92ef0f5257c7..b69e4541cc9e20 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14398,7 +14398,7 @@ dependencies = [
 
 [[package]]
 name = "zed"
-version = "0.156.0"
+version = "0.157.0"
 dependencies = [
  "activity_indicator",
  "anyhow",
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index 04e2be7ed02666..e22f75f5bb3e54 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -2,7 +2,7 @@
 description = "The fast, collaborative code editor."
 edition = "2021"
 name = "zed"
-version = "0.156.0"
+version = "0.157.0"
 publish = false
 license = "GPL-3.0-or-later"
 authors = ["Zed Team <hi@zed.dev>"]

From 2cd12f84def5bf4a05ca4e19138d33e4e1d6073c Mon Sep 17 00:00:00 2001
From: Victor Roetman <victory747@gmail.com>
Date: Wed, 2 Oct 2024 12:18:41 -0400
Subject: [PATCH 441/762] docs: Add FIPS mode error to Linux troubleshooting
 (#18407)

- Closes: #18335
Update linux.md with a workaround for the
```
crypto/fips/fips.c:154: OpenSSL internal error: FATAL FIPS SELFTEST FAILURE
```
error when using bundled libssl and libcrypto.

Co-authored-by: Peter Tripp <peter@zed.dev>
---
 docs/src/linux.md | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/docs/src/linux.md b/docs/src/linux.md
index 33d12d0a8ca02f..4abd7de8ba8ebd 100644
--- a/docs/src/linux.md
+++ b/docs/src/linux.md
@@ -144,3 +144,20 @@ If you are seeing "too many open files" then first try `sysctl fs.inotify`.
 - You should see that `max_user_watches` is 8000 or higher (you can change the limit with `sudo sysctl fs.inotify.max_user_watches=64000`). Zed needs one watch per directory in all your open projects + one per git repository + a handful more for settings, themes, keymaps, extensions.
 
 It is also possible that you are running out of file descriptors. You can check the limits with `ulimit` and update them by editing `/etc/security/limits.conf`.
+
+### FIPS Mode OpenSSL internal error {#fips}
+
+If your machine is running in FIPS mode (`cat /proc/sys/crypto/fips_enabled` is set to `1`) Zed may fail to start and output the following when launched with `zed --foreground`:
+
+```
+crypto/fips/fips.c:154: OpenSSL internal error: FATAL FIPS SELFTEST FAILURE
+```
+
+As a workaround, remove the bundled `libssl` and `libcrypto` libraries from the `zed.app/lib` directory:
+
+```
+rm ~/.local/zed.app/lib/libssl.so.1.1
+rm ~/.local/zed.app/lib/libcrypto.so.1.1
+```
+
+This will force zed to fallback to the system `libssl` and `libcrypto` libraries.

From 167af4bc1d3acf3bc2b7d624983ce52602d9bc08 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 2 Oct 2024 12:33:13 -0400
Subject: [PATCH 442/762] Use `const` over `static` for string literals
 (#18635)

I noticed a few places where we were storing `&'static str`s in
`static`s instead of `const`s.

This PR updates them to use `const`.

Release Notes:

- N/A
---
 crates/client/src/client.rs            | 2 +-
 crates/collab/src/api/events.rs        | 2 +-
 crates/editor/src/clangd_ext.rs        | 2 +-
 crates/editor/src/rust_analyzer_ext.rs | 2 +-
 crates/gpui/src/taffy.rs               | 2 +-
 crates/task/src/vscode_format.rs       | 4 ++--
 crates/worktree/src/worktree.rs        | 2 +-
 crates/zed/src/reliability.rs          | 2 +-
 8 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 48bd646d8aa70e..d565d620c3c206 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -1752,7 +1752,7 @@ impl CredentialsProvider for KeychainCredentialsProvider {
 }
 
 /// prefix for the zed:// url scheme
-pub static ZED_URL_SCHEME: &str = "zed";
+pub const ZED_URL_SCHEME: &str = "zed";
 
 /// Parses the given link into a Zed link.
 ///
diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index 377741f434c2f8..bbfa69c0b8f70b 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -23,7 +23,7 @@ use telemetry_events::{
 };
 use uuid::Uuid;
 
-static CRASH_REPORTS_BUCKET: &str = "zed-crash-reports";
+const CRASH_REPORTS_BUCKET: &str = "zed-crash-reports";
 
 pub fn router() -> Router {
     Router::new()
diff --git a/crates/editor/src/clangd_ext.rs b/crates/editor/src/clangd_ext.rs
index 2f0f7aaee47e7a..501f81b1073df2 100644
--- a/crates/editor/src/clangd_ext.rs
+++ b/crates/editor/src/clangd_ext.rs
@@ -9,7 +9,7 @@ use crate::lsp_ext::find_specific_language_server_in_selection;
 
 use crate::{element::register_action, Editor, SwitchSourceHeader};
 
-static CLANGD_SERVER_NAME: &str = "clangd";
+const CLANGD_SERVER_NAME: &str = "clangd";
 
 fn is_c_language(language: &Language) -> bool {
     return language.name() == "C++".into() || language.name() == "C".into();
diff --git a/crates/editor/src/rust_analyzer_ext.rs b/crates/editor/src/rust_analyzer_ext.rs
index db17eaab282fae..fa39e5c9d49ce9 100644
--- a/crates/editor/src/rust_analyzer_ext.rs
+++ b/crates/editor/src/rust_analyzer_ext.rs
@@ -10,7 +10,7 @@ use crate::{
     ExpandMacroRecursively,
 };
 
-static RUST_ANALYZER_NAME: &str = "rust-analyzer";
+const RUST_ANALYZER_NAME: &str = "rust-analyzer";
 
 fn is_rust_language(language: &Language) -> bool {
     language.name() == "Rust".into()
diff --git a/crates/gpui/src/taffy.rs b/crates/gpui/src/taffy.rs
index a6a61031c9ce13..a80c734b81bbfc 100644
--- a/crates/gpui/src/taffy.rs
+++ b/crates/gpui/src/taffy.rs
@@ -24,7 +24,7 @@ pub struct TaffyLayoutEngine {
     nodes_to_measure: FxHashMap<LayoutId, NodeMeasureFn>,
 }
 
-static EXPECT_MESSAGE: &str = "we should avoid taffy layout errors by construction if possible";
+const EXPECT_MESSAGE: &str = "we should avoid taffy layout errors by construction if possible";
 
 impl TaffyLayoutEngine {
     pub fn new() -> Self {
diff --git a/crates/task/src/vscode_format.rs b/crates/task/src/vscode_format.rs
index 74be56b5b17695..c150ee807fb258 100644
--- a/crates/task/src/vscode_format.rs
+++ b/crates/task/src/vscode_format.rs
@@ -200,7 +200,7 @@ mod tests {
 
     #[test]
     fn can_deserialize_ts_tasks() {
-        static TYPESCRIPT_TASKS: &str = include_str!("../test_data/typescript.json");
+        const TYPESCRIPT_TASKS: &str = include_str!("../test_data/typescript.json");
         let vscode_definitions: VsCodeTaskFile =
             serde_json_lenient::from_str(TYPESCRIPT_TASKS).unwrap();
 
@@ -290,7 +290,7 @@ mod tests {
 
     #[test]
     fn can_deserialize_rust_analyzer_tasks() {
-        static RUST_ANALYZER_TASKS: &str = include_str!("../test_data/rust-analyzer.json");
+        const RUST_ANALYZER_TASKS: &str = include_str!("../test_data/rust-analyzer.json");
         let vscode_definitions: VsCodeTaskFile =
             serde_json_lenient::from_str(RUST_ANALYZER_TASKS).unwrap();
         let expected = vec![
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index a3daf8ea2eade7..40cd465d9ba7d5 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -351,7 +351,7 @@ pub enum Event {
     DeletedEntry(ProjectEntryId),
 }
 
-static EMPTY_PATH: &str = "";
+const EMPTY_PATH: &str = "";
 
 impl EventEmitter<Event> for Worktree {}
 
diff --git a/crates/zed/src/reliability.rs b/crates/zed/src/reliability.rs
index 50e5a05b823ed0..b40bbc78bdb479 100644
--- a/crates/zed/src/reliability.rs
+++ b/crates/zed/src/reliability.rs
@@ -441,7 +441,7 @@ async fn upload_previous_panics(
     Ok::<_, anyhow::Error>(most_recent_panic)
 }
 
-static LAST_CRASH_UPLOADED: &str = "LAST_CRASH_UPLOADED";
+const LAST_CRASH_UPLOADED: &str = "LAST_CRASH_UPLOADED";
 
 /// upload crashes from apple's diagnostic reports to our server.
 /// (only if telemetry is enabled)

From 845991c0e59a34e2d98300237956ede553c44289 Mon Sep 17 00:00:00 2001
From: Junseong Park <junseongpark.dev@gmail.com>
Date: Thu, 3 Oct 2024 01:35:35 +0900
Subject: [PATCH 443/762] docs: Add missing UI font settings to "Configuring
 Zed" (#18267)

- Add missing `ui_font` options in `configuring-zed.md`

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 docs/src/configuring-zed.md | 68 +++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index fbd5fa53cfbd84..230255597e35cf 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -2180,6 +2180,64 @@ Float values between `0.0` and `0.9`, where:
 }
 ```
 
+## UI Font Family
+
+- Description: The name of the font to use for text in the UI.
+- Setting: `ui_font_family`
+- Default: `Zed Plex Sans`
+
+**Options**
+
+The name of any font family installed on the system.
+
+## UI Font Features
+
+- Description: The OpenType features to enable for text in the UI.
+- Setting: `ui_font_features`
+- Default: `null`
+- Platform: macOS and Windows.
+
+**Options**
+
+Zed supports all OpenType features that can be enabled or disabled for a given UI font, as well as setting values for font features.
+
+For example, to disable font ligatures, add the following to your settings:
+
+```json
+{
+  "ui_font_features": {
+    "calt": false
+  }
+}
+```
+
+You can also set other OpenType features, like setting `cv01` to `7`:
+
+```json
+{
+  "ui_font_features": {
+    "cv01": 7
+  }
+}
+```
+
+## UI Font Fallbacks
+
+- Description: The font fallbacks to use for text in the UI.
+- Setting: `ui_font_fallbacks`
+- Default: `null`
+- Platform: macOS and Windows.
+
+**Options**
+
+For example, to use `Nerd Font` as a fallback, add the following to your settings:
+
+```json
+{
+  "ui_font_fallbacks": ["Nerd Font"]
+}
+```
+
 ## UI Font Size
 
 - Description: The default font size for text in the UI.
@@ -2190,6 +2248,16 @@ Float values between `0.0` and `0.9`, where:
 
 `integer` values from `6` to `100` pixels (inclusive)
 
+## UI Font Weight
+
+- Description: The default font weight for text in the UI.
+- Setting: `ui_font_weight`
+- Default: `400`
+
+**Options**
+
+`integer` values between `100` and `900`
+
 ## An example configuration:
 
 ```json

From 5aaaed52fc46fdc3029133fac4f96a7652681ea9 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 2 Oct 2024 18:57:03 +0200
Subject: [PATCH 444/762] Adjust spacing and sizing of buffer search bar icon
 buttons (#18638)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR mostly makes all of the search bar icon buttons all squared and
adjusts the spacing between them, as well as the additional input that
appears when you toggle the "Replace all" action.

<img width="900" alt="Screenshot 2024-10-02 at 6 08 30 PM"
src="https://github.com/user-attachments/assets/86d50a3b-94bd-4c6a-822e-5f7f7b2e2707">

---

Release Notes:

- N/A
---
 crates/search/src/buffer_search.rs  | 133 +++++++++++++++-------------
 crates/search/src/project_search.rs |   2 +-
 crates/search/src/search.rs         |   3 +-
 crates/search/src/search_bar.rs     |   3 +-
 4 files changed, 76 insertions(+), 65 deletions(-)

diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs
index 42b267c3c9563a..5846a6efc51dd2 100644
--- a/crates/search/src/buffer_search.rs
+++ b/crates/search/src/buffer_search.rs
@@ -27,7 +27,7 @@ use settings::Settings;
 use std::sync::Arc;
 use theme::ThemeSettings;
 
-use ui::{h_flex, prelude::*, IconButton, IconName, Tooltip, BASE_REM_SIZE_IN_PX};
+use ui::{h_flex, prelude::*, IconButton, IconButtonShape, IconName, Tooltip, BASE_REM_SIZE_IN_PX};
 use util::ResultExt;
 use workspace::{
     item::ItemHandle,
@@ -200,7 +200,7 @@ impl Render for BufferSearchBar {
         };
 
         let search_line = h_flex()
-            .mb_1()
+            .gap_2()
             .child(
                 h_flex()
                     .id("editor-scroll")
@@ -208,7 +208,6 @@ impl Render for BufferSearchBar {
                     .flex_1()
                     .h_8()
                     .px_2()
-                    .mr_2()
                     .py_1()
                     .border_1()
                     .border_color(editor_border)
@@ -244,66 +243,70 @@ impl Render for BufferSearchBar {
                         }))
                     }),
             )
-            .when(supported_options.replacement, |this| {
-                this.child(
-                    IconButton::new("buffer-search-bar-toggle-replace-button", IconName::Replace)
-                        .style(ButtonStyle::Subtle)
-                        .when(self.replace_enabled, |button| {
-                            button.style(ButtonStyle::Filled)
-                        })
-                        .on_click(cx.listener(|this, _: &ClickEvent, cx| {
-                            this.toggle_replace(&ToggleReplace, cx);
-                        }))
-                        .selected(self.replace_enabled)
-                        .size(ButtonSize::Compact)
-                        .tooltip({
-                            let focus_handle = focus_handle.clone();
-                            move |cx| {
-                                Tooltip::for_action_in(
-                                    "Toggle replace",
-                                    &ToggleReplace,
-                                    &focus_handle,
-                                    cx,
-                                )
-                            }
-                        }),
-                )
-            })
-            .when(supported_options.selection, |this| {
-                this.child(
-                    IconButton::new(
-                        "buffer-search-bar-toggle-search-selection-button",
-                        IconName::SearchSelection,
-                    )
-                    .style(ButtonStyle::Subtle)
-                    .when(self.selection_search_enabled, |button| {
-                        button.style(ButtonStyle::Filled)
-                    })
-                    .on_click(cx.listener(|this, _: &ClickEvent, cx| {
-                        this.toggle_selection(&ToggleSelection, cx);
-                    }))
-                    .selected(self.selection_search_enabled)
-                    .size(ButtonSize::Compact)
-                    .tooltip({
-                        let focus_handle = focus_handle.clone();
-                        move |cx| {
-                            Tooltip::for_action_in(
-                                "Toggle Search Selection",
-                                &ToggleSelection,
-                                &focus_handle,
-                                cx,
-                            )
-                        }
-                    }),
-                )
-            })
             .child(
                 h_flex()
                     .flex_none()
+                    .gap_0p5()
+                    .when(supported_options.replacement, |this| {
+                        this.child(
+                            IconButton::new(
+                                "buffer-search-bar-toggle-replace-button",
+                                IconName::Replace,
+                            )
+                            .style(ButtonStyle::Subtle)
+                            .shape(IconButtonShape::Square)
+                            .when(self.replace_enabled, |button| {
+                                button.style(ButtonStyle::Filled)
+                            })
+                            .on_click(cx.listener(|this, _: &ClickEvent, cx| {
+                                this.toggle_replace(&ToggleReplace, cx);
+                            }))
+                            .selected(self.replace_enabled)
+                            .tooltip({
+                                let focus_handle = focus_handle.clone();
+                                move |cx| {
+                                    Tooltip::for_action_in(
+                                        "Toggle Replace",
+                                        &ToggleReplace,
+                                        &focus_handle,
+                                        cx,
+                                    )
+                                }
+                            }),
+                        )
+                    })
+                    .when(supported_options.selection, |this| {
+                        this.child(
+                            IconButton::new(
+                                "buffer-search-bar-toggle-search-selection-button",
+                                IconName::SearchSelection,
+                            )
+                            .style(ButtonStyle::Subtle)
+                            .shape(IconButtonShape::Square)
+                            .when(self.selection_search_enabled, |button| {
+                                button.style(ButtonStyle::Filled)
+                            })
+                            .on_click(cx.listener(|this, _: &ClickEvent, cx| {
+                                this.toggle_selection(&ToggleSelection, cx);
+                            }))
+                            .selected(self.selection_search_enabled)
+                            .tooltip({
+                                let focus_handle = focus_handle.clone();
+                                move |cx| {
+                                    Tooltip::for_action_in(
+                                        "Toggle Search Selection",
+                                        &ToggleSelection,
+                                        &focus_handle,
+                                        cx,
+                                    )
+                                }
+                            }),
+                        )
+                    })
                     .child(
                         IconButton::new("select-all", ui::IconName::SelectAll)
                             .on_click(|_, cx| cx.dispatch_action(SelectAllMatches.boxed_clone()))
-                            .size(ButtonSize::Compact)
+                            .shape(IconButtonShape::Square)
                             .tooltip({
                                 let focus_handle = focus_handle.clone();
                                 move |cx| {
@@ -332,11 +335,13 @@ impl Render for BufferSearchBar {
                     ))
                     .when(!narrow_mode, |this| {
                         this.child(h_flex().ml_2().min_w(rems_from_px(40.)).child(
-                            Label::new(match_text).color(if self.active_match_index.is_some() {
-                                Color::Default
-                            } else {
-                                Color::Disabled
-                            }),
+                            Label::new(match_text).size(LabelSize::Small).color(
+                                if self.active_match_index.is_some() {
+                                    Color::Default
+                                } else {
+                                    Color::Disabled
+                                },
+                            ),
                         ))
                     }),
             );
@@ -367,8 +372,10 @@ impl Render for BufferSearchBar {
                 .child(
                     h_flex()
                         .flex_none()
+                        .gap_0p5()
                         .child(
                             IconButton::new("search-replace-next", ui::IconName::ReplaceNext)
+                                .shape(IconButtonShape::Square)
                                 .tooltip({
                                     let focus_handle = focus_handle.clone();
                                     move |cx| {
@@ -386,6 +393,7 @@ impl Render for BufferSearchBar {
                         )
                         .child(
                             IconButton::new("search-replace-all", ui::IconName::ReplaceAll)
+                                .shape(IconButtonShape::Square)
                                 .tooltip({
                                     let focus_handle = focus_handle.clone();
                                     move |cx| {
@@ -441,6 +449,7 @@ impl Render for BufferSearchBar {
                     .when(!narrow_mode, |div| {
                         div.child(
                             IconButton::new(SharedString::from("Close"), IconName::Close)
+                                .shape(IconButtonShape::Square)
                                 .tooltip(move |cx| {
                                     Tooltip::for_action("Close Search Bar", &Dismiss, cx)
                                 })
diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs
index 12e6ccc12dc496..693d4b265867fb 100644
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -1634,7 +1634,7 @@ impl Render for ProjectSearchBar {
                             let focus_handle = focus_handle.clone();
                             move |cx| {
                                 Tooltip::for_action_in(
-                                    "Toggle replace",
+                                    "Toggle Replace",
                                     &ToggleReplace,
                                     &focus_handle,
                                     cx,
diff --git a/crates/search/src/search.rs b/crates/search/src/search.rs
index 0ceb8e710b5f41..60ff80834feed4 100644
--- a/crates/search/src/search.rs
+++ b/crates/search/src/search.rs
@@ -5,7 +5,7 @@ use gpui::{actions, Action, AppContext, FocusHandle, IntoElement};
 use project::search::SearchQuery;
 pub use project_search::ProjectSearchView;
 use ui::{prelude::*, Tooltip};
-use ui::{ButtonStyle, IconButton};
+use ui::{ButtonStyle, IconButton, IconButtonShape};
 use workspace::notifications::NotificationId;
 use workspace::{Toast, Workspace};
 
@@ -112,6 +112,7 @@ impl SearchOptions {
         IconButton::new(self.label(), self.icon())
             .on_click(action)
             .style(ButtonStyle::Subtle)
+            .shape(IconButtonShape::Square)
             .selected(active)
             .tooltip({
                 let action = self.to_toggle_action();
diff --git a/crates/search/src/search_bar.rs b/crates/search/src/search_bar.rs
index 102f04c4b95c28..080679663d0ba4 100644
--- a/crates/search/src/search_bar.rs
+++ b/crates/search/src/search_bar.rs
@@ -1,6 +1,6 @@
 use gpui::{Action, FocusHandle, IntoElement};
-use ui::IconButton;
 use ui::{prelude::*, Tooltip};
+use ui::{IconButton, IconButtonShape};
 
 pub(super) fn render_nav_button(
     icon: ui::IconName,
@@ -13,6 +13,7 @@ pub(super) fn render_nav_button(
         SharedString::from(format!("search-nav-button-{}", action.name())),
         icon,
     )
+    .shape(IconButtonShape::Square)
     .on_click(|_, cx| cx.dispatch_action(action.boxed_clone()))
     .tooltip(move |cx| Tooltip::for_action_in(tooltip, action, &focus_handle, cx))
     .disabled(!active)

From a5f50e5c1e7fc982fad3bc700e55aee3243791f1 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 2 Oct 2024 18:57:20 +0200
Subject: [PATCH 445/762] Tweak warning diagnostic toggle (#18637)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR adds color to the warning diagnostic toggle, so that, if it's
turned on, the warning icon is yellow. And, in the opposite case, it's
muted.

| Turned on | Turned off |
|--------|--------|
| <img width="1136" alt="Screenshot 2024-10-02 at 6 08 30 PM"
src="https://github.com/user-attachments/assets/be64738b-4c14-41d4-b1d4-ad788cf9e72b">
| <img width="1136" alt="Screenshot 2024-10-02 at 6 08 36 PM"
src="https://github.com/user-attachments/assets/d144ff50-4bf6-4c23-925a-05bcbbcd8b9d">
|

---

Release Notes:

- N/A
---
 crates/diagnostics/src/toolbar_controls.rs | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/crates/diagnostics/src/toolbar_controls.rs b/crates/diagnostics/src/toolbar_controls.rs
index b546db50a064ba..0d3000814262ad 100644
--- a/crates/diagnostics/src/toolbar_controls.rs
+++ b/crates/diagnostics/src/toolbar_controls.rs
@@ -1,7 +1,7 @@
 use crate::ProjectDiagnosticsEditor;
 use gpui::{EventEmitter, ParentElement, Render, View, ViewContext, WeakView};
 use ui::prelude::*;
-use ui::{IconButton, IconName, Tooltip};
+use ui::{IconButton, IconButtonShape, IconName, Tooltip};
 use workspace::{item::ItemHandle, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView};
 
 pub struct ToolbarControls {
@@ -33,11 +33,19 @@ impl Render for ToolbarControls {
             "Include Warnings"
         };
 
+        let warning_color = if include_warnings {
+            Color::Warning
+        } else {
+            Color::Muted
+        };
+
         h_flex()
+            .gap_1()
             .when(has_stale_excerpts, |div| {
                 div.child(
                     IconButton::new("update-excerpts", IconName::Update)
                         .icon_color(Color::Info)
+                        .shape(IconButtonShape::Square)
                         .disabled(is_updating)
                         .tooltip(move |cx| Tooltip::text("Update excerpts", cx))
                         .on_click(cx.listener(|this, _, cx| {
@@ -51,6 +59,8 @@ impl Render for ToolbarControls {
             })
             .child(
                 IconButton::new("toggle-warnings", IconName::Warning)
+                    .icon_color(warning_color)
+                    .shape(IconButtonShape::Square)
                     .tooltip(move |cx| Tooltip::text(tooltip, cx))
                     .on_click(cx.listener(|this, _, cx| {
                         if let Some(editor) = this.editor() {

From 209ebb0c65bc0ba56e4e0bad1a7b7e475414082b Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Wed, 2 Oct 2024 10:44:16 -0700
Subject: [PATCH 446/762] Revert "Fix blurry cursor on Wayland at a scale other
 than 100%" (#18642)

Closes #17771

Reverts zed-industries/zed#17496

This PR turns out to need more work than I thought when I merged it.

Release Notes:

- Linux: Fix a bug where the cursor would be the wrong size on Wayland
---
 .../gpui/src/platform/linux/wayland/client.rs |  3 +-
 .../gpui/src/platform/linux/wayland/cursor.rs | 33 ++++---------------
 2 files changed, 8 insertions(+), 28 deletions(-)

diff --git a/crates/gpui/src/platform/linux/wayland/client.rs b/crates/gpui/src/platform/linux/wayland/client.rs
index f0015a7e5820bd..ab87bb20242ed8 100644
--- a/crates/gpui/src/platform/linux/wayland/client.rs
+++ b/crates/gpui/src/platform/linux/wayland/client.rs
@@ -477,8 +477,7 @@ impl WaylandClient {
             .as_ref()
             .map(|primary_selection_manager| primary_selection_manager.get_device(&seat, &qh, ()));
 
-        // FIXME: Determine the scaling factor dynamically by the compositor
-        let mut cursor = Cursor::new(&conn, &globals, 24, 2);
+        let mut cursor = Cursor::new(&conn, &globals, 24);
 
         handle
             .insert_source(XDPEventSource::new(&common.background_executor), {
diff --git a/crates/gpui/src/platform/linux/wayland/cursor.rs b/crates/gpui/src/platform/linux/wayland/cursor.rs
index ea29eee73c71f4..6a527650429a4e 100644
--- a/crates/gpui/src/platform/linux/wayland/cursor.rs
+++ b/crates/gpui/src/platform/linux/wayland/cursor.rs
@@ -11,7 +11,6 @@ pub(crate) struct Cursor {
     theme_name: Option<String>,
     surface: WlSurface,
     size: u32,
-    scale: u32,
     shm: WlShm,
     connection: Connection,
 }
@@ -24,7 +23,7 @@ impl Drop for Cursor {
 }
 
 impl Cursor {
-    pub fn new(connection: &Connection, globals: &Globals, size: u32, scale: u32) -> Self {
+    pub fn new(connection: &Connection, globals: &Globals, size: u32) -> Self {
         Self {
             theme: CursorTheme::load(&connection, globals.shm.clone(), size).log_err(),
             theme_name: None,
@@ -32,7 +31,6 @@ impl Cursor {
             shm: globals.shm.clone(),
             connection: connection.clone(),
             size,
-            scale,
         }
     }
 
@@ -40,18 +38,14 @@ impl Cursor {
         if let Some(size) = size {
             self.size = size;
         }
-        if let Some(theme) = CursorTheme::load_from_name(
-            &self.connection,
-            self.shm.clone(),
-            theme_name,
-            self.size * self.scale,
-        )
-        .log_err()
+        if let Some(theme) =
+            CursorTheme::load_from_name(&self.connection, self.shm.clone(), theme_name, self.size)
+                .log_err()
         {
             self.theme = Some(theme);
             self.theme_name = Some(theme_name.to_string());
         } else if let Some(theme) =
-            CursorTheme::load(&self.connection, self.shm.clone(), self.size * self.scale).log_err()
+            CursorTheme::load(&self.connection, self.shm.clone(), self.size).log_err()
         {
             self.theme = Some(theme);
             self.theme_name = None;
@@ -97,22 +91,9 @@ impl Cursor {
                 let (width, height) = buffer.dimensions();
                 let (hot_x, hot_y) = buffer.hotspot();
 
-                let scaled_width = width / self.scale;
-                let scaled_height = height / self.scale;
-                let scaled_hot_x = hot_x / self.scale;
-                let scaled_hot_y = hot_y / self.scale;
-
-                self.surface.set_buffer_scale(self.scale as i32);
-
-                wl_pointer.set_cursor(
-                    serial_id,
-                    Some(&self.surface),
-                    scaled_hot_x as i32,
-                    scaled_hot_y as i32,
-                );
+                wl_pointer.set_cursor(serial_id, Some(&self.surface), hot_x as i32, hot_y as i32);
                 self.surface.attach(Some(&buffer), 0, 0);
-                self.surface
-                    .damage(0, 0, scaled_width as i32, scaled_height as i32);
+                self.surface.damage(0, 0, width as i32, height as i32);
                 self.surface.commit();
             }
         } else {

From 0e8276560f2e9de2dd1783ef8d9e208d01dada44 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 2 Oct 2024 14:10:19 -0400
Subject: [PATCH 447/762] language: Update buffer doc comments (#18646)

This PR updates the doc comments in `buffer.rs` to use the standard
style for linking to other items.

Release Notes:

- N/A
---
 crates/language/src/buffer.rs | 45 ++++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 8afc4d389db7f5..20ecd9594b9d4a 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -73,7 +73,7 @@ pub use lsp::DiagnosticSeverity;
 /// a diff against the contents of its file.
 pub static BUFFER_DIFF_TASK: LazyLock<TaskLabel> = LazyLock::new(TaskLabel::new);
 
-/// Indicate whether a [Buffer] has permissions to edit.
+/// Indicate whether a [`Buffer`] has permissions to edit.
 #[derive(PartialEq, Clone, Copy, Debug)]
 pub enum Capability {
     /// The buffer is a mutable replica.
@@ -211,7 +211,7 @@ pub struct Diagnostic {
     ///
     /// When a language server produces a diagnostic with
     /// one or more associated diagnostics, those diagnostics are all
-    /// assigned a single group id.
+    /// assigned a single group ID.
     pub group_id: usize,
     /// Whether this diagnostic is the primary diagnostic for its group.
     ///
@@ -718,7 +718,7 @@ impl Buffer {
         self
     }
 
-    /// Returns the [Capability] of this buffer.
+    /// Returns the [`Capability`] of this buffer.
     pub fn capability(&self) -> Capability {
         self.capability
     }
@@ -728,7 +728,7 @@ impl Buffer {
         self.capability == Capability::ReadOnly
     }
 
-    /// Builds a [Buffer] with the given underlying [TextBuffer], diff base, [File] and [Capability].
+    /// Builds a [`Buffer`] with the given underlying [`TextBuffer`], diff base, [`File`] and [`Capability`].
     pub fn build(
         buffer: TextBuffer,
         diff_base: Option<String>,
@@ -941,7 +941,7 @@ impl Buffer {
         self.syntax_map.lock().language_registry()
     }
 
-    /// Assign the buffer a new [Capability].
+    /// Assign the buffer a new [`Capability`].
     pub fn set_capability(&mut self, capability: Capability, cx: &mut ModelContext<Self>) {
         self.capability = capability;
         cx.emit(BufferEvent::CapabilityChanged)
@@ -1032,7 +1032,7 @@ impl Buffer {
         cx.notify();
     }
 
-    /// Updates the [File] backing this buffer. This should be called when
+    /// Updates the [`File`] backing this buffer. This should be called when
     /// the file has changed or has been deleted.
     pub fn file_updated(&mut self, new_file: Arc<dyn File>, cx: &mut ModelContext<Self>) {
         let mut file_changed = false;
@@ -1071,7 +1071,7 @@ impl Buffer {
         }
     }
 
-    /// Returns the current diff base, see [Buffer::set_diff_base].
+    /// Returns the current diff base, see [`Buffer::set_diff_base`].
     pub fn diff_base(&self) -> Option<&Rope> {
         match self.diff_base.as_ref()? {
             BufferDiffBase::Git(rope) | BufferDiffBase::PastBufferVersion { rope, .. } => {
@@ -1142,12 +1142,12 @@ impl Buffer {
         }))
     }
 
-    /// Returns the primary [Language] assigned to this [Buffer].
+    /// Returns the primary [`Language`] assigned to this [`Buffer`].
     pub fn language(&self) -> Option<&Arc<Language>> {
         self.language.as_ref()
     }
 
-    /// Returns the [Language] at the given location.
+    /// Returns the [`Language`] at the given location.
     pub fn language_at<D: ToOffset>(&self, position: D) -> Option<Arc<Language>> {
         let offset = position.to_offset(self);
         self.syntax_map
@@ -2730,6 +2730,7 @@ impl BufferSnapshot {
             .collect();
         (captures, highlight_maps)
     }
+
     /// Iterates over chunks of text in the given range of the buffer. Text is chunked
     /// in an arbitrary way due to being stored in a [`Rope`](text::Rope). The text is also
     /// returned in chunks where each chunk has a single syntax highlighting style and
@@ -2781,12 +2782,12 @@ impl BufferSnapshot {
             .last()
     }
 
-    /// Returns the main [Language]
+    /// Returns the main [`Language`].
     pub fn language(&self) -> Option<&Arc<Language>> {
         self.language.as_ref()
     }
 
-    /// Returns the [Language] at the given location.
+    /// Returns the [`Language`] at the given location.
     pub fn language_at<D: ToOffset>(&self, position: D) -> Option<&Arc<Language>> {
         self.syntax_layer_at(position)
             .map(|info| info.language)
@@ -2806,7 +2807,7 @@ impl BufferSnapshot {
         CharClassifier::new(self.language_scope_at(point))
     }
 
-    /// Returns the [LanguageScope] at the given location.
+    /// Returns the [`LanguageScope`] at the given location.
     pub fn language_scope_at<D: ToOffset>(&self, position: D) -> Option<LanguageScope> {
         let offset = position.to_offset(self);
         let mut scope = None;
@@ -2961,7 +2962,7 @@ impl BufferSnapshot {
 
     /// Returns the outline for the buffer.
     ///
-    /// This method allows passing an optional [SyntaxTheme] to
+    /// This method allows passing an optional [`SyntaxTheme`] to
     /// syntax-highlight the returned symbols.
     pub fn outline(&self, theme: Option<&SyntaxTheme>) -> Option<Outline<Anchor>> {
         self.outline_items_containing(0..self.len(), true, theme)
@@ -2970,7 +2971,7 @@ impl BufferSnapshot {
 
     /// Returns all the symbols that contain the given position.
     ///
-    /// This method allows passing an optional [SyntaxTheme] to
+    /// This method allows passing an optional [`SyntaxTheme`] to
     /// syntax-highlight the returned symbols.
     pub fn symbols_containing<T: ToOffset>(
         &self,
@@ -3213,7 +3214,7 @@ impl BufferSnapshot {
     }
 
     /// For each grammar in the language, runs the provided
-    /// [tree_sitter::Query] against the given range.
+    /// [`tree_sitter::Query`] against the given range.
     pub fn matches(
         &self,
         range: Range<usize>,
@@ -3774,7 +3775,7 @@ impl BufferSnapshot {
             })
     }
 
-    /// Whether the buffer contains any git changes.
+    /// Whether the buffer contains any Git changes.
     pub fn has_git_diff(&self) -> bool {
         !self.git_diff.is_empty()
     }
@@ -3856,7 +3857,7 @@ impl BufferSnapshot {
     }
 
     /// Returns all the diagnostic groups associated with the given
-    /// language server id. If no language server id is provided,
+    /// language server ID. If no language server ID is provided,
     /// all diagnostics groups are returned.
     pub fn diagnostic_groups(
         &self,
@@ -4239,7 +4240,7 @@ impl Default for Diagnostic {
 }
 
 impl IndentSize {
-    /// Returns an [IndentSize] representing the given spaces.
+    /// Returns an [`IndentSize`] representing the given spaces.
     pub fn spaces(len: u32) -> Self {
         Self {
             len,
@@ -4247,7 +4248,7 @@ impl IndentSize {
         }
     }
 
-    /// Returns an [IndentSize] representing a tab.
+    /// Returns an [`IndentSize`] representing a tab.
     pub fn tab() -> Self {
         Self {
             len: 1,
@@ -4255,12 +4256,12 @@ impl IndentSize {
         }
     }
 
-    /// An iterator over the characters represented by this [IndentSize].
+    /// An iterator over the characters represented by this [`IndentSize`].
     pub fn chars(&self) -> impl Iterator<Item = char> {
         iter::repeat(self.char()).take(self.len as usize)
     }
 
-    /// The character representation of this [IndentSize].
+    /// The character representation of this [`IndentSize`].
     pub fn char(&self) -> char {
         match self.kind {
             IndentKind::Space => ' ',
@@ -4268,7 +4269,7 @@ impl IndentSize {
         }
     }
 
-    /// Consumes the current [IndentSize] and returns a new one that has
+    /// Consumes the current [`IndentSize`] and returns a new one that has
     /// been shrunk or enlarged by the given size along the given direction.
     pub fn with_delta(mut self, direction: Ordering, size: IndentSize) -> Self {
         match direction {

From 7c4615519befe8c35b25e22620d45b07b4b9c401 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 2 Oct 2024 14:23:59 -0400
Subject: [PATCH 448/762] editor: Ensure proposed changes editor is
 syntax-highlighted when opened (#18648)

This PR fixes an issue where the proposed changes editor would not have
any syntax highlighting until a modification was made.

When creating the branch buffer we reparse the buffer to rebuild the
syntax map.

Release Notes:

- N/A
---
 crates/language/src/buffer.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 20ecd9594b9d4a..1f4c56ecc86ff6 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -819,6 +819,9 @@ impl Buffer {
                 branch.set_language_registry(language_registry);
             }
 
+            // Reparse the branch buffer so that we get syntax highlighting immediately.
+            branch.reparse(cx);
+
             branch
         })
     }

From 778dedec6c07bca9803c2d6b84ea7c3be7f6fe7e Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 2 Oct 2024 22:00:40 +0300
Subject: [PATCH 449/762] Prepare to sync other kinds of settings (#18616)

This PR does not change how things work for settings, but lays the
ground work for the future functionality.
After this change, Zed is prepared to sync more than just
`settings.json` files from local worktree and user config.

* ssh tasks

Part of this work is to streamline the task sync mechanism.
Instead of having an extra set of requests to fetch the task contents
from the server (as remote-via-collab does now and does not cover all
sync cases), we want to reuse the existing mechanism for synchronizing
user and local settings.

* editorconfig

Part of the task is to sync .editorconfig file changes to everyone which
involves sending and storing those configs.


Both ssh (and remove-over-collab) .zed/tasks.json and .editorconfig
files behave similar to .zed/settings.json local files: they belong to a
certain path in a certain worktree; may update over time, changing Zed's
functionality; can be merged hierarchically.
Settings sync follows the same "config file changed -> send to watchers
-> parse and merge locally and on watchers" path that's needed for both
new kinds of files, ergo the messaging layer is extended to send more
types of settings for future watch & parse and merge impls to follow.

Release Notes:

- N/A
---
 .../20221109000000_test_schema.sql            |   1 +
 ...20241002120231_add_local_settings_kind.sql |   1 +
 crates/collab/src/db.rs                       |  20 +++
 crates/collab/src/db/queries/projects.rs      |   9 ++
 crates/collab/src/db/queries/rooms.rs         |   1 +
 .../src/db/tables/worktree_settings_file.rs   |  16 ++
 crates/collab/src/rpc.rs                      |   2 +
 crates/collab/src/tests/integration_tests.rs  |  44 +++++-
 crates/project/src/project_settings.rs        |  46 +++++-
 crates/proto/proto/zed.proto                  |  13 ++
 crates/settings/src/settings.rs               |   3 +-
 crates/settings/src/settings_store.rs         | 140 +++++++++++-------
 12 files changed, 222 insertions(+), 74 deletions(-)
 create mode 100644 crates/collab/migrations/20241002120231_add_local_settings_kind.sql

diff --git a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
index 5c2c3961600acd..5764aceea5fc4a 100644
--- a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
+++ b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
@@ -112,6 +112,7 @@ CREATE TABLE "worktree_settings_files" (
     "worktree_id" INTEGER NOT NULL,
     "path" VARCHAR NOT NULL,
     "content" TEXT,
+    "kind" VARCHAR,
     PRIMARY KEY(project_id, worktree_id, path),
     FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE
 );
diff --git a/crates/collab/migrations/20241002120231_add_local_settings_kind.sql b/crates/collab/migrations/20241002120231_add_local_settings_kind.sql
new file mode 100644
index 00000000000000..aec4ffb8f8519b
--- /dev/null
+++ b/crates/collab/migrations/20241002120231_add_local_settings_kind.sql
@@ -0,0 +1 @@
+ALTER TABLE "worktree_settings_files" ADD COLUMN "kind" VARCHAR;
diff --git a/crates/collab/src/db.rs b/crates/collab/src/db.rs
index 5c30a857389241..f717566824e7b9 100644
--- a/crates/collab/src/db.rs
+++ b/crates/collab/src/db.rs
@@ -35,6 +35,7 @@ use std::{
 };
 use time::PrimitiveDateTime;
 use tokio::sync::{Mutex, OwnedMutexGuard};
+use worktree_settings_file::LocalSettingsKind;
 
 #[cfg(test)]
 pub use tests::TestDb;
@@ -766,6 +767,7 @@ pub struct Worktree {
 pub struct WorktreeSettingsFile {
     pub path: String,
     pub content: String,
+    pub kind: LocalSettingsKind,
 }
 
 pub struct NewExtensionVersion {
@@ -783,3 +785,21 @@ pub struct ExtensionVersionConstraints {
     pub schema_versions: RangeInclusive<i32>,
     pub wasm_api_versions: RangeInclusive<SemanticVersion>,
 }
+
+impl LocalSettingsKind {
+    pub fn from_proto(proto_kind: proto::LocalSettingsKind) -> Self {
+        match proto_kind {
+            proto::LocalSettingsKind::Settings => Self::Settings,
+            proto::LocalSettingsKind::Tasks => Self::Tasks,
+            proto::LocalSettingsKind::Editorconfig => Self::Editorconfig,
+        }
+    }
+
+    pub fn to_proto(&self) -> proto::LocalSettingsKind {
+        match self {
+            Self::Settings => proto::LocalSettingsKind::Settings,
+            Self::Tasks => proto::LocalSettingsKind::Tasks,
+            Self::Editorconfig => proto::LocalSettingsKind::Editorconfig,
+        }
+    }
+}
diff --git a/crates/collab/src/db/queries/projects.rs b/crates/collab/src/db/queries/projects.rs
index 8091c6620570f2..ceac78203d9a1b 100644
--- a/crates/collab/src/db/queries/projects.rs
+++ b/crates/collab/src/db/queries/projects.rs
@@ -1,3 +1,4 @@
+use anyhow::Context as _;
 use util::ResultExt;
 
 use super::*;
@@ -527,6 +528,12 @@ impl Database {
         connection: ConnectionId,
     ) -> Result<TransactionGuard<Vec<ConnectionId>>> {
         let project_id = ProjectId::from_proto(update.project_id);
+        let kind = match update.kind {
+            Some(kind) => proto::LocalSettingsKind::from_i32(kind)
+                .with_context(|| format!("unknown worktree settings kind: {kind}"))?,
+            None => proto::LocalSettingsKind::Settings,
+        };
+        let kind = LocalSettingsKind::from_proto(kind);
         self.project_transaction(project_id, |tx| async move {
             // Ensure the update comes from the host.
             let project = project::Entity::find_by_id(project_id)
@@ -543,6 +550,7 @@ impl Database {
                     worktree_id: ActiveValue::Set(update.worktree_id as i64),
                     path: ActiveValue::Set(update.path.clone()),
                     content: ActiveValue::Set(content.clone()),
+                    kind: ActiveValue::Set(kind),
                 })
                 .on_conflict(
                     OnConflict::columns([
@@ -800,6 +808,7 @@ impl Database {
                     worktree.settings_files.push(WorktreeSettingsFile {
                         path: db_settings_file.path,
                         content: db_settings_file.content,
+                        kind: db_settings_file.kind,
                     });
                 }
             }
diff --git a/crates/collab/src/db/queries/rooms.rs b/crates/collab/src/db/queries/rooms.rs
index 635e2d232f087f..baba0f2cf9d7c2 100644
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@@ -735,6 +735,7 @@ impl Database {
                     worktree.settings_files.push(WorktreeSettingsFile {
                         path: db_settings_file.path,
                         content: db_settings_file.content,
+                        kind: db_settings_file.kind,
                     });
                 }
             }
diff --git a/crates/collab/src/db/tables/worktree_settings_file.rs b/crates/collab/src/db/tables/worktree_settings_file.rs
index 92348c1ec94366..71f7b73fc1c399 100644
--- a/crates/collab/src/db/tables/worktree_settings_file.rs
+++ b/crates/collab/src/db/tables/worktree_settings_file.rs
@@ -11,9 +11,25 @@ pub struct Model {
     #[sea_orm(primary_key)]
     pub path: String,
     pub content: String,
+    pub kind: LocalSettingsKind,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
 pub enum Relation {}
 
 impl ActiveModelBehavior for ActiveModel {}
+
+#[derive(
+    Copy, Clone, Debug, PartialEq, Eq, EnumIter, DeriveActiveEnum, Default, Hash, serde::Serialize,
+)]
+#[sea_orm(rs_type = "String", db_type = "String(StringLen::None)")]
+#[serde(rename_all = "snake_case")]
+pub enum LocalSettingsKind {
+    #[default]
+    #[sea_orm(string_value = "settings")]
+    Settings,
+    #[sea_orm(string_value = "tasks")]
+    Tasks,
+    #[sea_orm(string_value = "editorconfig")]
+    Editorconfig,
+}
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index d9683fb8b366c1..5f21df4ab9dbce 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -1739,6 +1739,7 @@ fn notify_rejoined_projects(
                         worktree_id: worktree.id,
                         path: settings_file.path,
                         content: Some(settings_file.content),
+                        kind: Some(settings_file.kind.to_proto().into()),
                     },
                 )?;
             }
@@ -2220,6 +2221,7 @@ fn join_project_internal(
                     worktree_id: worktree.id,
                     path: settings_file.path,
                     content: Some(settings_file.content),
+                    kind: Some(proto::update_user_settings::Kind::Settings.into()),
                 },
             )?;
         }
diff --git a/crates/collab/src/tests/integration_tests.rs b/crates/collab/src/tests/integration_tests.rs
index 615ad52e2ef367..28591136344177 100644
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -33,7 +33,7 @@ use project::{
 };
 use rand::prelude::*;
 use serde_json::json;
-use settings::SettingsStore;
+use settings::{LocalSettingsKind, SettingsStore};
 use std::{
     cell::{Cell, RefCell},
     env, future, mem,
@@ -3327,8 +3327,16 @@ async fn test_local_settings(
                 .local_settings(worktree_b.read(cx).id())
                 .collect::<Vec<_>>(),
             &[
-                (Path::new("").into(), r#"{"tab_size":2}"#.to_string()),
-                (Path::new("a").into(), r#"{"tab_size":8}"#.to_string()),
+                (
+                    Path::new("").into(),
+                    LocalSettingsKind::Settings,
+                    r#"{"tab_size":2}"#.to_string()
+                ),
+                (
+                    Path::new("a").into(),
+                    LocalSettingsKind::Settings,
+                    r#"{"tab_size":8}"#.to_string()
+                ),
             ]
         )
     });
@@ -3346,8 +3354,16 @@ async fn test_local_settings(
                 .local_settings(worktree_b.read(cx).id())
                 .collect::<Vec<_>>(),
             &[
-                (Path::new("").into(), r#"{}"#.to_string()),
-                (Path::new("a").into(), r#"{"tab_size":8}"#.to_string()),
+                (
+                    Path::new("").into(),
+                    LocalSettingsKind::Settings,
+                    r#"{}"#.to_string()
+                ),
+                (
+                    Path::new("a").into(),
+                    LocalSettingsKind::Settings,
+                    r#"{"tab_size":8}"#.to_string()
+                ),
             ]
         )
     });
@@ -3375,8 +3391,16 @@ async fn test_local_settings(
                 .local_settings(worktree_b.read(cx).id())
                 .collect::<Vec<_>>(),
             &[
-                (Path::new("a").into(), r#"{"tab_size":8}"#.to_string()),
-                (Path::new("b").into(), r#"{"tab_size":4}"#.to_string()),
+                (
+                    Path::new("a").into(),
+                    LocalSettingsKind::Settings,
+                    r#"{"tab_size":8}"#.to_string()
+                ),
+                (
+                    Path::new("b").into(),
+                    LocalSettingsKind::Settings,
+                    r#"{"tab_size":4}"#.to_string()
+                ),
             ]
         )
     });
@@ -3406,7 +3430,11 @@ async fn test_local_settings(
             store
                 .local_settings(worktree_b.read(cx).id())
                 .collect::<Vec<_>>(),
-            &[(Path::new("a").into(), r#"{"hard_tabs":true}"#.to_string()),]
+            &[(
+                Path::new("a").into(),
+                LocalSettingsKind::Settings,
+                r#"{"hard_tabs":true}"#.to_string()
+            ),]
         )
     });
 }
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index d794563672ed06..87150587b3607e 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -1,3 +1,4 @@
+use anyhow::Context;
 use collections::HashMap;
 use fs::Fs;
 use gpui::{AppContext, AsyncAppContext, BorrowAppContext, EventEmitter, Model, ModelContext};
@@ -6,7 +7,7 @@ use paths::local_settings_file_relative_path;
 use rpc::{proto, AnyProtoClient, TypedEnvelope};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{InvalidSettingsError, Settings, SettingsSources, SettingsStore};
+use settings::{InvalidSettingsError, LocalSettingsKind, Settings, SettingsSources, SettingsStore};
 use std::{
     path::{Path, PathBuf},
     sync::Arc,
@@ -266,13 +267,14 @@ impl SettingsObserver {
         let store = cx.global::<SettingsStore>();
         for worktree in self.worktree_store.read(cx).worktrees() {
             let worktree_id = worktree.read(cx).id().to_proto();
-            for (path, content) in store.local_settings(worktree.read(cx).id()) {
+            for (path, kind, content) in store.local_settings(worktree.read(cx).id()) {
                 downstream_client
                     .send(proto::UpdateWorktreeSettings {
                         project_id,
                         worktree_id,
                         path: path.to_string_lossy().into(),
                         content: Some(content),
+                        kind: Some(local_settings_kind_to_proto(kind).into()),
                     })
                     .log_err();
             }
@@ -288,6 +290,11 @@ impl SettingsObserver {
         envelope: TypedEnvelope<proto::UpdateWorktreeSettings>,
         mut cx: AsyncAppContext,
     ) -> anyhow::Result<()> {
+        let kind = match envelope.payload.kind {
+            Some(kind) => proto::LocalSettingsKind::from_i32(kind)
+                .with_context(|| format!("unknown kind {kind}"))?,
+            None => proto::LocalSettingsKind::Settings,
+        };
         this.update(&mut cx, |this, cx| {
             let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
             let Some(worktree) = this
@@ -297,10 +304,12 @@ impl SettingsObserver {
             else {
                 return;
             };
+
             this.update_settings(
                 worktree,
                 [(
                     PathBuf::from(&envelope.payload.path).into(),
+                    local_settings_kind_from_proto(kind),
                     envelope.payload.content,
                 )],
                 cx,
@@ -327,6 +336,7 @@ impl SettingsObserver {
             ssh.send(proto::UpdateUserSettings {
                 project_id: 0,
                 content,
+                kind: Some(proto::LocalSettingsKind::Settings.into()),
             })
             .log_err();
         }
@@ -342,6 +352,7 @@ impl SettingsObserver {
                     ssh.send(proto::UpdateUserSettings {
                         project_id: 0,
                         content,
+                        kind: Some(proto::LocalSettingsKind::Settings.into()),
                     })
                     .log_err();
                 }
@@ -397,6 +408,7 @@ impl SettingsObserver {
                 settings_contents.push(async move {
                     (
                         settings_dir,
+                        LocalSettingsKind::Settings,
                         if removed {
                             None
                         } else {
@@ -413,15 +425,15 @@ impl SettingsObserver {
 
         let worktree = worktree.clone();
         cx.spawn(move |this, cx| async move {
-            let settings_contents: Vec<(Arc<Path>, _)> =
+            let settings_contents: Vec<(Arc<Path>, _, _)> =
                 futures::future::join_all(settings_contents).await;
             cx.update(|cx| {
                 this.update(cx, |this, cx| {
                     this.update_settings(
                         worktree,
-                        settings_contents
-                            .into_iter()
-                            .map(|(path, content)| (path, content.and_then(|c| c.log_err()))),
+                        settings_contents.into_iter().map(|(path, kind, content)| {
+                            (path, kind, content.and_then(|c| c.log_err()))
+                        }),
                         cx,
                     )
                 })
@@ -433,17 +445,18 @@ impl SettingsObserver {
     fn update_settings(
         &mut self,
         worktree: Model<Worktree>,
-        settings_contents: impl IntoIterator<Item = (Arc<Path>, Option<String>)>,
+        settings_contents: impl IntoIterator<Item = (Arc<Path>, LocalSettingsKind, Option<String>)>,
         cx: &mut ModelContext<Self>,
     ) {
         let worktree_id = worktree.read(cx).id();
         let remote_worktree_id = worktree.read(cx).id();
 
         let result = cx.update_global::<SettingsStore, anyhow::Result<()>>(|store, cx| {
-            for (directory, file_content) in settings_contents {
+            for (directory, kind, file_content) in settings_contents {
                 store.set_local_settings(
                     worktree_id,
                     directory.clone(),
+                    kind,
                     file_content.as_deref(),
                     cx,
                 )?;
@@ -455,6 +468,7 @@ impl SettingsObserver {
                             worktree_id: remote_worktree_id.to_proto(),
                             path: directory.to_string_lossy().into_owned(),
                             content: file_content,
+                            kind: Some(local_settings_kind_to_proto(kind).into()),
                         })
                         .log_err();
                 }
@@ -481,3 +495,19 @@ impl SettingsObserver {
         }
     }
 }
+
+pub fn local_settings_kind_from_proto(kind: proto::LocalSettingsKind) -> LocalSettingsKind {
+    match kind {
+        proto::LocalSettingsKind::Settings => LocalSettingsKind::Settings,
+        proto::LocalSettingsKind::Tasks => LocalSettingsKind::Tasks,
+        proto::LocalSettingsKind::Editorconfig => LocalSettingsKind::Editorconfig,
+    }
+}
+
+pub fn local_settings_kind_to_proto(kind: LocalSettingsKind) -> proto::LocalSettingsKind {
+    match kind {
+        LocalSettingsKind::Settings => proto::LocalSettingsKind::Settings,
+        LocalSettingsKind::Tasks => proto::LocalSettingsKind::Tasks,
+        LocalSettingsKind::Editorconfig => proto::LocalSettingsKind::Editorconfig,
+    }
+}
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index 07f64557f47e1d..f6e9645e9c11ac 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -642,6 +642,13 @@ message UpdateWorktreeSettings {
     uint64 worktree_id = 2;
     string path = 3;
     optional string content = 4;
+    optional LocalSettingsKind kind = 5;
+}
+
+enum LocalSettingsKind {
+    Settings = 0;
+    Tasks = 1;
+    Editorconfig = 2;
 }
 
 message CreateProjectEntry {
@@ -2487,6 +2494,12 @@ message AddWorktreeResponse {
 message UpdateUserSettings {
     uint64 project_id = 1;
     string content = 2;
+    optional Kind kind = 3;
+
+    enum Kind {
+        Settings = 0;
+        Tasks = 1;
+    }
 }
 
 message CheckFileExists {
diff --git a/crates/settings/src/settings.rs b/crates/settings/src/settings.rs
index f1f8591bba4525..2ed01dc7c722fd 100644
--- a/crates/settings/src/settings.rs
+++ b/crates/settings/src/settings.rs
@@ -14,7 +14,8 @@ pub use json_schema::*;
 pub use keymap_file::KeymapFile;
 pub use settings_file::*;
 pub use settings_store::{
-    InvalidSettingsError, Settings, SettingsLocation, SettingsSources, SettingsStore,
+    InvalidSettingsError, LocalSettingsKind, Settings, SettingsLocation, SettingsSources,
+    SettingsStore,
 };
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
diff --git a/crates/settings/src/settings_store.rs b/crates/settings/src/settings_store.rs
index 20bf52f2c57ef0..445420c1db8a7d 100644
--- a/crates/settings/src/settings_store.rs
+++ b/crates/settings/src/settings_store.rs
@@ -157,13 +157,14 @@ pub struct SettingsLocation<'a> {
     pub path: &'a Path,
 }
 
-/// A set of strongly-typed setting values defined via multiple JSON files.
+/// A set of strongly-typed setting values defined via multiple config files.
 pub struct SettingsStore {
     setting_values: HashMap<TypeId, Box<dyn AnySettingValue>>,
     raw_default_settings: serde_json::Value,
     raw_user_settings: serde_json::Value,
     raw_extension_settings: serde_json::Value,
-    raw_local_settings: BTreeMap<(WorktreeId, Arc<Path>), serde_json::Value>,
+    raw_local_settings:
+        BTreeMap<(WorktreeId, Arc<Path>), HashMap<LocalSettingsKind, serde_json::Value>>,
     tab_size_callback: Option<(
         TypeId,
         Box<dyn Fn(&dyn Any) -> Option<usize> + Send + Sync + 'static>,
@@ -174,6 +175,13 @@ pub struct SettingsStore {
     >,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum LocalSettingsKind {
+    Settings,
+    Tasks,
+    Editorconfig,
+}
+
 impl Global for SettingsStore {}
 
 #[derive(Debug)]
@@ -520,19 +528,21 @@ impl SettingsStore {
     pub fn set_local_settings(
         &mut self,
         root_id: WorktreeId,
-        path: Arc<Path>,
+        directory_path: Arc<Path>,
+        kind: LocalSettingsKind,
         settings_content: Option<&str>,
         cx: &mut AppContext,
     ) -> Result<()> {
+        let raw_local_settings = self
+            .raw_local_settings
+            .entry((root_id, directory_path.clone()))
+            .or_default();
         if settings_content.is_some_and(|content| !content.is_empty()) {
-            self.raw_local_settings.insert(
-                (root_id, path.clone()),
-                parse_json_with_comments(settings_content.unwrap())?,
-            );
+            raw_local_settings.insert(kind, parse_json_with_comments(settings_content.unwrap())?);
         } else {
-            self.raw_local_settings.remove(&(root_id, path.clone()));
+            raw_local_settings.remove(&kind);
         }
-        self.recompute_values(Some((root_id, &path)), cx)?;
+        self.recompute_values(Some((root_id, &directory_path)), cx)?;
         Ok(())
     }
 
@@ -553,7 +563,8 @@ impl SettingsStore {
 
     /// Add or remove a set of local settings via a JSON string.
     pub fn clear_local_settings(&mut self, root_id: WorktreeId, cx: &mut AppContext) -> Result<()> {
-        self.raw_local_settings.retain(|k, _| k.0 != root_id);
+        self.raw_local_settings
+            .retain(|(worktree_id, _), _| worktree_id != &root_id);
         self.recompute_values(Some((root_id, "".as_ref())), cx)?;
         Ok(())
     }
@@ -561,7 +572,7 @@ impl SettingsStore {
     pub fn local_settings(
         &self,
         root_id: WorktreeId,
-    ) -> impl '_ + Iterator<Item = (Arc<Path>, String)> {
+    ) -> impl '_ + Iterator<Item = (Arc<Path>, LocalSettingsKind, String)> {
         self.raw_local_settings
             .range(
                 (root_id, Path::new("").into())
@@ -570,7 +581,12 @@ impl SettingsStore {
                         Path::new("").into(),
                     ),
             )
-            .map(|((_, path), content)| (path.clone(), serde_json::to_string(content).unwrap()))
+            .flat_map(|((_, path), content)| {
+                content.iter().filter_map(|(&kind, raw_content)| {
+                    let parsed_content = serde_json::to_string(raw_content).log_err()?;
+                    Some((path.clone(), kind, parsed_content))
+                })
+            })
     }
 
     pub fn json_schema(
@@ -739,56 +755,63 @@ impl SettingsStore {
             // Reload the local values for the setting.
             paths_stack.clear();
             project_settings_stack.clear();
-            for ((root_id, path), local_settings) in &self.raw_local_settings {
-                // Build a stack of all of the local values for that setting.
-                while let Some(prev_entry) = paths_stack.last() {
-                    if let Some((prev_root_id, prev_path)) = prev_entry {
-                        if root_id != prev_root_id || !path.starts_with(prev_path) {
-                            paths_stack.pop();
-                            project_settings_stack.pop();
-                            continue;
+            for ((root_id, directory_path), local_settings) in &self.raw_local_settings {
+                if let Some(local_settings) = local_settings.get(&LocalSettingsKind::Settings) {
+                    // Build a stack of all of the local values for that setting.
+                    while let Some(prev_entry) = paths_stack.last() {
+                        if let Some((prev_root_id, prev_path)) = prev_entry {
+                            if root_id != prev_root_id || !directory_path.starts_with(prev_path) {
+                                paths_stack.pop();
+                                project_settings_stack.pop();
+                                continue;
+                            }
                         }
+                        break;
                     }
-                    break;
-                }
 
-                match setting_value.deserialize_setting(local_settings) {
-                    Ok(local_settings) => {
-                        paths_stack.push(Some((*root_id, path.as_ref())));
-                        project_settings_stack.push(local_settings);
-
-                        // If a local settings file changed, then avoid recomputing local
-                        // settings for any path outside of that directory.
-                        if changed_local_path.map_or(
-                            false,
-                            |(changed_root_id, changed_local_path)| {
-                                *root_id != changed_root_id || !path.starts_with(changed_local_path)
-                            },
-                        ) {
-                            continue;
-                        }
-
-                        if let Some(value) = setting_value
-                            .load_setting(
-                                SettingsSources {
-                                    default: &default_settings,
-                                    extensions: extension_settings.as_ref(),
-                                    user: user_settings.as_ref(),
-                                    release_channel: release_channel_settings.as_ref(),
-                                    project: &project_settings_stack.iter().collect::<Vec<_>>(),
+                    match setting_value.deserialize_setting(local_settings) {
+                        Ok(local_settings) => {
+                            paths_stack.push(Some((*root_id, directory_path.as_ref())));
+                            project_settings_stack.push(local_settings);
+
+                            // If a local settings file changed, then avoid recomputing local
+                            // settings for any path outside of that directory.
+                            if changed_local_path.map_or(
+                                false,
+                                |(changed_root_id, changed_local_path)| {
+                                    *root_id != changed_root_id
+                                        || !directory_path.starts_with(changed_local_path)
                                 },
-                                cx,
-                            )
-                            .log_err()
-                        {
-                            setting_value.set_local_value(*root_id, path.clone(), value);
+                            ) {
+                                continue;
+                            }
+
+                            if let Some(value) = setting_value
+                                .load_setting(
+                                    SettingsSources {
+                                        default: &default_settings,
+                                        extensions: extension_settings.as_ref(),
+                                        user: user_settings.as_ref(),
+                                        release_channel: release_channel_settings.as_ref(),
+                                        project: &project_settings_stack.iter().collect::<Vec<_>>(),
+                                    },
+                                    cx,
+                                )
+                                .log_err()
+                            {
+                                setting_value.set_local_value(
+                                    *root_id,
+                                    directory_path.clone(),
+                                    value,
+                                );
+                            }
+                        }
+                        Err(error) => {
+                            return Err(anyhow!(InvalidSettingsError::LocalSettings {
+                                path: directory_path.join(local_settings_file_relative_path()),
+                                message: error.to_string()
+                            }));
                         }
-                    }
-                    Err(error) => {
-                        return Err(anyhow!(InvalidSettingsError::LocalSettings {
-                            path: path.join(local_settings_file_relative_path()),
-                            message: error.to_string()
-                        }));
                     }
                 }
             }
@@ -1201,6 +1224,7 @@ mod tests {
             .set_local_settings(
                 WorktreeId::from_usize(1),
                 Path::new("/root1").into(),
+                LocalSettingsKind::Settings,
                 Some(r#"{ "user": { "staff": true } }"#),
                 cx,
             )
@@ -1209,6 +1233,7 @@ mod tests {
             .set_local_settings(
                 WorktreeId::from_usize(1),
                 Path::new("/root1/subdir").into(),
+                LocalSettingsKind::Settings,
                 Some(r#"{ "user": { "name": "Jane Doe" } }"#),
                 cx,
             )
@@ -1218,6 +1243,7 @@ mod tests {
             .set_local_settings(
                 WorktreeId::from_usize(1),
                 Path::new("/root2").into(),
+                LocalSettingsKind::Settings,
                 Some(r#"{ "user": { "age": 42 }, "key2": "b" }"#),
                 cx,
             )

From f809787275850a70a45a30bf7b72ae5c9dd547b2 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 2 Oct 2024 15:23:22 -0400
Subject: [PATCH 450/762] Update cloudflare/wrangler-action digest to 168bc28
 (#18651)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
|
[cloudflare/wrangler-action](https://redirect.github.com/cloudflare/wrangler-action)
| action | digest | `f84a562` -> `168bc28` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguOTcuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 .github/workflows/deploy_cloudflare.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/deploy_cloudflare.yml b/.github/workflows/deploy_cloudflare.yml
index 5cf4d6fd13140e..5c09c29b0f44f2 100644
--- a/.github/workflows/deploy_cloudflare.yml
+++ b/.github/workflows/deploy_cloudflare.yml
@@ -36,28 +36,28 @@ jobs:
           mdbook build ./docs --dest-dir=../target/deploy/docs/
 
       - name: Deploy Docs
-        uses: cloudflare/wrangler-action@f84a562284fc78278ff9052435d9526f9c718361 # v3
+        uses: cloudflare/wrangler-action@168bc28b7078db16f6f1ecc26477fc2248592143 # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: pages deploy target/deploy --project-name=docs
 
       - name: Deploy Install
-        uses: cloudflare/wrangler-action@f84a562284fc78278ff9052435d9526f9c718361 # v3
+        uses: cloudflare/wrangler-action@168bc28b7078db16f6f1ecc26477fc2248592143 # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: r2 object put -f script/install.sh zed-open-source-website-assets/install.sh
 
       - name: Deploy Docs Workers
-        uses: cloudflare/wrangler-action@f84a562284fc78278ff9052435d9526f9c718361 # v3
+        uses: cloudflare/wrangler-action@168bc28b7078db16f6f1ecc26477fc2248592143 # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: deploy .cloudflare/docs-proxy/src/worker.js
 
       - name: Deploy Install Workers
-        uses: cloudflare/wrangler-action@f84a562284fc78278ff9052435d9526f9c718361 # v3
+        uses: cloudflare/wrangler-action@168bc28b7078db16f6f1ecc26477fc2248592143 # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}

From 3a5deb5c6fc7ae1354cc5c59773055e85519a3cc Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 3 Oct 2024 01:00:48 +0530
Subject: [PATCH 451/762] Replace isahc with async ureq (#18414)

REplace isahc with ureq everywhere gpui is used.

This should allow us to make http requests without libssl; and avoid a
long-tail of panics caused by ishac.

Release Notes:

- (potentially breaking change) updated our http client

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
---
 Cargo.lock                                    | 602 ++++++++++++------
 Cargo.toml                                    |  17 +-
 crates/client/Cargo.toml                      |   3 +-
 crates/client/src/client.rs                   |  27 +-
 crates/collab/Cargo.toml                      |   2 +-
 crates/collab/src/api/events.rs               |  40 +-
 crates/collab/src/llm.rs                      |  12 +-
 crates/collab/src/rpc.rs                      |   6 +-
 crates/evals/Cargo.toml                       |   2 +-
 crates/evals/src/eval.rs                      |   7 +-
 crates/extension/Cargo.toml                   |   4 +-
 crates/extension/src/extension_builder.rs     |   2 +-
 crates/extension/src/extension_store_test.rs  |  52 +-
 crates/extension_cli/Cargo.toml               |   2 +-
 crates/extension_cli/src/main.rs              |   9 +-
 crates/http_client/Cargo.toml                 |   4 +-
 crates/http_client/src/http_client.rs         |  29 +-
 crates/isahc_http_client/LICENSE-APACHE       |   1 -
 .../src/isahc_http_client.rs                  | 105 ---
 crates/live_kit_server/Cargo.toml             |   2 +-
 crates/reqwest_client/Cargo.toml              |  31 +
 crates/reqwest_client/LICENSE-GPL             |   1 +
 crates/reqwest_client/examples/client.rs      |  16 +
 crates/reqwest_client/src/reqwest_client.rs   | 232 +++++++
 crates/semantic_index/Cargo.toml              |   2 +-
 crates/semantic_index/examples/index.rs       |   7 +-
 .../Cargo.toml                                |  16 +-
 crates/ureq_client/LICENSE-GPL                |   1 +
 crates/ureq_client/examples/client.rs         |  24 +
 crates/ureq_client/src/ureq_client.rs         | 187 ++++++
 crates/vim/Cargo.toml                         |   2 +-
 crates/zed/Cargo.toml                         |   2 +-
 crates/zed/src/main.rs                        |  10 +-
 33 files changed, 1063 insertions(+), 396 deletions(-)
 delete mode 120000 crates/isahc_http_client/LICENSE-APACHE
 delete mode 100644 crates/isahc_http_client/src/isahc_http_client.rs
 create mode 100644 crates/reqwest_client/Cargo.toml
 create mode 120000 crates/reqwest_client/LICENSE-GPL
 create mode 100644 crates/reqwest_client/examples/client.rs
 create mode 100644 crates/reqwest_client/src/reqwest_client.rs
 rename crates/{isahc_http_client => ureq_client}/Cargo.toml (52%)
 create mode 120000 crates/ureq_client/LICENSE-GPL
 create mode 100644 crates/ureq_client/examples/client.rs
 create mode 100644 crates/ureq_client/src/ureq_client.rs

diff --git a/Cargo.lock b/Cargo.lock
index b69e4541cc9e20..a96e59df34c1db 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -846,8 +846,8 @@ dependencies = [
  "chrono",
  "futures-util",
  "http-types",
- "hyper",
- "hyper-rustls",
+ "hyper 0.14.30",
+ "hyper-rustls 0.24.2",
  "serde",
  "serde_json",
  "serde_path_to_error",
@@ -880,15 +880,14 @@ checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
 
 [[package]]
 name = "async-tls"
-version = "0.12.0"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfeefd0ca297cbbb3bd34fd6b228401c2a5177038257afd751bc29f0a2da4795"
+checksum = "b2ae3c9eba89d472a0e4fe1dea433df78fbbe63d2b764addaf2ba3a6bde89a5e"
 dependencies = [
  "futures-core",
  "futures-io",
- "rustls 0.20.9",
+ "rustls 0.21.12",
  "rustls-pemfile 1.0.4",
- "webpki",
  "webpki-roots 0.22.6",
 ]
 
@@ -905,9 +904,9 @@ dependencies = [
 
 [[package]]
 name = "async-tungstenite"
-version = "0.23.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1e9efbe14612da0a19fb983059a0b621e9cf6225d7018ecab4f9988215540dc"
+checksum = "90e661b6cb0a6eb34d02c520b052daa3aa9ac0cc02495c9d066bbce13ead132b"
 dependencies = [
  "async-std",
  "async-tls",
@@ -915,7 +914,7 @@ dependencies = [
  "futures-util",
  "log",
  "pin-project-lite",
- "tungstenite 0.20.1",
+ "tungstenite 0.24.0",
 ]
 
 [[package]]
@@ -1064,7 +1063,7 @@ dependencies = [
  "fastrand 2.1.1",
  "hex",
  "http 0.2.12",
- "ring 0.17.8",
+ "ring",
  "time",
  "tokio",
  "tracing",
@@ -1233,7 +1232,7 @@ dependencies = [
  "once_cell",
  "p256",
  "percent-encoding",
- "ring 0.17.8",
+ "ring",
  "sha2",
  "subtle",
  "time",
@@ -1336,13 +1335,13 @@ dependencies = [
  "aws-smithy-types",
  "bytes 1.7.1",
  "fastrand 2.1.1",
- "h2",
+ "h2 0.3.26",
  "http 0.2.12",
  "http-body 0.4.6",
  "http-body 1.0.1",
  "httparse",
- "hyper",
- "hyper-rustls",
+ "hyper 0.14.30",
+ "hyper-rustls 0.24.2",
  "once_cell",
  "pin-project-lite",
  "pin-utils",
@@ -1432,7 +1431,7 @@ dependencies = [
  "headers",
  "http 0.2.12",
  "http-body 0.4.6",
- "hyper",
+ "hyper 0.14.30",
  "itoa",
  "matchit",
  "memchr",
@@ -1445,7 +1444,7 @@ dependencies = [
  "serde_path_to_error",
  "serde_urlencoded",
  "sha1",
- "sync_wrapper",
+ "sync_wrapper 0.1.2",
  "tokio",
  "tokio-tungstenite 0.20.1",
  "tower",
@@ -1584,7 +1583,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "shlex",
  "syn 2.0.76",
 ]
@@ -1604,7 +1603,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "shlex",
  "syn 2.0.76",
 ]
@@ -2100,12 +2099,6 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
-[[package]]
-name = "castaway"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2698f953def977c68f935bb0dfa959375ad4638570e969e2f1e9f433cbf1af6"
-
 [[package]]
 name = "cbc"
 version = "0.1.2"
@@ -2363,8 +2356,8 @@ dependencies = [
  "clickhouse-derive",
  "clickhouse-rs-cityhash-sys",
  "futures 0.3.30",
- "hyper",
- "hyper-tls",
+ "hyper 0.14.30",
+ "hyper-tls 0.5.0",
  "lz4",
  "sealed",
  "serde",
@@ -2402,6 +2395,7 @@ dependencies = [
  "anyhow",
  "async-native-tls",
  "async-recursion 0.3.2",
+ "async-tls",
  "async-tungstenite",
  "chrono",
  "clock",
@@ -2419,8 +2413,6 @@ dependencies = [
  "rand 0.8.5",
  "release_channel",
  "rpc",
- "rustls 0.20.9",
- "rustls-native-certs 0.8.0",
  "schemars",
  "serde",
  "serde_json",
@@ -2567,9 +2559,8 @@ dependencies = [
  "headless",
  "hex",
  "http_client",
- "hyper",
+ "hyper 0.14.30",
  "indoc",
- "isahc_http_client",
  "jsonwebtoken",
  "language",
  "language_model",
@@ -2593,7 +2584,8 @@ dependencies = [
  "release_channel",
  "remote",
  "remote_server",
- "reqwest",
+ "reqwest 0.11.27",
+ "reqwest_client",
  "rpc",
  "rustc-demangle",
  "scrypt",
@@ -2677,7 +2669,7 @@ dependencies = [
 name = "collections"
 version = "0.1.0"
 dependencies = [
- "rustc-hash",
+ "rustc-hash 1.1.0",
 ]
 
 [[package]]
@@ -2995,7 +2987,7 @@ dependencies = [
  "log",
  "rangemap",
  "rayon",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "rustybuzz",
  "self_cell",
  "swash",
@@ -3085,7 +3077,7 @@ dependencies = [
  "hashbrown 0.14.5",
  "log",
  "regalloc2",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "smallvec",
  "target-lexicon",
 ]
@@ -3341,36 +3333,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "curl"
-version = "0.4.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e2161dd6eba090ff1594084e95fd67aeccf04382ffea77999ea94ed42ec67b6"
-dependencies = [
- "curl-sys",
- "libc",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "socket2 0.5.7",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "curl-sys"
-version = "0.4.74+curl-8.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8af10b986114528fcdc4b63b6f5f021b7057618411046a4de2ba0f0149a097bf"
-dependencies = [
- "cc",
- "libc",
- "libz-sys",
- "openssl-sys",
- "pkg-config",
- "vcpkg",
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "cursor-icon"
 version = "1.1.0"
@@ -4032,7 +3994,6 @@ dependencies = [
  "git",
  "gpui",
  "http_client",
- "isahc_http_client",
  "language",
  "languages",
  "node_runtime",
@@ -4043,6 +4004,7 @@ dependencies = [
  "serde_json",
  "settings",
  "smol",
+ "ureq_client",
 ]
 
 [[package]]
@@ -4127,7 +4089,6 @@ dependencies = [
  "gpui",
  "http_client",
  "indexed_docs",
- "isahc_http_client",
  "language",
  "log",
  "lsp",
@@ -4136,6 +4097,7 @@ dependencies = [
  "paths",
  "project",
  "release_channel",
+ "reqwest_client",
  "schemars",
  "semantic_version",
  "serde",
@@ -4145,8 +4107,10 @@ dependencies = [
  "snippet_provider",
  "task",
  "theme",
+ "tokio",
  "toml 0.8.19",
  "ui",
+ "ureq_client",
  "url",
  "util",
  "wasm-encoder 0.215.0",
@@ -4166,9 +4130,9 @@ dependencies = [
  "env_logger",
  "extension",
  "fs",
- "isahc_http_client",
  "language",
  "log",
+ "reqwest_client",
  "rpc",
  "serde",
  "serde_json",
@@ -4415,7 +4379,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "nanorand",
- "spin 0.9.8",
+ "spin",
 ]
 
 [[package]]
@@ -5181,6 +5145,25 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "h2"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524e8ac6999421f49a846c2d4411f337e53497d8ec55d67753beffa43c5d9205"
+dependencies = [
+ "atomic-waker",
+ "bytes 1.7.1",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http 1.1.0",
+ "indexmap 2.4.0",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
 [[package]]
 name = "half"
 version = "2.4.1"
@@ -5561,8 +5544,10 @@ dependencies = [
  "anyhow",
  "derive_more",
  "futures 0.3.30",
- "http 0.2.12",
+ "http 1.1.0",
  "log",
+ "rustls 0.21.12",
+ "rustls-native-certs 0.8.0",
  "serde",
  "serde_json",
  "smol",
@@ -5603,7 +5588,7 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2",
+ "h2 0.3.26",
  "http 0.2.12",
  "http-body 0.4.6",
  "httparse",
@@ -5617,6 +5602,26 @@ dependencies = [
  "want",
 ]
 
+[[package]]
+name = "hyper"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50dfd22e0e76d0f662d429a5f80fcaf3855009297eab6a0a9f8543834744ba05"
+dependencies = [
+ "bytes 1.7.1",
+ "futures-channel",
+ "futures-util",
+ "h2 0.4.6",
+ "http 1.1.0",
+ "http-body 1.0.1",
+ "httparse",
+ "itoa",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
 [[package]]
 name = "hyper-rustls"
 version = "0.24.2"
@@ -5625,12 +5630,29 @@ checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
  "futures-util",
  "http 0.2.12",
- "hyper",
+ "hyper 0.14.30",
  "log",
  "rustls 0.21.12",
  "rustls-native-certs 0.6.3",
  "tokio",
- "tokio-rustls",
+ "tokio-rustls 0.24.1",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.27.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08afdbb5c31130e3034af566421053ab03787c640246a446327f550d11bcb333"
+dependencies = [
+ "futures-util",
+ "http 1.1.0",
+ "hyper 1.4.1",
+ "hyper-util",
+ "rustls 0.23.13",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls 0.26.0",
+ "tower-service",
 ]
 
 [[package]]
@@ -5640,12 +5662,47 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
 dependencies = [
  "bytes 1.7.1",
- "hyper",
+ "hyper 0.14.30",
  "native-tls",
  "tokio",
  "tokio-native-tls",
 ]
 
+[[package]]
+name = "hyper-tls"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
+dependencies = [
+ "bytes 1.7.1",
+ "http-body-util",
+ "hyper 1.4.1",
+ "hyper-util",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+ "tower-service",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41296eb09f183ac68eec06e03cdbea2e759633d4067b2f6552fc2e009bcad08b"
+dependencies = [
+ "bytes 1.7.1",
+ "futures-channel",
+ "futures-util",
+ "http 1.1.0",
+ "http-body 1.0.1",
+ "hyper 1.4.1",
+ "pin-project-lite",
+ "socket2 0.5.7",
+ "tokio",
+ "tower-service",
+ "tracing",
+]
+
 [[package]]
 name = "iana-time-zone"
 version = "0.1.60"
@@ -6013,44 +6070,6 @@ version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 
-[[package]]
-name = "isahc"
-version = "1.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "334e04b4d781f436dc315cb1e7515bd96826426345d498149e4bde36b67f8ee9"
-dependencies = [
- "async-channel 1.9.0",
- "castaway",
- "crossbeam-utils",
- "curl",
- "curl-sys",
- "encoding_rs",
- "event-listener 2.5.3",
- "futures-lite 1.13.0",
- "http 0.2.12",
- "log",
- "mime",
- "once_cell",
- "polling 2.8.0",
- "slab",
- "sluice",
- "tracing",
- "tracing-futures",
- "url",
- "waker-fn",
-]
-
-[[package]]
-name = "isahc_http_client"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "futures 0.3.30",
- "http_client",
- "isahc",
- "util",
-]
-
 [[package]]
 name = "itertools"
 version = "0.10.5"
@@ -6155,7 +6174,7 @@ dependencies = [
  "base64 0.21.7",
  "js-sys",
  "pem",
- "ring 0.17.8",
+ "ring",
  "serde",
  "serde_json",
  "simple_asn1",
@@ -6406,7 +6425,7 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 dependencies = [
- "spin 0.9.8",
+ "spin",
 ]
 
 [[package]]
@@ -6601,7 +6620,7 @@ dependencies = [
  "prost",
  "prost-build",
  "prost-types",
- "reqwest",
+ "reqwest 0.12.8",
  "serde",
 ]
 
@@ -7085,7 +7104,7 @@ dependencies = [
  "hexf-parse",
  "indexmap 2.4.0",
  "log",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "spirv",
  "termcolor",
  "thiserror",
@@ -8742,6 +8761,54 @@ dependencies = [
  "zed_actions",
 ]
 
+[[package]]
+name = "quinn"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c7c5fdde3cdae7203427dc4f0a68fe0ed09833edc525a03456b153b79828684"
+dependencies = [
+ "bytes 1.7.1",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash 2.0.0",
+ "rustls 0.23.13",
+ "socket2 0.5.7",
+ "thiserror",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fadfaed2cd7f389d0161bb73eeb07b7b78f8691047a6f3e73caaeae55310a4a6"
+dependencies = [
+ "bytes 1.7.1",
+ "rand 0.8.5",
+ "ring",
+ "rustc-hash 2.0.0",
+ "rustls 0.23.13",
+ "slab",
+ "thiserror",
+ "tinyvec",
+ "tracing",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fe68c2e9e1a1234e218683dbdf9f9dfcb094113c5ac2b938dfcb9bab4c4140b"
+dependencies = [
+ "libc",
+ "once_cell",
+ "socket2 0.5.7",
+ "tracing",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.37"
@@ -9019,7 +9086,7 @@ checksum = "ad156d539c879b7a24a363a2016d77961786e71f48f2e2fc8302a92abd2429a6"
 dependencies = [
  "hashbrown 0.13.2",
  "log",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "slice-group-by",
  "smallvec",
 ]
@@ -9196,11 +9263,11 @@ dependencies = [
  "encoding_rs",
  "futures-core",
  "futures-util",
- "h2",
+ "h2 0.3.26",
  "http 0.2.12",
  "http-body 0.4.6",
- "hyper",
- "hyper-tls",
+ "hyper 0.14.30",
+ "hyper-tls 0.5.0",
  "ipnet",
  "js-sys",
  "log",
@@ -9213,8 +9280,8 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_urlencoded",
- "sync_wrapper",
- "system-configuration",
+ "sync_wrapper 0.1.2",
+ "system-configuration 0.5.1",
  "tokio",
  "tokio-native-tls",
  "tower-service",
@@ -9225,6 +9292,68 @@ dependencies = [
  "winreg 0.50.0",
 ]
 
+[[package]]
+name = "reqwest"
+version = "0.12.8"
+source = "git+https://github.com/zed-industries/reqwest.git?rev=fd110f6998da16bbca97b6dddda9be7827c50e29#fd110f6998da16bbca97b6dddda9be7827c50e29"
+dependencies = [
+ "base64 0.22.1",
+ "bytes 1.7.1",
+ "encoding_rs",
+ "futures-core",
+ "futures-util",
+ "h2 0.4.6",
+ "http 1.1.0",
+ "http-body 1.0.1",
+ "http-body-util",
+ "hyper 1.4.1",
+ "hyper-rustls 0.27.3",
+ "hyper-tls 0.6.0",
+ "hyper-util",
+ "ipnet",
+ "js-sys",
+ "log",
+ "mime",
+ "native-tls",
+ "once_cell",
+ "percent-encoding",
+ "pin-project-lite",
+ "quinn",
+ "rustls 0.23.13",
+ "rustls-pemfile 2.1.3",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper 1.0.1",
+ "system-configuration 0.6.1",
+ "tokio",
+ "tokio-native-tls",
+ "tokio-rustls 0.26.0",
+ "tokio-util",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams",
+ "web-sys",
+ "windows-registry",
+]
+
+[[package]]
+name = "reqwest_client"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "bytes 1.7.1",
+ "futures 0.3.30",
+ "http_client",
+ "reqwest 0.12.8",
+ "serde",
+ "smol",
+ "tokio",
+]
+
 [[package]]
 name = "resvg"
 version = "0.41.0"
@@ -9273,21 +9402,6 @@ dependencies = [
  "util",
 ]
 
-[[package]]
-name = "ring"
-version = "0.16.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
-dependencies = [
- "cc",
- "libc",
- "once_cell",
- "spin 0.5.2",
- "untrusted 0.7.1",
- "web-sys",
- "winapi",
-]
-
 [[package]]
 name = "ring"
 version = "0.17.8"
@@ -9298,8 +9412,8 @@ dependencies = [
  "cfg-if",
  "getrandom 0.2.15",
  "libc",
- "spin 0.9.8",
- "untrusted 0.9.0",
+ "spin",
+ "untrusted",
  "windows-sys 0.52.0",
 ]
 
@@ -9455,7 +9569,7 @@ dependencies = [
  "futures 0.3.30",
  "glob",
  "rand 0.8.5",
- "ring 0.17.8",
+ "ring",
  "serde",
  "serde_json",
  "shellexpand 3.1.0",
@@ -9527,6 +9641,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc-hash"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152"
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -9578,26 +9698,28 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.20.9"
+version = "0.21.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b80e3dec595989ea8510028f30c408a4630db12c9cbb8de34203b89d6577e99"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 dependencies = [
  "log",
- "ring 0.16.20",
+ "ring",
+ "rustls-webpki 0.101.7",
  "sct",
- "webpki",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.21.12"
+version = "0.23.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
+checksum = "f2dabaac7466917e566adb06783a81ca48944c6898a1b08b9374106dd671f4c8"
 dependencies = [
- "log",
- "ring 0.17.8",
- "rustls-webpki",
- "sct",
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki 0.102.8",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
@@ -9656,8 +9778,19 @@ version = "0.101.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 dependencies = [
- "ring 0.17.8",
- "untrusted 0.9.0",
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.102.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
 ]
 
 [[package]]
@@ -9771,8 +9904,8 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "ring 0.17.8",
- "untrusted 0.9.0",
+ "ring",
+ "untrusted",
 ]
 
 [[package]]
@@ -9968,7 +10101,6 @@ dependencies = [
  "gpui",
  "heed",
  "http_client",
- "isahc_http_client",
  "language",
  "language_model",
  "languages",
@@ -9986,6 +10118,7 @@ dependencies = [
  "tree-sitter",
  "ui",
  "unindent",
+ "ureq_client",
  "util",
  "workspace",
  "worktree",
@@ -10418,17 +10551,6 @@ dependencies = [
  "version_check",
 ]
 
-[[package]]
-name = "sluice"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d7400c0eff44aa2fcb5e31a5f24ba9716ed90138769e4977a2ba6014ae63eb5"
-dependencies = [
- "async-channel 1.9.0",
- "futures-core",
- "futures-io",
-]
-
 [[package]]
 name = "smallvec"
 version = "1.13.2"
@@ -10543,12 +10665,6 @@ dependencies = [
  "smallvec",
 ]
 
-[[package]]
-name = "spin"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
-
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -11178,6 +11294,15 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
 
+[[package]]
+name = "sync_wrapper"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394"
+dependencies = [
+ "futures-core",
+]
+
 [[package]]
 name = "synchronoise"
 version = "1.0.1"
@@ -11218,7 +11343,18 @@ checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
 dependencies = [
  "bitflags 1.3.2",
  "core-foundation 0.9.4",
- "system-configuration-sys",
+ "system-configuration-sys 0.5.0",
+]
+
+[[package]]
+name = "system-configuration"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
+dependencies = [
+ "bitflags 2.6.0",
+ "core-foundation 0.9.4",
+ "system-configuration-sys 0.6.0",
 ]
 
 [[package]]
@@ -11231,6 +11367,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "system-configuration-sys"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "system-deps"
 version = "6.2.2"
@@ -11607,7 +11753,7 @@ dependencies = [
  "fancy-regex",
  "lazy_static",
  "parking_lot",
- "rustc-hash",
+ "rustc-hash 1.1.0",
 ]
 
 [[package]]
@@ -11822,6 +11968,17 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "tokio-rustls"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4"
+dependencies = [
+ "rustls 0.23.13",
+ "rustls-pki-types",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-socks"
 version = "0.5.2"
@@ -11871,9 +12028,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.11"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1"
+checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a"
 dependencies = [
  "bytes 1.7.1",
  "futures-core",
@@ -12055,16 +12212,6 @@ dependencies = [
  "valuable",
 ]
 
-[[package]]
-name = "tracing-futures"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
-dependencies = [
- "pin-project",
- "tracing",
-]
-
 [[package]]
 name = "tracing-log"
 version = "0.2.0"
@@ -12371,6 +12518,24 @@ dependencies = [
  "utf-8",
 ]
 
+[[package]]
+name = "tungstenite"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
+dependencies = [
+ "byteorder",
+ "bytes 1.7.1",
+ "data-encoding",
+ "http 1.1.0",
+ "httparse",
+ "log",
+ "rand 0.8.5",
+ "sha1",
+ "thiserror",
+ "utf-8",
+]
+
 [[package]]
 name = "typeid"
 version = "1.0.2"
@@ -12531,15 +12696,40 @@ checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
 
 [[package]]
 name = "untrusted"
-version = "0.7.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
-name = "untrusted"
-version = "0.9.0"
+name = "ureq"
+version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+checksum = "f8cdd25c339e200129fe4de81451814e5228c9b771d57378817d6117cc2b3f97"
+dependencies = [
+ "base64 0.21.7",
+ "flate2",
+ "log",
+ "once_cell",
+ "rustls 0.21.12",
+ "rustls-webpki 0.101.7",
+ "url",
+ "webpki-roots 0.25.4",
+]
+
+[[package]]
+name = "ureq_client"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "futures 0.3.30",
+ "gpui",
+ "http_client",
+ "parking_lot",
+ "serde",
+ "smol",
+ "ureq",
+ "util",
+]
 
 [[package]]
 name = "url"
@@ -12844,7 +13034,7 @@ dependencies = [
  "futures-util",
  "headers",
  "http 0.2.12",
- "hyper",
+ "hyper 0.14.30",
  "log",
  "mime",
  "mime_guess",
@@ -12980,6 +13170,19 @@ dependencies = [
  "wasmparser 0.201.0",
 ]
 
+[[package]]
+name = "wasm-streams"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b65dc4c90b63b118468cf747d8bf3566c1913ef60be765b5730ead9e0a3ba129"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "wasmparser"
 version = "0.201.0"
@@ -13395,8 +13598,8 @@ version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53"
 dependencies = [
- "ring 0.17.8",
- "untrusted 0.9.0",
+ "ring",
+ "untrusted",
 ]
 
 [[package]]
@@ -13653,6 +13856,17 @@ dependencies = [
  "syn 2.0.76",
 ]
 
+[[package]]
+name = "windows-registry"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e400001bb720a623c1c69032f8e3e4cf09984deec740f007dd2b03ec864804b0"
+dependencies = [
+ "windows-result 0.2.0",
+ "windows-strings",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-result"
 version = "0.1.2"
@@ -14443,7 +14657,6 @@ dependencies = [
  "image_viewer",
  "inline_completion_button",
  "install_cli",
- "isahc_http_client",
  "journal",
  "language",
  "language_model",
@@ -14496,6 +14709,7 @@ dependencies = [
  "tree-sitter-md",
  "tree-sitter-rust",
  "ui",
+ "ureq_client",
  "url",
  "urlencoding",
  "util",
diff --git a/Cargo.toml b/Cargo.toml
index 1ef14dae70c202..fea528db5b89ee 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,6 +7,7 @@ members = [
     "crates/assistant",
     "crates/assistant_slash_command",
     "crates/assistant_tool",
+    "crates/ureq_client",
     "crates/audio",
     "crates/auto_update",
     "crates/breadcrumbs",
@@ -52,7 +53,6 @@ members = [
     "crates/indexed_docs",
     "crates/inline_completion_button",
     "crates/install_cli",
-    "crates/isahc_http_client",
     "crates/journal",
     "crates/language",
     "crates/language_model",
@@ -87,6 +87,7 @@ members = [
     "crates/release_channel",
     "crates/remote",
     "crates/remote_server",
+    "crates/reqwest_client",
     "crates/repl",
     "crates/rich_text",
     "crates/rope",
@@ -186,6 +187,8 @@ assets = { path = "crates/assets" }
 assistant = { path = "crates/assistant" }
 assistant_slash_command = { path = "crates/assistant_slash_command" }
 assistant_tool = { path = "crates/assistant_tool" }
+ureq_client = { path = "crates/ureq_client" }
+async-compat = { version = "0.2.1" }
 audio = { path = "crates/audio" }
 auto_update = { path = "crates/auto_update" }
 breadcrumbs = { path = "crates/breadcrumbs" }
@@ -228,7 +231,6 @@ image_viewer = { path = "crates/image_viewer" }
 indexed_docs = { path = "crates/indexed_docs" }
 inline_completion_button = { path = "crates/inline_completion_button" }
 install_cli = { path = "crates/install_cli" }
-isahc_http_client = { path = "crates/isahc_http_client" }
 journal = { path = "crates/journal" }
 language = { path = "crates/language" }
 language_model = { path = "crates/language_model" }
@@ -265,6 +267,7 @@ release_channel = { path = "crates/release_channel" }
 remote = { path = "crates/remote" }
 remote_server = { path = "crates/remote_server" }
 repl = { path = "crates/repl" }
+reqwest_client = { path = "crates/reqwest_client" }
 rich_text = { path = "crates/rich_text" }
 rope = { path = "crates/rope" }
 rpc = { path = "crates/rpc" }
@@ -325,7 +328,7 @@ async-pipe = { git = "https://github.com/zed-industries/async-pipe-rs", rev = "8
 async-recursion = "1.0.0"
 async-tar = "0.5.0"
 async-trait = "0.1"
-async-tungstenite = "0.23"
+async-tungstenite = "0.28"
 async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
 base64 = "0.22"
@@ -364,10 +367,7 @@ ignore = "0.4.22"
 image = "0.25.1"
 indexmap = { version = "1.6.2", features = ["serde"] }
 indoc = "2"
-# We explicitly disable http2 support in isahc.
-isahc = { version = "1.7.2", default-features = false, features = [
-    "text-decoding",
-] }
+
 itertools = "0.13.0"
 jsonwebtoken = "9.3"
 libc = "0.2"
@@ -392,13 +392,14 @@ pulldown-cmark = { version = "0.12.0", default-features = false }
 rand = "0.8.5"
 regex = "1.5"
 repair_json = "0.1.0"
+reqwest  = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29" }
 rsa = "0.9.6"
 runtimelib = { version = "0.15", default-features = false, features = [
     "async-dispatcher-runtime",
 ] }
 rustc-demangle = "0.1.23"
 rust-embed = { version = "8.4", features = ["include-exclude"] }
-rustls = "0.20.3"
+rustls = "0.21.12"
 rustls-native-certs = "0.8.0"
 schemars = { version = "0.8", features = ["impl_json_schema"] }
 semver = "1.0"
diff --git a/crates/client/Cargo.toml b/crates/client/Cargo.toml
index dd420bbbe63184..c3fbea1f98a882 100644
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -18,6 +18,7 @@ test-support = ["clock/test-support", "collections/test-support", "gpui/test-sup
 [dependencies]
 anyhow.workspace = true
 async-recursion = "0.3"
+async-tls = "0.13"
 async-tungstenite = { workspace = true, features = ["async-std", "async-tls"] }
 chrono = { workspace = true, features = ["serde"] }
 clock.workspace = true
@@ -34,8 +35,6 @@ postage.workspace = true
 rand.workspace = true
 release_channel.workspace = true
 rpc = { workspace = true, features = ["gpui"] }
-rustls.workspace = true
-rustls-native-certs.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index d565d620c3c206..819bd7551f5965 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -1023,7 +1023,7 @@ impl Client {
         &self,
         http: Arc<HttpClientWithUrl>,
         release_channel: Option<ReleaseChannel>,
-    ) -> impl Future<Output = Result<Url>> {
+    ) -> impl Future<Output = Result<url::Url>> {
         #[cfg(any(test, feature = "test-support"))]
         let url_override = self.rpc_url.read().clone();
 
@@ -1117,7 +1117,7 @@ impl Client {
             // for us from the RPC URL.
             //
             // Among other things, it will generate and set a `Sec-WebSocket-Key` header for us.
-            let mut request = rpc_url.into_client_request()?;
+            let mut request = IntoClientRequest::into_client_request(rpc_url.as_str())?;
 
             // We then modify the request to add our desired headers.
             let request_headers = request.headers_mut();
@@ -1137,30 +1137,13 @@ impl Client {
 
             match url_scheme {
                 Https => {
-                    let client_config = {
-                        let mut root_store = rustls::RootCertStore::empty();
-
-                        let root_certs = rustls_native_certs::load_native_certs();
-                        for error in root_certs.errors {
-                            log::warn!("error loading native certs: {:?}", error);
-                        }
-                        root_store.add_parsable_certificates(
-                            &root_certs
-                                .certs
-                                .into_iter()
-                                .map(|cert| cert.as_ref().to_owned())
-                                .collect::<Vec<_>>(),
-                        );
-                        rustls::ClientConfig::builder()
-                            .with_safe_defaults()
-                            .with_root_certificates(root_store)
-                            .with_no_client_auth()
-                    };
                     let (stream, _) =
                         async_tungstenite::async_tls::client_async_tls_with_connector(
                             request,
                             stream,
-                            Some(client_config.into()),
+                            Some(async_tls::TlsConnector::from(
+                                http_client::TLS_CONFIG.clone(),
+                            )),
                         )
                         .await?;
                     Ok(Connection::new(
diff --git a/crates/collab/Cargo.toml b/crates/collab/Cargo.toml
index ad43d2d1f0cf50..7d4c5d0c706b7e 100644
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -37,7 +37,7 @@ futures.workspace = true
 google_ai.workspace = true
 hex.workspace = true
 http_client.workspace = true
-isahc_http_client.workspace = true
+reqwest_client.workspace = true
 jsonwebtoken.workspace = true
 live_kit_server.workspace = true
 log.workspace = true
diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index bbfa69c0b8f70b..dd1370e8866442 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -674,7 +674,7 @@ pub struct EditorEventRow {
     copilot_enabled_for_language: bool,
     historical_event: bool,
     architecture: String,
-    is_staff: Option<bool>,
+    is_staff: bool,
     major: Option<i32>,
     minor: Option<i32>,
     patch: Option<i32>,
@@ -708,7 +708,7 @@ impl EditorEventRow {
             installation_id: body.installation_id.clone().unwrap_or_default(),
             session_id: body.session_id.clone(),
             metrics_id: body.metrics_id.clone().unwrap_or_default(),
-            is_staff: body.is_staff,
+            is_staff: body.is_staff.unwrap_or_default(),
             time: time.timestamp_millis(),
             operation: event.operation,
             file_extension: event.file_extension.unwrap_or_default(),
@@ -741,7 +741,7 @@ pub struct InlineCompletionEventRow {
     region_code: String,
     city: String,
     time: i64,
-    is_staff: Option<bool>,
+    is_staff: bool,
     major: Option<i32>,
     minor: Option<i32>,
     patch: Option<i32>,
@@ -772,7 +772,7 @@ impl InlineCompletionEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone().unwrap_or_default(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff,
+            is_staff: body.is_staff.unwrap_or_default(),
             time: time.timestamp_millis(),
             file_extension: event.file_extension.unwrap_or_default(),
             signed_in: wrapper.signed_in,
@@ -800,7 +800,7 @@ pub struct CallEventRow {
     // ClientEventBase
     installation_id: String,
     session_id: Option<String>,
-    is_staff: Option<bool>,
+    is_staff: bool,
     time: i64,
 
     // CallEventRow
@@ -832,7 +832,7 @@ impl CallEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone().unwrap_or_default(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff,
+            is_staff: body.is_staff.unwrap_or_default(),
             time: time.timestamp_millis(),
             operation: event.operation,
             room_id: event.room_id,
@@ -856,7 +856,7 @@ pub struct AssistantEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: Option<bool>,
+    is_staff: bool,
     time: i64,
 
     // AssistantEventRow
@@ -891,7 +891,7 @@ impl AssistantEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff,
+            is_staff: body.is_staff.unwrap_or_default(),
             time: time.timestamp_millis(),
             conversation_id: event.conversation_id.unwrap_or_default(),
             kind: event.kind.to_string(),
@@ -909,7 +909,7 @@ impl AssistantEventRow {
 pub struct CpuEventRow {
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: Option<bool>,
+    is_staff: bool,
     usage_as_percentage: f32,
     core_count: u32,
     app_version: String,
@@ -947,7 +947,7 @@ impl CpuEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff,
+            is_staff: body.is_staff.unwrap_or_default(),
             time: time.timestamp_millis(),
             usage_as_percentage: event.usage_as_percentage,
             core_count: event.core_count,
@@ -970,7 +970,7 @@ pub struct MemoryEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: Option<bool>,
+    is_staff: bool,
     time: i64,
 
     // MemoryEventRow
@@ -1001,7 +1001,7 @@ impl MemoryEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff,
+            is_staff: body.is_staff.unwrap_or_default(),
             time: time.timestamp_millis(),
             memory_in_bytes: event.memory_in_bytes,
             virtual_memory_in_bytes: event.virtual_memory_in_bytes,
@@ -1024,7 +1024,7 @@ pub struct AppEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: Option<bool>,
+    is_staff: bool,
     time: i64,
 
     // AppEventRow
@@ -1054,7 +1054,7 @@ impl AppEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff,
+            is_staff: body.is_staff.unwrap_or_default(),
             time: time.timestamp_millis(),
             operation: event.operation,
         }
@@ -1076,7 +1076,7 @@ pub struct SettingEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: Option<bool>,
+    is_staff: bool,
     time: i64,
     // SettingEventRow
     setting: String,
@@ -1106,7 +1106,7 @@ impl SettingEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff,
+            is_staff: body.is_staff.unwrap_or_default(),
             time: time.timestamp_millis(),
             setting: event.setting,
             value: event.value,
@@ -1129,7 +1129,7 @@ pub struct ExtensionEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: Option<bool>,
+    is_staff: bool,
     time: i64,
 
     // ExtensionEventRow
@@ -1164,7 +1164,7 @@ impl ExtensionEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff,
+            is_staff: body.is_staff.unwrap_or_default(),
             time: time.timestamp_millis(),
             extension_id: event.extension_id,
             extension_version: event.version,
@@ -1198,7 +1198,7 @@ pub struct ReplEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: Option<bool>,
+    is_staff: bool,
     time: i64,
 
     // ReplEventRow
@@ -1230,7 +1230,7 @@ impl ReplEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff,
+            is_staff: body.is_staff.unwrap_or_default(),
             time: time.timestamp_millis(),
             kernel_language: event.kernel_language,
             kernel_status: event.kernel_status,
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index 14f10342a78dd7..2d040cfa28e1a9 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -22,7 +22,8 @@ use chrono::{DateTime, Duration, Utc};
 use collections::HashMap;
 use db::{usage_measure::UsageMeasure, ActiveUserCount, LlmDatabase};
 use futures::{Stream, StreamExt as _};
-use isahc_http_client::IsahcHttpClient;
+
+use reqwest_client::ReqwestClient;
 use rpc::ListModelsResponse;
 use rpc::{
     proto::Plan, LanguageModelProvider, PerformCompletionParams, EXPIRED_LLM_TOKEN_HEADER_NAME,
@@ -43,7 +44,7 @@ pub struct LlmState {
     pub config: Config,
     pub executor: Executor,
     pub db: Arc<LlmDatabase>,
-    pub http_client: IsahcHttpClient,
+    pub http_client: ReqwestClient,
     pub clickhouse_client: Option<clickhouse::Client>,
     active_user_count_by_model:
         RwLock<HashMap<(LanguageModelProvider, String), (DateTime<Utc>, ActiveUserCount)>>,
@@ -69,11 +70,8 @@ impl LlmState {
         let db = Arc::new(db);
 
         let user_agent = format!("Zed Server/{}", env!("CARGO_PKG_VERSION"));
-        let http_client = IsahcHttpClient::builder()
-            .default_header("User-Agent", user_agent)
-            .build()
-            .map(IsahcHttpClient::from)
-            .context("failed to construct http client")?;
+        let http_client =
+            ReqwestClient::user_agent(&user_agent).context("failed to construct http client")?;
 
         let this = Self {
             executor,
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index 5f21df4ab9dbce..27c95a5b44e1a8 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -36,8 +36,8 @@ use collections::{HashMap, HashSet};
 pub use connection_pool::{ConnectionPool, ZedVersion};
 use core::fmt::{self, Debug, Formatter};
 use http_client::HttpClient;
-use isahc_http_client::IsahcHttpClient;
 use open_ai::{OpenAiEmbeddingModel, OPEN_AI_API_URL};
+use reqwest_client::ReqwestClient;
 use sha2::Digest;
 use supermaven_api::{CreateExternalUserRequest, SupermavenAdminApi};
 
@@ -954,8 +954,8 @@ impl Server {
             tracing::info!("connection opened");
 
             let user_agent = format!("Zed Server/{}", env!("CARGO_PKG_VERSION"));
-            let http_client = match IsahcHttpClient::builder().default_header("User-Agent", user_agent).build() {
-                Ok(http_client) => Arc::new(IsahcHttpClient::from(http_client)),
+            let http_client = match ReqwestClient::user_agent(&user_agent) {
+                Ok(http_client) => Arc::new(http_client),
                 Err(error) => {
                     tracing::error!(?error, "failed to create HTTP client");
                     return;
diff --git a/crates/evals/Cargo.toml b/crates/evals/Cargo.toml
index 400ab139aa2e40..52af0ce446f918 100644
--- a/crates/evals/Cargo.toml
+++ b/crates/evals/Cargo.toml
@@ -16,6 +16,7 @@ path = "src/eval.rs"
 [dependencies]
 clap.workspace = true
 anyhow.workspace = true
+ureq_client.workspace = true
 client.workspace = true
 clock.workspace = true
 collections.workspace = true
@@ -24,7 +25,6 @@ feature_flags.workspace = true
 fs.workspace = true
 git.workspace = true
 gpui.workspace = true
-isahc_http_client.workspace = true
 language.workspace = true
 languages.workspace = true
 http_client.workspace = true
diff --git a/crates/evals/src/eval.rs b/crates/evals/src/eval.rs
index 899d8210537111..e2dc5c8e03a2fa 100644
--- a/crates/evals/src/eval.rs
+++ b/crates/evals/src/eval.rs
@@ -32,6 +32,7 @@ use std::{
         Arc,
     },
 };
+use ureq_client::UreqClient;
 
 const CODESEARCH_NET_DIR: &'static str = "target/datasets/code-search-net";
 const EVAL_REPOS_DIR: &'static str = "target/datasets/eval-repos";
@@ -100,7 +101,11 @@ fn main() -> Result<()> {
 
     gpui::App::headless().run(move |cx| {
         let executor = cx.background_executor().clone();
-        let client = isahc_http_client::IsahcHttpClient::new(None, None);
+        let client = Arc::new(UreqClient::new(
+            None,
+            "Zed LLM evals".to_string(),
+            executor.clone(),
+        ));
         cx.set_http_client(client.clone());
         match cli.command {
             Commands::Fetch {} => {
diff --git a/crates/extension/Cargo.toml b/crates/extension/Cargo.toml
index 6ce1bd6862a1dd..9fea3a768a0c02 100644
--- a/crates/extension/Cargo.toml
+++ b/crates/extension/Cargo.toml
@@ -56,10 +56,12 @@ task.workspace = true
 serde_json_lenient.workspace = true
 
 [dev-dependencies]
-isahc_http_client.workspace = true
+ureq_client.workspace = true
 ctor.workspace = true
 env_logger.workspace = true
 parking_lot.workspace = true
+reqwest_client.workspace = true
+tokio.workspace = true
 
 fs = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
diff --git a/crates/extension/src/extension_builder.rs b/crates/extension/src/extension_builder.rs
index 7380e699f9e715..876d0336dc7077 100644
--- a/crates/extension/src/extension_builder.rs
+++ b/crates/extension/src/extension_builder.rs
@@ -25,7 +25,7 @@ use wit_component::ComponentEncoder;
 /// Once Rust 1.78 is released, there will be a `wasm32-wasip2` target available, so we will
 /// not need the adapter anymore.
 const RUST_TARGET: &str = "wasm32-wasip1";
-const WASI_ADAPTER_URL: &str =
+pub const WASI_ADAPTER_URL: &str =
     "https://github.com/bytecodealliance/wasmtime/releases/download/v18.0.2/wasi_snapshot_preview1.reactor.wasm";
 
 /// Compiling Tree-sitter parsers from C to WASM requires Clang 17, and a WASM build of libc
diff --git a/crates/extension/src/extension_store_test.rs b/crates/extension/src/extension_store_test.rs
index 126e6b2cfbdad0..7a3c645e041a14 100644
--- a/crates/extension/src/extension_store_test.rs
+++ b/crates/extension/src/extension_store_test.rs
@@ -1,3 +1,4 @@
+use crate::extension_builder::WASI_ADAPTER_URL;
 use crate::extension_manifest::SchemaVersion;
 use crate::extension_settings::ExtensionSettings;
 use crate::{
@@ -11,14 +12,14 @@ use collections::BTreeMap;
 use fs::{FakeFs, Fs, RealFs};
 use futures::{io::BufReader, AsyncReadExt, StreamExt};
 use gpui::{Context, SemanticVersion, TestAppContext};
-use http_client::{FakeHttpClient, Response};
+use http_client::{AsyncBody, FakeHttpClient, HttpClient, Response};
 use indexed_docs::IndexedDocsRegistry;
-use isahc_http_client::IsahcHttpClient;
 use language::{LanguageMatcher, LanguageRegistry, LanguageServerBinaryStatus, LanguageServerName};
 use node_runtime::NodeRuntime;
 use parking_lot::Mutex;
 use project::{Project, DEFAULT_COMPLETION_CONTEXT};
 use release_channel::AppVersion;
+use reqwest_client::ReqwestClient;
 use serde_json::json;
 use settings::{Settings as _, SettingsStore};
 use snippet_provider::SnippetRegistry;
@@ -28,6 +29,7 @@ use std::{
     sync::Arc,
 };
 use theme::ThemeRegistry;
+use ureq_client::UreqClient;
 use util::test::temp_tree;
 
 #[cfg(test)]
@@ -576,7 +578,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
             std::env::consts::ARCH
         )
     });
-    let builder_client = IsahcHttpClient::new(None, Some(user_agent));
+    let builder_client = Arc::new(UreqClient::new(None, user_agent, cx.executor().clone()));
 
     let extension_store = cx.new_model(|cx| {
         ExtensionStore::new(
@@ -769,6 +771,50 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
     assert!(fs.metadata(&expected_server_path).await.unwrap().is_none());
 }
 
+#[gpui::test]
+async fn test_wasi_adapter_download(cx: &mut TestAppContext) {
+    let client = Arc::new(UreqClient::new(
+        None,
+        "zed-test-wasi-adapter-download".to_string(),
+        cx.executor().clone(),
+    ));
+
+    let mut response = client
+        .get(WASI_ADAPTER_URL, AsyncBody::default(), true)
+        .await
+        .unwrap();
+
+    let mut content = Vec::new();
+    let mut body = BufReader::new(response.body_mut());
+    body.read_to_end(&mut content).await.unwrap();
+
+    assert!(wasmparser::Parser::is_core_wasm(&content));
+    assert_eq!(content.len(), 96801); // Determined by downloading this to my computer
+    wit_component::ComponentEncoder::default()
+        .adapter("wasi_snapshot_preview1", &content)
+        .unwrap();
+}
+
+#[tokio::test]
+async fn test_wasi_adapter_download_tokio() {
+    let client = Arc::new(ReqwestClient::new());
+
+    let mut response = client
+        .get(WASI_ADAPTER_URL, AsyncBody::default(), true)
+        .await
+        .unwrap();
+
+    let mut content = Vec::new();
+    let mut body = BufReader::new(response.body_mut());
+    body.read_to_end(&mut content).await.unwrap();
+
+    assert!(wasmparser::Parser::is_core_wasm(&content));
+    assert_eq!(content.len(), 96801); // Determined by downloading this to my computer
+    wit_component::ComponentEncoder::default()
+        .adapter("wasi_snapshot_preview1", &content)
+        .unwrap();
+}
+
 fn init_test(cx: &mut TestAppContext) {
     cx.update(|cx| {
         let store = SettingsStore::test(cx);
diff --git a/crates/extension_cli/Cargo.toml b/crates/extension_cli/Cargo.toml
index bc649d8e04989f..3e109a0036b2fc 100644
--- a/crates/extension_cli/Cargo.toml
+++ b/crates/extension_cli/Cargo.toml
@@ -18,7 +18,7 @@ clap = { workspace = true, features = ["derive"] }
 env_logger.workspace = true
 extension = { workspace = true, features = ["no-webrtc"] }
 fs.workspace = true
-isahc_http_client.workspace = true
+reqwest_client.workspace = true
 language.workspace = true
 log.workspace = true
 rpc.workspace = true
diff --git a/crates/extension_cli/src/main.rs b/crates/extension_cli/src/main.rs
index 6eaebca2f0e9bf..dd6f2213781197 100644
--- a/crates/extension_cli/src/main.rs
+++ b/crates/extension_cli/src/main.rs
@@ -13,8 +13,8 @@ use extension::{
     extension_builder::{CompileExtensionOptions, ExtensionBuilder},
     ExtensionManifest,
 };
-use isahc_http_client::IsahcHttpClient;
 use language::LanguageConfig;
+use reqwest_client::ReqwestClient;
 use theme::ThemeRegistry;
 use tree_sitter::{Language, Query, WasmStore};
 
@@ -66,12 +66,7 @@ async fn main() -> Result<()> {
         std::env::consts::OS,
         std::env::consts::ARCH
     );
-    let http_client = Arc::new(
-        IsahcHttpClient::builder()
-            .default_header("User-Agent", user_agent)
-            .build()
-            .map(IsahcHttpClient::from)?,
-    );
+    let http_client = Arc::new(ReqwestClient::user_agent(&user_agent)?);
 
     let builder = ExtensionBuilder::new(http_client, scratch_dir);
     builder
diff --git a/crates/http_client/Cargo.toml b/crates/http_client/Cargo.toml
index 0244ac41042b6f..52c2947b8a7e4f 100644
--- a/crates/http_client/Cargo.toml
+++ b/crates/http_client/Cargo.toml
@@ -16,7 +16,9 @@ path = "src/http_client.rs"
 doctest = true
 
 [dependencies]
-http = "0.2"
+http = "1.1"
+rustls.workspace = true
+rustls-native-certs.workspace = true
 anyhow.workspace = true
 derive_more.workspace = true
 futures.workspace = true
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index 2f029a1d236bba..015c73a448c5b8 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -11,13 +11,21 @@ use http::request::Builder;
 #[cfg(feature = "test-support")]
 use std::fmt;
 use std::{
-    sync::{Arc, Mutex},
+    sync::{Arc, LazyLock, Mutex},
     time::Duration,
 };
 pub use url::Url;
 
+#[derive(Clone)]
 pub struct ReadTimeout(pub Duration);
-#[derive(Default, Debug, Clone)]
+impl Default for ReadTimeout {
+    fn default() -> Self {
+        Self(Duration::from_secs(5))
+    }
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Hash)]
+
 pub enum RedirectPolicy {
     #[default]
     NoFollow,
@@ -26,6 +34,23 @@ pub enum RedirectPolicy {
 }
 pub struct FollowRedirects(pub bool);
 
+pub static TLS_CONFIG: LazyLock<Arc<rustls::ClientConfig>> = LazyLock::new(|| {
+    let mut root_store = rustls::RootCertStore::empty();
+
+    let root_certs = rustls_native_certs::load_native_certs();
+    for error in root_certs.errors {
+        log::warn!("error loading native certs: {:?}", error);
+    }
+    root_store.add_parsable_certificates(&root_certs.certs);
+
+    Arc::new(
+        rustls::ClientConfig::builder()
+            .with_safe_defaults()
+            .with_root_certificates(root_store)
+            .with_no_client_auth(),
+    )
+});
+
 pub trait HttpRequestExt {
     /// Set a read timeout on the request.
     /// For isahc, this is the low_speed_timeout.
diff --git a/crates/isahc_http_client/LICENSE-APACHE b/crates/isahc_http_client/LICENSE-APACHE
deleted file mode 120000
index 1cd601d0a3affa..00000000000000
--- a/crates/isahc_http_client/LICENSE-APACHE
+++ /dev/null
@@ -1 +0,0 @@
-../../LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/isahc_http_client/src/isahc_http_client.rs b/crates/isahc_http_client/src/isahc_http_client.rs
deleted file mode 100644
index 778f6a04598909..00000000000000
--- a/crates/isahc_http_client/src/isahc_http_client.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use std::{mem, sync::Arc, time::Duration};
-
-use futures::future::BoxFuture;
-use util::maybe;
-
-pub use isahc::config::Configurable;
-pub struct IsahcHttpClient(isahc::HttpClient);
-
-pub use http_client::*;
-
-impl IsahcHttpClient {
-    pub fn new(proxy: Option<Uri>, user_agent: Option<String>) -> Arc<IsahcHttpClient> {
-        let mut builder = isahc::HttpClient::builder()
-            .connect_timeout(Duration::from_secs(5))
-            .low_speed_timeout(100, Duration::from_secs(5))
-            .proxy(proxy.clone());
-        if let Some(agent) = user_agent {
-            builder = builder.default_header("User-Agent", agent);
-        }
-        Arc::new(IsahcHttpClient(builder.build().unwrap()))
-    }
-    pub fn builder() -> isahc::HttpClientBuilder {
-        isahc::HttpClientBuilder::new()
-    }
-}
-
-impl From<isahc::HttpClient> for IsahcHttpClient {
-    fn from(client: isahc::HttpClient) -> Self {
-        Self(client)
-    }
-}
-
-impl HttpClient for IsahcHttpClient {
-    fn proxy(&self) -> Option<&Uri> {
-        None
-    }
-
-    fn send(
-        &self,
-        req: http_client::http::Request<http_client::AsyncBody>,
-    ) -> BoxFuture<'static, Result<http_client::Response<http_client::AsyncBody>, anyhow::Error>>
-    {
-        let redirect_policy = req
-            .extensions()
-            .get::<http_client::RedirectPolicy>()
-            .cloned()
-            .unwrap_or_default();
-        let read_timeout = req
-            .extensions()
-            .get::<http_client::ReadTimeout>()
-            .map(|t| t.0);
-        let req = maybe!({
-            let (mut parts, body) = req.into_parts();
-            let mut builder = isahc::Request::builder()
-                .method(parts.method)
-                .uri(parts.uri)
-                .version(parts.version);
-            if let Some(read_timeout) = read_timeout {
-                builder = builder.low_speed_timeout(100, read_timeout);
-            }
-
-            let headers = builder.headers_mut()?;
-            mem::swap(headers, &mut parts.headers);
-
-            let extensions = builder.extensions_mut()?;
-            mem::swap(extensions, &mut parts.extensions);
-
-            let isahc_body = match body.0 {
-                http_client::Inner::Empty => isahc::AsyncBody::empty(),
-                http_client::Inner::AsyncReader(reader) => isahc::AsyncBody::from_reader(reader),
-                http_client::Inner::SyncReader(reader) => {
-                    isahc::AsyncBody::from_bytes_static(reader.into_inner())
-                }
-            };
-
-            builder
-                .redirect_policy(match redirect_policy {
-                    http_client::RedirectPolicy::FollowAll => isahc::config::RedirectPolicy::Follow,
-                    http_client::RedirectPolicy::FollowLimit(limit) => {
-                        isahc::config::RedirectPolicy::Limit(limit)
-                    }
-                    http_client::RedirectPolicy::NoFollow => isahc::config::RedirectPolicy::None,
-                })
-                .body(isahc_body)
-                .ok()
-        });
-
-        let client = self.0.clone();
-
-        Box::pin(async move {
-            match req {
-                Some(req) => client
-                    .send_async(req)
-                    .await
-                    .map_err(Into::into)
-                    .map(|response| {
-                        let (parts, body) = response.into_parts();
-                        let body = http_client::AsyncBody::from_reader(body);
-                        http_client::Response::from_parts(parts, body)
-                    }),
-                None => Err(anyhow::anyhow!("Request was malformed")),
-            }
-        })
-    }
-}
diff --git a/crates/live_kit_server/Cargo.toml b/crates/live_kit_server/Cargo.toml
index bad4c5a05f4754..4b4b5e13dad43b 100644
--- a/crates/live_kit_server/Cargo.toml
+++ b/crates/live_kit_server/Cargo.toml
@@ -20,7 +20,7 @@ jsonwebtoken.workspace = true
 log.workspace = true
 prost.workspace = true
 prost-types.workspace = true
-reqwest = "0.11"
+reqwest.workspace = true
 serde.workspace = true
 
 [build-dependencies]
diff --git a/crates/reqwest_client/Cargo.toml b/crates/reqwest_client/Cargo.toml
new file mode 100644
index 00000000000000..d39319125299f1
--- /dev/null
+++ b/crates/reqwest_client/Cargo.toml
@@ -0,0 +1,31 @@
+[package]
+name = "reqwest_client"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "Apache-2.0"
+
+[lints]
+workspace = true
+
+[features]
+test-support = []
+
+[lib]
+path = "src/reqwest_client.rs"
+doctest = true
+
+[[example]]
+name = "client"
+path = "examples/client.rs"
+
+[dependencies]
+anyhow.workspace = true
+futures.workspace = true
+serde.workspace = true
+smol.workspace = true
+http_client.workspace = true
+tokio.workspace = true
+bytes = "1.0"
+
+reqwest = { workspace = true, features = ["rustls-tls-manual-roots", "stream"] }
diff --git a/crates/reqwest_client/LICENSE-GPL b/crates/reqwest_client/LICENSE-GPL
new file mode 120000
index 00000000000000..89e542f750cd38
--- /dev/null
+++ b/crates/reqwest_client/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
\ No newline at end of file
diff --git a/crates/reqwest_client/examples/client.rs b/crates/reqwest_client/examples/client.rs
new file mode 100644
index 00000000000000..1f50d21e4edc2b
--- /dev/null
+++ b/crates/reqwest_client/examples/client.rs
@@ -0,0 +1,16 @@
+use futures::AsyncReadExt as _;
+use http_client::AsyncBody;
+use http_client::HttpClient;
+use reqwest_client::ReqwestClient;
+
+#[tokio::main]
+async fn main() {
+    let resp = ReqwestClient::new()
+        .get("http://zed.dev", AsyncBody::empty(), true)
+        .await
+        .unwrap();
+
+    let mut body = String::new();
+    resp.into_body().read_to_string(&mut body).await.unwrap();
+    println!("{}", &body);
+}
diff --git a/crates/reqwest_client/src/reqwest_client.rs b/crates/reqwest_client/src/reqwest_client.rs
new file mode 100644
index 00000000000000..6e84c58954ab12
--- /dev/null
+++ b/crates/reqwest_client/src/reqwest_client.rs
@@ -0,0 +1,232 @@
+use std::{borrow::Cow, io::Read, pin::Pin, task::Poll};
+
+use anyhow::anyhow;
+use bytes::{BufMut, Bytes, BytesMut};
+use futures::{AsyncRead, TryStreamExt};
+use http_client::{http, AsyncBody, ReadTimeout};
+use reqwest::header::{HeaderMap, HeaderValue};
+use smol::future::FutureExt;
+
+const DEFAULT_CAPACITY: usize = 4096;
+
+pub struct ReqwestClient {
+    client: reqwest::Client,
+}
+
+impl ReqwestClient {
+    pub fn new() -> Self {
+        Self {
+            client: reqwest::Client::new(),
+        }
+    }
+
+    pub fn user_agent(agent: &str) -> anyhow::Result<Self> {
+        let mut map = HeaderMap::new();
+        map.insert(http::header::USER_AGENT, HeaderValue::from_str(agent)?);
+        Ok(Self {
+            client: reqwest::Client::builder().default_headers(map).build()?,
+        })
+    }
+}
+
+impl From<reqwest::Client> for ReqwestClient {
+    fn from(client: reqwest::Client) -> Self {
+        Self { client }
+    }
+}
+
+// This struct is essentially a re-implementation of
+// https://docs.rs/tokio-util/0.7.12/tokio_util/io/struct.ReaderStream.html
+// except outside of Tokio's aegis
+struct ReaderStream {
+    reader: Option<Pin<Box<dyn futures::AsyncRead + Send + Sync>>>,
+    buf: BytesMut,
+    capacity: usize,
+}
+
+impl ReaderStream {
+    fn new(reader: Pin<Box<dyn futures::AsyncRead + Send + Sync>>) -> Self {
+        Self {
+            reader: Some(reader),
+            buf: BytesMut::new(),
+            capacity: DEFAULT_CAPACITY,
+        }
+    }
+}
+
+impl futures::Stream for ReaderStream {
+    type Item = std::io::Result<Bytes>;
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        let mut this = self.as_mut();
+
+        let mut reader = match this.reader.take() {
+            Some(r) => r,
+            None => return Poll::Ready(None),
+        };
+
+        if this.buf.capacity() == 0 {
+            let capacity = this.capacity;
+            this.buf.reserve(capacity);
+        }
+
+        match poll_read_buf(&mut reader, cx, &mut this.buf) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(Err(err)) => {
+                self.reader = None;
+
+                Poll::Ready(Some(Err(err)))
+            }
+            Poll::Ready(Ok(0)) => {
+                self.reader = None;
+                Poll::Ready(None)
+            }
+            Poll::Ready(Ok(_)) => {
+                let chunk = this.buf.split();
+                self.reader = Some(reader);
+                Poll::Ready(Some(Ok(chunk.freeze())))
+            }
+        }
+    }
+}
+
+/// Implementation from https://docs.rs/tokio-util/0.7.12/src/tokio_util/util/poll_buf.rs.html
+/// Specialized for this use case
+pub fn poll_read_buf(
+    io: &mut Pin<Box<dyn futures::AsyncRead + Send + Sync>>,
+    cx: &mut std::task::Context<'_>,
+    buf: &mut BytesMut,
+) -> Poll<std::io::Result<usize>> {
+    if !buf.has_remaining_mut() {
+        return Poll::Ready(Ok(0));
+    }
+
+    let n = {
+        let dst = buf.chunk_mut();
+
+        // Safety: `chunk_mut()` returns a `&mut UninitSlice`, and `UninitSlice` is a
+        // transparent wrapper around `[MaybeUninit<u8>]`.
+        let dst = unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit<u8>]) };
+        let mut buf = tokio::io::ReadBuf::uninit(dst);
+        let ptr = buf.filled().as_ptr();
+        let unfilled_portion = buf.initialize_unfilled();
+        // SAFETY: Pin projection
+        let io_pin = unsafe { Pin::new_unchecked(io) };
+        std::task::ready!(io_pin.poll_read(cx, unfilled_portion)?);
+
+        // Ensure the pointer does not change from under us
+        assert_eq!(ptr, buf.filled().as_ptr());
+        buf.filled().len()
+    };
+
+    // Safety: This is guaranteed to be the number of initialized (and read)
+    // bytes due to the invariants provided by `ReadBuf::filled`.
+    unsafe {
+        buf.advance_mut(n);
+    }
+
+    Poll::Ready(Ok(n))
+}
+
+enum WrappedBodyInner {
+    None,
+    SyncReader(std::io::Cursor<Cow<'static, [u8]>>),
+    Stream(ReaderStream),
+}
+
+struct WrappedBody(WrappedBodyInner);
+
+impl WrappedBody {
+    fn new(body: AsyncBody) -> Self {
+        match body.0 {
+            http_client::Inner::Empty => Self(WrappedBodyInner::None),
+            http_client::Inner::SyncReader(cursor) => Self(WrappedBodyInner::SyncReader(cursor)),
+            http_client::Inner::AsyncReader(pin) => {
+                Self(WrappedBodyInner::Stream(ReaderStream::new(pin)))
+            }
+        }
+    }
+}
+
+impl futures::stream::Stream for WrappedBody {
+    type Item = Result<Bytes, std::io::Error>;
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        match &mut self.0 {
+            WrappedBodyInner::None => Poll::Ready(None),
+            WrappedBodyInner::SyncReader(cursor) => {
+                let mut buf = Vec::new();
+                match cursor.read_to_end(&mut buf) {
+                    Ok(_) => {
+                        return Poll::Ready(Some(Ok(Bytes::from(buf))));
+                    }
+                    Err(e) => return Poll::Ready(Some(Err(e))),
+                }
+            }
+            WrappedBodyInner::Stream(stream) => {
+                // SAFETY: Pin projection
+                let stream = unsafe { Pin::new_unchecked(stream) };
+                futures::Stream::poll_next(stream, cx)
+            }
+        }
+    }
+}
+
+impl http_client::HttpClient for ReqwestClient {
+    fn proxy(&self) -> Option<&http::Uri> {
+        None
+    }
+
+    fn send(
+        &self,
+        req: http::Request<http_client::AsyncBody>,
+    ) -> futures::future::BoxFuture<
+        'static,
+        Result<http_client::Response<http_client::AsyncBody>, anyhow::Error>,
+    > {
+        let (parts, body) = req.into_parts();
+
+        let mut request = self.client.request(parts.method, parts.uri.to_string());
+
+        request = request.headers(parts.headers);
+
+        if let Some(redirect_policy) = parts.extensions.get::<http_client::RedirectPolicy>() {
+            request = request.redirect_policy(match redirect_policy {
+                http_client::RedirectPolicy::NoFollow => reqwest::redirect::Policy::none(),
+                http_client::RedirectPolicy::FollowLimit(limit) => {
+                    reqwest::redirect::Policy::limited(*limit as usize)
+                }
+                http_client::RedirectPolicy::FollowAll => reqwest::redirect::Policy::limited(100),
+            });
+        }
+
+        if let Some(ReadTimeout(timeout)) = parts.extensions.get::<ReadTimeout>() {
+            request = request.timeout(*timeout);
+        }
+
+        let body = WrappedBody::new(body);
+        let request = request.body(reqwest::Body::wrap_stream(body));
+
+        async move {
+            let response = request.send().await.map_err(|e| anyhow!(e))?;
+            let status = response.status();
+            let mut builder = http::Response::builder().status(status.as_u16());
+            for (name, value) in response.headers() {
+                builder = builder.header(name, value);
+            }
+            let bytes = response.bytes_stream();
+            let bytes = bytes
+                .map_err(|e| futures::io::Error::new(futures::io::ErrorKind::Other, e))
+                .into_async_read();
+            let body = http_client::AsyncBody::from_reader(bytes);
+            builder.body(body).map_err(|e| anyhow!(e))
+        }
+        .boxed()
+    }
+}
diff --git a/crates/semantic_index/Cargo.toml b/crates/semantic_index/Cargo.toml
index 691d6e57f6d448..8842093f7857ff 100644
--- a/crates/semantic_index/Cargo.toml
+++ b/crates/semantic_index/Cargo.toml
@@ -51,7 +51,7 @@ workspace.workspace = true
 worktree.workspace = true
 
 [dev-dependencies]
-isahc_http_client.workspace = true
+ureq_client.workspace = true
 env_logger.workspace = true
 client = { workspace = true, features = ["test-support"] }
 fs = { workspace = true, features = ["test-support"] }
diff --git a/crates/semantic_index/examples/index.rs b/crates/semantic_index/examples/index.rs
index c5c2c633a10603..1ebed4c17f3bda 100644
--- a/crates/semantic_index/examples/index.rs
+++ b/crates/semantic_index/examples/index.rs
@@ -2,7 +2,6 @@ use client::Client;
 use futures::channel::oneshot;
 use gpui::App;
 use http_client::HttpClientWithUrl;
-use isahc_http_client::IsahcHttpClient;
 use language::language_settings::AllLanguageSettings;
 use project::Project;
 use semantic_index::{OpenAiEmbeddingModel, OpenAiEmbeddingProvider, SemanticDb};
@@ -29,7 +28,11 @@ fn main() {
         let clock = Arc::new(FakeSystemClock::default());
 
         let http = Arc::new(HttpClientWithUrl::new(
-            IsahcHttpClient::new(None, None),
+            Arc::new(ureq_client::UreqClient::new(
+                None,
+                "Zed semantic index example".to_string(),
+                cx.background_executor().clone(),
+            )),
             "http://localhost:11434",
             None,
         ));
diff --git a/crates/isahc_http_client/Cargo.toml b/crates/ureq_client/Cargo.toml
similarity index 52%
rename from crates/isahc_http_client/Cargo.toml
rename to crates/ureq_client/Cargo.toml
index 82f7621bf8cace..a14419a2261a05 100644
--- a/crates/isahc_http_client/Cargo.toml
+++ b/crates/ureq_client/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "isahc_http_client"
+name = "ureq_client"
 version = "0.1.0"
 edition = "2021"
 publish = false
@@ -12,11 +12,21 @@ workspace = true
 test-support = []
 
 [lib]
-path = "src/isahc_http_client.rs"
+path = "src/ureq_client.rs"
+doctest = true
+
+[[example]]
+name = "client"
+path = "examples/client.rs"
 
 [dependencies]
 anyhow.workspace = true
 futures.workspace = true
+serde.workspace = true
+smol.workspace = true
+gpui.workspace = true
 http_client.workspace = true
-isahc.workspace = true
 util.workspace = true
+parking_lot.workspace = true
+
+ureq = "=2.9.1"
diff --git a/crates/ureq_client/LICENSE-GPL b/crates/ureq_client/LICENSE-GPL
new file mode 120000
index 00000000000000..89e542f750cd38
--- /dev/null
+++ b/crates/ureq_client/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
\ No newline at end of file
diff --git a/crates/ureq_client/examples/client.rs b/crates/ureq_client/examples/client.rs
new file mode 100644
index 00000000000000..c5caae40dac9ec
--- /dev/null
+++ b/crates/ureq_client/examples/client.rs
@@ -0,0 +1,24 @@
+use futures::AsyncReadExt;
+use http_client::{AsyncBody, HttpClient};
+use ureq_client::UreqClient;
+
+fn main() {
+    gpui::App::headless().run(|cx| {
+        println!("{:?}", std::thread::current().id());
+        cx.spawn(|cx| async move {
+            let resp = UreqClient::new(
+                None,
+                "Conrad's bot".to_string(),
+                cx.background_executor().clone(),
+            )
+            .get("http://zed.dev", AsyncBody::empty(), true)
+            .await
+            .unwrap();
+
+            let mut body = String::new();
+            resp.into_body().read_to_string(&mut body).await.unwrap();
+            println!("{}", body);
+        })
+        .detach();
+    })
+}
diff --git a/crates/ureq_client/src/ureq_client.rs b/crates/ureq_client/src/ureq_client.rs
new file mode 100644
index 00000000000000..8951e80ac2df5e
--- /dev/null
+++ b/crates/ureq_client/src/ureq_client.rs
@@ -0,0 +1,187 @@
+use std::collections::HashMap;
+use std::io::Read;
+use std::sync::Arc;
+use std::time::Duration;
+use std::{pin::Pin, task::Poll};
+
+use anyhow::Error;
+use futures::channel::mpsc;
+use futures::future::BoxFuture;
+use futures::{AsyncRead, SinkExt, StreamExt};
+use http_client::{http, AsyncBody, HttpClient, RedirectPolicy, Uri};
+use smol::future::FutureExt;
+use util::ResultExt;
+
+pub struct UreqClient {
+    // Note in ureq 2.x the options are stored on the Agent.
+    // In ureq 3.x we'll be able to set these on the request.
+    // In practice it's probably "fine" to have many clients, the number of distinct options
+    // is low; and most requests to the same connection will have the same options so the
+    // connection pool will work.
+    clients: Arc<parking_lot::Mutex<HashMap<(Duration, RedirectPolicy), ureq::Agent>>>,
+    proxy_url: Option<Uri>,
+    proxy: Option<ureq::Proxy>,
+    user_agent: String,
+    background_executor: gpui::BackgroundExecutor,
+}
+
+impl UreqClient {
+    pub fn new(
+        proxy_url: Option<Uri>,
+        user_agent: String,
+        background_executor: gpui::BackgroundExecutor,
+    ) -> Self {
+        Self {
+            clients: Arc::default(),
+            proxy_url: proxy_url.clone(),
+            proxy: proxy_url.and_then(|url| ureq::Proxy::new(url.to_string()).log_err()),
+            user_agent,
+            background_executor,
+        }
+    }
+
+    fn agent_for(&self, redirect_policy: RedirectPolicy, timeout: Duration) -> ureq::Agent {
+        let mut clients = self.clients.lock();
+        // in case our assumption of distinct options is wrong, we'll sporadically clean it out.
+        if clients.len() > 50 {
+            clients.clear()
+        }
+
+        clients
+            .entry((timeout, redirect_policy.clone()))
+            .or_insert_with(|| {
+                let mut builder = ureq::AgentBuilder::new()
+                    .timeout_connect(Duration::from_secs(5))
+                    .timeout_read(timeout)
+                    .timeout_write(timeout)
+                    .user_agent(&self.user_agent)
+                    .tls_config(http_client::TLS_CONFIG.clone())
+                    .redirects(match redirect_policy {
+                        RedirectPolicy::NoFollow => 0,
+                        RedirectPolicy::FollowLimit(limit) => limit,
+                        RedirectPolicy::FollowAll => 100,
+                    });
+                if let Some(proxy) = &self.proxy {
+                    builder = builder.proxy(proxy.clone());
+                }
+                builder.build()
+            })
+            .clone()
+    }
+}
+impl HttpClient for UreqClient {
+    fn proxy(&self) -> Option<&Uri> {
+        self.proxy_url.as_ref()
+    }
+
+    fn send(
+        &self,
+        request: http::Request<AsyncBody>,
+    ) -> BoxFuture<'static, Result<http::Response<AsyncBody>, Error>> {
+        let agent = self.agent_for(
+            request
+                .extensions()
+                .get::<RedirectPolicy>()
+                .cloned()
+                .unwrap_or_default(),
+            request
+                .extensions()
+                .get::<http_client::ReadTimeout>()
+                .cloned()
+                .unwrap_or_default()
+                .0,
+        );
+        let mut req = agent.request(&request.method().as_ref(), &request.uri().to_string());
+        for (name, value) in request.headers().into_iter() {
+            req = req.set(name.as_str(), value.to_str().unwrap());
+        }
+        let body = request.into_body();
+        let executor = self.background_executor.clone();
+
+        self.background_executor
+            .spawn(async move {
+                let response = req.send(body)?;
+
+                let mut builder = http::Response::builder()
+                    .status(response.status())
+                    .version(http::Version::HTTP_11);
+                for name in response.headers_names() {
+                    if let Some(value) = response.header(&name) {
+                        builder = builder.header(name, value);
+                    }
+                }
+
+                let body = AsyncBody::from_reader(UreqResponseReader::new(executor, response));
+                let http_response = builder.body(body)?;
+
+                Ok(http_response)
+            })
+            .boxed()
+    }
+}
+
+struct UreqResponseReader {
+    receiver: mpsc::Receiver<std::io::Result<Vec<u8>>>,
+    buffer: Vec<u8>,
+    idx: usize,
+    _task: gpui::Task<()>,
+}
+
+impl UreqResponseReader {
+    fn new(background_executor: gpui::BackgroundExecutor, response: ureq::Response) -> Self {
+        let (mut sender, receiver) = mpsc::channel(1);
+        let mut reader = response.into_reader();
+        let task = background_executor.spawn(async move {
+            let mut buffer = vec![0; 8192];
+            loop {
+                let n = match reader.read(&mut buffer) {
+                    Ok(0) => break,
+                    Ok(n) => n,
+                    Err(e) => {
+                        let _ = sender.send(Err(e)).await;
+                        break;
+                    }
+                };
+                let _ = sender.send(Ok(buffer[..n].to_vec())).await;
+            }
+        });
+
+        UreqResponseReader {
+            _task: task,
+            receiver,
+            buffer: Vec::new(),
+            idx: 0,
+        }
+    }
+}
+
+impl AsyncRead for UreqResponseReader {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &mut [u8],
+    ) -> Poll<std::io::Result<usize>> {
+        if self.buffer.is_empty() {
+            match self.receiver.poll_next_unpin(cx) {
+                Poll::Ready(Some(Ok(data))) => self.buffer = data,
+                Poll::Ready(Some(Err(e))) => {
+                    return Poll::Ready(Err(e));
+                }
+                Poll::Ready(None) => {
+                    return Poll::Ready(Ok(0));
+                }
+                Poll::Pending => {
+                    return Poll::Pending;
+                }
+            }
+        }
+        let n = std::cmp::min(buf.len(), self.buffer.len() - self.idx);
+        buf[..n].copy_from_slice(&self.buffer[self.idx..self.idx + n]);
+        self.idx += n;
+        if self.idx == self.buffer.len() {
+            self.buffer.clear();
+            self.idx = 0;
+        }
+        Poll::Ready(Ok(n))
+    }
+}
diff --git a/crates/vim/Cargo.toml b/crates/vim/Cargo.toml
index dcbf2e8b597a34..99394b7922c4fa 100644
--- a/crates/vim/Cargo.toml
+++ b/crates/vim/Cargo.toml
@@ -17,7 +17,7 @@ neovim = ["nvim-rs", "async-compat", "async-trait", "tokio"]
 
 [dependencies]
 anyhow.workspace = true
-async-compat = { version = "0.2.1", "optional" = true }
+async-compat = { workspace = true, "optional" = true }
 async-trait = { workspace = true, "optional" = true }
 collections.workspace = true
 command_palette.workspace = true
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index e22f75f5bb3e54..ac73bf15eea18d 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -57,7 +57,7 @@ http_client.workspace = true
 image_viewer.workspace = true
 inline_completion_button.workspace = true
 install_cli.workspace = true
-isahc_http_client.workspace = true
+ureq_client.workspace = true
 journal.workspace = true
 language.workspace = true
 language_model.workspace = true
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 06f1d926aea37d..adb5feb9fe5bdc 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -24,9 +24,9 @@ use gpui::{
     UpdateGlobal as _, VisualContext,
 };
 use http_client::{read_proxy_from_env, Uri};
-use isahc_http_client::IsahcHttpClient;
 use language::LanguageRegistry;
 use log::LevelFilter;
+use ureq_client::UreqClient;
 
 use assets::Assets;
 use node_runtime::{NodeBinaryOptions, NodeRuntime};
@@ -334,9 +334,7 @@ fn main() {
 
     log::info!("========== starting zed ==========");
 
-    let app = App::new()
-        .with_assets(Assets)
-        .with_http_client(IsahcHttpClient::new(None, None));
+    let app = App::new().with_assets(Assets);
 
     let system_id = app.background_executor().block(system_id()).ok();
     let installation_id = app.background_executor().block(installation_id()).ok();
@@ -470,8 +468,8 @@ fn main() {
                     .ok()
             })
             .or_else(read_proxy_from_env);
-        let http = IsahcHttpClient::new(proxy_url, Some(user_agent));
-        cx.set_http_client(http);
+        let http = UreqClient::new(proxy_url, user_agent, cx.background_executor().clone());
+        cx.set_http_client(Arc::new(http));
 
         <dyn Fs>::set_global(fs.clone(), cx);
 

From 9565a90528056988a402280c9303f55843bc63fb Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 2 Oct 2024 16:10:25 -0400
Subject: [PATCH 452/762] collab: Revert changes to Clickhouse event rows
 (#18654)

This PR reverts the changes to the Clickhouse event rows that were
included in https://github.com/zed-industries/zed/pull/18414.

The changes don't seem to be correct, as they make the row structs
differ from the underlying table schema.

Release Notes:

- N/A
---
 crates/collab/src/api/events.rs | 40 ++++++++++++++++-----------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index dd1370e8866442..bbfa69c0b8f70b 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -674,7 +674,7 @@ pub struct EditorEventRow {
     copilot_enabled_for_language: bool,
     historical_event: bool,
     architecture: String,
-    is_staff: bool,
+    is_staff: Option<bool>,
     major: Option<i32>,
     minor: Option<i32>,
     patch: Option<i32>,
@@ -708,7 +708,7 @@ impl EditorEventRow {
             installation_id: body.installation_id.clone().unwrap_or_default(),
             session_id: body.session_id.clone(),
             metrics_id: body.metrics_id.clone().unwrap_or_default(),
-            is_staff: body.is_staff.unwrap_or_default(),
+            is_staff: body.is_staff,
             time: time.timestamp_millis(),
             operation: event.operation,
             file_extension: event.file_extension.unwrap_or_default(),
@@ -741,7 +741,7 @@ pub struct InlineCompletionEventRow {
     region_code: String,
     city: String,
     time: i64,
-    is_staff: bool,
+    is_staff: Option<bool>,
     major: Option<i32>,
     minor: Option<i32>,
     patch: Option<i32>,
@@ -772,7 +772,7 @@ impl InlineCompletionEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone().unwrap_or_default(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff.unwrap_or_default(),
+            is_staff: body.is_staff,
             time: time.timestamp_millis(),
             file_extension: event.file_extension.unwrap_or_default(),
             signed_in: wrapper.signed_in,
@@ -800,7 +800,7 @@ pub struct CallEventRow {
     // ClientEventBase
     installation_id: String,
     session_id: Option<String>,
-    is_staff: bool,
+    is_staff: Option<bool>,
     time: i64,
 
     // CallEventRow
@@ -832,7 +832,7 @@ impl CallEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone().unwrap_or_default(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff.unwrap_or_default(),
+            is_staff: body.is_staff,
             time: time.timestamp_millis(),
             operation: event.operation,
             room_id: event.room_id,
@@ -856,7 +856,7 @@ pub struct AssistantEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: bool,
+    is_staff: Option<bool>,
     time: i64,
 
     // AssistantEventRow
@@ -891,7 +891,7 @@ impl AssistantEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff.unwrap_or_default(),
+            is_staff: body.is_staff,
             time: time.timestamp_millis(),
             conversation_id: event.conversation_id.unwrap_or_default(),
             kind: event.kind.to_string(),
@@ -909,7 +909,7 @@ impl AssistantEventRow {
 pub struct CpuEventRow {
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: bool,
+    is_staff: Option<bool>,
     usage_as_percentage: f32,
     core_count: u32,
     app_version: String,
@@ -947,7 +947,7 @@ impl CpuEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff.unwrap_or_default(),
+            is_staff: body.is_staff,
             time: time.timestamp_millis(),
             usage_as_percentage: event.usage_as_percentage,
             core_count: event.core_count,
@@ -970,7 +970,7 @@ pub struct MemoryEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: bool,
+    is_staff: Option<bool>,
     time: i64,
 
     // MemoryEventRow
@@ -1001,7 +1001,7 @@ impl MemoryEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff.unwrap_or_default(),
+            is_staff: body.is_staff,
             time: time.timestamp_millis(),
             memory_in_bytes: event.memory_in_bytes,
             virtual_memory_in_bytes: event.virtual_memory_in_bytes,
@@ -1024,7 +1024,7 @@ pub struct AppEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: bool,
+    is_staff: Option<bool>,
     time: i64,
 
     // AppEventRow
@@ -1054,7 +1054,7 @@ impl AppEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff.unwrap_or_default(),
+            is_staff: body.is_staff,
             time: time.timestamp_millis(),
             operation: event.operation,
         }
@@ -1076,7 +1076,7 @@ pub struct SettingEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: bool,
+    is_staff: Option<bool>,
     time: i64,
     // SettingEventRow
     setting: String,
@@ -1106,7 +1106,7 @@ impl SettingEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff.unwrap_or_default(),
+            is_staff: body.is_staff,
             time: time.timestamp_millis(),
             setting: event.setting,
             value: event.value,
@@ -1129,7 +1129,7 @@ pub struct ExtensionEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: bool,
+    is_staff: Option<bool>,
     time: i64,
 
     // ExtensionEventRow
@@ -1164,7 +1164,7 @@ impl ExtensionEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff.unwrap_or_default(),
+            is_staff: body.is_staff,
             time: time.timestamp_millis(),
             extension_id: event.extension_id,
             extension_version: event.version,
@@ -1198,7 +1198,7 @@ pub struct ReplEventRow {
     // ClientEventBase
     installation_id: Option<String>,
     session_id: Option<String>,
-    is_staff: bool,
+    is_staff: Option<bool>,
     time: i64,
 
     // ReplEventRow
@@ -1230,7 +1230,7 @@ impl ReplEventRow {
             os_version: body.os_version.clone().unwrap_or_default(),
             installation_id: body.installation_id.clone(),
             session_id: body.session_id.clone(),
-            is_staff: body.is_staff.unwrap_or_default(),
+            is_staff: body.is_staff,
             time: time.timestamp_millis(),
             kernel_language: event.kernel_language,
             kernel_status: event.kernel_status,

From 6f4385e73741b0cba6cb3028ecd8d4d76086ba4b Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 2 Oct 2024 16:26:48 -0400
Subject: [PATCH 453/762] Sort dependencies in `Cargo.toml` files (#18657)

This PR sorts the dependencies in various `Cargo.toml` files after
#18414.

Release Notes:

- N/A
---
 Cargo.toml                       | 24 ++++++++++++------------
 crates/collab/Cargo.toml         | 12 ++++++------
 crates/evals/Cargo.toml          | 12 ++++++------
 crates/extension/Cargo.toml      | 17 ++++++++---------
 crates/extension_cli/Cargo.toml  |  2 +-
 crates/http_client/Cargo.toml    |  6 +++---
 crates/reqwest_client/Cargo.toml |  4 ++--
 crates/semantic_index/Cargo.toml | 18 +++++++++---------
 crates/ureq_client/Cargo.toml    |  7 +++----
 crates/vim/Cargo.toml            | 10 ++++------
 crates/zed/Cargo.toml            |  2 +-
 11 files changed, 55 insertions(+), 59 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index fea528db5b89ee..8feb93a57856a2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,6 @@ members = [
     "crates/assistant",
     "crates/assistant_slash_command",
     "crates/assistant_tool",
-    "crates/ureq_client",
     "crates/audio",
     "crates/auto_update",
     "crates/breadcrumbs",
@@ -87,8 +86,8 @@ members = [
     "crates/release_channel",
     "crates/remote",
     "crates/remote_server",
-    "crates/reqwest_client",
     "crates/repl",
+    "crates/reqwest_client",
     "crates/rich_text",
     "crates/rope",
     "crates/rpc",
@@ -123,6 +122,7 @@ members = [
     "crates/ui",
     "crates/ui_input",
     "crates/ui_macros",
+    "crates/ureq_client",
     "crates/util",
     "crates/vcs_menu",
     "crates/vim",
@@ -176,6 +176,7 @@ members = [
 default-members = ["crates/zed"]
 
 [workspace.dependencies]
+
 #
 # Workspace member crates
 #
@@ -187,8 +188,6 @@ assets = { path = "crates/assets" }
 assistant = { path = "crates/assistant" }
 assistant_slash_command = { path = "crates/assistant_slash_command" }
 assistant_tool = { path = "crates/assistant_tool" }
-ureq_client = { path = "crates/ureq_client" }
-async-compat = { version = "0.2.1" }
 audio = { path = "crates/audio" }
 auto_update = { path = "crates/auto_update" }
 breadcrumbs = { path = "crates/breadcrumbs" }
@@ -223,7 +222,6 @@ go_to_line = { path = "crates/go_to_line" }
 google_ai = { path = "crates/google_ai" }
 gpui = { path = "crates/gpui" }
 gpui_macros = { path = "crates/gpui_macros" }
-handlebars = "4.3"
 headless = { path = "crates/headless" }
 html_to_markdown = { path = "crates/html_to_markdown" }
 http_client = { path = "crates/http_client" }
@@ -302,6 +300,7 @@ title_bar = { path = "crates/title_bar" }
 ui = { path = "crates/ui" }
 ui_input = { path = "crates/ui_input" }
 ui_macros = { path = "crates/ui_macros" }
+ureq_client = { path = "crates/ureq_client" }
 util = { path = "crates/util" }
 vcs_menu = { path = "crates/vcs_menu" }
 vim = { path = "crates/vim" }
@@ -321,6 +320,7 @@ any_vec = "0.14"
 anyhow = "1.0.86"
 arrayvec = { version = "0.7.4", features = ["serde"] }
 ashpd = "0.9.1"
+async-compat = "0.2.1"
 async-compression = { version = "0.4", features = ["gzip", "futures-io"] }
 async-dispatcher = "0.1"
 async-fs = "1.6"
@@ -359,15 +359,15 @@ futures-batch = "0.6.1"
 futures-lite = "1.13"
 git2 = { version = "0.19", default-features = false }
 globset = "0.4"
+handlebars = "4.3"
 heed = { version = "0.20.1", features = ["read-txn-no-tls"] }
 hex = "0.4.3"
-hyper = "0.14"
 html5ever = "0.27.0"
+hyper = "0.14"
 ignore = "0.4.22"
 image = "0.25.1"
 indexmap = { version = "1.6.2", features = ["serde"] }
 indoc = "2"
-
 itertools = "0.13.0"
 jsonwebtoken = "9.3"
 libc = "0.2"
@@ -382,17 +382,18 @@ ordered-float = "2.1.1"
 palette = { version = "0.7.5", default-features = false, features = ["std"] }
 parking_lot = "0.12.1"
 pathdiff = "0.2"
-profiling = "1"
 postage = { version = "0.5", features = ["futures-traits"] }
 pretty_assertions = "1.3.0"
+profiling = "1"
 prost = "0.9"
 prost-build = "0.9"
 prost-types = "0.9"
+protols-tree-sitter-proto = { git = "https://github.com/zed-industries/tree-sitter-proto", rev = "0848bd30a64be48772e15fbb9d5ba8c0cc5772ad" }
 pulldown-cmark = { version = "0.12.0", default-features = false }
 rand = "0.8.5"
 regex = "1.5"
 repair_json = "0.1.0"
-reqwest  = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29" }
+reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29" }
 rsa = "0.9.6"
 runtimelib = { version = "0.15", default-features = false, features = [
     "async-dispatcher-runtime",
@@ -453,15 +454,14 @@ tree-sitter-html = "0.20"
 tree-sitter-jsdoc = "0.23"
 tree-sitter-json = "0.23"
 tree-sitter-md = { git = "https://github.com/zed-industries/tree-sitter-markdown", rev = "4cfa6aad6b75052a5077c80fd934757d9267d81b" }
-protols-tree-sitter-proto = { git = "https://github.com/zed-industries/tree-sitter-proto", rev = "0848bd30a64be48772e15fbb9d5ba8c0cc5772ad" }
 tree-sitter-python = "0.23"
 tree-sitter-regex = "0.23"
 tree-sitter-ruby = "0.23"
 tree-sitter-rust = "0.23"
 tree-sitter-typescript = "0.23"
-tree-sitter-yaml =  { git = "https://github.com/zed-industries/tree-sitter-yaml", rev = "baff0b51c64ef6a1fb1f8390f3ad6015b83ec13a" }
-unindent = "0.1.7"
+tree-sitter-yaml = { git = "https://github.com/zed-industries/tree-sitter-yaml", rev = "baff0b51c64ef6a1fb1f8390f3ad6015b83ec13a" }
 unicase = "2.6"
+unindent = "0.1.7"
 unicode-segmentation = "1.10"
 url = "2.2"
 uuid = { version = "1.1.2", features = ["v4", "v5", "serde"] }
diff --git a/crates/collab/Cargo.toml b/crates/collab/Cargo.toml
index 7d4c5d0c706b7e..de7a3c621465e0 100644
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -28,8 +28,8 @@ axum = { version = "0.6", features = ["json", "headers", "ws"] }
 axum-extra = { version = "0.4", features = ["erased-json"] }
 base64.workspace = true
 chrono.workspace = true
-clock.workspace = true
 clickhouse.workspace = true
+clock.workspace = true
 collections.workspace = true
 dashmap.workspace = true
 envy = "0.4.2"
@@ -37,19 +37,19 @@ futures.workspace = true
 google_ai.workspace = true
 hex.workspace = true
 http_client.workspace = true
-reqwest_client.workspace = true
 jsonwebtoken.workspace = true
 live_kit_server.workspace = true
 log.workspace = true
 nanoid.workspace = true
 open_ai.workspace = true
-supermaven_api.workspace = true
 parking_lot.workspace = true
 prometheus = "0.13"
 prost.workspace = true
 rand.workspace = true
 reqwest = { version = "0.11", features = ["json"] }
+reqwest_client.workspace = true
 rpc.workspace = true
+rustc-demangle.workspace = true
 scrypt = "0.11"
 sea-orm = { version = "1.1.0-rc.1", features = ["sqlx-postgres", "postgres-array", "runtime-tokio-rustls", "with-uuid"] }
 semantic_version.workspace = true
@@ -61,7 +61,7 @@ sha2.workspace = true
 sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres", "json", "time", "uuid", "any"] }
 strum.workspace = true
 subtle.workspace = true
-rustc-demangle.workspace = true
+supermaven_api.workspace = true
 telemetry_events.workspace = true
 text.workspace = true
 thiserror.workspace = true
@@ -85,6 +85,7 @@ client = { workspace = true, features = ["test-support"] }
 collab_ui = { workspace = true, features = ["test-support"] }
 collections = { workspace = true, features = ["test-support"] }
 ctor.workspace = true
+dev_server_projects.workspace = true
 editor = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
 file_finder.workspace = true
@@ -92,6 +93,7 @@ fs = { workspace = true, features = ["test-support"] }
 git = { workspace = true, features = ["test-support"] }
 git_hosting_providers.workspace = true
 gpui = { workspace = true, features = ["test-support"] }
+headless.workspace = true
 hyper.workspace = true
 indoc.workspace = true
 language = { workspace = true, features = ["test-support"] }
@@ -108,7 +110,6 @@ recent_projects = { workspace = true }
 release_channel.workspace = true
 remote = { workspace = true, features = ["test-support"] }
 remote_server.workspace = true
-dev_server_projects.workspace = true
 rpc = { workspace = true, features = ["test-support"] }
 sea-orm = { version = "1.1.0-rc.1", features = ["sqlx-sqlite"] }
 serde_json.workspace = true
@@ -120,7 +121,6 @@ unindent.workspace = true
 util.workspace = true
 workspace = { workspace = true, features = ["test-support"] }
 worktree = { workspace = true, features = ["test-support"] }
-headless.workspace = true
 
 [package.metadata.cargo-machete]
 ignored = ["async-stripe"]
diff --git a/crates/evals/Cargo.toml b/crates/evals/Cargo.toml
index 52af0ce446f918..2697b768453f16 100644
--- a/crates/evals/Cargo.toml
+++ b/crates/evals/Cargo.toml
@@ -14,9 +14,8 @@ name = "eval"
 path = "src/eval.rs"
 
 [dependencies]
-clap.workspace = true
 anyhow.workspace = true
-ureq_client.workspace = true
+clap.workspace = true
 client.workspace = true
 clock.workspace = true
 collections.workspace = true
@@ -25,14 +24,15 @@ feature_flags.workspace = true
 fs.workspace = true
 git.workspace = true
 gpui.workspace = true
+http_client.workspace = true
 language.workspace = true
 languages.workspace = true
-http_client.workspace = true
+node_runtime.workspace = true
 open_ai.workspace = true
 project.workspace = true
-settings.workspace = true
+semantic_index.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+settings.workspace = true
 smol.workspace = true
-semantic_index.workspace = true
-node_runtime.workspace = true
+ureq_client.workspace = true
diff --git a/crates/extension/Cargo.toml b/crates/extension/Cargo.toml
index 9fea3a768a0c02..2b1d6193f86699 100644
--- a/crates/extension/Cargo.toml
+++ b/crates/extension/Cargo.toml
@@ -39,32 +39,31 @@ schemars.workspace = true
 semantic_version.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+serde_json_lenient.workspace = true
 settings.workspace = true
 snippet_provider.workspace = true
+task.workspace = true
 theme.workspace = true
 toml.workspace = true
 ui.workspace = true
 url.workspace = true
 util.workspace = true
 wasm-encoder.workspace = true
-wasmtime.workspace = true
-wasmtime-wasi.workspace = true
 wasmparser.workspace = true
+wasmtime-wasi.workspace = true
+wasmtime.workspace = true
 wit-component.workspace = true
 workspace.workspace = true
-task.workspace = true
-serde_json_lenient.workspace = true
 
 [dev-dependencies]
-ureq_client.workspace = true
 ctor.workspace = true
 env_logger.workspace = true
-parking_lot.workspace = true
-reqwest_client.workspace = true
-tokio.workspace = true
-
 fs = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }
+parking_lot.workspace = true
 project = { workspace = true, features = ["test-support"] }
+reqwest_client.workspace = true
+tokio.workspace = true
+ureq_client.workspace = true
 workspace = { workspace = true, features = ["test-support"] }
diff --git a/crates/extension_cli/Cargo.toml b/crates/extension_cli/Cargo.toml
index 3e109a0036b2fc..6de3e858d4fff5 100644
--- a/crates/extension_cli/Cargo.toml
+++ b/crates/extension_cli/Cargo.toml
@@ -18,9 +18,9 @@ clap = { workspace = true, features = ["derive"] }
 env_logger.workspace = true
 extension = { workspace = true, features = ["no-webrtc"] }
 fs.workspace = true
-reqwest_client.workspace = true
 language.workspace = true
 log.workspace = true
+reqwest_client.workspace = true
 rpc.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/http_client/Cargo.toml b/crates/http_client/Cargo.toml
index 52c2947b8a7e4f..e8585cff9820fd 100644
--- a/crates/http_client/Cargo.toml
+++ b/crates/http_client/Cargo.toml
@@ -16,13 +16,13 @@ path = "src/http_client.rs"
 doctest = true
 
 [dependencies]
-http = "1.1"
-rustls.workspace = true
-rustls-native-certs.workspace = true
 anyhow.workspace = true
 derive_more.workspace = true
 futures.workspace = true
+http = "1.1"
 log.workspace = true
+rustls-native-certs.workspace = true
+rustls.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 smol.workspace = true
diff --git a/crates/reqwest_client/Cargo.toml b/crates/reqwest_client/Cargo.toml
index d39319125299f1..060a382d72ee43 100644
--- a/crates/reqwest_client/Cargo.toml
+++ b/crates/reqwest_client/Cargo.toml
@@ -21,11 +21,11 @@ path = "examples/client.rs"
 
 [dependencies]
 anyhow.workspace = true
+bytes = "1.0"
 futures.workspace = true
+http_client.workspace = true
 serde.workspace = true
 smol.workspace = true
-http_client.workspace = true
 tokio.workspace = true
-bytes = "1.0"
 
 reqwest = { workspace = true, features = ["rustls-tls-manual-roots", "stream"] }
diff --git a/crates/semantic_index/Cargo.toml b/crates/semantic_index/Cargo.toml
index 8842093f7857ff..508e64ffea3626 100644
--- a/crates/semantic_index/Cargo.toml
+++ b/crates/semantic_index/Cargo.toml
@@ -26,42 +26,42 @@ clock.workspace = true
 collections.workspace = true
 feature_flags.workspace = true
 fs.workspace = true
-futures.workspace = true
 futures-batch.workspace = true
+futures.workspace = true
 gpui.workspace = true
+heed.workspace = true
+http_client.workspace = true
 language.workspace = true
 language_model.workspace = true
 log.workspace = true
-heed.workspace = true
-http_client.workspace = true
 open_ai.workspace = true
 parking_lot.workspace = true
 project.workspace = true
-settings.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+settings.workspace = true
 sha2.workspace = true
 smol.workspace = true
 theme.workspace = true
 tree-sitter.workspace = true
 ui. workspace = true
-util. workspace = true
 unindent.workspace = true
+util. workspace = true
 workspace.workspace = true
 worktree.workspace = true
 
 [dev-dependencies]
-ureq_client.workspace = true
-env_logger.workspace = true
 client = { workspace = true, features = ["test-support"] }
+env_logger.workspace = true
 fs = { workspace = true, features = ["test-support"] }
 futures.workspace = true
 gpui = { workspace = true, features = ["test-support"] }
+http_client = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }
 languages.workspace = true
 project = { workspace = true, features = ["test-support"] }
 tempfile.workspace = true
+ureq_client.workspace = true
 util = { workspace = true, features = ["test-support"] }
-worktree = { workspace = true, features = ["test-support"] }
 workspace = { workspace = true, features = ["test-support"] }
-http_client = { workspace = true, features = ["test-support"] }
+worktree = { workspace = true, features = ["test-support"] }
diff --git a/crates/ureq_client/Cargo.toml b/crates/ureq_client/Cargo.toml
index a14419a2261a05..757ba010946c70 100644
--- a/crates/ureq_client/Cargo.toml
+++ b/crates/ureq_client/Cargo.toml
@@ -22,11 +22,10 @@ path = "examples/client.rs"
 [dependencies]
 anyhow.workspace = true
 futures.workspace = true
-serde.workspace = true
-smol.workspace = true
 gpui.workspace = true
 http_client.workspace = true
-util.workspace = true
 parking_lot.workspace = true
-
+serde.workspace = true
+smol.workspace = true
 ureq = "=2.9.1"
+util.workspace = true
diff --git a/crates/vim/Cargo.toml b/crates/vim/Cargo.toml
index 99394b7922c4fa..bb347f49b79d84 100644
--- a/crates/vim/Cargo.toml
+++ b/crates/vim/Cargo.toml
@@ -28,10 +28,9 @@ itertools.workspace = true
 language.workspace = true
 log.workspace = true
 multi_buffer.workspace = true
-nvim-rs = { git = "https://github.com/KillTheMule/nvim-rs", branch = "master", features = [
-    "use_tokio",
-], optional = true }
+nvim-rs = { git = "https://github.com/KillTheMule/nvim-rs", branch = "master", features = ["use_tokio"], optional = true }
 regex.workspace = true
+schemars.workspace = true
 search.workspace = true
 serde.workspace = true
 serde_derive.workspace = true
@@ -39,21 +38,20 @@ serde_json.workspace = true
 settings.workspace = true
 tokio = { version = "1.15", "optional" = true }
 ui.workspace = true
+util.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
-schemars.workspace = true
-util.workspace = true
 
 [dev-dependencies]
 command_palette.workspace = true
 editor = { workspace = true, features = ["test-support"] }
 futures.workspace = true
 gpui = { workspace = true, features = ["test-support"] }
-release_channel.workspace = true
 indoc.workspace = true
 language = { workspace = true, features = ["test-support"] }
 lsp = { workspace = true, features = ["test-support"] }
 parking_lot.workspace = true
+release_channel.workspace = true
 settings.workspace = true
 util = { workspace = true, features = ["test-support"] }
 workspace = { workspace = true, features = ["test-support"] }
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index ac73bf15eea18d..e340e176a74146 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -57,7 +57,6 @@ http_client.workspace = true
 image_viewer.workspace = true
 inline_completion_button.workspace = true
 install_cli.workspace = true
-ureq_client.workspace = true
 journal.workspace = true
 language.workspace = true
 language_model.workspace = true
@@ -108,6 +107,7 @@ theme.workspace = true
 theme_selector.workspace = true
 time.workspace = true
 ui.workspace = true
+ureq_client.workspace = true
 url.workspace = true
 urlencoding = "2.1.2"
 util.workspace = true

From e2d613a803e0f04c6365d832e5300059ab493ae3 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 2 Oct 2024 17:39:32 -0400
Subject: [PATCH 454/762] Update Rust crate clap to v4.5.19 (#18660)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [clap](https://redirect.github.com/clap-rs/clap) |
workspace.dependencies | patch | `4.5.18` -> `4.5.19` |

---

### Release Notes

<details>
<summary>clap-rs/clap (clap)</summary>

###
[`v4.5.19`](https://redirect.github.com/clap-rs/clap/blob/HEAD/CHANGELOG.md#4519---2024-10-01)

[Compare
Source](https://redirect.github.com/clap-rs/clap/compare/v4.5.18...v4.5.19)

##### Internal

-   Update dependencies

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguOTcuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a96e59df34c1db..187d0c92c806c2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2275,9 +2275,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.18"
+version = "4.5.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0956a43b323ac1afaffc053ed5c4b7c1f1800bacd1683c353aabbb752515dd3"
+checksum = "7be5744db7978a28d9df86a214130d106a89ce49644cbc4e3f0c22c3fba30615"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -2285,9 +2285,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.18"
+version = "4.5.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d72166dd41634086d5803a47eb71ae740e61d84709c36f3c34110173db3961b"
+checksum = "a5fbc17d3ef8278f55b282b2a2e75ae6f6c7d4bb70ed3d0382375104bfafdb4b"
 dependencies = [
  "anstream",
  "anstyle",
@@ -11571,12 +11571,12 @@ dependencies = [
 
 [[package]]
 name = "terminal_size"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7"
+checksum = "4f599bd7ca042cfdf8f4512b277c02ba102247820f9d9d4a9f521f496751a6ef"
 dependencies = [
  "rustix 0.38.35",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]

From 19b186671b85cb587c187bd33b1ccead43abe49a Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Thu, 3 Oct 2024 00:35:56 +0200
Subject: [PATCH 455/762] ssh: Add session state indicator to title bar
 (#18645)

![image](https://github.com/user-attachments/assets/0ed6f59c-e0e7-49e6-8db7-f09ec5cdf653)
The indicator turns yellow when ssh client is trying to reconnect. Note
that the state tracking is probably not ideal (we'll see how it pans out
once we start dog-fooding), but at the very least "green=good" should be
a decent mental model for now.

Release Notes:

- N/A
---
 crates/project/src/project.rs                 |  9 +++-
 crates/recent_projects/src/ssh_connections.rs |  1 +
 crates/remote/src/ssh_session.rs              | 16 +++++--
 crates/title_bar/src/title_bar.rs             | 45 ++++++++++++++++++-
 4 files changed, 66 insertions(+), 5 deletions(-)

diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index dadbd394bbf9b5..59c2c895cddcb6 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -1217,7 +1217,10 @@ impl Project {
         server.ssh_connection_string.is_some()
     }
 
-    pub fn ssh_connection_string(&self, cx: &ModelContext<Self>) -> Option<SharedString> {
+    pub fn ssh_connection_string(&self, cx: &AppContext) -> Option<SharedString> {
+        if let Some(ssh_state) = &self.ssh_client {
+            return Some(ssh_state.connection_string().into());
+        }
         let dev_server_id = self.dev_server_project_id()?;
         dev_server_projects::Store::global(cx)
             .read(cx)
@@ -1226,6 +1229,10 @@ impl Project {
             .clone()
     }
 
+    pub fn ssh_is_connected(&self) -> Option<bool> {
+        Some(!self.ssh_client.as_ref()?.is_reconnect_underway())
+    }
+
     pub fn replica_id(&self) -> ReplicaId {
         match self.client_state {
             ProjectClientState::Remote { replica_id, .. } => replica_id,
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index d0fffc031f0bff..1aff16a4a44f71 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -317,6 +317,7 @@ impl SshClientDelegate {
         if release_channel == ReleaseChannel::Dev
             && platform.arch == std::env::consts::ARCH
             && platform.os == std::env::consts::OS
+            && false
         {
             use smol::process::{Command, Stdio};
 
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 6bca9938baac71..89ec5db949aa70 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -36,6 +36,7 @@ use std::{
     time::Instant,
 };
 use tempfile::TempDir;
+use util::maybe;
 
 #[derive(
     Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, serde::Serialize, serde::Deserialize,
@@ -48,7 +49,7 @@ pub struct SshSocket {
     socket_path: PathBuf,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct SshConnectionOptions {
     pub host: String,
     pub username: Option<String>,
@@ -250,6 +251,7 @@ struct SshRemoteClientState {
 pub struct SshRemoteClient {
     client: Arc<ChannelClient>,
     inner_state: Mutex<Option<SshRemoteClientState>>,
+    connection_options: SshConnectionOptions,
 }
 
 impl SshRemoteClient {
@@ -265,6 +267,7 @@ impl SshRemoteClient {
         let this = Arc::new(Self {
             client,
             inner_state: Mutex::new(None),
+            connection_options: connection_options.clone(),
         });
 
         let inner_state = {
@@ -272,8 +275,7 @@ impl SshRemoteClient {
                 ChannelForwarder::new(incoming_tx, outgoing_rx, cx);
 
             let (ssh_connection, ssh_process) =
-                Self::establish_connection(connection_options.clone(), delegate.clone(), cx)
-                    .await?;
+                Self::establish_connection(connection_options, delegate.clone(), cx).await?;
 
             let multiplex_task = Self::multiplex(
                 Arc::downgrade(&this),
@@ -505,6 +507,13 @@ impl SshRemoteClient {
         self.client.clone().into()
     }
 
+    pub fn connection_string(&self) -> String {
+        self.connection_options.connection_string()
+    }
+
+    pub fn is_reconnect_underway(&self) -> bool {
+        maybe!({ Some(self.inner_state.try_lock()?.is_none()) }).unwrap_or_default()
+    }
     #[cfg(any(test, feature = "test-support"))]
     pub fn fake(
         client_cx: &mut gpui::TestAppContext,
@@ -519,6 +528,7 @@ impl SshRemoteClient {
                 Arc::new(Self {
                     client,
                     inner_state: Mutex::new(None),
+                    connection_options: SshConnectionOptions::default(),
                 })
             }),
             server_cx.update(|cx| ChannelClient::new(client_to_server_rx, server_to_client_tx, cx)),
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index d6cc839cfdb7bc..81f908ce797902 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -18,7 +18,7 @@ use gpui::{
     StatefulInteractiveElement, Styled, Subscription, View, ViewContext, VisualContext, WeakView,
 };
 use project::{Project, RepositoryEntry};
-use recent_projects::RecentProjects;
+use recent_projects::{OpenRemote, RecentProjects};
 use rpc::proto::{self, DevServerStatus};
 use smallvec::SmallVec;
 use std::sync::Arc;
@@ -262,6 +262,46 @@ impl TitleBar {
         self
     }
 
+    fn render_ssh_project_host(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
+        let host = self.project.read(cx).ssh_connection_string(cx)?;
+        let meta = SharedString::from(format!("Connected to: {host}"));
+        let indicator_color = if self.project.read(cx).ssh_is_connected()? {
+            Color::Success
+        } else {
+            Color::Warning
+        };
+        let indicator = div()
+            .absolute()
+            .w_1_4()
+            .h_1_4()
+            .right_0p5()
+            .bottom_0p5()
+            .p_1()
+            .rounded_2xl()
+            .bg(indicator_color.color(cx));
+
+        Some(
+            div()
+                .child(
+                    IconButton::new("ssh-server-icon", IconName::Server)
+                        .tooltip(move |cx| {
+                            Tooltip::with_meta(
+                                "Remote Project",
+                                Some(&OpenRemote),
+                                meta.clone(),
+                                cx,
+                            )
+                        })
+                        .shape(ui::IconButtonShape::Square)
+                        .on_click(|_, cx| {
+                            cx.dispatch_action(OpenRemote.boxed_clone());
+                        }),
+                )
+                .child(indicator)
+                .into_any_element(),
+        )
+    }
+
     pub fn render_project_host(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
         if let Some(dev_server) =
             self.project
@@ -296,6 +336,9 @@ impl TitleBar {
                     .into_any_element(),
             );
         }
+        if self.project.read(cx).is_via_ssh() {
+            return self.render_ssh_project_host(cx);
+        }
 
         if self.project.read(cx).is_disconnected() {
             return Some(

From c48d4dbc6bad8127d6992fea3fbf4c3091dc9650 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Wed, 2 Oct 2024 22:06:07 -0400
Subject: [PATCH 456/762] Add basic outline panel docs (#18674)

Bandaid to: https://github.com/zed-industries/zed/issues/18672

Release Notes:

- Added basic outline panel docs
---
 docs/src/SUMMARY.md       |  1 +
 docs/src/outline-panel.md | 26 ++++++++++++++++++++++++++
 2 files changed, 27 insertions(+)
 create mode 100644 docs/src/outline-panel.md

diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
index f0e4784f89cd92..e7d837e479bce1 100644
--- a/docs/src/SUMMARY.md
+++ b/docs/src/SUMMARY.md
@@ -22,6 +22,7 @@
 # Using Zed
 
 - [Multibuffers](./multibuffers.md)
+- [Outline Panel](./outline-panel.md)
 - [Code Completions](./completions.md)
 - [Channels](./channels.md)
 - [Collaboration](./collaboration.md)
diff --git a/docs/src/outline-panel.md b/docs/src/outline-panel.md
new file mode 100644
index 00000000000000..ee654514b25c2c
--- /dev/null
+++ b/docs/src/outline-panel.md
@@ -0,0 +1,26 @@
+# Outline Panel
+
+In addition to the modal outline (`cmd-shift-o`), Zed offers an outline panel. The outline panel can be deployed via `cmd-shift-b`, or via the `Outline Panel` button in the status bar.
+
+When viewing a "singleton" buffer, the outline panel works similarly to that of the outline modal - it displays the outline of the current buffer's symbols, as reported by tree-sitter. Clicking on an entry allows you to jump to the associated section in the file. The outline view will also automatically scroll to the section associated with the current cursor position within the file.
+
+![Using the outline panel in a singleton buffer](https://zed.dev/img/outline-panel/singleton.png)
+
+The outline panel truly excels when used with multi-buffers. Here are some examples of its versatility:
+
+1. Project Search Results:
+
+Get an overview of search results across your project.
+![Using the outline panel in a project search multi-buffer](https://zed.dev/img/outline-panel/project-search.png)
+
+2. Project Diagnostics:
+
+View a summary of all errors and warnings reported by the language server.
+![Using the outline panel while viewing project diagnostics multi-buffer](https://zed.dev/img/outline-panel/project-diagnostics.png)
+
+3. Find All References:
+
+Quickly navigate through all references when using the `editor: find all references` action.
+![Using the outline panel while viewing `find all references` multi-buffer](https://zed.dev/img/outline-panel/find-all-references.png)
+
+The outline view provides a great way to quickly navigate to specific parts of your code and helps you maintain context when working with large result sets in multi-buffers.

From df21fe174d91cd15ee984de3c78f018b347ad8e9 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Wed, 2 Oct 2024 22:16:56 -0400
Subject: [PATCH 457/762] Add command palette action name to outline panel docs
 (#18678)

Release Notes:

- N/A
---
 docs/src/outline-panel.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/src/outline-panel.md b/docs/src/outline-panel.md
index ee654514b25c2c..998f310076f01b 100644
--- a/docs/src/outline-panel.md
+++ b/docs/src/outline-panel.md
@@ -1,6 +1,6 @@
 # Outline Panel
 
-In addition to the modal outline (`cmd-shift-o`), Zed offers an outline panel. The outline panel can be deployed via `cmd-shift-b`, or via the `Outline Panel` button in the status bar.
+In addition to the modal outline (`cmd-shift-o`), Zed offers an outline panel. The outline panel can be deployed via `cmd-shift-b` (`outline panel: toggle focus` via the command palette), or by clicking the `Outline Panel` button in the status bar.
 
 When viewing a "singleton" buffer, the outline panel works similarly to that of the outline modal - it displays the outline of the current buffer's symbols, as reported by tree-sitter. Clicking on an entry allows you to jump to the associated section in the file. The outline view will also automatically scroll to the section associated with the current cursor position within the file.
 

From 9cd42427d88afad3423fa2546ed656839295cf3f Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 2 Oct 2024 23:28:00 -0400
Subject: [PATCH 458/762] Update Rust crate thiserror to v1.0.64 (#18677)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [thiserror](https://redirect.github.com/dtolnay/thiserror) |
workspace.dependencies | patch | `1.0.63` -> `1.0.64` |

---

### Release Notes

<details>
<summary>dtolnay/thiserror (thiserror)</summary>

###
[`v1.0.64`](https://redirect.github.com/dtolnay/thiserror/releases/tag/1.0.64)

[Compare
Source](https://redirect.github.com/dtolnay/thiserror/compare/1.0.63...1.0.64)

- Exclude derived impls from coverage instrumentation
([#&#8203;322](https://redirect.github.com/dtolnay/thiserror/issues/322),
thanks [@&#8203;oxalica](https://redirect.github.com/oxalica))

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguOTcuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 187d0c92c806c2..821bedbec040f8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11702,18 +11702,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.63"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
+checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.63"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
+checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
 dependencies = [
  "proc-macro2",
  "quote",

From 1e8297a469a4c922c23d6c6912d13832a4a09b4b Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Thu, 3 Oct 2024 15:38:42 +0300
Subject: [PATCH 459/762] Remove a debug dev config line (#18689)

Follow-up of https://github.com/zed-industries/zed/pull/18645

Release Notes:

- N/A
---
 crates/recent_projects/src/ssh_connections.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 1aff16a4a44f71..d0fffc031f0bff 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -317,7 +317,6 @@ impl SshClientDelegate {
         if release_channel == ReleaseChannel::Dev
             && platform.arch == std::env::consts::ARCH
             && platform.os == std::env::consts::OS
-            && false
         {
             use smol::process::{Command, Stdio};
 

From dc85378b9679253c03d5a11a8c5f0f3ae0d641d7 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 3 Oct 2024 16:23:56 +0200
Subject: [PATCH 460/762] Clean up style properties on hunk controls (#18639)

This PR removes some duplicate style properties on the hunk controls,
namely padding, border, and background color.

Release Notes:

- N/A
---
 crates/editor/src/hunk_diff.rs | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index ff3451fc9216b0..7fbb07ae35c79e 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -379,6 +379,7 @@ impl Editor {
             });
 
         let border_color = cx.theme().colors().border_variant;
+        let bg_color = cx.theme().colors().editor_background;
         let gutter_color = match hunk.status {
             DiffHunkStatus::Added => cx.theme().status().created,
             DiffHunkStatus::Modified => cx.theme().status().modified,
@@ -394,6 +395,7 @@ impl Editor {
             render: Box::new({
                 let editor = cx.view().clone();
                 let hunk = hunk.clone();
+
                 move |cx| {
                     let hunk_controls_menu_handle =
                         editor.read(cx).hunk_controls_menu_handle.clone();
@@ -404,7 +406,7 @@ impl Editor {
                         .w_full()
                         .border_t_1()
                         .border_color(border_color)
-                        .bg(cx.theme().colors().editor_background)
+                        .bg(bg_color)
                         .child(
                             div()
                                 .id("gutter-strip")
@@ -424,14 +426,9 @@ impl Editor {
                         )
                         .child(
                             h_flex()
-                                .pl_2()
-                                .pr_6()
+                                .px_6()
                                 .size_full()
                                 .justify_between()
-                                .border_t_1()
-                                .pl_6()
-                                .pr_6()
-                                .border_color(border_color)
                                 .child(
                                     h_flex()
                                         .gap_1()
@@ -608,7 +605,7 @@ impl Editor {
                                                                 move |menu, _| {
                                                                     menu.context(focus.clone())
                                                                         .action(
-                                                                            "Discard All",
+                                                                            "Discard All Hunks",
                                                                             RevertFile
                                                                                 .boxed_clone(),
                                                                         )

From 773ad6bfd154b9f14b9b2b7009fd5d53926f9e3f Mon Sep 17 00:00:00 2001
From: Nate Butler <iamnbutler@gmail.com>
Date: Thu, 3 Oct 2024 10:27:19 -0400
Subject: [PATCH 461/762] Document the `theme` crate (#18690)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR enables required documentation for the `theme` crate starts on
documenting it.

The end goal is to have all meaningful documentation in the crate filled
out – However I'm not sure that just adding `#![deny(missing_docs)]` to
the whole crate is the right approach.

I don't know that having 200+ "The color of the _ color" field docs is
useful however–In the short term I've excluded some of the modules that
contain structs with a ton of fields (`colors, `status`, etc.) until we
decide what the right solution here is.

Next steps are to clean up the crate, removing unused modules or those
with low usage in favor of other approaches.

Changes in this PR:
- Enable the `deny(missing_docs)` lint for the `theme` crate
- Start documenting a subset of the crate.
- Enable `#![allow(missing_docs)]` for some modules.


Release Notes:

- N/A
---
 crates/theme/src/default_colors.rs         | 15 +++--
 crates/theme/src/default_theme.rs          |  3 +
 crates/theme/src/font_family_cache.rs      |  3 +
 crates/theme/src/registry.rs               | 11 ++++
 crates/theme/src/scale.rs                  |  1 +
 crates/theme/src/schema.rs                 |  2 +
 crates/theme/src/settings.rs               | 70 +++++++++++++++++++++-
 crates/theme/src/styles/accents.rs         |  3 +
 crates/theme/src/styles/colors.rs          |  2 +
 crates/theme/src/styles/players.rs         |  2 +
 crates/theme/src/styles/status.rs          |  2 +
 crates/theme/src/styles/stories/color.rs   |  1 +
 crates/theme/src/styles/stories/players.rs |  1 +
 crates/theme/src/styles/syntax.rs          |  2 +
 crates/theme/src/styles/system.rs          |  2 +
 crates/theme/src/theme.rs                  | 41 ++++++++++++-
 16 files changed, 152 insertions(+), 9 deletions(-)

diff --git a/crates/theme/src/default_colors.rs b/crates/theme/src/default_colors.rs
index a7521bd374d1c3..49c216c0e07e78 100644
--- a/crates/theme/src/default_colors.rs
+++ b/crates/theme/src/default_colors.rs
@@ -8,12 +8,13 @@ pub(crate) fn neutral() -> ColorScaleSet {
     sand()
 }
 
-// Note: We aren't currently making use of the default colors, as all of the
-// themes have a value set for each color.
-//
-// We'll need to revisit these once we're ready to launch user themes, which may
-// not specify a value for each color (and thus should fall back to the defaults).
+/// The default colors for the theme.
+///
+/// Themes that do not specify all colors are refined off of these defaults.
 impl ThemeColors {
+    /// Returns the default colors for light themes.
+    ///
+    /// Themes that do not specify all colors are refined off of these defaults.
     pub fn light() -> Self {
         let system = SystemColors::default();
 
@@ -114,6 +115,9 @@ impl ThemeColors {
         }
     }
 
+    /// Returns the default colors for dark themes.
+    ///
+    /// Themes that do not specify all colors are refined off of these defaults.
     pub fn dark() -> Self {
         let system = SystemColors::default();
 
@@ -247,6 +251,7 @@ impl TryFrom<StaticColorScaleSet> for ColorScaleSet {
     }
 }
 
+/// Color scales used to build the default themes.
 pub fn default_color_scales() -> ColorScales {
     ColorScales {
         gray: gray(),
diff --git a/crates/theme/src/default_theme.rs b/crates/theme/src/default_theme.rs
index 6722b847badb96..58063409165330 100644
--- a/crates/theme/src/default_theme.rs
+++ b/crates/theme/src/default_theme.rs
@@ -45,6 +45,9 @@ pub(crate) fn zed_pro_moonlight() -> Theme {
     }
 }
 
+/// Returns the Zed Pro theme family.
+///
+/// Note: To be removed until the theme is implemented.
 pub fn zed_pro_family() -> ThemeFamily {
     ThemeFamily {
         id: "zed_pro".to_string(),
diff --git a/crates/theme/src/font_family_cache.rs b/crates/theme/src/font_family_cache.rs
index c9583b9e8d3bc7..755d829902a48f 100644
--- a/crates/theme/src/font_family_cache.rs
+++ b/crates/theme/src/font_family_cache.rs
@@ -25,14 +25,17 @@ struct GlobalFontFamilyCache(Arc<FontFamilyCache>);
 impl Global for GlobalFontFamilyCache {}
 
 impl FontFamilyCache {
+    /// Initializes the global font family cache.
     pub fn init_global(cx: &mut AppContext) {
         cx.default_global::<GlobalFontFamilyCache>();
     }
 
+    /// Returns the global font family cache.
     pub fn global(cx: &AppContext) -> Arc<Self> {
         GlobalFontFamilyCache::global(cx).0.clone()
     }
 
+    /// Returns the list of font families.
     pub fn list_font_families(&self, cx: &AppContext) -> Vec<SharedString> {
         if self.state.read().loaded_at.is_some() {
             return self.state.read().font_families.clone();
diff --git a/crates/theme/src/registry.rs b/crates/theme/src/registry.rs
index b70377f4408b98..a77ab141a6547b 100644
--- a/crates/theme/src/registry.rs
+++ b/crates/theme/src/registry.rs
@@ -17,9 +17,12 @@ use crate::{
     ThemeStyles,
 };
 
+/// The metadata for a theme.
 #[derive(Debug, Clone)]
 pub struct ThemeMeta {
+    /// The name of the theme.
     pub name: SharedString,
+    /// The appearance of the theme.
     pub appearance: Appearance,
 }
 
@@ -38,6 +41,7 @@ struct ThemeRegistryState {
     themes: HashMap<SharedString, Arc<Theme>>,
 }
 
+/// The registry for themes.
 pub struct ThemeRegistry {
     state: RwLock<ThemeRegistryState>,
     assets: Box<dyn AssetSource>,
@@ -61,6 +65,7 @@ impl ThemeRegistry {
         cx.set_global(GlobalThemeRegistry(Arc::new(ThemeRegistry::new(assets))));
     }
 
+    /// Creates a new [`ThemeRegistry`] with the given [`AssetSource`].
     pub fn new(assets: Box<dyn AssetSource>) -> Self {
         let registry = Self {
             state: RwLock::new(ThemeRegistryState {
@@ -99,6 +104,7 @@ impl ThemeRegistry {
         }
     }
 
+    /// Inserts user themes into the registry.
     pub fn insert_user_themes(&self, themes: impl IntoIterator<Item = ThemeContent>) {
         self.insert_themes(themes.into_iter().map(|user_theme| {
             let mut theme_colors = match user_theme.appearance {
@@ -185,16 +191,19 @@ impl ThemeRegistry {
             .retain(|name, _| !themes_to_remove.contains(name))
     }
 
+    /// Removes all themes from the registry.
     pub fn clear(&mut self) {
         self.state.write().themes.clear();
     }
 
+    /// Returns the names of all themes in the registry.
     pub fn list_names(&self, _staff: bool) -> Vec<SharedString> {
         let mut names = self.state.read().themes.keys().cloned().collect::<Vec<_>>();
         names.sort();
         names
     }
 
+    /// Returns the metadata of all themes in the registry.
     pub fn list(&self, _staff: bool) -> Vec<ThemeMeta> {
         self.state
             .read()
@@ -207,6 +216,7 @@ impl ThemeRegistry {
             .collect()
     }
 
+    /// Returns the theme with the given name.
     pub fn get(&self, name: &str) -> Result<Arc<Theme>> {
         self.state
             .read()
@@ -261,6 +271,7 @@ impl ThemeRegistry {
         Ok(())
     }
 
+    /// Asynchronously reads the user theme from the specified path.
     pub async fn read_user_theme(theme_path: &Path, fs: Arc<dyn Fs>) -> Result<ThemeFamilyContent> {
         let reader = fs.open_sync(theme_path).await?;
         let theme_family: ThemeFamilyContent = serde_json_lenient::from_reader(reader)?;
diff --git a/crates/theme/src/scale.rs b/crates/theme/src/scale.rs
index 1146090edcc1e7..a70dcb9789a3c8 100644
--- a/crates/theme/src/scale.rs
+++ b/crates/theme/src/scale.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use gpui::{AppContext, Hsla, SharedString};
 
 use crate::{ActiveTheme, Appearance};
diff --git a/crates/theme/src/schema.rs b/crates/theme/src/schema.rs
index 91863061236f24..af334d8aed54b9 100644
--- a/crates/theme/src/schema.rs
+++ b/crates/theme/src/schema.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use anyhow::Result;
 use gpui::{FontStyle, FontWeight, HighlightStyle, Hsla, WindowBackgroundAppearance};
 use indexmap::IndexMap;
diff --git a/crates/theme/src/settings.rs b/crates/theme/src/settings.rs
index 86383cec8ea079..0c8ea782cd6081 100644
--- a/crates/theme/src/settings.rs
+++ b/crates/theme/src/settings.rs
@@ -35,6 +35,9 @@ const MIN_LINE_HEIGHT: f32 = 1.0;
     Deserialize,
     JsonSchema,
 )]
+
+/// Specifies the density of the UI.
+/// Note: This setting is still experimental. See [this tracking issue](https://github.com/zed-industries/zed/issues/18078)
 #[serde(rename_all = "snake_case")]
 pub enum UiDensity {
     /// A denser UI with tighter spacing and smaller elements.
@@ -50,6 +53,8 @@ pub enum UiDensity {
 }
 
 impl UiDensity {
+    /// The spacing ratio of a given density.
+    /// TODO: Standardize usage throughout the app or remove
     pub fn spacing_ratio(self) -> f32 {
         match self {
             UiDensity::Compact => 0.75,
@@ -80,17 +85,43 @@ impl From<UiDensity> for String {
     }
 }
 
+/// Customizable settings for the UI and theme system.
 #[derive(Clone)]
 pub struct ThemeSettings {
+    /// The UI font size. Determines the size of text in the UI,
+    /// as well as the size of a [gpui::Rems] unit.
+    ///
+    /// Changing this will impact the size of all UI elements.
     pub ui_font_size: Pixels,
+    /// The font used for UI elements.
     pub ui_font: Font,
-    pub buffer_font: Font,
+    /// The font size used for buffers, and the terminal.
+    ///
+    /// The terminal font size can be overridden using it's own setting.
     pub buffer_font_size: Pixels,
+    /// The font used for buffers, and the terminal.
+    ///
+    /// The terminal font family can be overridden using it's own setting.
+    pub buffer_font: Font,
+    /// The line height for buffers, and the terminal.
+    ///
+    /// Changing this may affect the spacing of some UI elements.
+    ///
+    /// The terminal font family can be overridden using it's own setting.
     pub buffer_line_height: BufferLineHeight,
+    /// The current theme selection.
+    /// TODO: Document this further
     pub theme_selection: Option<ThemeSelection>,
+    /// The active theme.
     pub active_theme: Arc<Theme>,
+    /// Manual overrides for the active theme.
+    ///
+    /// Note: This setting is still experimental. See [this tracking issue](https://github.com/zed-industries/zed/issues/18078)
     pub theme_overrides: Option<ThemeStyleContent>,
+    /// The density of the UI.
+    /// Note: This setting is still experimental. See [this tracking issue](
     pub ui_density: UiDensity,
+    /// The amount of fading applied to unnecessary code.
     pub unnecessary_code_fade: f32,
 }
 
@@ -181,15 +212,21 @@ pub(crate) struct AdjustedUiFontSize(Pixels);
 
 impl Global for AdjustedUiFontSize {}
 
+/// Represents the selection of a theme, which can be either static or dynamic.
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(untagged)]
 pub enum ThemeSelection {
+    /// A static theme selection, represented by a single theme name.
     Static(#[schemars(schema_with = "theme_name_ref")] String),
+    /// A dynamic theme selection, which can change based the [ThemeMode].
     Dynamic {
+        /// The mode used to determine which theme to use.
         #[serde(default)]
         mode: ThemeMode,
+        /// The theme to use for light mode.
         #[schemars(schema_with = "theme_name_ref")]
         light: String,
+        /// The theme to use for dark mode.
         #[schemars(schema_with = "theme_name_ref")]
         dark: String,
     },
@@ -199,6 +236,12 @@ fn theme_name_ref(_: &mut SchemaGenerator) -> Schema {
     Schema::new_ref("#/definitions/ThemeName".into())
 }
 
+// TODO: Rename ThemeMode -> ThemeAppearanceMode
+/// The mode use to select a theme.
+///
+/// `Light` and `Dark` will select their respective themes.
+///
+/// `System` will select the theme based on the system's appearance.
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Default, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ThemeMode {
@@ -214,6 +257,7 @@ pub enum ThemeMode {
 }
 
 impl ThemeSelection {
+    /// Returns the theme name for the selected [ThemeMode].
     pub fn theme(&self, system_appearance: Appearance) -> &str {
         match self {
             Self::Static(theme) => theme,
@@ -228,6 +272,7 @@ impl ThemeSelection {
         }
     }
 
+    /// Returns the [ThemeMode] for the [ThemeSelection].
     pub fn mode(&self) -> Option<ThemeMode> {
         match self {
             ThemeSelection::Static(_) => None,
@@ -327,6 +372,7 @@ impl ThemeSettingsContent {
         }
     }
 
+    /// Sets the mode for the theme.
     pub fn set_mode(&mut self, mode: ThemeMode) {
         if let Some(selection) = self.theme.as_mut() {
             match selection {
@@ -355,16 +401,23 @@ impl ThemeSettingsContent {
     }
 }
 
+/// The buffer's line height.
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, JsonSchema, Default)]
 #[serde(rename_all = "snake_case")]
 pub enum BufferLineHeight {
+    /// A less dense line height.
     #[default]
     Comfortable,
+    /// The default line height.
     Standard,
+    /// A custom line height.
+    ///
+    /// A line height of 1.0 is the height of the buffer's font size.
     Custom(f32),
 }
 
 impl BufferLineHeight {
+    /// Returns the value of the line height.
     pub fn value(&self) -> f32 {
         match self {
             BufferLineHeight::Comfortable => 1.618,
@@ -375,12 +428,15 @@ impl BufferLineHeight {
 }
 
 impl ThemeSettings {
+    /// Returns the [AdjustedBufferFontSize].
     pub fn buffer_font_size(&self, cx: &AppContext) -> Pixels {
         cx.try_global::<AdjustedBufferFontSize>()
             .map_or(self.buffer_font_size, |size| size.0)
             .max(MIN_FONT_SIZE)
     }
 
+    // TODO: Rename: `line_height` -> `buffer_line_height`
+    /// Returns the buffer's line height.
     pub fn line_height(&self) -> f32 {
         f32::max(self.buffer_line_height.value(), MIN_LINE_HEIGHT)
     }
@@ -433,6 +489,7 @@ impl ThemeSettings {
     }
 }
 
+/// Observe changes to the adjusted buffer font size.
 pub fn observe_buffer_font_size_adjustment<V: 'static>(
     cx: &mut ViewContext<V>,
     f: impl 'static + Fn(&mut V, &mut ViewContext<V>),
@@ -440,6 +497,7 @@ pub fn observe_buffer_font_size_adjustment<V: 'static>(
     cx.observe_global::<AdjustedBufferFontSize>(f)
 }
 
+/// Sets the adjusted buffer font size.
 pub fn adjusted_font_size(size: Pixels, cx: &mut AppContext) -> Pixels {
     if let Some(AdjustedBufferFontSize(adjusted_size)) = cx.try_global::<AdjustedBufferFontSize>() {
         let buffer_font_size = ThemeSettings::get_global(cx).buffer_font_size;
@@ -451,12 +509,14 @@ pub fn adjusted_font_size(size: Pixels, cx: &mut AppContext) -> Pixels {
     .max(MIN_FONT_SIZE)
 }
 
+/// Returns the adjusted buffer font size.
 pub fn get_buffer_font_size(cx: &AppContext) -> Pixels {
     let buffer_font_size = ThemeSettings::get_global(cx).buffer_font_size;
     cx.try_global::<AdjustedBufferFontSize>()
         .map_or(buffer_font_size, |adjusted_size| adjusted_size.0)
 }
 
+/// Adjusts the buffer font size.
 pub fn adjust_buffer_font_size(cx: &mut AppContext, f: fn(&mut Pixels)) {
     let buffer_font_size = ThemeSettings::get_global(cx).buffer_font_size;
     let mut adjusted_size = cx
@@ -469,10 +529,12 @@ pub fn adjust_buffer_font_size(cx: &mut AppContext, f: fn(&mut Pixels)) {
     cx.refresh();
 }
 
+/// Returns whether the buffer font size has been adjusted.
 pub fn has_adjusted_buffer_font_size(cx: &mut AppContext) -> bool {
     cx.has_global::<AdjustedBufferFontSize>()
 }
 
+/// Resets the buffer font size to the default value.
 pub fn reset_buffer_font_size(cx: &mut AppContext) {
     if cx.has_global::<AdjustedBufferFontSize>() {
         cx.remove_global::<AdjustedBufferFontSize>();
@@ -480,6 +542,8 @@ pub fn reset_buffer_font_size(cx: &mut AppContext) {
     }
 }
 
+// TODO: Make private, change usages to use `get_ui_font_size` instead.
+#[allow(missing_docs)]
 pub fn setup_ui_font(cx: &mut WindowContext) -> gpui::Font {
     let (ui_font, ui_font_size) = {
         let theme_settings = ThemeSettings::get_global(cx);
@@ -491,12 +555,14 @@ pub fn setup_ui_font(cx: &mut WindowContext) -> gpui::Font {
     ui_font
 }
 
+/// Gets the adjusted UI font size.
 pub fn get_ui_font_size(cx: &AppContext) -> Pixels {
     let ui_font_size = ThemeSettings::get_global(cx).ui_font_size;
     cx.try_global::<AdjustedUiFontSize>()
         .map_or(ui_font_size, |adjusted_size| adjusted_size.0)
 }
 
+/// Sets the adjusted UI font size.
 pub fn adjust_ui_font_size(cx: &mut AppContext, f: fn(&mut Pixels)) {
     let ui_font_size = ThemeSettings::get_global(cx).ui_font_size;
     let mut adjusted_size = cx
@@ -509,10 +575,12 @@ pub fn adjust_ui_font_size(cx: &mut AppContext, f: fn(&mut Pixels)) {
     cx.refresh();
 }
 
+/// Returns whether the UI font size has been adjusted.
 pub fn has_adjusted_ui_font_size(cx: &mut AppContext) -> bool {
     cx.has_global::<AdjustedUiFontSize>()
 }
 
+/// Resets the UI font size to the default value.
 pub fn reset_ui_font_size(cx: &mut AppContext) {
     if cx.has_global::<AdjustedUiFontSize>() {
         cx.remove_global::<AdjustedUiFontSize>();
diff --git a/crates/theme/src/styles/accents.rs b/crates/theme/src/styles/accents.rs
index dfcd19911b26f6..e4d7f03cf62201 100644
--- a/crates/theme/src/styles/accents.rs
+++ b/crates/theme/src/styles/accents.rs
@@ -20,6 +20,7 @@ impl Default for AccentColors {
 }
 
 impl AccentColors {
+    /// Returns the set of dark accent colors.
     pub fn dark() -> Self {
         Self(vec![
             blue().dark().step_9(),
@@ -38,6 +39,7 @@ impl AccentColors {
         ])
     }
 
+    /// Returns the set of light accent colors.
     pub fn light() -> Self {
         Self(vec![
             blue().light().step_9(),
@@ -58,6 +60,7 @@ impl AccentColors {
 }
 
 impl AccentColors {
+    /// Returns the color for the given index.
     pub fn color_for_index(&self, index: u32) -> Hsla {
         self.0[index as usize % self.0.len()]
     }
diff --git a/crates/theme/src/styles/colors.rs b/crates/theme/src/styles/colors.rs
index 225275f37b6191..881a68334dcf64 100644
--- a/crates/theme/src/styles/colors.rs
+++ b/crates/theme/src/styles/colors.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::{Hsla, WindowBackgroundAppearance};
 use refineable::Refineable;
 use std::sync::Arc;
diff --git a/crates/theme/src/styles/players.rs b/crates/theme/src/styles/players.rs
index e80c7161b15b12..130721033239ce 100644
--- a/crates/theme/src/styles/players.rs
+++ b/crates/theme/src/styles/players.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::Hsla;
 use serde_derive::Deserialize;
 
diff --git a/crates/theme/src/styles/status.rs b/crates/theme/src/styles/status.rs
index 854b876ac20b33..84afae701d0f09 100644
--- a/crates/theme/src/styles/status.rs
+++ b/crates/theme/src/styles/status.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::Hsla;
 use refineable::Refineable;
 
diff --git a/crates/theme/src/styles/stories/color.rs b/crates/theme/src/styles/stories/color.rs
index 90e84bcf0f2ded..8e6c86ba762ba8 100644
--- a/crates/theme/src/styles/stories/color.rs
+++ b/crates/theme/src/styles/stories/color.rs
@@ -4,6 +4,7 @@ use story::Story;
 
 use crate::{default_color_scales, ColorScaleStep};
 
+/// The story showcasing all the default color scales
 pub struct ColorsStory;
 
 impl Render for ColorsStory {
diff --git a/crates/theme/src/styles/stories/players.rs b/crates/theme/src/styles/stories/players.rs
index 2b356670bf66a6..0d50c6edc9afcd 100644
--- a/crates/theme/src/styles/stories/players.rs
+++ b/crates/theme/src/styles/stories/players.rs
@@ -3,6 +3,7 @@ use story::Story;
 
 use crate::{ActiveTheme, PlayerColors};
 
+/// The story showcasing the player colors
 pub struct PlayerStory;
 
 impl Render for PlayerStory {
diff --git a/crates/theme/src/styles/syntax.rs b/crates/theme/src/styles/syntax.rs
index 8016445c16c6af..0a97ff77f23c8e 100644
--- a/crates/theme/src/styles/syntax.rs
+++ b/crates/theme/src/styles/syntax.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use std::sync::Arc;
 
 use gpui::{HighlightStyle, Hsla};
diff --git a/crates/theme/src/styles/system.rs b/crates/theme/src/styles/system.rs
index aeb0865155d68a..54e892b79c49f9 100644
--- a/crates/theme/src/styles/system.rs
+++ b/crates/theme/src/styles/system.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::{hsla, Hsla};
 
 #[derive(Clone)]
diff --git a/crates/theme/src/theme.rs b/crates/theme/src/theme.rs
index af38c9efc6f7ec..a6ca59d734e245 100644
--- a/crates/theme/src/theme.rs
+++ b/crates/theme/src/theme.rs
@@ -1,3 +1,5 @@
+#![deny(missing_docs)]
+
 //! # Theme
 //!
 //! This crate provides the theme system for Zed.
@@ -10,6 +12,9 @@ mod default_colors;
 mod default_theme;
 mod font_family_cache;
 mod one_themes;
+/// A prelude for working with the theme system.
+///
+/// TODO: remove this. This only publishes default colors.
 pub mod prelude;
 mod registry;
 mod scale;
@@ -35,16 +40,22 @@ use gpui::{
 };
 use serde::Deserialize;
 
+/// Defines window border radius for platforms that use client side decorations.
+pub const CLIENT_SIDE_DECORATION_ROUNDING: Pixels = px(10.0);
+/// Defines window shadow size for platforms that use client side decorations.
+pub const CLIENT_SIDE_DECORATION_SHADOW: Pixels = px(10.0);
+
+/// The appearance of the theme.
 #[derive(Debug, PartialEq, Clone, Copy, Deserialize)]
 pub enum Appearance {
+    /// A light appearance.
     Light,
+    /// A dark appearance.
     Dark,
 }
 
-pub const CLIENT_SIDE_DECORATION_ROUNDING: Pixels = px(10.0);
-pub const CLIENT_SIDE_DECORATION_SHADOW: Pixels = px(10.0);
-
 impl Appearance {
+    /// Returns whether the appearance is light.
     pub fn is_light(&self) -> bool {
         match self {
             Self::Light => true,
@@ -62,6 +73,7 @@ impl From<WindowAppearance> for Appearance {
     }
 }
 
+/// Which themes should be loaded. This is used primarlily for testing.
 pub enum LoadThemes {
     /// Only load the base theme.
     ///
@@ -72,6 +84,7 @@ pub enum LoadThemes {
     All(Box<dyn AssetSource>),
 }
 
+/// Initialize the theme system.
 pub fn init(themes_to_load: LoadThemes, cx: &mut AppContext) {
     let (assets, load_user_themes) = match themes_to_load {
         LoadThemes::JustBase => (Box::new(()) as Box<dyn AssetSource>, false),
@@ -97,7 +110,9 @@ pub fn init(themes_to_load: LoadThemes, cx: &mut AppContext) {
     .detach();
 }
 
+/// Implementing this trait allows accessing the active theme.
 pub trait ActiveTheme {
+    /// Returns the active theme.
     fn theme(&self) -> &Arc<Theme>;
 }
 
@@ -107,21 +122,39 @@ impl ActiveTheme for AppContext {
     }
 }
 
+/// A theme family is a grouping of themes under a single name.
+///
+/// For example, the "One" theme family contains the "One Light" and "One Dark" themes.
+///
+/// It can also be used to package themes with many variants.
+///
+/// For example, the "Atelier" theme family contains "Cave", "Dune", "Estuary", "Forest", "Heath", etc.
 pub struct ThemeFamily {
+    /// The unique identifier for the theme family.
     pub id: String,
+    /// The name of the theme family. This will be displayed in the UI, such as when adding or removing a theme family.
     pub name: SharedString,
+    /// The author of the theme family.
     pub author: SharedString,
+    /// The [Theme]s in the family.
     pub themes: Vec<Theme>,
+    /// The color scales used by the themes in the family.
+    /// Note: This will be removed in the future.
     pub scales: ColorScales,
 }
 
 impl ThemeFamily {}
 
+/// A theme is the primary mechanism for defining the appearance of the UI.
 #[derive(Clone)]
 pub struct Theme {
+    /// The unique identifier for the theme.
     pub id: String,
+    /// The name of the theme.
     pub name: SharedString,
+    /// The appearance of the theme (light or dark).
     pub appearance: Appearance,
+    /// The colors and other styles for the theme.
     pub styles: ThemeStyles,
 }
 
@@ -181,6 +214,8 @@ impl Theme {
     }
 }
 
+/// Compounds a color with an alpha value.
+/// TODO: Replace this with a method on Hsla.
 pub fn color_alpha(color: Hsla, alpha: f32) -> Hsla {
     let mut color = color;
     color.a = alpha;

From 29796aa4128f917c8e3056d04f3801b2eac657d6 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 3 Oct 2024 11:14:22 -0400
Subject: [PATCH 462/762] Update Rust crate serde_json to v1.0.128 (#18669)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [serde_json](https://redirect.github.com/serde-rs/json) | dependencies
| patch | `1.0.127` -> `1.0.128` |
| [serde_json](https://redirect.github.com/serde-rs/json) |
workspace.dependencies | patch | `1.0.127` -> `1.0.128` |

---

### Release Notes

<details>
<summary>serde-rs/json (serde_json)</summary>

###
[`v1.0.128`](https://redirect.github.com/serde-rs/json/releases/tag/1.0.128)

[Compare
Source](https://redirect.github.com/serde-rs/json/compare/1.0.127...1.0.128)

- Support serializing maps containing 128-bit integer keys to
serde_json::Value
([#&#8203;1188](https://redirect.github.com/serde-rs/json/issues/1188),
thanks [@&#8203;Mrreadiness](https://redirect.github.com/Mrreadiness))

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about these
updates again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguOTcuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 821bedbec040f8..a94de65bc9896c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10194,9 +10194,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.127"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
+checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
 dependencies = [
  "indexmap 2.4.0",
  "itoa",

From ddcd45bb457215afcd74f3d2bf995c7687604ff1 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 3 Oct 2024 17:27:42 +0200
Subject: [PATCH 463/762] docs: Add tweaks to the outline panel page (#18697)

Thought we could be extra clear here with the meaning of "singleton
buffers".

Release Notes:

- N/A
---
 docs/src/outline-panel.md    | 13 +++++++++----
 docs/theme/css/general.css   |  1 +
 docs/theme/css/variables.css |  4 ++++
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/docs/src/outline-panel.md b/docs/src/outline-panel.md
index 998f310076f01b..bc743596d6bcb1 100644
--- a/docs/src/outline-panel.md
+++ b/docs/src/outline-panel.md
@@ -2,25 +2,30 @@
 
 In addition to the modal outline (`cmd-shift-o`), Zed offers an outline panel. The outline panel can be deployed via `cmd-shift-b` (`outline panel: toggle focus` via the command palette), or by clicking the `Outline Panel` button in the status bar.
 
-When viewing a "singleton" buffer, the outline panel works similarly to that of the outline modal - it displays the outline of the current buffer's symbols, as reported by tree-sitter. Clicking on an entry allows you to jump to the associated section in the file. The outline view will also automatically scroll to the section associated with the current cursor position within the file.
+When viewing a "singleton" buffer (i.e., a single file on a tab), the outline panel works similarly to that of the outline modal－it displays the outline of the current buffer's symbols, as reported by tree-sitter. Clicking on an entry allows you to jump to the associated section in the file. The outline view will also automatically scroll to the section associated with the current cursor position within the file.
 
 ![Using the outline panel in a singleton buffer](https://zed.dev/img/outline-panel/singleton.png)
 
+## Usage with multibuffers
+
 The outline panel truly excels when used with multi-buffers. Here are some examples of its versatility:
 
-1. Project Search Results:
+### Project Search Results
 
 Get an overview of search results across your project.
+
 ![Using the outline panel in a project search multi-buffer](https://zed.dev/img/outline-panel/project-search.png)
 
-2. Project Diagnostics:
+### Project Diagnostics
 
 View a summary of all errors and warnings reported by the language server.
+
 ![Using the outline panel while viewing project diagnostics multi-buffer](https://zed.dev/img/outline-panel/project-diagnostics.png)
 
-3. Find All References:
+### Find All References
 
 Quickly navigate through all references when using the `editor: find all references` action.
+
 ![Using the outline panel while viewing `find all references` multi-buffer](https://zed.dev/img/outline-panel/find-all-references.png)
 
 The outline view provides a great way to quickly navigate to specific parts of your code and helps you maintain context when working with large result sets in multi-buffers.
diff --git a/docs/theme/css/general.css b/docs/theme/css/general.css
index b422890751c508..d1b8e9b92653e7 100644
--- a/docs/theme/css/general.css
+++ b/docs/theme/css/general.css
@@ -182,6 +182,7 @@ h6:target::before {
 .content img,
 .content video {
   max-width: 100%;
+  background-color: var(--media-bg);
   border: 1px solid;
   border-color: var(--border);
   border-radius: 8px;
diff --git a/docs/theme/css/variables.css b/docs/theme/css/variables.css
index a7c0ed7114b405..55ae4a427da269 100644
--- a/docs/theme/css/variables.css
+++ b/docs/theme/css/variables.css
@@ -26,6 +26,8 @@
   --border-light: hsl(220, 13%, 90%);
   --border-hover: hsl(220, 13%, 70%);
 
+  --media-bg: hsl(50, 25%, 92%);
+
   --sidebar-fg: hsl(0, 0%, 0%);
   --sidebar-non-existant: #aaaaaa;
   --sidebar-active: hsl(220, 93%, 42%);
@@ -98,6 +100,8 @@
   --border-light: hsl(220, 13%, 90%);
   --border-hover: hsl(220, 13%, 40%);
 
+  --media-bg: hsl(220, 13%, 8%);
+
   --sidebar-bg: hsl(220, 13%, 10%);
   --sidebar-fg: hsl(220, 14%, 71%);
   --sidebar-non-existant: #505254;

From ded3d3fc14a438f606d5e8b03eaf92310723fce4 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 3 Oct 2024 11:29:29 -0400
Subject: [PATCH 464/762] Update Python to v3.12.7 (#18652)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [python](https://redirect.github.com/containerbase/python-prebuild) |
dependencies | patch | `3.12.6` -> `3.12.7` |

---

### Release Notes

<details>
<summary>containerbase/python-prebuild (python)</summary>

###
[`v3.12.7`](https://redirect.github.com/containerbase/python-prebuild/releases/tag/3.12.7)

[Compare
Source](https://redirect.github.com/containerbase/python-prebuild/compare/3.12.6...3.12.7)

##### Bug Fixes

-   **deps:** update dependency python to v3.12.7

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguOTcuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 script/update_top_ranking_issues/poetry.lock    | 4 ++--
 script/update_top_ranking_issues/pyproject.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/script/update_top_ranking_issues/poetry.lock b/script/update_top_ranking_issues/poetry.lock
index a85844e645f100..c151c8bc1ddd74 100644
--- a/script/update_top_ranking_issues/poetry.lock
+++ b/script/update_top_ranking_issues/poetry.lock
@@ -529,5 +529,5 @@ files = [
 
 [metadata]
 lock-version = "2.0"
-python-versions = "3.12.6"
-content-hash = "7827704e06a8c195297507e0d05e7a7c3843ed299bd353f31570ee4c435c6896"
+python-versions = "3.12.7"
+content-hash = "809bd421af8a34dd500ba704d954ae8e1f6edf15b6af74a0d3fda987b69c8cbe"
diff --git a/script/update_top_ranking_issues/pyproject.toml b/script/update_top_ranking_issues/pyproject.toml
index 15d8346bb99103..cd5cd2cc2ed270 100644
--- a/script/update_top_ranking_issues/pyproject.toml
+++ b/script/update_top_ranking_issues/pyproject.toml
@@ -8,7 +8,7 @@ readme = "README.md"
 [tool.poetry.dependencies]
 mypy = "1.6.0"
 PyGithub = "1.55"
-python = "3.12.6"
+python = "3.12.7"
 pytz = "2022.1"
 typer = "0.9.0"
 types-pytz = "2023.3.1.1"

From f7b3680e4dbd664dc72344f67b957907260bc2d7 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 3 Oct 2024 11:32:04 -0400
Subject: [PATCH 465/762] Update Rust crate pretty_assertions to v1.4.1
 (#18668)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
|
[pretty_assertions](https://redirect.github.com/rust-pretty-assertions/rust-pretty-assertions)
| workspace.dependencies | patch | `1.4.0` -> `1.4.1` |

---

### Release Notes

<details>
<summary>rust-pretty-assertions/rust-pretty-assertions
(pretty_assertions)</summary>

###
[`v1.4.1`](https://redirect.github.com/rust-pretty-assertions/rust-pretty-assertions/blob/HEAD/CHANGELOG.md#v141)

[Compare
Source](https://redirect.github.com/rust-pretty-assertions/rust-pretty-assertions/compare/v1.4.0...v1.4.1)

#### Fixed

- Show feature-flagged code in documentation. Thanks to
[@&#8203;sandydoo](https://redirect.github.com/sandydoo) for the fix!
([#&#8203;130](https://redirect.github.com/rust-pretty-assertions/rust-pretty-assertions/pull/130))

#### Internal

- Bump `yansi` version to `1.x`. Thanks to
[@&#8203;SergioBenitez](https://redirect.github.com/SergioBenitez) for
the update, and maintaining this library!
([#&#8203;121](https://redirect.github.com/rust-pretty-assertions/rust-pretty-assertions/pull/121))

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguOTcuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a94de65bc9896c..16597cd5d2f12e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8370,9 +8370,9 @@ dependencies = [
 
 [[package]]
 name = "pretty_assertions"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
+checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d"
 dependencies = [
  "diff",
  "yansi",
@@ -14527,9 +14527,9 @@ dependencies = [
 
 [[package]]
 name = "yansi"
-version = "0.5.1"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
 
 [[package]]
 name = "yazi"

From a9f816d5fb143380a8c3876e7a31e2c10826bb45 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 3 Oct 2024 12:38:51 -0400
Subject: [PATCH 466/762] telemetry_events: Update crate-level docs (#18703)

This PR updates the `telemetry_events` crate to use module-level
documentation for its crate-level docs.

Release Notes:

- N/A
---
 crates/telemetry_events/src/telemetry_events.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/telemetry_events/src/telemetry_events.rs b/crates/telemetry_events/src/telemetry_events.rs
index d6e737b929e1f5..f7b18523df17eb 100644
--- a/crates/telemetry_events/src/telemetry_events.rs
+++ b/crates/telemetry_events/src/telemetry_events.rs
@@ -1,4 +1,5 @@
-/// Please see: [Telemetry in Zed](https://zed.dev/docs/telemetry) for additional documentation.
+//! See [Telemetry in Zed](https://zed.dev/docs/telemetry) for additional information.
+
 use semantic_version::SemanticVersion;
 use serde::{Deserialize, Serialize};
 use std::{fmt::Display, sync::Arc, time::Duration};

From 8c95b8d89a9c7eb1a21fb88565806f2d780e45f8 Mon Sep 17 00:00:00 2001
From: Nate Butler <iamnbutler@gmail.com>
Date: Thu, 3 Oct 2024 13:17:31 -0400
Subject: [PATCH 467/762] `theme` crate spring cleaning (#18695)

This PR does some spring cleaning on the `theme` crate:

- Removed two unused stories and the story dep
- Removed the `one` theme family (from the `theme` crate, not the app),
this is now `zed_default_themes`.
- This will hopefully remove some confusion caused by this theme we
started in rust but didn't end up using
- Removed `theme::prelude` (it just re-exported scale colors, which we
don't use outside `theme`)
- Removed completely unused `zed_pro` themes (we started on these during
the gpui2 port and didn't finish them.)

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 Cargo.lock                                    |   1 -
 crates/theme/Cargo.toml                       |   2 -
 crates/theme/src/default_theme.rs             |  71 ---------
 .../src/{one_themes.rs => fallback_themes.rs} |  18 +--
 crates/theme/src/prelude.rs                   |   6 -
 crates/theme/src/registry.rs                  |   9 +-
 crates/theme/src/settings.rs                  |   4 +-
 crates/theme/src/styles.rs                    |   6 -
 crates/theme/src/styles/stories/color.rs      |  40 -----
 crates/theme/src/styles/stories/mod.rs        |   5 -
 crates/theme/src/styles/stories/players.rs    | 143 ------------------
 crates/theme/src/theme.rs                     |   8 +-
 crates/theme/theme.md                         |  15 --
 crates/theme/util/hex_to_hsla.py              |  35 -----
 14 files changed, 15 insertions(+), 348 deletions(-)
 delete mode 100644 crates/theme/src/default_theme.rs
 rename crates/theme/src/{one_themes.rs => fallback_themes.rs} (96%)
 delete mode 100644 crates/theme/src/prelude.rs
 delete mode 100644 crates/theme/src/styles/stories/color.rs
 delete mode 100644 crates/theme/src/styles/stories/mod.rs
 delete mode 100644 crates/theme/src/styles/stories/players.rs
 delete mode 100644 crates/theme/theme.md
 delete mode 100644 crates/theme/util/hex_to_hsla.py

diff --git a/Cargo.lock b/Cargo.lock
index 16597cd5d2f12e..0a14f04f892b68 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11655,7 +11655,6 @@ dependencies = [
  "serde_json_lenient",
  "serde_repr",
  "settings",
- "story",
  "util",
  "uuid",
 ]
diff --git a/crates/theme/Cargo.toml b/crates/theme/Cargo.toml
index 934faa1186286b..b751bea727c754 100644
--- a/crates/theme/Cargo.toml
+++ b/crates/theme/Cargo.toml
@@ -10,7 +10,6 @@ workspace = true
 
 [features]
 default = []
-stories = ["dep:story"]
 test-support = ["gpui/test-support", "fs/test-support", "settings/test-support"]
 
 [lib]
@@ -36,7 +35,6 @@ serde_json.workspace = true
 serde_json_lenient.workspace = true
 serde_repr.workspace = true
 settings.workspace = true
-story = { workspace = true, optional = true }
 util.workspace = true
 uuid.workspace = true
 
diff --git a/crates/theme/src/default_theme.rs b/crates/theme/src/default_theme.rs
deleted file mode 100644
index 58063409165330..00000000000000
--- a/crates/theme/src/default_theme.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-use std::sync::Arc;
-
-use gpui::WindowBackgroundAppearance;
-
-use crate::AccentColors;
-
-use crate::{
-    default_color_scales,
-    one_themes::{one_dark, one_family},
-    Appearance, PlayerColors, StatusColors, SyntaxTheme, SystemColors, Theme, ThemeColors,
-    ThemeFamily, ThemeStyles,
-};
-
-fn zed_pro_daylight() -> Theme {
-    Theme {
-        id: "zed_pro_daylight".to_string(),
-        name: "Zed Pro Daylight".into(),
-        appearance: Appearance::Light,
-        styles: ThemeStyles {
-            window_background_appearance: WindowBackgroundAppearance::Opaque,
-            system: SystemColors::default(),
-            colors: ThemeColors::light(),
-            status: StatusColors::light(),
-            player: PlayerColors::light(),
-            syntax: Arc::new(SyntaxTheme::default()),
-            accents: AccentColors::light(),
-        },
-    }
-}
-
-pub(crate) fn zed_pro_moonlight() -> Theme {
-    Theme {
-        id: "zed_pro_moonlight".to_string(),
-        name: "Zed Pro Moonlight".into(),
-        appearance: Appearance::Dark,
-        styles: ThemeStyles {
-            window_background_appearance: WindowBackgroundAppearance::Opaque,
-            system: SystemColors::default(),
-            colors: ThemeColors::dark(),
-            status: StatusColors::dark(),
-            player: PlayerColors::dark(),
-            syntax: Arc::new(SyntaxTheme::default()),
-            accents: AccentColors::dark(),
-        },
-    }
-}
-
-/// Returns the Zed Pro theme family.
-///
-/// Note: To be removed until the theme is implemented.
-pub fn zed_pro_family() -> ThemeFamily {
-    ThemeFamily {
-        id: "zed_pro".to_string(),
-        name: "Zed Pro".into(),
-        author: "Zed Team".into(),
-        themes: vec![zed_pro_daylight(), zed_pro_moonlight()],
-        scales: default_color_scales(),
-    }
-}
-
-impl Default for ThemeFamily {
-    fn default() -> Self {
-        one_family()
-    }
-}
-
-impl Default for Theme {
-    fn default() -> Self {
-        one_dark()
-    }
-}
diff --git a/crates/theme/src/one_themes.rs b/crates/theme/src/fallback_themes.rs
similarity index 96%
rename from crates/theme/src/one_themes.rs
rename to crates/theme/src/fallback_themes.rs
index 50a4184e8bc934..553c75623381d6 100644
--- a/crates/theme/src/one_themes.rs
+++ b/crates/theme/src/fallback_themes.rs
@@ -7,21 +7,21 @@ use crate::{
     SystemColors, Theme, ThemeColors, ThemeFamily, ThemeStyles,
 };
 
-// Note: This theme family is not the one you see in Zed at the moment.
-// This is a from-scratch rebuild that Nate started work on. We currently
-// only use this in the tests, and the One family from the `themes/` directory
-// is what gets loaded into Zed when running it.
-pub fn one_family() -> ThemeFamily {
+/// The default theme family for Zed.
+///
+/// This is used to construct the default theme fallback values, as well as to
+/// have a theme available at compile time for tests.
+pub fn zed_default_themes() -> ThemeFamily {
     ThemeFamily {
-        id: "one".to_string(),
-        name: "One".into(),
+        id: "zed-default".to_string(),
+        name: "Zed Default".into(),
         author: "".into(),
-        themes: vec![one_dark()],
+        themes: vec![zed_default_dark()],
         scales: default_color_scales(),
     }
 }
 
-pub(crate) fn one_dark() -> Theme {
+pub(crate) fn zed_default_dark() -> Theme {
     let bg = hsla(215. / 360., 12. / 100., 15. / 100., 1.);
     let editor = hsla(220. / 360., 12. / 100., 18. / 100., 1.);
     let elevated_surface = hsla(225. / 360., 12. / 100., 17. / 100., 1.);
diff --git a/crates/theme/src/prelude.rs b/crates/theme/src/prelude.rs
deleted file mode 100644
index e8e2378249fd4a..00000000000000
--- a/crates/theme/src/prelude.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#[allow(unused)]
-pub(crate) use crate::default_colors::{
-    amber, black, blue, bronze, brown, crimson, cyan, gold, grass, gray, green, indigo, iris, jade,
-    lime, mauve, mint, olive, orange, pink, plum, purple, red, ruby, sage, sand, sky, slate, teal,
-    tomato, violet, white, yellow,
-};
diff --git a/crates/theme/src/registry.rs b/crates/theme/src/registry.rs
index a77ab141a6547b..771511973f5743 100644
--- a/crates/theme/src/registry.rs
+++ b/crates/theme/src/registry.rs
@@ -74,12 +74,9 @@ impl ThemeRegistry {
             assets,
         };
 
-        // We're loading our new versions of the One themes by default, as
-        // we need them to be loaded for tests.
-        //
-        // These themes will get overwritten when `load_user_themes` is called
-        // when Zed starts, so the One variants used will be the ones ported from Zed1.
-        registry.insert_theme_families([crate::one_themes::one_family()]);
+        // We're loading the Zed default theme, as we need a theme to be loaded
+        // for tests.
+        registry.insert_theme_families([crate::fallback_themes::zed_default_themes()]);
 
         registry
     }
diff --git a/crates/theme/src/settings.rs b/crates/theme/src/settings.rs
index 0c8ea782cd6081..d126ec058c2c62 100644
--- a/crates/theme/src/settings.rs
+++ b/crates/theme/src/settings.rs
@@ -1,4 +1,4 @@
-use crate::one_themes::one_dark;
+use crate::fallback_themes::zed_default_dark;
 use crate::{Appearance, SyntaxTheme, Theme, ThemeRegistry, ThemeStyleContent};
 use anyhow::Result;
 use derive_more::{Deref, DerefMut};
@@ -629,7 +629,7 @@ impl settings::Settings for ThemeSettings {
             theme_selection: defaults.theme.clone(),
             active_theme: themes
                 .get(defaults.theme.as_ref().unwrap().theme(*system_appearance))
-                .or(themes.get(&one_dark().name))
+                .or(themes.get(&zed_default_dark().name))
                 .unwrap(),
             theme_overrides: None,
             ui_density: defaults.ui_density.unwrap_or(UiDensity::Default),
diff --git a/crates/theme/src/styles.rs b/crates/theme/src/styles.rs
index 137603113aadcb..da22f8de1f5f1b 100644
--- a/crates/theme/src/styles.rs
+++ b/crates/theme/src/styles.rs
@@ -5,15 +5,9 @@ mod status;
 mod syntax;
 mod system;
 
-#[cfg(feature = "stories")]
-mod stories;
-
 pub use accents::*;
 pub use colors::*;
 pub use players::*;
 pub use status::*;
 pub use syntax::*;
 pub use system::*;
-
-#[cfg(feature = "stories")]
-pub use stories::*;
diff --git a/crates/theme/src/styles/stories/color.rs b/crates/theme/src/styles/stories/color.rs
deleted file mode 100644
index 8e6c86ba762ba8..00000000000000
--- a/crates/theme/src/styles/stories/color.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use gpui::prelude::*;
-use gpui::{div, px, ViewContext};
-use story::Story;
-
-use crate::{default_color_scales, ColorScaleStep};
-
-/// The story showcasing all the default color scales
-pub struct ColorsStory;
-
-impl Render for ColorsStory {
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
-        let color_scales = default_color_scales();
-
-        Story::container().child(Story::title("Colors")).child(
-            div()
-                .id("colors")
-                .flex()
-                .flex_col()
-                .gap_1()
-                .overflow_y_scroll()
-                .text_color(gpui::white())
-                .children(color_scales.into_iter().map(|scale| {
-                    div()
-                        .flex()
-                        .child(
-                            div()
-                                .w(px(75.))
-                                .line_height(px(24.))
-                                .child(scale.name().clone()),
-                        )
-                        .child(
-                            div().flex().gap_1().children(
-                                ColorScaleStep::ALL
-                                    .map(|step| div().flex().size_6().bg(scale.step(cx, step))),
-                            ),
-                        )
-                })),
-        )
-    }
-}
diff --git a/crates/theme/src/styles/stories/mod.rs b/crates/theme/src/styles/stories/mod.rs
deleted file mode 100644
index af6af965484adc..00000000000000
--- a/crates/theme/src/styles/stories/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-mod color;
-mod players;
-
-pub use color::*;
-pub use players::*;
diff --git a/crates/theme/src/styles/stories/players.rs b/crates/theme/src/styles/stories/players.rs
deleted file mode 100644
index 0d50c6edc9afcd..00000000000000
--- a/crates/theme/src/styles/stories/players.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-use gpui::{div, img, px, IntoElement, ParentElement, Render, Styled, ViewContext};
-use story::Story;
-
-use crate::{ActiveTheme, PlayerColors};
-
-/// The story showcasing the player colors
-pub struct PlayerStory;
-
-impl Render for PlayerStory {
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
-        Story::container().child(
-            div()
-                .flex()
-                .flex_col()
-                .gap_4()
-                .child(Story::title_for::<PlayerColors>())
-                .child(Story::label("Player Colors"))
-                .child(
-                    div()
-                        .flex()
-                        .flex_col()
-                        .gap_1()
-                        .child(
-                            div().flex().gap_1().children(
-                                cx.theme()
-                                    .players()
-                                    .0
-                                    .clone()
-                                    .iter_mut()
-                                    .map(|player| div().w_8().h_8().rounded_md().bg(player.cursor)),
-                            ),
-                        )
-                        .child(
-                            div().flex().gap_1().children(
-                                cx.theme().players().0.clone().iter_mut().map(|player| {
-                                    div().w_8().h_8().rounded_md().bg(player.background)
-                                }),
-                            ),
-                        )
-                        .child(
-                            div().flex().gap_1().children(
-                                cx.theme().players().0.clone().iter_mut().map(|player| {
-                                    div().w_8().h_8().rounded_md().bg(player.selection)
-                                }),
-                            ),
-                        ),
-                )
-                .child(Story::label("Avatar Rings"))
-                .child(div().flex().gap_1().children(
-                    cx.theme().players().0.clone().iter_mut().map(|player| {
-                        div()
-                            .my_1()
-                            .rounded_full()
-                            .border_2()
-                            .border_color(player.cursor)
-                            .child(
-                                img("https://avatars.githubusercontent.com/u/1714999?v=4")
-                                    .rounded_full()
-                                    .size_6()
-                                    .bg(gpui::red()),
-                            )
-                    }),
-                ))
-                .child(Story::label("Player Backgrounds"))
-                .child(div().flex().gap_1().children(
-                    cx.theme().players().0.clone().iter_mut().map(|player| {
-                        div()
-                            .my_1()
-                            .rounded_xl()
-                            .flex()
-                            .items_center()
-                            .h_8()
-                            .py_0p5()
-                            .px_1p5()
-                            .bg(player.background)
-                            .child(
-                                div()
-                                    .relative()
-                                    .mx_neg_1()
-                                    .rounded_full()
-                                    .border_2()
-                                    .border_color(player.background)
-                                    .size(px(28.))
-                                    .child(
-                                        img("https://avatars.githubusercontent.com/u/1714999?v=4")
-                                            .rounded_full()
-                                            .size(px(24.))
-                                            .bg(gpui::red()),
-                                    ),
-                            )
-                            .child(
-                                div()
-                                    .relative()
-                                    .mx_neg_1()
-                                    .rounded_full()
-                                    .border_2()
-                                    .border_color(player.background)
-                                    .size(px(28.))
-                                    .child(
-                                        img("https://avatars.githubusercontent.com/u/1714999?v=4")
-                                            .rounded_full()
-                                            .size(px(24.))
-                                            .bg(gpui::red()),
-                                    ),
-                            )
-                            .child(
-                                div()
-                                    .relative()
-                                    .mx_neg_1()
-                                    .rounded_full()
-                                    .border_2()
-                                    .border_color(player.background)
-                                    .size(px(28.))
-                                    .child(
-                                        img("https://avatars.githubusercontent.com/u/1714999?v=4")
-                                            .rounded_full()
-                                            .size(px(24.))
-                                            .bg(gpui::red()),
-                                    ),
-                            )
-                    }),
-                ))
-                .child(Story::label("Player Selections"))
-                .child(div().flex().flex_col().gap_px().children(
-                    cx.theme().players().0.clone().iter_mut().map(|player| {
-                        div()
-                            .flex()
-                            .child(
-                                div()
-                                    .flex()
-                                    .flex_none()
-                                    .rounded_sm()
-                                    .px_0p5()
-                                    .text_color(cx.theme().colors().text)
-                                    .bg(player.selection)
-                                    .child("The brown fox jumped over the lazy dog."),
-                            )
-                            .child(div().flex_1())
-                    }),
-                )),
-        )
-    }
-}
diff --git a/crates/theme/src/theme.rs b/crates/theme/src/theme.rs
index a6ca59d734e245..d4436e53295278 100644
--- a/crates/theme/src/theme.rs
+++ b/crates/theme/src/theme.rs
@@ -9,13 +9,8 @@
 //! A theme is a collection of colors used to build a consistent appearance for UI components across the application.
 
 mod default_colors;
-mod default_theme;
+mod fallback_themes;
 mod font_family_cache;
-mod one_themes;
-/// A prelude for working with the theme system.
-///
-/// TODO: remove this. This only publishes default colors.
-pub mod prelude;
 mod registry;
 mod scale;
 mod schema;
@@ -26,7 +21,6 @@ use std::sync::Arc;
 
 use ::settings::{Settings, SettingsStore};
 pub use default_colors::*;
-pub use default_theme::*;
 pub use font_family_cache::*;
 pub use registry::*;
 pub use scale::*;
diff --git a/crates/theme/theme.md b/crates/theme/theme.md
deleted file mode 100644
index 4cb19eb3c4ebef..00000000000000
--- a/crates/theme/theme.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# Theme
-
-This crate provides the theme system for Zed.
-
-## Overview
-
-A theme is a collection of colors used to build a consistent appearance for UI components across the application.
-To produce a theme in Zed,
-
-A theme is made of two parts: A [ThemeFamily] and one or more [Theme]s.
-
-//
-A [ThemeFamily] contains metadata like theme name, author, and theme-specific [ColorScales] as well as a series of themes.
-
-- [ThemeColors] - A set of colors that are used to style the UI. Refer to the [ThemeColors] documentation for more information.
diff --git a/crates/theme/util/hex_to_hsla.py b/crates/theme/util/hex_to_hsla.py
deleted file mode 100644
index 17faa186d8c6e6..00000000000000
--- a/crates/theme/util/hex_to_hsla.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import colorsys
-import sys
-
-def hex_to_rgb(hex):
-    hex = hex.lstrip('#')
-    if len(hex) == 8: # 8 digit hex color
-        r, g, b, a = (int(hex[i:i+2], 16) for i in (0, 2, 4, 6))
-        return r, g, b, a / 255.0
-    else: # 6 digit hex color
-        return tuple(int(hex[i:i+2], 16) for i in (0, 2, 4)) + (1.0,)
-
-def rgb_to_hsla(rgb):
-    h, l, s = colorsys.rgb_to_hls(rgb[0]/255.0, rgb[1]/255.0, rgb[2]/255.0)
-    a = rgb[3] # alpha value
-    return (round(h * 360, 1), round(s * 100, 1), round(l * 100, 1), round(a, 3))
-
-def hex_to_hsla(hex):
-    return rgb_to_hsla(hex_to_rgb(hex))
-
-if len(sys.argv) != 2:
-    print("Usage: python util/hex_to_hsla.py <6 or 8 digit hex color or comma-separated list of colors>")
-else:
-    input_arg = sys.argv[1]
-    if ',' in input_arg: # comma-separated list of colors
-        hex_colors = input_arg.split(',')
-        hslas = [] # output array
-        for hex_color in hex_colors:
-            hex_color = hex_color.strip("'\" ")
-            h, s, l, a = hex_to_hsla(hex_color)
-            hslas.append(f"hsla({h} / 360., {s} / 100., {l} / 100., {a})")
-        print(hslas)
-    else: # single color
-        hex_color = input_arg.strip("'\"")
-        h, s, l, a = hex_to_hsla(hex_color)
-        print(f"hsla({h} / 360., {s} / 100., {l} / 100., {a})")

From cddd7875a42cb017b2751e5b6639ba322f6629df Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 3 Oct 2024 13:37:43 -0400
Subject: [PATCH 468/762] Extract Protocol Buffers support into an extension
 (#18704)

This PR extracts the Protocol Buffers support into an extension.

Release Notes:

- Removed built-in support for Protocol Buffers, in favor of making it
available as an extension. The Protocol Buffers extension will be
suggested for download when you open a `.proto` file.
---
 Cargo.lock                                            | 10 ----------
 Cargo.toml                                            |  1 -
 crates/extensions_ui/src/extension_suggest.rs         |  1 +
 crates/languages/Cargo.toml                           |  2 --
 crates/languages/src/lib.rs                           |  4 +---
 extensions/proto/extension.toml                       | 11 +++++++++++
 .../proto/languages}/proto/config.toml                |  0
 .../proto/languages}/proto/highlights.scm             |  0
 .../proto/languages}/proto/outline.scm                |  0
 9 files changed, 13 insertions(+), 16 deletions(-)
 create mode 100644 extensions/proto/extension.toml
 rename {crates/languages/src => extensions/proto/languages}/proto/config.toml (100%)
 rename {crates/languages/src => extensions/proto/languages}/proto/highlights.scm (100%)
 rename {crates/languages/src => extensions/proto/languages}/proto/outline.scm (100%)

diff --git a/Cargo.lock b/Cargo.lock
index 0a14f04f892b68..12b38967cc3fbf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6386,7 +6386,6 @@ dependencies = [
  "node_runtime",
  "paths",
  "project",
- "protols-tree-sitter-proto",
  "regex",
  "rope",
  "rust-embed",
@@ -8644,15 +8643,6 @@ version = "2.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94"
 
-[[package]]
-name = "protols-tree-sitter-proto"
-version = "0.2.0"
-source = "git+https://github.com/zed-industries/tree-sitter-proto?rev=0848bd30a64be48772e15fbb9d5ba8c0cc5772ad#0848bd30a64be48772e15fbb9d5ba8c0cc5772ad"
-dependencies = [
- "cc",
- "tree-sitter-language",
-]
-
 [[package]]
 name = "psm"
 version = "0.1.21"
diff --git a/Cargo.toml b/Cargo.toml
index 8feb93a57856a2..a23663f5c818f8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -388,7 +388,6 @@ profiling = "1"
 prost = "0.9"
 prost-build = "0.9"
 prost-types = "0.9"
-protols-tree-sitter-proto = { git = "https://github.com/zed-industries/tree-sitter-proto", rev = "0848bd30a64be48772e15fbb9d5ba8c0cc5772ad" }
 pulldown-cmark = { version = "0.12.0", default-features = false }
 rand = "0.8.5"
 regex = "1.5"
diff --git a/crates/extensions_ui/src/extension_suggest.rs b/crates/extensions_ui/src/extension_suggest.rs
index 89f51fdebcfee9..ed003f25b7f235 100644
--- a/crates/extensions_ui/src/extension_suggest.rs
+++ b/crates/extensions_ui/src/extension_suggest.rs
@@ -54,6 +54,7 @@ const SUGGESTIONS_BY_EXTENSION_ID: &[(&str, &[&str])] = &[
     ("ocaml", &["ml", "mli"]),
     ("php", &["php"]),
     ("prisma", &["prisma"]),
+    ("proto", &["proto"]),
     ("purescript", &["purs"]),
     ("r", &["r", "R"]),
     ("racket", &["rkt"]),
diff --git a/crates/languages/Cargo.toml b/crates/languages/Cargo.toml
index 19842efac20cf7..dc7868ea86dda4 100644
--- a/crates/languages/Cargo.toml
+++ b/crates/languages/Cargo.toml
@@ -21,7 +21,6 @@ load-grammars = [
     "tree-sitter-jsdoc",
     "tree-sitter-json",
     "tree-sitter-md",
-    "protols-tree-sitter-proto",
     "tree-sitter-python",
     "tree-sitter-regex",
     "tree-sitter-rust",
@@ -46,7 +45,6 @@ lsp.workspace = true
 node_runtime.workspace = true
 paths.workspace = true
 project.workspace = true
-protols-tree-sitter-proto = { workspace = true, optional = true }
 regex.workspace = true
 rope.workspace = true
 rust-embed.workspace = true
diff --git a/crates/languages/src/lib.rs b/crates/languages/src/lib.rs
index 295df6e419b7ec..374b32c0ac3494 100644
--- a/crates/languages/src/lib.rs
+++ b/crates/languages/src/lib.rs
@@ -45,7 +45,6 @@ pub fn init(languages: Arc<LanguageRegistry>, node_runtime: NodeRuntime, cx: &mu
         ("jsonc", tree_sitter_json::LANGUAGE),
         ("markdown", tree_sitter_md::LANGUAGE),
         ("markdown-inline", tree_sitter_md::INLINE_LANGUAGE),
-        ("proto", protols_tree_sitter_proto::LANGUAGE),
         ("python", tree_sitter_python::LANGUAGE),
         ("regex", tree_sitter_regex::LANGUAGE),
         ("rust", tree_sitter_rust::LANGUAGE),
@@ -183,7 +182,6 @@ pub fn init(languages: Arc<LanguageRegistry>, node_runtime: NodeRuntime, cx: &mu
         "yaml",
         vec![Arc::new(yaml::YamlLspAdapter::new(node_runtime.clone()))]
     );
-    language!("proto");
 
     // Register globally available language servers.
     //
@@ -277,7 +275,7 @@ pub fn language(name: &str, grammar: tree_sitter::Language) -> Arc<Language> {
 fn load_config(name: &str) -> LanguageConfig {
     let config_toml = String::from_utf8(
         LanguageDir::get(&format!("{}/config.toml", name))
-            .unwrap()
+            .unwrap_or_else(|| panic!("missing config for language {:?}", name))
             .data
             .to_vec(),
     )
diff --git a/extensions/proto/extension.toml b/extensions/proto/extension.toml
new file mode 100644
index 00000000000000..a49ba7a4c4a7ec
--- /dev/null
+++ b/extensions/proto/extension.toml
@@ -0,0 +1,11 @@
+id = "proto"
+name = "Proto"
+description = "Protocol Buffers support."
+version = "0.1.0"
+schema_version = 1
+authors = ["Zed Industries <support@zed.dev>"]
+repository = "https://github.com/zed-industries/zed"
+
+[grammars.proto]
+repository = "https://github.com/zed-industries/tree-sitter-proto"
+commit = "0848bd30a64be48772e15fbb9d5ba8c0cc5772ad"
diff --git a/crates/languages/src/proto/config.toml b/extensions/proto/languages/proto/config.toml
similarity index 100%
rename from crates/languages/src/proto/config.toml
rename to extensions/proto/languages/proto/config.toml
diff --git a/crates/languages/src/proto/highlights.scm b/extensions/proto/languages/proto/highlights.scm
similarity index 100%
rename from crates/languages/src/proto/highlights.scm
rename to extensions/proto/languages/proto/highlights.scm
diff --git a/crates/languages/src/proto/outline.scm b/extensions/proto/languages/proto/outline.scm
similarity index 100%
rename from crates/languages/src/proto/outline.scm
rename to extensions/proto/languages/proto/outline.scm

From cac98b7bbff89e6b0c7f632940ce55597fa1c55c Mon Sep 17 00:00:00 2001
From: Jordan Pittman <jordan@cryptica.me>
Date: Thu, 3 Oct 2024 14:38:17 -0400
Subject: [PATCH 469/762] Show color swatches for LSP completions (#18665)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes #11991

Release Notes:

- Added support for color swatches for language server completions.

<img width="502" alt="Screenshot 2024-10-02 at 19 02 22"
src="https://github.com/user-attachments/assets/57e85492-3760-461a-9b17-a846dc40576b">

<img width="534" alt="Screenshot 2024-10-02 at 19 02 48"
src="https://github.com/user-attachments/assets/713ac41c-16f0-4ad3-9103-d2c9b3fa8b2e">

This implementation is mostly a port of the VSCode version of the
ColorExtractor. It seems reasonable the we should support _at least_
what VSCode does for detecting color swatches from LSP completions.

This implementation could definitely be better perf-wise by writing a
dedicated color parser. I also think it would be neat if, in the future,
Zed handled _more_ color formats — especially wide-gamut colors.

There are a few differences to the regexes in the VSCode implementation
but mainly so simplify the implementation :
- The hex vs rgb/hsl regexes were split into two parts
- The rgb/hsl regexes allow 3 or 4 color components whether hsla/rgba or
not and the parsing implementation accepts/rejects colors as needed

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 crates/editor/src/editor.rs           |   5 +
 crates/project/src/color_extractor.rs | 297 ++++++++++++++++++++++++++
 crates/project/src/project.rs         |  17 +-
 typos.toml                            |   4 +-
 4 files changed, 320 insertions(+), 3 deletions(-)
 create mode 100644 crates/project/src/color_extractor.rs

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 525a94f2582ab1..e2355461046e36 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -1228,6 +1228,10 @@ impl CompletionsMenu {
                                 None
                             };
 
+                        let color_swatch = completion
+                            .color()
+                            .map(|color| div().size_4().bg(color).rounded(px(2.)));
+
                         div().min_w(px(220.)).max_w(px(540.)).child(
                             ListItem::new(mat.candidate_id)
                                 .inset(true)
@@ -1243,6 +1247,7 @@ impl CompletionsMenu {
                                         task.detach_and_log_err(cx)
                                     }
                                 }))
+                                .start_slot::<Div>(color_swatch)
                                 .child(h_flex().overflow_hidden().child(completion_label))
                                 .end_slot::<Label>(documentation_label),
                         )
diff --git a/crates/project/src/color_extractor.rs b/crates/project/src/color_extractor.rs
new file mode 100644
index 00000000000000..f44246da4c10da
--- /dev/null
+++ b/crates/project/src/color_extractor.rs
@@ -0,0 +1,297 @@
+use std::sync::LazyLock;
+
+use gpui::{Hsla, Rgba};
+use lsp::{CompletionItem, Documentation};
+use regex::{Regex, RegexBuilder};
+
+const HEX: &'static str = r#"(#(?:[\da-fA-F]{3}){1,2})"#;
+const RGB_OR_HSL: &'static str = r#"(rgba?|hsla?)\(\s*(\d{1,3}%?)\s*,\s*(\d{1,3}%?)\s*,\s*(\d{1,3}%?)\s*(?:,\s*(1|0?\.\d+))?\s*\)"#;
+
+static RELAXED_HEX_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    RegexBuilder::new(HEX)
+        .case_insensitive(false)
+        .build()
+        .expect("Failed to create RELAXED_HEX_REGEX")
+});
+
+static STRICT_HEX_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    RegexBuilder::new(&format!("^{HEX}$"))
+        .case_insensitive(true)
+        .build()
+        .expect("Failed to create STRICT_HEX_REGEX")
+});
+
+static RELAXED_RGB_OR_HSL_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    RegexBuilder::new(RGB_OR_HSL)
+        .case_insensitive(false)
+        .build()
+        .expect("Failed to create RELAXED_RGB_OR_HSL_REGEX")
+});
+
+static STRICT_RGB_OR_HSL_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    RegexBuilder::new(&format!("^{RGB_OR_HSL}$"))
+        .case_insensitive(true)
+        .build()
+        .expect("Failed to create STRICT_RGB_OR_HSL_REGEX")
+});
+
+/// Extracts a color from an LSP [`CompletionItem`].
+///
+/// Adapted from https://github.com/microsoft/vscode/blob/a6870fcb6d79093738c17e8319b760cf1c41764a/src/vs/editor/contrib/suggest/browser/suggestWidgetRenderer.ts#L34-L61
+pub fn extract_color(item: &CompletionItem) -> Option<Hsla> {
+    // Try to extract from entire `label` field.
+    parse(&item.label, ParseMode::Strict)
+        // Try to extract from entire `detail` field.
+        .or_else(|| {
+            item.detail
+                .as_ref()
+                .and_then(|detail| parse(detail, ParseMode::Strict))
+        })
+        // Try to extract from beginning or end of `documentation` field.
+        .or_else(|| match item.documentation {
+            Some(Documentation::String(ref str)) => parse(str, ParseMode::Relaxed),
+            Some(Documentation::MarkupContent(ref markup)) => {
+                parse(&markup.value, ParseMode::Relaxed)
+            }
+            None => None,
+        })
+}
+
+enum ParseMode {
+    Strict,
+    Relaxed,
+}
+
+fn parse(str: &str, mode: ParseMode) -> Option<Hsla> {
+    let (hex, rgb) = match mode {
+        ParseMode::Strict => (&STRICT_HEX_REGEX, &STRICT_RGB_OR_HSL_REGEX),
+        ParseMode::Relaxed => (&RELAXED_HEX_REGEX, &RELAXED_RGB_OR_HSL_REGEX),
+    };
+
+    if let Some(captures) = hex.captures(str) {
+        let rmatch = captures.get(0)?;
+
+        // Color must be anchored to start or end of string.
+        if rmatch.start() > 0 && rmatch.end() != str.len() {
+            return None;
+        }
+
+        let hex = captures.get(1)?.as_str();
+
+        return from_hex(hex);
+    }
+
+    if let Some(captures) = rgb.captures(str) {
+        let rmatch = captures.get(0)?;
+
+        // Color must be anchored to start or end of string.
+        if rmatch.start() > 0 && rmatch.end() != str.len() {
+            return None;
+        }
+
+        let typ = captures.get(1)?.as_str();
+        let r_or_h = captures.get(2)?.as_str();
+        let g_or_s = captures.get(3)?.as_str();
+        let b_or_l = captures.get(4)?.as_str();
+        let a = captures.get(5).map(|a| a.as_str());
+
+        return match (typ, a) {
+            ("rgb", None) | ("rgba", Some(_)) => from_rgb(r_or_h, g_or_s, b_or_l, a),
+            ("hsl", None) | ("hsla", Some(_)) => from_hsl(r_or_h, g_or_s, b_or_l, a),
+            _ => None,
+        };
+    }
+
+    return None;
+}
+
+fn parse_component(value: &str, max: f32) -> Option<f32> {
+    if let Some(field) = value.strip_suffix("%") {
+        field.parse::<f32>().map(|value| value / 100.).ok()
+    } else {
+        value.parse::<f32>().map(|value| value / max).ok()
+    }
+}
+
+fn from_hex(hex: &str) -> Option<Hsla> {
+    Rgba::try_from(hex).map(Hsla::from).ok()
+}
+
+fn from_rgb(r: &str, g: &str, b: &str, a: Option<&str>) -> Option<Hsla> {
+    let r = parse_component(r, 255.)?;
+    let g = parse_component(g, 255.)?;
+    let b = parse_component(b, 255.)?;
+    let a = a.and_then(|a| parse_component(a, 1.0)).unwrap_or(1.0);
+
+    Some(Rgba { r, g, b, a }.into())
+}
+
+fn from_hsl(h: &str, s: &str, l: &str, a: Option<&str>) -> Option<Hsla> {
+    let h = parse_component(h, 360.)?;
+    let s = parse_component(s, 100.)?;
+    let l = parse_component(l, 100.)?;
+    let a = a.and_then(|a| parse_component(a, 1.0)).unwrap_or(1.0);
+
+    Some(Hsla { h, s, l, a })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gpui::rgba;
+    use lsp::{CompletionItem, CompletionItemKind};
+
+    pub static COLOR_TABLE: LazyLock<Vec<(&'static str, Option<u32>)>> = LazyLock::new(|| {
+        vec![
+            // -- Invalid --
+            // Invalid hex
+            ("f0f", None),
+            ("#fof", None),
+            // Extra field
+            ("rgb(255, 0, 0, 0.0)", None),
+            ("hsl(120, 0, 0, 0.0)", None),
+            // Missing field
+            ("rgba(255, 0, 0)", None),
+            ("hsla(120, 0, 0)", None),
+            // No decimal after zero
+            ("rgba(255, 0, 0, 0)", None),
+            ("hsla(120, 0, 0, 0)", None),
+            // Decimal after one
+            ("rgba(255, 0, 0, 1.0)", None),
+            ("hsla(120, 0, 0, 1.0)", None),
+            // HEX (sRGB)
+            ("#f0f", Some(0xFF00FFFF)),
+            ("#ff0000", Some(0xFF0000FF)),
+            // RGB / RGBA (sRGB)
+            ("rgb(255, 0, 0)", Some(0xFF0000FF)),
+            ("rgba(255, 0, 0, 0.4)", Some(0xFF000066)),
+            ("rgba(255, 0, 0, 1)", Some(0xFF0000FF)),
+            ("rgb(20%, 0%, 0%)", Some(0x330000FF)),
+            ("rgba(20%, 0%, 0%, 1)", Some(0x330000FF)),
+            ("rgb(0%, 20%, 0%)", Some(0x003300FF)),
+            ("rgba(0%, 20%, 0%, 1)", Some(0x003300FF)),
+            ("rgb(0%, 0%, 20%)", Some(0x000033FF)),
+            ("rgba(0%, 0%, 20%, 1)", Some(0x000033FF)),
+            // HSL / HSLA (sRGB)
+            ("hsl(0, 100%, 50%)", Some(0xFF0000FF)),
+            ("hsl(120, 100%, 50%)", Some(0x00FF00FF)),
+            ("hsla(0, 100%, 50%, 0.0)", Some(0xFF000000)),
+            ("hsla(0, 100%, 50%, 0.4)", Some(0xFF000066)),
+            ("hsla(0, 100%, 50%, 1)", Some(0xFF0000FF)),
+            ("hsla(120, 100%, 50%, 0.0)", Some(0x00FF0000)),
+            ("hsla(120, 100%, 50%, 0.4)", Some(0x00FF0066)),
+            ("hsla(120, 100%, 50%, 1)", Some(0x00FF00FF)),
+        ]
+    });
+
+    #[test]
+    fn can_extract_from_label() {
+        for (color_str, color_val) in COLOR_TABLE.iter() {
+            let color = extract_color(&CompletionItem {
+                kind: Some(CompletionItemKind::COLOR),
+                label: color_str.to_string(),
+                detail: None,
+                documentation: None,
+                ..Default::default()
+            });
+
+            assert_eq!(color, color_val.map(|v| Hsla::from(rgba(v))));
+        }
+    }
+
+    #[test]
+    fn only_whole_label_matches_are_allowed() {
+        for (color_str, _) in COLOR_TABLE.iter() {
+            let color = extract_color(&CompletionItem {
+                kind: Some(CompletionItemKind::COLOR),
+                label: format!("{} foo", color_str).to_string(),
+                detail: None,
+                documentation: None,
+                ..Default::default()
+            });
+
+            assert_eq!(color, None);
+        }
+    }
+
+    #[test]
+    fn can_extract_from_detail() {
+        for (color_str, color_val) in COLOR_TABLE.iter() {
+            let color = extract_color(&CompletionItem {
+                kind: Some(CompletionItemKind::COLOR),
+                label: "".to_string(),
+                detail: Some(color_str.to_string()),
+                documentation: None,
+                ..Default::default()
+            });
+
+            assert_eq!(color, color_val.map(|v| Hsla::from(rgba(v))));
+        }
+    }
+
+    #[test]
+    fn only_whole_detail_matches_are_allowed() {
+        for (color_str, _) in COLOR_TABLE.iter() {
+            let color = extract_color(&CompletionItem {
+                kind: Some(CompletionItemKind::COLOR),
+                label: "".to_string(),
+                detail: Some(format!("{} foo", color_str).to_string()),
+                documentation: None,
+                ..Default::default()
+            });
+
+            assert_eq!(color, None);
+        }
+    }
+
+    #[test]
+    fn can_extract_from_documentation_start() {
+        for (color_str, color_val) in COLOR_TABLE.iter() {
+            let color = extract_color(&CompletionItem {
+                kind: Some(CompletionItemKind::COLOR),
+                label: "".to_string(),
+                detail: None,
+                documentation: Some(Documentation::String(
+                    format!("{} foo", color_str).to_string(),
+                )),
+                ..Default::default()
+            });
+
+            assert_eq!(color, color_val.map(|v| Hsla::from(rgba(v))));
+        }
+    }
+
+    #[test]
+    fn can_extract_from_documentation_end() {
+        for (color_str, color_val) in COLOR_TABLE.iter() {
+            let color = extract_color(&CompletionItem {
+                kind: Some(CompletionItemKind::COLOR),
+                label: "".to_string(),
+                detail: None,
+                documentation: Some(Documentation::String(
+                    format!("foo {}", color_str).to_string(),
+                )),
+                ..Default::default()
+            });
+
+            assert_eq!(color, color_val.map(|v| Hsla::from(rgba(v))));
+        }
+    }
+
+    #[test]
+    fn cannot_extract_from_documentation_middle() {
+        for (color_str, _) in COLOR_TABLE.iter() {
+            let color = extract_color(&CompletionItem {
+                kind: Some(CompletionItemKind::COLOR),
+                label: "".to_string(),
+                detail: None,
+                documentation: Some(Documentation::String(
+                    format!("foo {} foo", color_str).to_string(),
+                )),
+                ..Default::default()
+            });
+
+            assert_eq!(color, None);
+        }
+    }
+}
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 59c2c895cddcb6..4b8c0509644747 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -1,4 +1,5 @@
 pub mod buffer_store;
+mod color_extractor;
 pub mod connection_manager;
 pub mod debounced_delay;
 pub mod lsp_command;
@@ -36,7 +37,7 @@ use futures::{
 
 use git::{blame::Blame, repository::GitRepository};
 use gpui::{
-    AnyModel, AppContext, AsyncAppContext, BorrowAppContext, Context, EventEmitter, Model,
+    AnyModel, AppContext, AsyncAppContext, BorrowAppContext, Context, EventEmitter, Hsla, Model,
     ModelContext, SharedString, Task, WeakModel, WindowContext,
 };
 use itertools::Itertools;
@@ -47,7 +48,9 @@ use language::{
     Documentation, File as _, Language, LanguageRegistry, LanguageServerName, PointUtf16, ToOffset,
     ToPointUtf16, Transaction, Unclipped,
 };
-use lsp::{CompletionContext, DocumentHighlightKind, LanguageServer, LanguageServerId};
+use lsp::{
+    CompletionContext, CompletionItemKind, DocumentHighlightKind, LanguageServer, LanguageServerId,
+};
 use lsp_command::*;
 use node_runtime::NodeRuntime;
 use parking_lot::{Mutex, RwLock};
@@ -4445,6 +4448,16 @@ impl Completion {
     pub fn is_snippet(&self) -> bool {
         self.lsp_completion.insert_text_format == Some(lsp::InsertTextFormat::SNIPPET)
     }
+
+    /// Returns the corresponding color for this completion.
+    ///
+    /// Will return `None` if this completion's kind is not [`CompletionItemKind::COLOR`].
+    pub fn color(&self) -> Option<Hsla> {
+        match self.lsp_completion.kind {
+            Some(CompletionItemKind::COLOR) => color_extractor::extract_color(&self.lsp_completion),
+            _ => None,
+        }
+    }
 }
 
 #[derive(Debug)]
diff --git a/typos.toml b/typos.toml
index 1b5c82b9069806..113fb728d1d2e3 100644
--- a/typos.toml
+++ b/typos.toml
@@ -58,6 +58,8 @@ extend-ignore-re = [
     # ProtoLS crate with tree-sitter Protobuf grammar.
     "protols",
     # x11rb SelectionNotifyEvent struct field
-    "requestor"
+    "requestor",
+    # Not an actual typo but an intentionally invalid color, in `color_extractor`
+    "#fof"
 ]
 check-filename = true

From 43d05a432b838e6a3ebca5ad936700f8a13c65f2 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Thu, 3 Oct 2024 14:38:49 -0400
Subject: [PATCH 470/762] Close stale issues out after 7 days (#18707)

Closes #ISSUE

Release Notes:

- N/A
---
 .github/workflows/close_stale_issues.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/close_stale_issues.yml
index bbafb6c9851c4a..03c89b74b72c9c 100644
--- a/.github/workflows/close_stale_issues.yml
+++ b/.github/workflows/close_stale_issues.yml
@@ -14,7 +14,7 @@ jobs:
           stale-issue-message: >
             Hi there! 👋
 
-            We're working to clean up our issue tracker by closing older issues that might not be relevant anymore. Are you able to reproduce this issue in the latest version of Zed? If so, please let us know by commenting on this issue and we will keep it open; otherwise, we'll close it in 10 days. Feel free to open a new issue if you're seeing this message after the issue has been closed.
+            We're working to clean up our issue tracker by closing older issues that might not be relevant anymore. Are you able to reproduce this issue in the latest version of Zed? If so, please let us know by commenting on this issue and we will keep it open; otherwise, we'll close it in 7 days. Feel free to open a new issue if you're seeing this message after the issue has been closed.
 
             Thanks for your help!
           close-issue-message: "This issue was closed due to inactivity; feel free to open a new issue if you're still experiencing this problem!"
@@ -23,7 +23,7 @@ jobs:
           # 'community' to 'zed' repository. The migration added activity to all
           # issues, preventing 365 days from working until then.
           days-before-stale: 180
-          days-before-close: 10
+          days-before-close: 7
           any-of-issue-labels: "defect,panic / crash"
           operations-per-run: 1000
           ascending: true

From fd22c9bef9a4f1d9243cd844d95ff779728967f7 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 3 Oct 2024 15:20:41 -0400
Subject: [PATCH 471/762] editor: Use predefined `rounding` value for color
 swatches (#18708)

This PR updates the color swatches added in #18665 to use a predefined
`rounding` value instead of a literal value.

The underlying values are the same, but we don't want to diverge from
our design system.

Release Notes:

- N/A
---
 crates/editor/src/editor.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index e2355461046e36..6fdcb22605de90 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -1230,7 +1230,7 @@ impl CompletionsMenu {
 
                         let color_swatch = completion
                             .color()
-                            .map(|color| div().size_4().bg(color).rounded(px(2.)));
+                            .map(|color| div().size_4().bg(color).rounded_sm());
 
                         div().min_w(px(220.)).max_w(px(540.)).child(
                             ListItem::new(mat.candidate_id)

From 8d6fa9526e076c7cf6e805fc0d73630162e0a81c Mon Sep 17 00:00:00 2001
From: Junkui Zhang <364772080@qq.com>
Date: Fri, 4 Oct 2024 04:00:33 +0800
Subject: [PATCH 472/762] windows: Fix sometimes log error messages don't show
 the crate name (#18706)

On windows, path could be something like `C:\path\to\the\crate`. Hence,
`split('/')` would refuse to work in this case.

### Before

![Screenshot 2024-10-04
023652](https://github.com/user-attachments/assets/9c14fb24-5ee0-4b56-8fbd-313abb28f134)

### After

![Screenshot 2024-10-04
024115](https://github.com/user-attachments/assets/217e175c-b0e1-4589-9c3d-98670882b185)


Release Notes:

- N/A
---
 crates/util/src/util.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/util/src/util.rs b/crates/util/src/util.rs
index a161b8bac2b59f..50fc070009ebf6 100644
--- a/crates/util/src/util.rs
+++ b/crates/util/src/util.rs
@@ -378,9 +378,13 @@ fn log_error_with_caller<E>(caller: core::panic::Location<'_>, error: E, level:
 where
     E: std::fmt::Debug,
 {
+    #[cfg(not(target_os = "windows"))]
+    let file = caller.file();
+    #[cfg(target_os = "windows")]
+    let file = caller.file().replace('\\', "/");
     // In this codebase, the first segment of the file path is
     // the 'crates' folder, followed by the crate name.
-    let target = caller.file().split('/').nth(1);
+    let target = file.split('/').nth(1);
 
     log::logger().log(
         &log::Record::builder()

From 6635758009842dcf901fe341082e496549cb8577 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 3 Oct 2024 16:18:28 -0400
Subject: [PATCH 473/762] vcs_menu: Streamline branch creation from branch
 selector (#18712)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR streamlines the branch creation from the branch selector when
searching for a branch that does not exist.

The branch selector will show the available branches, as it does today:

<img width="576" alt="Screenshot 2024-10-03 at 4 01 25 PM"
src="https://github.com/user-attachments/assets/e1904f5b-4aad-4f88-901d-ab9422ec18bb">

When entering the name of a branch that does not exist, the picker will
be populated with an entry to create a new branch:

<img width="570" alt="Screenshot 2024-10-03 at 4 01 37 PM"
src="https://github.com/user-attachments/assets/07f8d12c-9422-4fd8-a6dc-ae450e297a13">

Selecting that entry will create the branch and switch to it.

Release Notes:

- Streamlined creating a new branch from the branch selector.
---
 crates/vcs_menu/src/lib.rs | 156 ++++++++++++++++++-------------------
 1 file changed, 75 insertions(+), 81 deletions(-)

diff --git a/crates/vcs_menu/src/lib.rs b/crates/vcs_menu/src/lib.rs
index 091c378ca70c5a..720a427ae90efe 100644
--- a/crates/vcs_menu/src/lib.rs
+++ b/crates/vcs_menu/src/lib.rs
@@ -74,8 +74,23 @@ impl Render for BranchList {
     }
 }
 
+#[derive(Debug, Clone)]
+enum BranchEntry {
+    Branch(StringMatch),
+    NewBranch { name: String },
+}
+
+impl BranchEntry {
+    fn name(&self) -> &str {
+        match self {
+            Self::Branch(branch) => &branch.string,
+            Self::NewBranch { name } => &name,
+        }
+    }
+}
+
 pub struct BranchListDelegate {
-    matches: Vec<StringMatch>,
+    matches: Vec<BranchEntry>,
     all_branches: Vec<Branch>,
     workspace: View<Workspace>,
     selected_index: usize,
@@ -194,8 +209,14 @@ impl PickerDelegate for BranchListDelegate {
             picker
                 .update(&mut cx, |picker, _| {
                     let delegate = &mut picker.delegate;
-                    delegate.matches = matches;
+                    delegate.matches = matches.into_iter().map(BranchEntry::Branch).collect();
                     if delegate.matches.is_empty() {
+                        if !query.is_empty() {
+                            delegate.matches.push(BranchEntry::NewBranch {
+                                name: query.trim().replace(' ', "-"),
+                            });
+                        }
+
                         delegate.selected_index = 0;
                     } else {
                         delegate.selected_index =
@@ -208,32 +229,44 @@ impl PickerDelegate for BranchListDelegate {
     }
 
     fn confirm(&mut self, _: bool, cx: &mut ViewContext<Picker<Self>>) {
-        let current_pick = self.selected_index();
-        let Some(current_pick) = self
-            .matches
-            .get(current_pick)
-            .map(|pick| pick.string.clone())
-        else {
+        let Some(branch) = self.matches.get(self.selected_index()) else {
             return;
         };
-        cx.spawn(|picker, mut cx| async move {
-            picker
-                .update(&mut cx, |this, cx| {
-                    let project = this.delegate.workspace.read(cx).project().read(cx);
-                    let repo = project
-                        .get_first_worktree_root_repo(cx)
-                        .context("failed to get root repository for first worktree")?;
-                    let status = repo
-                        .change_branch(&current_pick);
-                    if status.is_err() {
-                        this.delegate.display_error_toast(format!("Failed to checkout branch '{current_pick}', check for conflicts or unstashed files"), cx);
-                        status?;
-                    }
-                    cx.emit(DismissEvent);
+        cx.spawn({
+            let branch = branch.clone();
+            |picker, mut cx| async move {
+                picker
+                    .update(&mut cx, |this, cx| {
+                        let project = this.delegate.workspace.read(cx).project().read(cx);
+                        let repo = project
+                            .get_first_worktree_root_repo(cx)
+                            .context("failed to get root repository for first worktree")?;
 
-                    Ok::<(), anyhow::Error>(())
-                })
-                .log_err();
+                        let branch_to_checkout = match branch {
+                            BranchEntry::Branch(branch) => branch.string,
+                            BranchEntry::NewBranch { name: branch_name } => {
+                                let status = repo.create_branch(&branch_name);
+                                if status.is_err() {
+                                    this.delegate.display_error_toast(format!("Failed to create branch '{branch_name}', check for conflicts or unstashed files"), cx);
+                                    status?;
+                                }
+
+                                branch_name
+                            }
+                        };
+
+                        let status = repo.change_branch(&branch_to_checkout);
+                        if status.is_err() {
+                            this.delegate.display_error_toast(format!("Failed to checkout branch '{branch_to_checkout}', check for conflicts or unstashed files"), cx);
+                            status?;
+                        }
+
+                        cx.emit(DismissEvent);
+
+                        Ok::<(), anyhow::Error>(())
+                    })
+                    .log_err();
+            }
         })
         .detach();
     }
@@ -250,19 +283,28 @@ impl PickerDelegate for BranchListDelegate {
     ) -> Option<Self::ListItem> {
         let hit = &self.matches[ix];
         let shortened_branch_name =
-            util::truncate_and_trailoff(&hit.string, self.branch_name_trailoff_after);
-        let highlights: Vec<_> = hit
-            .positions
-            .iter()
-            .filter(|index| index < &&self.branch_name_trailoff_after)
-            .copied()
-            .collect();
+            util::truncate_and_trailoff(&hit.name(), self.branch_name_trailoff_after);
+
         Some(
             ListItem::new(SharedString::from(format!("vcs-menu-{ix}")))
                 .inset(true)
                 .spacing(ListItemSpacing::Sparse)
                 .selected(selected)
-                .start_slot(HighlightedLabel::new(shortened_branch_name, highlights)),
+                .map(|parent| match hit {
+                    BranchEntry::Branch(branch) => {
+                        let highlights: Vec<_> = branch
+                            .positions
+                            .iter()
+                            .filter(|index| index < &&self.branch_name_trailoff_after)
+                            .copied()
+                            .collect();
+
+                        parent.child(HighlightedLabel::new(shortened_branch_name, highlights))
+                    }
+                    BranchEntry::NewBranch { name } => {
+                        parent.child(Label::new(format!("Create branch '{name}'")))
+                    }
+                }),
         )
     }
 
@@ -289,52 +331,4 @@ impl PickerDelegate for BranchListDelegate {
         };
         Some(v_flex().mt_1().child(label).into_any_element())
     }
-
-    fn render_footer(&self, cx: &mut ViewContext<Picker<Self>>) -> Option<AnyElement> {
-        if self.last_query.is_empty() {
-            return None;
-        }
-
-        Some(
-            h_flex()
-                .p_2()
-                .border_t_1()
-                .border_color(cx.theme().colors().border_variant)
-                .justify_end()
-                .child(h_flex().w_full())
-                .child(
-                    Button::new("branch-picker-create-branch-button", "Create Branch")
-                        .icon(IconName::Plus)
-                        .icon_size(IconSize::Small)
-                        .icon_color(Color::Muted)
-                        .icon_position(IconPosition::Start)
-                        .on_click(cx.listener(|_, _, cx| {
-                            cx.spawn(|picker, mut cx| async move {
-                                picker.update(&mut cx, |this, cx| {
-                                    let project =
-                                        this.delegate.workspace.read(cx).project().read(cx);
-                                    let current_pick = &this.delegate.last_query;
-                                    let repo = project.get_first_worktree_root_repo(cx).context(
-                                        "failed to get root repository for first worktree",
-                                    )?;
-                                    let status = repo.create_branch(current_pick);
-                                    if status.is_err() {
-                                        this.delegate.display_error_toast(format!("Failed to create branch '{current_pick}', check for conflicts or unstashed files"), cx);
-                                        status?;
-                                    }
-                                    let status = repo.change_branch(current_pick);
-                                    if status.is_err() {
-                                        this.delegate.display_error_toast(format!("Failed to check branch '{current_pick}', check for conflicts or unstashed files"), cx);
-                                        status?;
-                                    }
-                                    this.cancel(&Default::default(), cx);
-                                    Ok::<(), anyhow::Error>(())
-                                })
-                            })
-                            .detach_and_log_err(cx);
-                        }))
-                )
-                .into_any_element(),
-        )
-    }
 }

From e2647025ac833856961a1234ed2bd0202f9c4746 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=96mer=20Sinan=20A=C4=9Facan?= <omeragacan@gmail.com>
Date: Fri, 4 Oct 2024 09:10:26 +0200
Subject: [PATCH 474/762] Add vim::MoveTo{Next,Prev} flags for regex and case
 sensitive search (#18429)

This makes the hard-coded regex and case-sensitive search flags in
`vim::MoveToNext` and `vim::MoveToPrev` commands configurable in key
bindings.

Example:

```json
{
  "context": "VimControl && !menu",
  "bindings": {
    "*": ["vim::MoveToNext", { "regex": false, "caseSensitive": false }],
    "#": ["vim::MoveToPrev", { "regex": false, "caseSensitive": false }]
  }
}
```

Closes #15837.

Release Notes:

- Added `regex` and `caseSensitive` arguments to `vim::MoveToNext` and
`vim ::MoveToPrev` commands, for toggling regex and case sensitive
search.
---
 crates/vim/src/normal/search.rs | 35 ++++++++++++++++++++++++++++++---
 1 file changed, 32 insertions(+), 3 deletions(-)

diff --git a/crates/vim/src/normal/search.rs b/crates/vim/src/normal/search.rs
index 28f33d49d85f20..519606b0e5d649 100644
--- a/crates/vim/src/normal/search.rs
+++ b/crates/vim/src/normal/search.rs
@@ -5,6 +5,7 @@ use gpui::{actions, impl_actions, ViewContext};
 use language::Point;
 use search::{buffer_search, BufferSearchBar, SearchOptions};
 use serde_derive::Deserialize;
+use util::serde::default_true;
 use workspace::{notifications::NotifyResultExt, searchable::Direction};
 
 use crate::{
@@ -17,15 +18,23 @@ use crate::{
 #[derive(Clone, Deserialize, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct MoveToNext {
+    #[serde(default = "default_true")]
+    case_sensitive: bool,
     #[serde(default)]
     partial_word: bool,
+    #[serde(default = "default_true")]
+    regex: bool,
 }
 
 #[derive(Clone, Deserialize, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct MoveToPrev {
+    #[serde(default = "default_true")]
+    case_sensitive: bool,
     #[serde(default)]
     partial_word: bool,
+    #[serde(default = "default_true")]
+    regex: bool,
 }
 
 #[derive(Clone, Deserialize, PartialEq)]
@@ -73,11 +82,23 @@ pub(crate) fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {
 
 impl Vim {
     fn move_to_next(&mut self, action: &MoveToNext, cx: &mut ViewContext<Self>) {
-        self.move_to_internal(Direction::Next, !action.partial_word, cx)
+        self.move_to_internal(
+            Direction::Next,
+            action.case_sensitive,
+            !action.partial_word,
+            action.regex,
+            cx,
+        )
     }
 
     fn move_to_prev(&mut self, action: &MoveToPrev, cx: &mut ViewContext<Self>) {
-        self.move_to_internal(Direction::Prev, !action.partial_word, cx)
+        self.move_to_internal(
+            Direction::Prev,
+            action.case_sensitive,
+            !action.partial_word,
+            action.regex,
+            cx,
+        )
     }
 
     fn move_to_next_match(&mut self, _: &MoveToNextMatch, cx: &mut ViewContext<Self>) {
@@ -225,7 +246,9 @@ impl Vim {
     pub fn move_to_internal(
         &mut self,
         direction: Direction,
+        case_sensitive: bool,
         whole_word: bool,
+        regex: bool,
         cx: &mut ViewContext<Self>,
     ) {
         let Some(pane) = self.pane(cx) else { return };
@@ -239,7 +262,13 @@ impl Vim {
                 return false;
             };
             let search = search_bar.update(cx, |search_bar, cx| {
-                let options = SearchOptions::CASE_SENSITIVE | SearchOptions::REGEX;
+                let mut options = SearchOptions::NONE;
+                if case_sensitive {
+                    options |= SearchOptions::CASE_SENSITIVE;
+                }
+                if regex {
+                    options |= SearchOptions::REGEX;
+                }
                 if !search_bar.show(cx) {
                     return None;
                 }

From a99750fd35ef4f44409f474228285b1842c1b7d3 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Fri, 4 Oct 2024 12:37:44 +0200
Subject: [PATCH 475/762] chore: Bump taffy to 0.5.2 (#18729)

Release Notes:

- N/A
---
 Cargo.lock               | 8 ++++----
 crates/gpui/Cargo.toml   | 2 +-
 crates/gpui/src/taffy.rs | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 12b38967cc3fbf..58d9ac0dce6c5c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5111,9 +5111,9 @@ dependencies = [
 
 [[package]]
 name = "grid"
-version = "0.13.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d196ffc1627db18a531359249b2bf8416178d84b729f3cebeb278f285fb9b58c"
+checksum = "be136d9dacc2a13cc70bb6c8f902b414fb2641f8db1314637c6b7933411a8f82"
 
 [[package]]
 name = "group"
@@ -11420,9 +11420,9 @@ dependencies = [
 
 [[package]]
 name = "taffy"
-version = "0.4.4"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ec17858c2d465b2f734b798b920818a974faf0babb15d7fef81818a4b2d16f1"
+checksum = "9cb893bff0f80ae17d3a57e030622a967b8dbc90e38284d9b4b1442e23873c94"
 dependencies = [
  "arrayvec",
  "grid",
diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml
index e2339a38edd1f4..56a419d2de6419 100644
--- a/crates/gpui/Cargo.toml
+++ b/crates/gpui/Cargo.toml
@@ -66,7 +66,7 @@ smallvec.workspace = true
 smol.workspace = true
 strum.workspace = true
 sum_tree.workspace = true
-taffy = "0.4.3"
+taffy = "0.5"
 thiserror.workspace = true
 util.workspace = true
 uuid.workspace = true
diff --git a/crates/gpui/src/taffy.rs b/crates/gpui/src/taffy.rs
index a80c734b81bbfc..c26b404b088d04 100644
--- a/crates/gpui/src/taffy.rs
+++ b/crates/gpui/src/taffy.rs
@@ -180,7 +180,7 @@ impl TaffyLayoutEngine {
             .compute_layout_with_measure(
                 id.into(),
                 available_space.into(),
-                |known_dimensions, available_space, node_id, _context| {
+                |known_dimensions, available_space, node_id, _context, _style| {
                     let Some(measure) = self.nodes_to_measure.get_mut(&node_id.into()) else {
                         return taffy::geometry::Size::default();
                     };

From 37ded190cf3c755ea544b489715fd9c0bf0845d9 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Fri, 4 Oct 2024 12:37:55 +0200
Subject: [PATCH 476/762] gpui: Use taffy to retrieve the parent for a given
 layout node (#18730)

Again. https://github.com/zed-industries/zed/pull/4070

Let's see how it goes this time around. The only thing that might've
been related to that revert on our Slack was about crashing in collab
panel.

Release Notes:

- N/A
---
 crates/gpui/src/taffy.rs | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/crates/gpui/src/taffy.rs b/crates/gpui/src/taffy.rs
index c26b404b088d04..feec5bf8c17bf7 100644
--- a/crates/gpui/src/taffy.rs
+++ b/crates/gpui/src/taffy.rs
@@ -18,7 +18,6 @@ type NodeMeasureFn =
 pub struct TaffyLayoutEngine {
     taffy: TaffyTree<()>,
     styles: FxHashMap<LayoutId, Style>,
-    children_to_parents: FxHashMap<LayoutId, LayoutId>,
     absolute_layout_bounds: FxHashMap<LayoutId, Bounds<Pixels>>,
     computed_layouts: FxHashSet<LayoutId>,
     nodes_to_measure: FxHashMap<LayoutId, NodeMeasureFn>,
@@ -31,7 +30,6 @@ impl TaffyLayoutEngine {
         TaffyLayoutEngine {
             taffy: TaffyTree::new(),
             styles: FxHashMap::default(),
-            children_to_parents: FxHashMap::default(),
             absolute_layout_bounds: FxHashMap::default(),
             computed_layouts: FxHashSet::default(),
             nodes_to_measure: FxHashMap::default(),
@@ -40,7 +38,6 @@ impl TaffyLayoutEngine {
 
     pub fn clear(&mut self) {
         self.taffy.clear();
-        self.children_to_parents.clear();
         self.absolute_layout_bounds.clear();
         self.computed_layouts.clear();
         self.nodes_to_measure.clear();
@@ -68,8 +65,6 @@ impl TaffyLayoutEngine {
                 })
                 .expect(EXPECT_MESSAGE)
                 .into();
-            self.children_to_parents
-                .extend(children.iter().map(|child_id| (*child_id, parent_id)));
             parent_id
         };
         self.styles.insert(layout_id, style);
@@ -209,8 +204,8 @@ impl TaffyLayoutEngine {
             size: layout.size.into(),
         };
 
-        if let Some(parent_id) = self.children_to_parents.get(&id).copied() {
-            let parent_bounds = self.layout_bounds(parent_id);
+        if let Some(parent_id) = self.taffy.parent(id.0) {
+            let parent_bounds = self.layout_bounds(parent_id.into());
             bounds.origin += parent_bounds.origin;
         }
         self.absolute_layout_bounds.insert(id, bounds);

From bafd7ed000fd8b370fc354d482ed82f0aef20ace Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Fri, 4 Oct 2024 13:58:57 +0200
Subject: [PATCH 477/762] gpui: Store measure functions as context of taffy
 nodes (#18732)

Taffy maintains a mapping of NodeId <-> Context anyways (and does the
lookup), so it's redundant for us to store it separately. Tl;dr: we get
rid of one map and one map lookup per layout request.

Release Notes:

- N/A
---
 crates/gpui/src/taffy.rs | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/crates/gpui/src/taffy.rs b/crates/gpui/src/taffy.rs
index feec5bf8c17bf7..9d99078ae5fc15 100644
--- a/crates/gpui/src/taffy.rs
+++ b/crates/gpui/src/taffy.rs
@@ -15,12 +15,13 @@ use taffy::{
 type NodeMeasureFn =
     Box<dyn FnMut(Size<Option<Pixels>>, Size<AvailableSpace>, &mut WindowContext) -> Size<Pixels>>;
 
+struct NodeContext {
+    measure: NodeMeasureFn,
+}
 pub struct TaffyLayoutEngine {
-    taffy: TaffyTree<()>,
-    styles: FxHashMap<LayoutId, Style>,
+    taffy: TaffyTree<NodeContext>,
     absolute_layout_bounds: FxHashMap<LayoutId, Bounds<Pixels>>,
     computed_layouts: FxHashSet<LayoutId>,
-    nodes_to_measure: FxHashMap<LayoutId, NodeMeasureFn>,
 }
 
 const EXPECT_MESSAGE: &str = "we should avoid taffy layout errors by construction if possible";
@@ -29,10 +30,8 @@ impl TaffyLayoutEngine {
     pub fn new() -> Self {
         TaffyLayoutEngine {
             taffy: TaffyTree::new(),
-            styles: FxHashMap::default(),
             absolute_layout_bounds: FxHashMap::default(),
             computed_layouts: FxHashSet::default(),
-            nodes_to_measure: FxHashMap::default(),
         }
     }
 
@@ -40,8 +39,6 @@ impl TaffyLayoutEngine {
         self.taffy.clear();
         self.absolute_layout_bounds.clear();
         self.computed_layouts.clear();
-        self.nodes_to_measure.clear();
-        self.styles.clear();
     }
 
     pub fn request_layout(
@@ -67,7 +64,6 @@ impl TaffyLayoutEngine {
                 .into();
             parent_id
         };
-        self.styles.insert(layout_id, style);
         layout_id
     }
 
@@ -82,11 +78,14 @@ impl TaffyLayoutEngine {
 
         let layout_id = self
             .taffy
-            .new_leaf_with_context(taffy_style, ())
+            .new_leaf_with_context(
+                taffy_style,
+                NodeContext {
+                    measure: Box::new(measure),
+                },
+            )
             .expect(EXPECT_MESSAGE)
             .into();
-        self.nodes_to_measure.insert(layout_id, Box::new(measure));
-        self.styles.insert(layout_id, style);
         layout_id
     }
 
@@ -175,8 +174,8 @@ impl TaffyLayoutEngine {
             .compute_layout_with_measure(
                 id.into(),
                 available_space.into(),
-                |known_dimensions, available_space, node_id, _context, _style| {
-                    let Some(measure) = self.nodes_to_measure.get_mut(&node_id.into()) else {
+                |known_dimensions, available_space, _node_id, node_context, _style| {
+                    let Some(node_context) = node_context else {
                         return taffy::geometry::Size::default();
                     };
 
@@ -185,7 +184,7 @@ impl TaffyLayoutEngine {
                         height: known_dimensions.height.map(Pixels),
                     };
 
-                    measure(known_dimensions, available_space.into(), cx).into()
+                    (node_context.measure)(known_dimensions, available_space.into(), cx).into()
                 },
             )
             .expect(EXPECT_MESSAGE);

From 9702310737cd6af24492a9dc0f56a54b34d64b59 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Fri, 4 Oct 2024 10:36:30 -0400
Subject: [PATCH 478/762] Update Rust crate sqlformat to v0.2.6 (#18676)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [sqlformat](https://redirect.github.com/shssoichiro/sqlformat-rs) |
dependencies | patch | `0.2.4` -> `0.2.6` |

---

### Release Notes

<details>
<summary>shssoichiro/sqlformat-rs (sqlformat)</summary>

###
[`v0.2.6`](https://redirect.github.com/shssoichiro/sqlformat-rs/blob/HEAD/CHANGELOG.md#Version-026)

[Compare
Source](https://redirect.github.com/shssoichiro/sqlformat-rs/compare/v0.2.5...v0.2.6)

- fix: ON UPDATE with two many blank formatted incorrectly
([#&#8203;46](https://redirect.github.com/shssoichiro/sqlformat-rs/issues/46))
-   fix: `EXCEPT` not handled well
- fix: REFERENCES xyz ON UPDATE .. causes formatter to treat the
remaining as an UPDATE statement
-   fix: Escaped strings formatted incorrectly
-   fix: RETURNING is not placed on a new line
- fix: fix the issue of misaligned comments after formatting
([#&#8203;40](https://redirect.github.com/shssoichiro/sqlformat-rs/issues/40))

###
[`v0.2.5`](https://redirect.github.com/shssoichiro/sqlformat-rs/compare/v0.2.4...v0.2.5)

[Compare
Source](https://redirect.github.com/shssoichiro/sqlformat-rs/compare/v0.2.4...v0.2.5)

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguOTcuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 58d9ac0dce6c5c..5eac9e23264bbb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10726,9 +10726,9 @@ dependencies = [
 
 [[package]]
 name = "sqlformat"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f895e3734318cc55f1fe66258926c9b910c124d47520339efecbb6c59cec7c1f"
+checksum = "7bba3a93db0cc4f7bdece8bb09e77e2e785c20bfebf79eb8340ed80708048790"
 dependencies = [
  "nom",
  "unicode_categories",

From d695de45046f401208ad63b54c60dcce3c5d3b1e Mon Sep 17 00:00:00 2001
From: Daste <stefankar1000@gmail.com>
Date: Fri, 4 Oct 2024 16:37:41 +0200
Subject: [PATCH 479/762] tab_switcher: Use git-aware colors for file icons
 (#18733)

Release Notes:

- Fixed tab switcher icons not respecting the `tabs.git_status` setting.

Fixes an issue mentioned in
https://github.com/zed-industries/zed/pull/17115#issuecomment-2378966170
- file icons in the tab switcher weren't colored according to git
status, even if `tabs.git_status` was set to true.

I used a similar approach I saw in other places of the project to get
the project entry and its git status, but maybe we could move the
coloring logic entirely to `tab_icon()`? Wouldn't this break anything?

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 Cargo.lock                              |  1 +
 crates/tab_switcher/Cargo.toml          |  5 +--
 crates/tab_switcher/src/tab_switcher.rs | 41 +++++++++++++++++++++----
 3 files changed, 39 insertions(+), 8 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5eac9e23264bbb..582388fc241618 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11412,6 +11412,7 @@ dependencies = [
  "project",
  "serde",
  "serde_json",
+ "settings",
  "theme",
  "ui",
  "util",
diff --git a/crates/tab_switcher/Cargo.toml b/crates/tab_switcher/Cargo.toml
index 65344499175622..c30469fb176c77 100644
--- a/crates/tab_switcher/Cargo.toml
+++ b/crates/tab_switcher/Cargo.toml
@@ -14,10 +14,13 @@ doctest = false
 
 [dependencies]
 collections.workspace = true
+editor.workspace = true
 gpui.workspace = true
 menu.workspace = true
 picker.workspace = true
+project.workspace = true
 serde.workspace = true
+settings.workspace = true
 ui.workspace = true
 util.workspace = true
 workspace.workspace = true
@@ -25,11 +28,9 @@ workspace.workspace = true
 [dev-dependencies]
 anyhow.workspace = true
 ctor.workspace = true
-editor.workspace = true
 env_logger.workspace = true
 gpui = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }
-project.workspace = true
 serde_json.workspace = true
 theme = { workspace = true, features = ["test-support"] }
 workspace = { workspace = true, features = ["test-support"] }
diff --git a/crates/tab_switcher/src/tab_switcher.rs b/crates/tab_switcher/src/tab_switcher.rs
index 0b3eaf9e8a5d2a..8c961dc54d4b66 100644
--- a/crates/tab_switcher/src/tab_switcher.rs
+++ b/crates/tab_switcher/src/tab_switcher.rs
@@ -2,18 +2,21 @@
 mod tab_switcher_tests;
 
 use collections::HashMap;
+use editor::items::entry_git_aware_label_color;
 use gpui::{
     actions, impl_actions, rems, Action, AnyElement, AppContext, DismissEvent, EntityId,
-    EventEmitter, FocusHandle, FocusableView, Modifiers, ModifiersChangedEvent, MouseButton,
+    EventEmitter, FocusHandle, FocusableView, Model, Modifiers, ModifiersChangedEvent, MouseButton,
     MouseUpEvent, ParentElement, Render, Styled, Task, View, ViewContext, VisualContext, WeakView,
 };
 use picker::{Picker, PickerDelegate};
+use project::Project;
 use serde::Deserialize;
+use settings::Settings;
 use std::sync::Arc;
 use ui::{prelude::*, ListItem, ListItemSpacing, Tooltip};
 use util::ResultExt;
 use workspace::{
-    item::{ItemHandle, TabContentParams},
+    item::{ItemHandle, ItemSettings, TabContentParams},
     pane::{render_item_indicator, tab_details, Event as PaneEvent},
     ModalView, Pane, SaveIntent, Workspace,
 };
@@ -76,8 +79,10 @@ impl TabSwitcher {
             })
         }
 
+        let project = workspace.project().clone();
         workspace.toggle_modal(cx, |cx| {
-            let delegate = TabSwitcherDelegate::new(action, cx.view().downgrade(), weak_pane, cx);
+            let delegate =
+                TabSwitcherDelegate::new(project, action, cx.view().downgrade(), weak_pane, cx);
             TabSwitcher::new(delegate, cx)
         });
     }
@@ -147,11 +152,13 @@ pub struct TabSwitcherDelegate {
     tab_switcher: WeakView<TabSwitcher>,
     selected_index: usize,
     pane: WeakView<Pane>,
+    project: Model<Project>,
     matches: Vec<TabMatch>,
 }
 
 impl TabSwitcherDelegate {
     fn new(
+        project: Model<Project>,
         action: &Toggle,
         tab_switcher: WeakView<TabSwitcher>,
         pane: WeakView<Pane>,
@@ -163,6 +170,7 @@ impl TabSwitcherDelegate {
             tab_switcher,
             selected_index: 0,
             pane,
+            project,
             matches: Vec::new(),
         }
     }
@@ -341,6 +349,29 @@ impl PickerDelegate for TabSwitcherDelegate {
             preview: tab_match.preview,
         };
         let label = tab_match.item.tab_content(params, cx);
+
+        let icon = tab_match.item.tab_icon(cx).map(|icon| {
+            let git_status_color = ItemSettings::get_global(cx)
+                .git_status
+                .then(|| {
+                    tab_match
+                        .item
+                        .project_path(cx)
+                        .as_ref()
+                        .and_then(|path| self.project.read(cx).entry_for_path(path, cx))
+                        .map(|entry| {
+                            entry_git_aware_label_color(
+                                entry.git_status,
+                                entry.is_ignored,
+                                selected,
+                            )
+                        })
+                })
+                .flatten();
+
+            icon.color(git_status_color.unwrap_or_default())
+        });
+
         let indicator = render_item_indicator(tab_match.item.boxed_clone(), cx);
         let indicator_color = if let Some(ref indicator) = indicator {
             indicator.color
@@ -378,9 +409,7 @@ impl PickerDelegate for TabSwitcherDelegate {
                 .inset(true)
                 .selected(selected)
                 .child(h_flex().w_full().child(label))
-                .when_some(tab_match.item.tab_icon(cx), |el, icon| {
-                    el.start_slot(div().child(icon))
-                })
+                .start_slot::<Icon>(icon)
                 .map(|el| {
                     if self.selected_index == ix {
                         el.end_slot::<AnyElement>(close_button)

From d012e35b04e1355e959e448dee766f6ca022059c Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Fri, 4 Oct 2024 11:09:20 -0400
Subject: [PATCH 480/762] Update Rust crate parking to v2.2.1 (#18664)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [parking](https://redirect.github.com/smol-rs/parking) | dependencies
| patch | `2.2.0` -> `2.2.1` |

---

### Release Notes

<details>
<summary>smol-rs/parking (parking)</summary>

###
[`v2.2.1`](https://redirect.github.com/smol-rs/parking/blob/HEAD/CHANGELOG.md#Version-221)

[Compare
Source](https://redirect.github.com/smol-rs/parking/compare/v2.2.0...v2.2.1)

- Specify the reason for using `parking` in the docs.
([#&#8203;25](https://redirect.github.com/smol-rs/parking/issues/25))

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguOTcuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 582388fc241618..e99c6ffd8ac7c9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -7859,9 +7859,9 @@ dependencies = [
 
 [[package]]
 name = "parking"
-version = "2.2.0"
+version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb813b8af86854136c6922af0598d719255ecb2179515e6e7730d468f05c9cae"
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
 
 [[package]]
 name = "parking_lot"

From 2f7430af70b2f531eeadaf71707200350ea928a7 Mon Sep 17 00:00:00 2001
From: Muhammad Talal Anwar <mail@talal.io>
Date: Fri, 4 Oct 2024 17:28:12 +0200
Subject: [PATCH 481/762] c: Add runnable for main function (#18720)

Release Notes:

- Added Runnable for C main function

This tags can then be used in tasks, for example:

```json
[
  {
    "label": "Run ${ZED_STEM}",
    "command": "gcc",
    "args": [
      "$ZED_FILE",
      "-o",
      "${ZED_DIRNAME}/${ZED_STEM}.out",
      "&&",
      "${ZED_DIRNAME}/${ZED_STEM}.out"
    ],
    "tags": ["c-main"]
  }
]

```
---
 crates/languages/src/c/runnables.scm | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 crates/languages/src/c/runnables.scm

diff --git a/crates/languages/src/c/runnables.scm b/crates/languages/src/c/runnables.scm
new file mode 100644
index 00000000000000..4eaf5f730e1059
--- /dev/null
+++ b/crates/languages/src/c/runnables.scm
@@ -0,0 +1,10 @@
+; Tag the main function
+(
+  (function_definition
+    declarator: (function_declarator
+      declarator: (identifier) @run
+    )
+  ) @c-main
+  (#eq? @run "main")
+  (#set! tag c-main)
+)

From 07e808d16f59e46c45d8f7c84e44974457e6a41d Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 4 Oct 2024 12:07:43 -0400
Subject: [PATCH 482/762] Document File Scan Exclusions (#18738)

Release Notes:

- N/A
---
 docs/src/configuring-zed.md | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 230255597e35cf..6740d51364ce7e 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -844,6 +844,27 @@ If the setting is set to `true`:
 
 The result is still `)))` and not `))))))`, which is what it would be by default.
 
+## File Scan Exclusions
+
+- Setting: `file_scan_exclusions`
+- Description: Configure how Add filename or directory globs that will be excluded by Zed entirely. They will be skipped during file scans, file searches and hidden from project file tree.
+- Default:
+
+```json
+"file_scan_exclusions": [
+  "**/.git",
+  "**/.svn",
+  "**/.hg",
+  "**/CVS",
+  "**/.DS_Store",
+  "**/Thumbs.db",
+  "**/.classpath",
+  "**/.settings"
+],
+```
+
+Note, specifying `file_scan_exclusions` in settings.json will override the defaults (shown above). If you are looking to exclude additional items you will need to include all the default values in your settings.
+
 ## File Types
 
 - Setting: `file_types`

From e3a6f89e2dc7d9323b6ceb09280cfe515f6dd6e2 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 4 Oct 2024 13:19:18 -0400
Subject: [PATCH 483/762] Make `report_assistant_event` take an
 `AssistantEvent` struct (#18741)

This PR makes the `report_assistant_event` method take an
`AssistantEvent` struct instead of all of the struct fields as
individual parameters.

Release Notes:

- N/A
---
 crates/assistant/src/context.rs               | 14 +++---
 crates/assistant/src/inline_assistant.rs      | 49 ++++++++++---------
 .../src/terminal_inline_assistant.rs          | 13 ++---
 crates/client/src/telemetry.rs                | 27 ++--------
 4 files changed, 44 insertions(+), 59 deletions(-)

diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index 4f1f885b33fe67..c30770cfed9591 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -46,7 +46,7 @@ use std::{
     sync::Arc,
     time::{Duration, Instant},
 };
-use telemetry_events::{AssistantKind, AssistantPhase};
+use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use text::BufferSnapshot;
 use util::{post_inc, ResultExt, TryFutureExt};
 use uuid::Uuid;
@@ -2133,14 +2133,14 @@ impl Context {
                     });
 
                     if let Some(telemetry) = this.telemetry.as_ref() {
-                        telemetry.report_assistant_event(
-                            Some(this.id.0.clone()),
-                            AssistantKind::Panel,
-                            AssistantPhase::Response,
-                            model.telemetry_id(),
+                        telemetry.report_assistant_event(AssistantEvent {
+                            conversation_id: Some(this.id.0.clone()),
+                            kind: AssistantKind::Panel,
+                            phase: AssistantPhase::Response,
+                            model: model.telemetry_id(),
                             response_latency,
                             error_message,
-                        );
+                        });
                     }
 
                     if let Ok(stop_reason) = result {
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index fac70f233c6562..94ae53ab54dcc8 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -50,6 +50,7 @@ use std::{
     task::{self, Poll},
     time::{Duration, Instant},
 };
+use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal_view::terminal_panel::TerminalPanel;
 use text::{OffsetRangeExt, ToPoint as _};
 use theme::ThemeSettings;
@@ -211,14 +212,14 @@ impl InlineAssistant {
     ) {
         if let Some(telemetry) = self.telemetry.as_ref() {
             if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                telemetry.report_assistant_event(
-                    None,
-                    telemetry_events::AssistantKind::Inline,
-                    telemetry_events::AssistantPhase::Invoked,
-                    model.telemetry_id(),
-                    None,
-                    None,
-                );
+                telemetry.report_assistant_event(AssistantEvent {
+                    conversation_id: None,
+                    kind: AssistantKind::Inline,
+                    phase: AssistantPhase::Invoked,
+                    model: model.telemetry_id(),
+                    response_latency: None,
+                    error_message: None,
+                });
             }
         }
         let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
@@ -763,18 +764,18 @@ impl InlineAssistant {
     pub fn finish_assist(&mut self, assist_id: InlineAssistId, undo: bool, cx: &mut WindowContext) {
         if let Some(telemetry) = self.telemetry.as_ref() {
             if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                telemetry.report_assistant_event(
-                    None,
-                    telemetry_events::AssistantKind::Inline,
-                    if undo {
-                        telemetry_events::AssistantPhase::Rejected
+                telemetry.report_assistant_event(AssistantEvent {
+                    conversation_id: None,
+                    kind: AssistantKind::Inline,
+                    phase: if undo {
+                        AssistantPhase::Rejected
                     } else {
-                        telemetry_events::AssistantPhase::Accepted
+                        AssistantPhase::Accepted
                     },
-                    model.telemetry_id(),
-                    None,
-                    None,
-                );
+                    model: model.telemetry_id(),
+                    response_latency: None,
+                    error_message: None,
+                });
             }
         }
         if let Some(assist) = self.assists.get(&assist_id) {
@@ -2920,14 +2921,14 @@ impl CodegenAlternative {
                             let error_message =
                                 result.as_ref().err().map(|error| error.to_string());
                             if let Some(telemetry) = telemetry {
-                                telemetry.report_assistant_event(
-                                    None,
-                                    telemetry_events::AssistantKind::Inline,
-                                    telemetry_events::AssistantPhase::Response,
-                                    model_telemetry_id,
+                                telemetry.report_assistant_event(AssistantEvent {
+                                    conversation_id: None,
+                                    kind: AssistantKind::Inline,
+                                    phase: AssistantPhase::Response,
+                                    model: model_telemetry_id,
                                     response_latency,
                                     error_message,
-                                );
+                                });
                             }
 
                             result?;
diff --git a/crates/assistant/src/terminal_inline_assistant.rs b/crates/assistant/src/terminal_inline_assistant.rs
index e1a26d851003eb..4cd9d74fc8fe8f 100644
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -25,6 +25,7 @@ use std::{
     sync::Arc,
     time::{Duration, Instant},
 };
+use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal::Terminal;
 use terminal_view::TerminalView;
 use theme::ThemeSettings;
@@ -1063,14 +1064,14 @@ impl Codegen {
 
                     let error_message = result.as_ref().err().map(|error| error.to_string());
                     if let Some(telemetry) = telemetry {
-                        telemetry.report_assistant_event(
-                            None,
-                            telemetry_events::AssistantKind::Inline,
-                            telemetry_events::AssistantPhase::Response,
-                            model_telemetry_id,
+                        telemetry.report_assistant_event(AssistantEvent {
+                            conversation_id: None,
+                            kind: AssistantKind::Inline,
+                            phase: AssistantPhase::Response,
+                            model: model_telemetry_id,
                             response_latency,
                             error_message,
-                        );
+                        });
                     }
 
                     result?;
diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index 6c1803df3d02d5..5ec2e5b1aa6dd4 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -16,9 +16,9 @@ use std::io::Write;
 use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
 use sysinfo::{CpuRefreshKind, Pid, ProcessRefreshKind, RefreshKind, System};
 use telemetry_events::{
-    ActionEvent, AppEvent, AssistantEvent, AssistantKind, AssistantPhase, CallEvent, CpuEvent,
-    EditEvent, EditorEvent, Event, EventRequestBody, EventWrapper, ExtensionEvent,
-    InlineCompletionEvent, MemoryEvent, ReplEvent, SettingEvent,
+    ActionEvent, AppEvent, AssistantEvent, CallEvent, CpuEvent, EditEvent, EditorEvent, Event,
+    EventRequestBody, EventWrapper, ExtensionEvent, InlineCompletionEvent, MemoryEvent, ReplEvent,
+    SettingEvent,
 };
 use tempfile::NamedTempFile;
 #[cfg(not(debug_assertions))]
@@ -391,25 +391,8 @@ impl Telemetry {
         self.report_event(event)
     }
 
-    pub fn report_assistant_event(
-        self: &Arc<Self>,
-        conversation_id: Option<String>,
-        kind: AssistantKind,
-        phase: AssistantPhase,
-        model: String,
-        response_latency: Option<Duration>,
-        error_message: Option<String>,
-    ) {
-        let event = Event::Assistant(AssistantEvent {
-            conversation_id,
-            kind,
-            phase,
-            model: model.to_string(),
-            response_latency,
-            error_message,
-        });
-
-        self.report_event(event)
+    pub fn report_assistant_event(self: &Arc<Self>, event: AssistantEvent) {
+        self.report_event(Event::Assistant(event));
     }
 
     pub fn report_call_event(

From dfe1e438325a9b3769c904ead99128d19bc2aaed Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 4 Oct 2024 14:13:07 -0400
Subject: [PATCH 484/762] docs: Linux XDG desktop secrets portals

---
 docs/src/linux.md | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/docs/src/linux.md b/docs/src/linux.md
index 4abd7de8ba8ebd..6e62300ec82e60 100644
--- a/docs/src/linux.md
+++ b/docs/src/linux.md
@@ -123,17 +123,26 @@ If Vulkan is configured correctly, and Zed is still slow for you, please [file a
 
 ### I can't open any files
 
-### Zed isn't remembering my login
-
 ### Clicking links isn't working
 
-All of these features are provided by XDG desktop portals, specifically:
+These features are provided by XDG desktop portals, specifically:
 
 - `org.freedesktop.portal.FileChooser`
 - `org.freedesktop.portal.OpenURI`
 
 Some window managers, such as `Hyprland`, don't provide a file picker by default. See [this list](https://wiki.archlinux.org/title/XDG_Desktop_Portal#List_of_backends_and_interfaces) as a starting point for alternatives.
 
+### Zed isn't remembering my API keys
+
+### Zed isn't remembering my login
+
+These feature also requires XDG desktop portals, specifically:
+
+- `org.freedesktop.portal.Secret` or
+- `org.freedesktop.Secrets`
+
+Zed needs a place to securely store secrets such as your Zed login cookie or your OpenAI API Keys and we use a system provided keychain to do this. Examples of packages that provide this are `gnome-keyring`, `KWallet` and `keepassxc` among others.
+
 ### Could not start inotify
 
 Zed relies on inotify to watch your filesystem for changes. If you cannot start inotify then Zed will not work reliably.

From 01ad22683d349206518e6778febdbbb0f4ff87b7 Mon Sep 17 00:00:00 2001
From: Boris Cherny <boris@performancejs.com>
Date: Fri, 4 Oct 2024 11:37:27 -0700
Subject: [PATCH 485/762] telemetry: Add `language_name` and `model_provider`
 (#18640)

This PR adds a bit more metadata for assistant logging.

Release Notes:

- Assistant: Added `language_name` and `model_provider` fields to
telemetry events.

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
Co-authored-by: Max <max@zed.dev>
---
 Cargo.lock                                    |  1 +
 crates/assistant/src/context.rs               |  7 ++
 crates/assistant/src/inline_assistant.rs      | 90 +++++++++++++------
 .../src/terminal_inline_assistant.rs          |  3 +
 crates/language_model/src/language_model.rs   |  7 ++
 crates/telemetry_events/Cargo.toml            |  1 +
 .../telemetry_events/src/telemetry_events.rs  |  3 +
 7 files changed, 83 insertions(+), 29 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e99c6ffd8ac7c9..3b2c1d2a60bcae 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11497,6 +11497,7 @@ dependencies = [
 name = "telemetry_events"
 version = "0.1.0"
 dependencies = [
+ "language",
  "semantic_version",
  "serde",
 ]
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index c30770cfed9591..c360c0cb69a7ec 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -2133,13 +2133,20 @@ impl Context {
                     });
 
                     if let Some(telemetry) = this.telemetry.as_ref() {
+                        let language_name = this
+                            .buffer
+                            .read(cx)
+                            .language()
+                            .map(|language| language.name());
                         telemetry.report_assistant_event(AssistantEvent {
                             conversation_id: Some(this.id.0.clone()),
                             kind: AssistantKind::Panel,
                             phase: AssistantPhase::Response,
                             model: model.telemetry_id(),
+                            model_provider: model.provider_id().to_string(),
                             response_latency,
                             error_message,
+                            language_name,
                         });
                     }
 
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index 94ae53ab54dcc8..b3427271b9a4eb 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -210,18 +210,6 @@ impl InlineAssistant {
         initial_prompt: Option<String>,
         cx: &mut WindowContext,
     ) {
-        if let Some(telemetry) = self.telemetry.as_ref() {
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                telemetry.report_assistant_event(AssistantEvent {
-                    conversation_id: None,
-                    kind: AssistantKind::Inline,
-                    phase: AssistantPhase::Invoked,
-                    model: model.telemetry_id(),
-                    response_latency: None,
-                    error_message: None,
-                });
-            }
-        }
         let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
 
         let mut selections = Vec::<Selection<Point>>::new();
@@ -268,6 +256,21 @@ impl InlineAssistant {
                 text_anchor: buffer.anchor_after(buffer_range.end),
             };
             codegen_ranges.push(start..end);
+
+            if let Some(telemetry) = self.telemetry.as_ref() {
+                if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+                    telemetry.report_assistant_event(AssistantEvent {
+                        conversation_id: None,
+                        kind: AssistantKind::Inline,
+                        phase: AssistantPhase::Invoked,
+                        model: model.telemetry_id(),
+                        model_provider: model.provider_id().to_string(),
+                        response_latency: None,
+                        error_message: None,
+                        language_name: buffer.language().map(|language| language.name()),
+                    });
+                }
+            }
         }
 
         let assist_group_id = self.next_assist_group_id.post_inc();
@@ -762,23 +765,34 @@ impl InlineAssistant {
     }
 
     pub fn finish_assist(&mut self, assist_id: InlineAssistId, undo: bool, cx: &mut WindowContext) {
-        if let Some(telemetry) = self.telemetry.as_ref() {
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                telemetry.report_assistant_event(AssistantEvent {
-                    conversation_id: None,
-                    kind: AssistantKind::Inline,
-                    phase: if undo {
-                        AssistantPhase::Rejected
-                    } else {
-                        AssistantPhase::Accepted
-                    },
-                    model: model.telemetry_id(),
-                    response_latency: None,
-                    error_message: None,
-                });
-            }
-        }
         if let Some(assist) = self.assists.get(&assist_id) {
+            if let Some(telemetry) = self.telemetry.as_ref() {
+                if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+                    let language_name = assist.editor.upgrade().and_then(|editor| {
+                        let multibuffer = editor.read(cx).buffer().read(cx);
+                        let ranges = multibuffer.range_to_buffer_ranges(assist.range.clone(), cx);
+                        ranges
+                            .first()
+                            .and_then(|(buffer, _, _)| buffer.read(cx).language())
+                            .map(|language| language.name())
+                    });
+                    telemetry.report_assistant_event(AssistantEvent {
+                        conversation_id: None,
+                        kind: AssistantKind::Inline,
+                        phase: if undo {
+                            AssistantPhase::Rejected
+                        } else {
+                            AssistantPhase::Accepted
+                        },
+                        model: model.telemetry_id(),
+                        model_provider: model.provider_id().to_string(),
+                        response_latency: None,
+                        error_message: None,
+                        language_name,
+                    });
+                }
+            }
+
             let assist_group_id = assist.group_id;
             if self.assist_groups[&assist_group_id].linked {
                 for assist_id in self.unlink_assist_group(assist_group_id, cx) {
@@ -2707,6 +2721,7 @@ impl CodegenAlternative {
         self.edit_position = Some(self.range.start.bias_right(&self.snapshot));
 
         let telemetry_id = model.telemetry_id();
+        let provider_id = model.provider_id();
         let chunks: LocalBoxFuture<Result<BoxStream<Result<String>>>> =
             if user_prompt.trim().to_lowercase() == "delete" {
                 async { Ok(stream::empty().boxed()) }.boxed_local()
@@ -2717,7 +2732,7 @@ impl CodegenAlternative {
                     .spawn(|_, cx| async move { model.stream_completion_text(request, &cx).await });
                 async move { Ok(chunks.await?.boxed()) }.boxed_local()
             };
-        self.handle_stream(telemetry_id, chunks, cx);
+        self.handle_stream(telemetry_id, provider_id.to_string(), chunks, cx);
         Ok(())
     }
 
@@ -2781,6 +2796,7 @@ impl CodegenAlternative {
     pub fn handle_stream(
         &mut self,
         model_telemetry_id: String,
+        model_provider_id: String,
         stream: impl 'static + Future<Output = Result<BoxStream<'static, Result<String>>>>,
         cx: &mut ModelContext<Self>,
     ) {
@@ -2811,6 +2827,15 @@ impl CodegenAlternative {
         }
 
         let telemetry = self.telemetry.clone();
+        let language_name = {
+            let multibuffer = self.buffer.read(cx);
+            let ranges = multibuffer.range_to_buffer_ranges(self.range.clone(), cx);
+            ranges
+                .first()
+                .and_then(|(buffer, _, _)| buffer.read(cx).language())
+                .map(|language| language.name())
+        };
+
         self.diff = Diff::default();
         self.status = CodegenStatus::Pending;
         let mut edit_start = self.range.start.to_offset(&snapshot);
@@ -2926,8 +2951,10 @@ impl CodegenAlternative {
                                     kind: AssistantKind::Inline,
                                     phase: AssistantPhase::Response,
                                     model: model_telemetry_id,
+                                    model_provider: model_provider_id.to_string(),
                                     response_latency,
                                     error_message,
+                                    language_name,
                                 });
                             }
 
@@ -3540,6 +3567,7 @@ mod tests {
         let (chunks_tx, chunks_rx) = mpsc::unbounded();
         codegen.update(cx, |codegen, cx| {
             codegen.handle_stream(
+                String::new(),
                 String::new(),
                 future::ready(Ok(chunks_rx.map(Ok).boxed())),
                 cx,
@@ -3611,6 +3639,7 @@ mod tests {
         let (chunks_tx, chunks_rx) = mpsc::unbounded();
         codegen.update(cx, |codegen, cx| {
             codegen.handle_stream(
+                String::new(),
                 String::new(),
                 future::ready(Ok(chunks_rx.map(Ok).boxed())),
                 cx,
@@ -3685,6 +3714,7 @@ mod tests {
         let (chunks_tx, chunks_rx) = mpsc::unbounded();
         codegen.update(cx, |codegen, cx| {
             codegen.handle_stream(
+                String::new(),
                 String::new(),
                 future::ready(Ok(chunks_rx.map(Ok).boxed())),
                 cx,
@@ -3758,6 +3788,7 @@ mod tests {
         let (chunks_tx, chunks_rx) = mpsc::unbounded();
         codegen.update(cx, |codegen, cx| {
             codegen.handle_stream(
+                String::new(),
                 String::new(),
                 future::ready(Ok(chunks_rx.map(Ok).boxed())),
                 cx,
@@ -3821,6 +3852,7 @@ mod tests {
         let (chunks_tx, chunks_rx) = mpsc::unbounded();
         codegen.update(cx, |codegen, cx| {
             codegen.handle_stream(
+                String::new(),
                 String::new(),
                 future::ready(Ok(chunks_rx.map(Ok).boxed())),
                 cx,
diff --git a/crates/assistant/src/terminal_inline_assistant.rs b/crates/assistant/src/terminal_inline_assistant.rs
index 4cd9d74fc8fe8f..d30ec2df11a793 100644
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -1040,6 +1040,7 @@ impl Codegen {
         self.transaction = Some(TerminalTransaction::start(self.terminal.clone()));
         self.generation = cx.spawn(|this, mut cx| async move {
             let model_telemetry_id = model.telemetry_id();
+            let model_provider_id = model.provider_id();
             let response = model.stream_completion_text(prompt, &cx).await;
             let generate = async {
                 let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);
@@ -1069,8 +1070,10 @@ impl Codegen {
                             kind: AssistantKind::Inline,
                             phase: AssistantPhase::Response,
                             model: model_telemetry_id,
+                            model_provider: model_provider_id.to_string(),
                             response_latency,
                             error_message,
+                            language_name: None,
                         });
                     }
 
diff --git a/crates/language_model/src/language_model.rs b/crates/language_model/src/language_model.rs
index 171f5fa819b0a7..81d0c874dce44a 100644
--- a/crates/language_model/src/language_model.rs
+++ b/crates/language_model/src/language_model.rs
@@ -22,6 +22,7 @@ pub use request::*;
 pub use role::*;
 use schemars::JsonSchema;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use std::fmt;
 use std::{future::Future, sync::Arc};
 use ui::IconName;
 
@@ -231,6 +232,12 @@ pub struct LanguageModelProviderId(pub SharedString);
 #[derive(Clone, Eq, PartialEq, Hash, Debug, Ord, PartialOrd)]
 pub struct LanguageModelProviderName(pub SharedString);
 
+impl fmt::Display for LanguageModelProviderId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 impl From<String> for LanguageModelId {
     fn from(value: String) -> Self {
         Self(SharedString::from(value))
diff --git a/crates/telemetry_events/Cargo.toml b/crates/telemetry_events/Cargo.toml
index 01145549b156f7..34ccc20c3a53fb 100644
--- a/crates/telemetry_events/Cargo.toml
+++ b/crates/telemetry_events/Cargo.toml
@@ -12,5 +12,6 @@ workspace = true
 path = "src/telemetry_events.rs"
 
 [dependencies]
+language.workspace = true
 semantic_version.workspace = true
 serde.workspace = true
diff --git a/crates/telemetry_events/src/telemetry_events.rs b/crates/telemetry_events/src/telemetry_events.rs
index f7b18523df17eb..56e94edb44ac1d 100644
--- a/crates/telemetry_events/src/telemetry_events.rs
+++ b/crates/telemetry_events/src/telemetry_events.rs
@@ -1,5 +1,6 @@
 //! See [Telemetry in Zed](https://zed.dev/docs/telemetry) for additional information.
 
+use language::LanguageName;
 use semantic_version::SemanticVersion;
 use serde::{Deserialize, Serialize};
 use std::{fmt::Display, sync::Arc, time::Duration};
@@ -153,8 +154,10 @@ pub struct AssistantEvent {
     pub phase: AssistantPhase,
     /// Name of the AI model used (gpt-4o, claude-3-5-sonnet, etc)
     pub model: String,
+    pub model_provider: String,
     pub response_latency: Option<Duration>,
     pub error_message: Option<String>,
+    pub language_name: Option<LanguageName>,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]

From cee019b1ea138c6efce131c4ae955e26a62e62aa Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 4 Oct 2024 15:06:05 -0400
Subject: [PATCH 486/762] editor: Qualify `RangeExt::overlaps` call to prevent
 phantom diagnostics (#18743)

This PR qualifies a call to `RangeExt::overlaps` to avoid some confusion
in rust-analyzer not being able to distinguish between
`RangeExt::overlaps` and `AnchorRangeExt::overlaps` and producing
phantom diagnostics.

We may also want to consider renaming the method on `AnchorRangeExt` to
disambiguate them.

Release Notes:

- N/A
---
 crates/editor/src/editor.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 6fdcb22605de90..62c2240828ee42 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -10792,7 +10792,7 @@ impl Editor {
             .selections
             .all::<Point>(cx)
             .iter()
-            .any(|selection| selection.range().overlaps(&intersection_range));
+            .any(|selection| RangeExt::overlaps(&selection.range(), &intersection_range));
 
         self.unfold_ranges(std::iter::once(intersection_range), true, autoscroll, cx)
     }

From 8f27ffda4d99f31b323e523bc3490339c7864bfe Mon Sep 17 00:00:00 2001
From: Remco Smits <djsmits12@gmail.com>
Date: Fri, 4 Oct 2024 22:07:58 +0200
Subject: [PATCH 487/762] gpui: Fix uniform list horizon offset for
 non-horizontal scrollable lists (#18748)

Closes #18739

/cc @osiewicz
/cc @maxdeviant

I'm not sure why the `+ padding.left` was added, but this was the cause
of the issue. I also tested removing the extra left padding but didn't
seem to see a difference inside the project panel. So we can maybe even
remove it?

**Before:**
![Screenshot 2024-10-04 at 21 43
34](https://github.com/user-attachments/assets/b5d67cd9-f92b-4301-880c-d351fe156c98)

**After:**
<img width="294" alt="Screenshot 2024-10-04 at 21 49 05"
src="https://github.com/user-attachments/assets/8cc84170-a86b-46b8-91c9-39def64f0bd0">

Release Notes:

- Fix code action list not horizontal aligned correctly
---
 crates/gpui/src/elements/uniform_list.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/gpui/src/elements/uniform_list.rs b/crates/gpui/src/elements/uniform_list.rs
index 54297d1214f3f9..d17d0781845d15 100644
--- a/crates/gpui/src/elements/uniform_list.rs
+++ b/crates/gpui/src/elements/uniform_list.rs
@@ -297,7 +297,11 @@ impl Element for UniformList {
                         for (mut item, ix) in items.into_iter().zip(visible_range) {
                             let item_origin = padded_bounds.origin
                                 + point(
-                                    scroll_offset.x + padding.left,
+                                    if can_scroll_horizontally {
+                                        scroll_offset.x + padding.left
+                                    } else {
+                                        scroll_offset.x
+                                    },
                                     item_height * ix + scroll_offset.y + padding.top,
                                 );
                             let available_width = if can_scroll_horizontally {

From 7608000df8c2e70b0381c7d933197242a3cd24ee Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 4 Oct 2024 16:56:01 -0400
Subject: [PATCH 488/762] Fix option-t and option-shift-t in terminal (#18749)

---
 assets/keymaps/default-macos.json | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index b405ee18528431..234485bc38a282 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -440,7 +440,12 @@
       "cmd-k shift-right": ["workspace::SwapPaneInDirection", "Right"],
       "cmd-k shift-up": ["workspace::SwapPaneInDirection", "Up"],
       "cmd-k shift-down": ["workspace::SwapPaneInDirection", "Down"],
-      "cmd-shift-x": "zed::Extensions",
+      "cmd-shift-x": "zed::Extensions"
+    }
+  },
+  {
+    "context": "Editor && !Terminal",
+    "bindings": {
       "alt-t": "task::Rerun",
       "alt-shift-t": "task::Spawn"
     }

From 1f31022cbe1d9811682986cd82bac9785b3aa266 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Sat, 5 Oct 2024 12:58:45 +0300
Subject: [PATCH 489/762] Compare migrations formatted uniformly (#18760)

Otherwise old migrations may be formatted differently than new
migrations, causing comparison errors.

Follow-up of https://github.com/zed-industries/zed/pull/18676

Release Notes:

- N/A
---
 Cargo.lock                     |  1 +
 Cargo.toml                     |  1 +
 crates/sqlez/Cargo.toml        |  1 +
 crates/sqlez/src/migrations.rs | 31 ++++++++++++++-----------------
 crates/sqlez_macros/Cargo.toml |  2 +-
 5 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3b2c1d2a60bcae..9945b2df9ac87a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10710,6 +10710,7 @@ dependencies = [
  "libsqlite3-sys",
  "parking_lot",
  "smol",
+ "sqlformat",
  "thread_local",
  "util",
  "uuid",
diff --git a/Cargo.toml b/Cargo.toml
index a23663f5c818f8..d6f4279449c0bb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -419,6 +419,7 @@ similar = "1.3"
 simplelog = "0.12.2"
 smallvec = { version = "1.6", features = ["union"] }
 smol = "1.2"
+sqlformat = "0.2"
 strsim = "0.11"
 strum = { version = "0.25.0", features = ["derive"] }
 subtle = "2.5.0"
diff --git a/crates/sqlez/Cargo.toml b/crates/sqlez/Cargo.toml
index 461017dd8d86b1..43626d7747e9e0 100644
--- a/crates/sqlez/Cargo.toml
+++ b/crates/sqlez/Cargo.toml
@@ -16,6 +16,7 @@ indoc.workspace = true
 libsqlite3-sys = { version = "0.28", features = ["bundled"] }
 parking_lot.workspace = true
 smol.workspace = true
+sqlformat.workspace = true
 thread_local = "1.1.4"
 util.workspace = true
 uuid.workspace = true
diff --git a/crates/sqlez/src/migrations.rs b/crates/sqlez/src/migrations.rs
index f97706d03bcaac..72187d0eb2698e 100644
--- a/crates/sqlez/src/migrations.rs
+++ b/crates/sqlez/src/migrations.rs
@@ -55,7 +55,16 @@ impl Connection {
                 .exec_bound("INSERT INTO migrations (domain, step, migration) VALUES (?, ?, ?)")?;
 
             for (index, migration) in migrations.iter().enumerate() {
+                let migration =
+                    sqlformat::format(migration, &sqlformat::QueryParams::None, Default::default());
                 if let Some((_, _, completed_migration)) = completed_migrations.get(index) {
+                    // Reformat completed migrations with the current `sqlformat` version, so that past migrations stored
+                    // conform to the new formatting rules.
+                    let completed_migration = sqlformat::format(
+                        completed_migration,
+                        &sqlformat::QueryParams::None,
+                        Default::default(),
+                    );
                     if completed_migration == migration {
                         // Migration already run. Continue
                         continue;
@@ -71,8 +80,8 @@ impl Connection {
                     }
                 }
 
-                self.eager_exec(migration)?;
-                store_completed_migration((domain, index, *migration))?;
+                self.eager_exec(&migration)?;
+                store_completed_migration((domain, index, migration))?;
             }
 
             Ok(())
@@ -108,11 +117,7 @@ mod test {
                 .select::<String>("SELECT (migration) FROM migrations")
                 .unwrap()()
             .unwrap()[..],
-            &[indoc! {"
-                CREATE TABLE test1 (
-                    a TEXT,
-                    b TEXT
-                )"}],
+            &[indoc! {"CREATE TABLE test1 (a TEXT, b TEXT)"}],
         );
 
         // Add another step to the migration and run it again
@@ -141,16 +146,8 @@ mod test {
                 .unwrap()()
             .unwrap()[..],
             &[
-                indoc! {"
-                    CREATE TABLE test1 (
-                        a TEXT,
-                        b TEXT
-                    )"},
-                indoc! {"
-                    CREATE TABLE test2 (
-                        c TEXT,
-                        d TEXT
-                    )"},
+                indoc! {"CREATE TABLE test1 (a TEXT, b TEXT)"},
+                indoc! {"CREATE TABLE test2 (c TEXT, d TEXT)"},
             ],
         );
     }
diff --git a/crates/sqlez_macros/Cargo.toml b/crates/sqlez_macros/Cargo.toml
index 93fcac42ecd636..3a0ae19c4663c8 100644
--- a/crates/sqlez_macros/Cargo.toml
+++ b/crates/sqlez_macros/Cargo.toml
@@ -15,5 +15,5 @@ doctest = false
 
 [dependencies]
 sqlez.workspace = true
-sqlformat = "0.2"
+sqlformat.workspace = true
 syn = "1.0"

From c9bee9f81f4254441583a426c7b8c7d3fb44e2ec Mon Sep 17 00:00:00 2001
From: Chris Boette <chrisbodhi@users.noreply.github.com>
Date: Sat, 5 Oct 2024 12:26:28 -0400
Subject: [PATCH 490/762] docs: Note the need for Rust when developing
 extensions (#18753)

---
 docs/src/extensions/developing-extensions.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docs/src/extensions/developing-extensions.md b/docs/src/extensions/developing-extensions.md
index 503d253fc33bb3..1ab1676e36fb69 100644
--- a/docs/src/extensions/developing-extensions.md
+++ b/docs/src/extensions/developing-extensions.md
@@ -76,6 +76,8 @@ zed::register_extension!(MyExtension);
 
 ## Developing an Extension Locally
 
+Before starting to develop an extension for Zed, be sure to [install Rust](https://www.rust-lang.org/tools/install).
+
 When developing an extension, you can use it in Zed without needing to publish it by installing it as a _dev extension_.
 
 From the extensions page, click the `Install Dev Extension` button and select the directory containing your extension.

From 8376dd2011099238ef7f6c6010a9953d3a6df97d Mon Sep 17 00:00:00 2001
From: Nate Butler <iamnbutler@gmail.com>
Date: Sat, 5 Oct 2024 23:28:34 -0400
Subject: [PATCH 491/762] `ui` crate docs & spring cleaning (#18768)

Similar to https://github.com/zed-industries/zed/pull/18690 &
https://github.com/zed-industries/zed/pull/18695, this PR enables
required docs for `ui` and does some cleanup.

Changes:
- Enables the `deny(missing_docs)` crate-wide.
- Adds `allow(missing_docs)` on many modules until folks pick them up to
document them
- Documents some modules (all in `ui/src/styles`)
- Crate root-level organization: Traits move to `traits`, other misc
organization
- Cleaned out a bunch of unused code.

Note: I'd like to remove `utils/format_distance` but the assistant panel
uses it. To move it over to use the `time_format` crate we may need to
update it to use `time` instead of `chrono`. Needs more investigation.

Release Notes:

- N/A
---
 crates/assistant/src/assistant_panel.rs       |   6 +-
 crates/assistant/src/prompt_library.rs        |   2 +-
 crates/storybook/src/stories/with_rem_size.rs |   2 +-
 crates/ui/src/components/avatar/avatar.rs     |  42 +----
 .../avatar/avatar_audio_status_indicator.rs   |   7 +
 .../avatar/avatar_availability_indicator.rs   |   1 +
 crates/ui/src/components/button/button.rs     |   1 +
 .../ui/src/components/button/button_icon.rs   |   1 +
 .../ui/src/components/button/button_like.rs   |  31 ++--
 .../ui/src/components/button/icon_button.rs   |   1 +
 .../ui/src/components/button/toggle_button.rs |   1 +
 crates/ui/src/components/checkbox.rs          |   1 +
 crates/ui/src/components/checkbox/checkbox.rs |   2 +
 .../checkbox/checkbox_with_label.rs           |   2 +
 crates/ui/src/components/context_menu.rs      |   5 +-
 crates/ui/src/components/disclosure.rs        |   1 +
 crates/ui/src/components/divider.rs           |   1 +
 crates/ui/src/components/dropdown_menu.rs     |   1 +
 crates/ui/src/components/facepile.rs          |   1 +
 crates/ui/src/components/icon.rs              |   1 +
 crates/ui/src/components/image.rs             |   1 +
 crates/ui/src/components/indicator.rs         |   1 +
 crates/ui/src/components/keybinding.rs        | 174 +++++++++++++++++-
 .../src/components/label/highlighted_label.rs |   2 +
 crates/ui/src/components/label/label.rs       |   2 +
 crates/ui/src/components/label/label_like.rs  |   2 +
 crates/ui/src/components/list/list.rs         |   2 +
 crates/ui/src/components/list/list_header.rs  |   2 +
 crates/ui/src/components/list/list_item.rs    |   2 +
 .../ui/src/components/list/list_separator.rs  |   2 +
 .../ui/src/components/list/list_sub_header.rs |   2 +
 crates/ui/src/components/modal.rs             |   2 +
 crates/ui/src/components/numeric_stepper.rs   |   2 +
 crates/ui/src/components/popover.rs           |   2 +
 crates/ui/src/components/popover_menu.rs      |   2 +
 crates/ui/src/components/radio.rs             |   2 +
 crates/ui/src/components/right_click_menu.rs  |   2 +
 .../ui/src/components/settings_container.rs   |   2 +
 crates/ui/src/components/settings_group.rs    |   2 +
 crates/ui/src/components/stack.rs             |   2 +
 crates/ui/src/components/stories.rs           |   3 +
 crates/ui/src/components/tab.rs               |   1 +
 crates/ui/src/components/tab_bar.rs           |   1 +
 crates/ui/src/components/tool_strip.rs        |   2 +
 crates/ui/src/components/tooltip.rs           |   2 +
 crates/ui/src/key_bindings.rs                 | 170 -----------------
 crates/ui/src/prelude.rs                      |  13 +-
 crates/ui/src/styles/appearance.rs            |   8 +-
 crates/ui/src/styles/color.rs                 |  41 ++++-
 crates/ui/src/styles/docs/elevation.md        |  44 -----
 crates/ui/src/styles/elevation.rs             |  47 ++---
 crates/ui/src/styles/spacing.rs               |  14 +-
 crates/ui/src/styles/typography.rs            |  21 ++-
 crates/ui/src/tests.rs                        |   1 +
 crates/ui/src/{ => tests}/path_str.rs         |  16 +-
 crates/ui/src/traits.rs                       |   6 +
 crates/ui/src/{ => traits}/clickable.rs       |   0
 crates/ui/src/{ => traits}/disableable.rs     |   0
 crates/ui/src/{ => traits}/fixed.rs           |   0
 crates/ui/src/{ => traits}/selectable.rs      |   0
 crates/ui/src/{ => traits}/styled_ext.rs      |   0
 .../ui/src/{ => traits}/visible_on_hover.rs   |   2 +
 crates/ui/src/ui.rs                           |  24 +--
 crates/ui/src/utils.rs                        |   4 +-
 crates/ui/src/utils/format_distance.rs        |   3 +
 crates/ui/src/{ => utils}/with_rem_size.rs    |   2 +
 66 files changed, 393 insertions(+), 352 deletions(-)
 delete mode 100644 crates/ui/src/key_bindings.rs
 delete mode 100644 crates/ui/src/styles/docs/elevation.md
 create mode 100644 crates/ui/src/tests.rs
 rename crates/ui/src/{ => tests}/path_str.rs (54%)
 create mode 100644 crates/ui/src/traits.rs
 rename crates/ui/src/{ => traits}/clickable.rs (100%)
 rename crates/ui/src/{ => traits}/disableable.rs (100%)
 rename crates/ui/src/{ => traits}/fixed.rs (100%)
 rename crates/ui/src/{ => traits}/selectable.rs (100%)
 rename crates/ui/src/{ => traits}/styled_ext.rs (100%)
 rename crates/ui/src/{ => traits}/visible_on_hover.rs (85%)
 rename crates/ui/src/{ => utils}/with_rem_size.rs (95%)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 15f9e5c59dfef9..20e6347d01c3d9 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -77,7 +77,7 @@ use ui::TintColor;
 use ui::{
     prelude::*,
     utils::{format_distance_from_now, DateTimeType},
-    Avatar, AvatarShape, ButtonLike, ContextMenu, Disclosure, ElevationIndex, KeyBinding, ListItem,
+    Avatar, ButtonLike, ContextMenu, Disclosure, ElevationIndex, KeyBinding, ListItem,
     ListItemSpacing, PopoverMenu, PopoverMenuHandle, Tooltip,
 };
 use util::{maybe, ResultExt};
@@ -262,9 +262,7 @@ impl PickerDelegate for SavedContextPickerDelegate {
                             .gap_2()
                             .children(if let Some(host_user) = host_user {
                                 vec![
-                                    Avatar::new(host_user.avatar_uri.clone())
-                                        .shape(AvatarShape::Circle)
-                                        .into_any_element(),
+                                    Avatar::new(host_user.avatar_uri.clone()).into_any_element(),
                                     Label::new(format!("Shared by @{}", host_user.github_login))
                                         .color(Color::Muted)
                                         .size(LabelSize::Small)
diff --git a/crates/assistant/src/prompt_library.rs b/crates/assistant/src/prompt_library.rs
index 24e20a18a799a6..6c43579d6ebd02 100644
--- a/crates/assistant/src/prompt_library.rs
+++ b/crates/assistant/src/prompt_library.rs
@@ -910,7 +910,7 @@ impl PromptLibrary {
                                                             .features
                                                             .clone(),
                                                         font_size: HeadlineSize::Large
-                                                            .size()
+                                                            .rems()
                                                             .into(),
                                                         font_weight: settings.ui_font.weight,
                                                         line_height: relative(
diff --git a/crates/storybook/src/stories/with_rem_size.rs b/crates/storybook/src/stories/with_rem_size.rs
index 11add24955bad3..558dab6c547784 100644
--- a/crates/storybook/src/stories/with_rem_size.rs
+++ b/crates/storybook/src/stories/with_rem_size.rs
@@ -1,7 +1,7 @@
 use gpui::{AnyElement, Hsla, Render};
 use story::Story;
 
-use ui::{prelude::*, WithRemSize};
+use ui::{prelude::*, utils::WithRemSize};
 
 pub struct WithRemSizeStory;
 
diff --git a/crates/ui/src/components/avatar/avatar.rs b/crates/ui/src/components/avatar/avatar.rs
index 27cf86a01fb014..4106b17452fd25 100644
--- a/crates/ui/src/components/avatar/avatar.rs
+++ b/crates/ui/src/components/avatar/avatar.rs
@@ -2,16 +2,6 @@ use crate::prelude::*;
 
 use gpui::{img, AnyElement, Hsla, ImageSource, Img, IntoElement, Styled};
 
-/// The shape of an [`Avatar`].
-#[derive(Debug, Default, PartialEq, Clone)]
-pub enum AvatarShape {
-    /// The avatar is shown in a circle.
-    #[default]
-    Circle,
-    /// The avatar is shown in a rectangle with rounded corners.
-    RoundedRectangle,
-}
-
 /// An element that renders a user avatar with customizable appearance options.
 ///
 /// # Examples
@@ -20,7 +10,6 @@ pub enum AvatarShape {
 /// use ui::{Avatar, AvatarShape};
 ///
 /// Avatar::new("path/to/image.png")
-///     .shape(AvatarShape::Circle)
 ///     .grayscale(true)
 ///     .border_color(gpui::red());
 /// ```
@@ -33,6 +22,7 @@ pub struct Avatar {
 }
 
 impl Avatar {
+    /// Creates a new avatar element with the specified image source.
     pub fn new(src: impl Into<ImageSource>) -> Self {
         Avatar {
             image: img(src),
@@ -42,26 +32,6 @@ impl Avatar {
         }
     }
 
-    /// Sets the shape of the avatar image.
-    ///
-    /// This method allows the shape of the avatar to be specified using an [`AvatarShape`].
-    /// It modifies the corner radius of the image to match the specified shape.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ui::{Avatar, AvatarShape};
-    ///
-    /// Avatar::new("path/to/image.png").shape(AvatarShape::Circle);
-    /// ```
-    pub fn shape(mut self, shape: AvatarShape) -> Self {
-        self.image = match shape {
-            AvatarShape::Circle => self.image.rounded_full(),
-            AvatarShape::RoundedRectangle => self.image.rounded_md(),
-        };
-        self
-    }
-
     /// Applies a grayscale filter to the avatar image.
     ///
     /// # Examples
@@ -76,6 +46,11 @@ impl Avatar {
         self
     }
 
+    /// Sets the border color of the avatar.
+    ///
+    /// This might be used to match the border to the background color of
+    /// the parent element to create the illusion of cropping another
+    /// shape underneath (for example in face piles.)
     pub fn border_color(mut self, color: impl Into<Hsla>) -> Self {
         self.border_color = Some(color.into());
         self
@@ -87,6 +62,7 @@ impl Avatar {
         self
     }
 
+    /// Sets the current indicator to be displayed on the avatar, if any.
     pub fn indicator<E: IntoElement>(mut self, indicator: impl Into<Option<E>>) -> Self {
         self.indicator = indicator.into().map(IntoElement::into_any_element);
         self
@@ -95,10 +71,6 @@ impl Avatar {
 
 impl RenderOnce for Avatar {
     fn render(mut self, cx: &mut WindowContext) -> impl IntoElement {
-        if self.image.style().corner_radii.top_left.is_none() {
-            self = self.shape(AvatarShape::Circle);
-        }
-
         let border_width = if self.border_color.is_some() {
             px(2.)
         } else {
diff --git a/crates/ui/src/components/avatar/avatar_audio_status_indicator.rs b/crates/ui/src/components/avatar/avatar_audio_status_indicator.rs
index e249727a0ce211..8ff6491db7b01b 100644
--- a/crates/ui/src/components/avatar/avatar_audio_status_indicator.rs
+++ b/crates/ui/src/components/avatar/avatar_audio_status_indicator.rs
@@ -2,12 +2,17 @@ use gpui::AnyView;
 
 use crate::prelude::*;
 
+/// The audio status of an player, for use in representing
+/// their status visually on their avatar.
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
 pub enum AudioStatus {
+    /// The player's microphone is muted.
     Muted,
+    /// The player's microphone is muted, and collaboration audio is disabled.
     Deafened,
 }
 
+/// An indicator that shows the audio status of a player.
 #[derive(IntoElement)]
 pub struct AvatarAudioStatusIndicator {
     audio_status: AudioStatus,
@@ -15,6 +20,7 @@ pub struct AvatarAudioStatusIndicator {
 }
 
 impl AvatarAudioStatusIndicator {
+    /// Creates a new `AvatarAudioStatusIndicator`
     pub fn new(audio_status: AudioStatus) -> Self {
         Self {
             audio_status,
@@ -22,6 +28,7 @@ impl AvatarAudioStatusIndicator {
         }
     }
 
+    /// Sets the tooltip for the indicator.
     pub fn tooltip(mut self, tooltip: impl Fn(&mut WindowContext) -> AnyView + 'static) -> Self {
         self.tooltip = Some(Box::new(tooltip));
         self
diff --git a/crates/ui/src/components/avatar/avatar_availability_indicator.rs b/crates/ui/src/components/avatar/avatar_availability_indicator.rs
index 3e4f9b2d1bc7d0..4690f8fccddba2 100644
--- a/crates/ui/src/components/avatar/avatar_availability_indicator.rs
+++ b/crates/ui/src/components/avatar/avatar_availability_indicator.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use crate::prelude::*;
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
diff --git a/crates/ui/src/components/button/button.rs b/crates/ui/src/components/button/button.rs
index 1e11d25cc6618e..f81de83a2bf7c4 100644
--- a/crates/ui/src/components/button/button.rs
+++ b/crates/ui/src/components/button/button.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use gpui::{AnyView, DefiniteLength};
 
 use crate::{prelude::*, ElevationIndex, IconPosition, KeyBinding, Spacing};
diff --git a/crates/ui/src/components/button/button_icon.rs b/crates/ui/src/components/button/button_icon.rs
index 54ca0f79218eaa..f3aebe7f765ffa 100644
--- a/crates/ui/src/components/button/button_icon.rs
+++ b/crates/ui/src/components/button/button_icon.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use crate::{prelude::*, Icon, IconName, IconSize};
 
 /// An icon that appears within a button.
diff --git a/crates/ui/src/components/button/button_like.rs b/crates/ui/src/components/button/button_like.rs
index a22c27d24176d0..22e84213913188 100644
--- a/crates/ui/src/components/button/button_like.rs
+++ b/crates/ui/src/components/button/button_like.rs
@@ -1,8 +1,9 @@
+#![allow(missing_docs)]
 use gpui::{relative, CursorStyle, DefiniteLength, MouseButton};
 use gpui::{transparent_black, AnyElement, AnyView, ClickEvent, Hsla, Rems};
 use smallvec::SmallVec;
 
-use crate::{prelude::*, Elevation, ElevationIndex, Spacing};
+use crate::{prelude::*, ElevationIndex, Spacing};
 
 /// A trait for buttons that can be Selected. Enables setting the [`ButtonStyle`] of a button when it is selected.
 pub trait SelectableButton: Selectable {
@@ -145,20 +146,12 @@ pub(crate) struct ButtonLikeStyles {
     pub icon_color: Hsla,
 }
 
-fn element_bg_from_elevation(elevation: Option<Elevation>, cx: &mut WindowContext) -> Hsla {
+fn element_bg_from_elevation(elevation: Option<ElevationIndex>, cx: &mut WindowContext) -> Hsla {
     match elevation {
-        Some(Elevation::ElevationIndex(ElevationIndex::Background)) => {
-            cx.theme().colors().element_background
-        }
-        Some(Elevation::ElevationIndex(ElevationIndex::ElevatedSurface)) => {
-            cx.theme().colors().surface_background
-        }
-        Some(Elevation::ElevationIndex(ElevationIndex::Surface)) => {
-            cx.theme().colors().elevated_surface_background
-        }
-        Some(Elevation::ElevationIndex(ElevationIndex::ModalSurface)) => {
-            cx.theme().colors().background
-        }
+        Some(ElevationIndex::Background) => cx.theme().colors().element_background,
+        Some(ElevationIndex::ElevatedSurface) => cx.theme().colors().surface_background,
+        Some(ElevationIndex::Surface) => cx.theme().colors().elevated_surface_background,
+        Some(ElevationIndex::ModalSurface) => cx.theme().colors().background,
         _ => cx.theme().colors().element_background,
     }
 }
@@ -166,7 +159,7 @@ fn element_bg_from_elevation(elevation: Option<Elevation>, cx: &mut WindowContex
 impl ButtonStyle {
     pub(crate) fn enabled(
         self,
-        elevation: Option<Elevation>,
+        elevation: Option<ElevationIndex>,
         cx: &mut WindowContext,
     ) -> ButtonLikeStyles {
         let filled_background = element_bg_from_elevation(elevation, cx);
@@ -196,7 +189,7 @@ impl ButtonStyle {
 
     pub(crate) fn hovered(
         self,
-        elevation: Option<Elevation>,
+        elevation: Option<ElevationIndex>,
         cx: &mut WindowContext,
     ) -> ButtonLikeStyles {
         let mut filled_background = element_bg_from_elevation(elevation, cx);
@@ -281,7 +274,7 @@ impl ButtonStyle {
     #[allow(unused)]
     pub(crate) fn disabled(
         self,
-        elevation: Option<Elevation>,
+        elevation: Option<ElevationIndex>,
         cx: &mut WindowContext,
     ) -> ButtonLikeStyles {
         element_bg_from_elevation(elevation, cx).fade_out(0.82);
@@ -348,7 +341,7 @@ pub struct ButtonLike {
     pub(super) selected_style: Option<ButtonStyle>,
     pub(super) width: Option<DefiniteLength>,
     pub(super) height: Option<DefiniteLength>,
-    pub(super) layer: Option<Elevation>,
+    pub(super) layer: Option<ElevationIndex>,
     size: ButtonSize,
     rounding: Option<ButtonLikeRounding>,
     tooltip: Option<Box<dyn Fn(&mut WindowContext) -> AnyView>>,
@@ -463,7 +456,7 @@ impl ButtonCommon for ButtonLike {
     }
 
     fn layer(mut self, elevation: ElevationIndex) -> Self {
-        self.layer = Some(elevation.into());
+        self.layer = Some(elevation);
         self
     }
 }
diff --git a/crates/ui/src/components/button/icon_button.rs b/crates/ui/src/components/button/icon_button.rs
index cf564efabb3817..bad10d6fb43b8d 100644
--- a/crates/ui/src/components/button/icon_button.rs
+++ b/crates/ui/src/components/button/icon_button.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use gpui::{AnyView, DefiniteLength};
 
 use super::button_like::{ButtonCommon, ButtonLike, ButtonSize, ButtonStyle};
diff --git a/crates/ui/src/components/button/toggle_button.rs b/crates/ui/src/components/button/toggle_button.rs
index 3ad47ed166d6e4..33577fc4e8c169 100644
--- a/crates/ui/src/components/button/toggle_button.rs
+++ b/crates/ui/src/components/button/toggle_button.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use gpui::{AnyView, ClickEvent};
 
 use crate::{prelude::*, ButtonLike, ButtonLikeRounding, ElevationIndex};
diff --git a/crates/ui/src/components/checkbox.rs b/crates/ui/src/components/checkbox.rs
index d750d6c0364645..d3c4d377ae26e4 100644
--- a/crates/ui/src/components/checkbox.rs
+++ b/crates/ui/src/components/checkbox.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 mod checkbox_with_label;
 
 pub use checkbox_with_label::*;
diff --git a/crates/ui/src/components/checkbox/checkbox.rs b/crates/ui/src/components/checkbox/checkbox.rs
index cd1ea97ea9d1ea..472bfb23f1091d 100644
--- a/crates/ui/src/components/checkbox/checkbox.rs
+++ b/crates/ui/src/components/checkbox/checkbox.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::{div, prelude::*, ElementId, IntoElement, Styled, WindowContext};
 
 use crate::prelude::*;
diff --git a/crates/ui/src/components/checkbox/checkbox_with_label.rs b/crates/ui/src/components/checkbox/checkbox_with_label.rs
index 2cf8fc28323b30..2b92e479389fc8 100644
--- a/crates/ui/src/components/checkbox/checkbox_with_label.rs
+++ b/crates/ui/src/components/checkbox/checkbox_with_label.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use std::sync::Arc;
 
 use crate::{prelude::*, Checkbox};
diff --git a/crates/ui/src/components/context_menu.rs b/crates/ui/src/components/context_menu.rs
index 644cb1dd24a9f9..92884b0182e660 100644
--- a/crates/ui/src/components/context_menu.rs
+++ b/crates/ui/src/components/context_menu.rs
@@ -1,6 +1,7 @@
+#![allow(missing_docs)]
 use crate::{
-    h_flex, prelude::*, v_flex, Icon, IconName, KeyBinding, Label, List, ListItem, ListSeparator,
-    ListSubHeader, WithRemSize,
+    h_flex, prelude::*, utils::WithRemSize, v_flex, Icon, IconName, KeyBinding, Label, List,
+    ListItem, ListSeparator, ListSubHeader,
 };
 use gpui::{
     px, Action, AnyElement, AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView,
diff --git a/crates/ui/src/components/disclosure.rs b/crates/ui/src/components/disclosure.rs
index 41ff0a4c3aca61..9e8ab48221e17f 100644
--- a/crates/ui/src/components/disclosure.rs
+++ b/crates/ui/src/components/disclosure.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use std::sync::Arc;
 
 use gpui::{ClickEvent, CursorStyle};
diff --git a/crates/ui/src/components/divider.rs b/crates/ui/src/components/divider.rs
index 772fc1a81a34b8..71234057b22910 100644
--- a/crates/ui/src/components/divider.rs
+++ b/crates/ui/src/components/divider.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use gpui::{Hsla, IntoElement};
 
 use crate::prelude::*;
diff --git a/crates/ui/src/components/dropdown_menu.rs b/crates/ui/src/components/dropdown_menu.rs
index ab2f6a372ee91d..8d930a63acd479 100644
--- a/crates/ui/src/components/dropdown_menu.rs
+++ b/crates/ui/src/components/dropdown_menu.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use gpui::{AnchorCorner, ClickEvent, CursorStyle, MouseButton, View};
 
 use crate::{prelude::*, ContextMenu, PopoverMenu};
diff --git a/crates/ui/src/components/facepile.rs b/crates/ui/src/components/facepile.rs
index f391fc60bb0caa..c3a56d8e20fe88 100644
--- a/crates/ui/src/components/facepile.rs
+++ b/crates/ui/src/components/facepile.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use crate::prelude::*;
 use gpui::{AnyElement, StyleRefinement};
 use smallvec::SmallVec;
diff --git a/crates/ui/src/components/icon.rs b/crates/ui/src/components/icon.rs
index 323181e84156f4..693caaaafdacc7 100644
--- a/crates/ui/src/components/icon.rs
+++ b/crates/ui/src/components/icon.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use gpui::{svg, AnimationElement, Hsla, IntoElement, Rems, Transformation};
 use serde::{Deserialize, Serialize};
 use strum::{EnumIter, EnumString, IntoStaticStr};
diff --git a/crates/ui/src/components/image.rs b/crates/ui/src/components/image.rs
index e7eefe5fea3100..a510b4d7a22492 100644
--- a/crates/ui/src/components/image.rs
+++ b/crates/ui/src/components/image.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use gpui::{svg, IntoElement, Rems, RenderOnce, Size, Styled, WindowContext};
 use serde::{Deserialize, Serialize};
 use strum::{EnumIter, EnumString, IntoStaticStr};
diff --git a/crates/ui/src/components/indicator.rs b/crates/ui/src/components/indicator.rs
index 0b4a3147c175db..009fe44dfef087 100644
--- a/crates/ui/src/components/indicator.rs
+++ b/crates/ui/src/components/indicator.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use crate::{prelude::*, AnyIcon};
 
 #[derive(Default)]
diff --git a/crates/ui/src/components/keybinding.rs b/crates/ui/src/components/keybinding.rs
index 1e4983f5adb808..135599b914bc03 100644
--- a/crates/ui/src/components/keybinding.rs
+++ b/crates/ui/src/components/keybinding.rs
@@ -1,5 +1,7 @@
+#![allow(missing_docs)]
+use crate::PlatformStyle;
 use crate::{h_flex, prelude::*, Icon, IconName, IconSize};
-use gpui::{relative, Action, FocusHandle, IntoElement, Keystroke};
+use gpui::{relative, Action, FocusHandle, IntoElement, Keystroke, WindowContext};
 
 #[derive(IntoElement, Clone)]
 pub struct KeyBinding {
@@ -192,3 +194,173 @@ impl KeyIcon {
         Self { icon }
     }
 }
+
+/// Returns a textual representation of the key binding for the given [`Action`].
+pub fn text_for_action(action: &dyn Action, cx: &mut WindowContext) -> Option<String> {
+    let key_binding = cx.bindings_for_action(action).last().cloned()?;
+    Some(text_for_key_binding(key_binding, PlatformStyle::platform()))
+}
+
+/// Returns a textual representation of the key binding for the given [`Action`]
+/// as if the provided [`FocusHandle`] was focused.
+pub fn text_for_action_in(
+    action: &dyn Action,
+    focus: &FocusHandle,
+    cx: &mut WindowContext,
+) -> Option<String> {
+    let key_binding = cx.bindings_for_action_in(action, focus).last().cloned()?;
+    Some(text_for_key_binding(key_binding, PlatformStyle::platform()))
+}
+
+/// Returns a textual representation of the given key binding for the specified platform.
+pub fn text_for_key_binding(
+    key_binding: gpui::KeyBinding,
+    platform_style: PlatformStyle,
+) -> String {
+    key_binding
+        .keystrokes()
+        .iter()
+        .map(|keystroke| text_for_keystroke(keystroke, platform_style))
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+/// Returns a textual representation of the given [`Keystroke`].
+pub fn text_for_keystroke(keystroke: &Keystroke, platform_style: PlatformStyle) -> String {
+    let mut text = String::new();
+
+    let delimiter = match platform_style {
+        PlatformStyle::Mac => '-',
+        PlatformStyle::Linux | PlatformStyle::Windows => '+',
+    };
+
+    if keystroke.modifiers.function {
+        match platform_style {
+            PlatformStyle::Mac => text.push_str("fn"),
+            PlatformStyle::Linux | PlatformStyle::Windows => text.push_str("Fn"),
+        }
+
+        text.push(delimiter);
+    }
+
+    if keystroke.modifiers.control {
+        match platform_style {
+            PlatformStyle::Mac => text.push_str("Control"),
+            PlatformStyle::Linux | PlatformStyle::Windows => text.push_str("Ctrl"),
+        }
+
+        text.push(delimiter);
+    }
+
+    if keystroke.modifiers.alt {
+        match platform_style {
+            PlatformStyle::Mac => text.push_str("Option"),
+            PlatformStyle::Linux | PlatformStyle::Windows => text.push_str("Alt"),
+        }
+
+        text.push(delimiter);
+    }
+
+    if keystroke.modifiers.platform {
+        match platform_style {
+            PlatformStyle::Mac => text.push_str("Command"),
+            PlatformStyle::Linux => text.push_str("Super"),
+            PlatformStyle::Windows => text.push_str("Win"),
+        }
+
+        text.push(delimiter);
+    }
+
+    if keystroke.modifiers.shift {
+        match platform_style {
+            PlatformStyle::Mac | PlatformStyle::Linux | PlatformStyle::Windows => {
+                text.push_str("Shift")
+            }
+        }
+
+        text.push(delimiter);
+    }
+
+    fn capitalize(str: &str) -> String {
+        let mut chars = str.chars();
+        match chars.next() {
+            None => String::new(),
+            Some(first_char) => first_char.to_uppercase().collect::<String>() + chars.as_str(),
+        }
+    }
+
+    let key = match keystroke.key.as_str() {
+        "pageup" => "PageUp",
+        "pagedown" => "PageDown",
+        key => &capitalize(key),
+    };
+
+    text.push_str(key);
+
+    text
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_text_for_keystroke() {
+        assert_eq!(
+            text_for_keystroke(&Keystroke::parse("cmd-c").unwrap(), PlatformStyle::Mac),
+            "Command-C".to_string()
+        );
+        assert_eq!(
+            text_for_keystroke(&Keystroke::parse("cmd-c").unwrap(), PlatformStyle::Linux),
+            "Super+C".to_string()
+        );
+        assert_eq!(
+            text_for_keystroke(&Keystroke::parse("cmd-c").unwrap(), PlatformStyle::Windows),
+            "Win+C".to_string()
+        );
+
+        assert_eq!(
+            text_for_keystroke(
+                &Keystroke::parse("ctrl-alt-delete").unwrap(),
+                PlatformStyle::Mac
+            ),
+            "Control-Option-Delete".to_string()
+        );
+        assert_eq!(
+            text_for_keystroke(
+                &Keystroke::parse("ctrl-alt-delete").unwrap(),
+                PlatformStyle::Linux
+            ),
+            "Ctrl+Alt+Delete".to_string()
+        );
+        assert_eq!(
+            text_for_keystroke(
+                &Keystroke::parse("ctrl-alt-delete").unwrap(),
+                PlatformStyle::Windows
+            ),
+            "Ctrl+Alt+Delete".to_string()
+        );
+
+        assert_eq!(
+            text_for_keystroke(
+                &Keystroke::parse("shift-pageup").unwrap(),
+                PlatformStyle::Mac
+            ),
+            "Shift-PageUp".to_string()
+        );
+        assert_eq!(
+            text_for_keystroke(
+                &Keystroke::parse("shift-pageup").unwrap(),
+                PlatformStyle::Linux
+            ),
+            "Shift+PageUp".to_string()
+        );
+        assert_eq!(
+            text_for_keystroke(
+                &Keystroke::parse("shift-pageup").unwrap(),
+                PlatformStyle::Windows
+            ),
+            "Shift+PageUp".to_string()
+        );
+    }
+}
diff --git a/crates/ui/src/components/label/highlighted_label.rs b/crates/ui/src/components/label/highlighted_label.rs
index 6b170bb810f42b..f9617139565113 100644
--- a/crates/ui/src/components/label/highlighted_label.rs
+++ b/crates/ui/src/components/label/highlighted_label.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use std::ops::Range;
 
 use gpui::{FontWeight, HighlightStyle, StyledText};
diff --git a/crates/ui/src/components/label/label.rs b/crates/ui/src/components/label/label.rs
index 898a59de775d9e..f65596184191c2 100644
--- a/crates/ui/src/components/label/label.rs
+++ b/crates/ui/src/components/label/label.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::{StyleRefinement, WindowContext};
 
 use crate::{prelude::*, LabelCommon, LabelLike, LabelSize, LineHeightStyle};
diff --git a/crates/ui/src/components/label/label_like.rs b/crates/ui/src/components/label/label_like.rs
index bc2fae15a7fdc4..0bd21eda4f34f9 100644
--- a/crates/ui/src/components/label/label_like.rs
+++ b/crates/ui/src/components/label/label_like.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::{relative, AnyElement, FontWeight, StyleRefinement, Styled, UnderlineStyle};
 use settings::Settings;
 use smallvec::SmallVec;
diff --git a/crates/ui/src/components/list/list.rs b/crates/ui/src/components/list/list.rs
index 4bf157ef4067d8..e112a558ee3eeb 100644
--- a/crates/ui/src/components/list/list.rs
+++ b/crates/ui/src/components/list/list.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::AnyElement;
 use smallvec::SmallVec;
 
diff --git a/crates/ui/src/components/list/list_header.rs b/crates/ui/src/components/list/list_header.rs
index 3b15f8cd3dd090..b69426b6d1f80f 100644
--- a/crates/ui/src/components/list/list_header.rs
+++ b/crates/ui/src/components/list/list_header.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use std::sync::Arc;
 
 use crate::{h_flex, prelude::*, Disclosure, Label};
diff --git a/crates/ui/src/components/list/list_item.rs b/crates/ui/src/components/list/list_item.rs
index e13fb8ef265ebf..37076737a6be0e 100644
--- a/crates/ui/src/components/list/list_item.rs
+++ b/crates/ui/src/components/list/list_item.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use std::sync::Arc;
 
 use gpui::{px, AnyElement, AnyView, ClickEvent, MouseButton, MouseDownEvent, Pixels};
diff --git a/crates/ui/src/components/list/list_separator.rs b/crates/ui/src/components/list/list_separator.rs
index 0d5fdf8d494fbe..aa53efab372f05 100644
--- a/crates/ui/src/components/list/list_separator.rs
+++ b/crates/ui/src/components/list/list_separator.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use crate::prelude::*;
 
 #[derive(IntoElement)]
diff --git a/crates/ui/src/components/list/list_sub_header.rs b/crates/ui/src/components/list/list_sub_header.rs
index 0ed072ebbf2c90..25132b76686626 100644
--- a/crates/ui/src/components/list/list_sub_header.rs
+++ b/crates/ui/src/components/list/list_sub_header.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use crate::prelude::*;
 use crate::{h_flex, Icon, IconName, IconSize, Label};
 
diff --git a/crates/ui/src/components/modal.rs b/crates/ui/src/components/modal.rs
index dec7a14a52fe5e..11611f9c0ffc92 100644
--- a/crates/ui/src/components/modal.rs
+++ b/crates/ui/src/components/modal.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use crate::{
     h_flex, v_flex, Clickable, Color, Headline, HeadlineSize, IconButton, IconButtonShape,
     IconName, Label, LabelCommon, LabelSize, Spacing,
diff --git a/crates/ui/src/components/numeric_stepper.rs b/crates/ui/src/components/numeric_stepper.rs
index 64ea79f21cc6de..39be56a455641c 100644
--- a/crates/ui/src/components/numeric_stepper.rs
+++ b/crates/ui/src/components/numeric_stepper.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::ClickEvent;
 
 use crate::{prelude::*, IconButtonShape};
diff --git a/crates/ui/src/components/popover.rs b/crates/ui/src/components/popover.rs
index af20f3818663d4..5bd6c1ed7ccbca 100644
--- a/crates/ui/src/components/popover.rs
+++ b/crates/ui/src/components/popover.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use crate::prelude::*;
 use crate::v_flex;
 use gpui::{
diff --git a/crates/ui/src/components/popover_menu.rs b/crates/ui/src/components/popover_menu.rs
index 02604b2cc6b19b..e05888bdf600cd 100644
--- a/crates/ui/src/components/popover_menu.rs
+++ b/crates/ui/src/components/popover_menu.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use std::{cell::RefCell, rc::Rc};
 
 use gpui::{
diff --git a/crates/ui/src/components/radio.rs b/crates/ui/src/components/radio.rs
index f3eeb9dac000d9..c4ceef5f8379a5 100644
--- a/crates/ui/src/components/radio.rs
+++ b/crates/ui/src/components/radio.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use std::sync::Arc;
 
 use crate::prelude::*;
diff --git a/crates/ui/src/components/right_click_menu.rs b/crates/ui/src/components/right_click_menu.rs
index c340a4ad896ef9..f68b85016c4d1e 100644
--- a/crates/ui/src/components/right_click_menu.rs
+++ b/crates/ui/src/components/right_click_menu.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use std::{cell::RefCell, rc::Rc};
 
 use gpui::{
diff --git a/crates/ui/src/components/settings_container.rs b/crates/ui/src/components/settings_container.rs
index df1c355e06a514..56248ce528022d 100644
--- a/crates/ui/src/components/settings_container.rs
+++ b/crates/ui/src/components/settings_container.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::AnyElement;
 use smallvec::SmallVec;
 
diff --git a/crates/ui/src/components/settings_group.rs b/crates/ui/src/components/settings_group.rs
index 60939640572dab..77b4416a4a4c95 100644
--- a/crates/ui/src/components/settings_group.rs
+++ b/crates/ui/src/components/settings_group.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::AnyElement;
 use smallvec::SmallVec;
 
diff --git a/crates/ui/src/components/stack.rs b/crates/ui/src/components/stack.rs
index 74a5e80575bfe0..2af0a5d3f98b08 100644
--- a/crates/ui/src/components/stack.rs
+++ b/crates/ui/src/components/stack.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::{div, Div};
 
 use crate::StyledExt;
diff --git a/crates/ui/src/components/stories.rs b/crates/ui/src/components/stories.rs
index 9014f5a47082f3..88325f2201b172 100644
--- a/crates/ui/src/components/stories.rs
+++ b/crates/ui/src/components/stories.rs
@@ -1,3 +1,6 @@
+// We allow missing docs for stories as the docs will more or less be
+// "This is the ___ story", which is not very useful.
+#![allow(missing_docs)]
 mod avatar;
 mod button;
 mod checkbox;
diff --git a/crates/ui/src/components/tab.rs b/crates/ui/src/components/tab.rs
index 1ec4cd4aecf3eb..9540063c78dc40 100644
--- a/crates/ui/src/components/tab.rs
+++ b/crates/ui/src/components/tab.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use std::cmp::Ordering;
 
 use gpui::{AnyElement, IntoElement, Stateful};
diff --git a/crates/ui/src/components/tab_bar.rs b/crates/ui/src/components/tab_bar.rs
index 0012c53ed81081..5657721e17a215 100644
--- a/crates/ui/src/components/tab_bar.rs
+++ b/crates/ui/src/components/tab_bar.rs
@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use gpui::{AnyElement, ScrollHandle};
 use smallvec::SmallVec;
 
diff --git a/crates/ui/src/components/tool_strip.rs b/crates/ui/src/components/tool_strip.rs
index ced4b271ad3c4a..78767aadf73fbb 100644
--- a/crates/ui/src/components/tool_strip.rs
+++ b/crates/ui/src/components/tool_strip.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use crate::prelude::*;
 use gpui::*;
 
diff --git a/crates/ui/src/components/tooltip.rs b/crates/ui/src/components/tooltip.rs
index dc02d60b36d4a3..89b89786b0dfa4 100644
--- a/crates/ui/src/components/tooltip.rs
+++ b/crates/ui/src/components/tooltip.rs
@@ -1,3 +1,5 @@
+#![allow(missing_docs)]
+
 use gpui::{Action, AnyView, FocusHandle, IntoElement, Render, VisualContext};
 use settings::Settings;
 use theme::ThemeSettings;
diff --git a/crates/ui/src/key_bindings.rs b/crates/ui/src/key_bindings.rs
deleted file mode 100644
index 7746d096fed9c0..00000000000000
--- a/crates/ui/src/key_bindings.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-use gpui::{Action, FocusHandle, KeyBinding, Keystroke, WindowContext};
-
-use crate::PlatformStyle;
-
-/// Returns a textual representation of the key binding for the given [`Action`].
-pub fn text_for_action(action: &dyn Action, cx: &mut WindowContext) -> Option<String> {
-    let key_binding = cx.bindings_for_action(action).last().cloned()?;
-    Some(text_for_key_binding(key_binding, PlatformStyle::platform()))
-}
-
-/// Returns a textual representation of the key binding for the given [`Action`]
-/// as if the provided [`FocusHandle`] was focused.
-pub fn text_for_action_in(
-    action: &dyn Action,
-    focus: &FocusHandle,
-    cx: &mut WindowContext,
-) -> Option<String> {
-    let key_binding = cx.bindings_for_action_in(action, focus).last().cloned()?;
-    Some(text_for_key_binding(key_binding, PlatformStyle::platform()))
-}
-
-/// Returns a textual representation of the given key binding for the specified platform.
-pub fn text_for_key_binding(key_binding: KeyBinding, platform_style: PlatformStyle) -> String {
-    key_binding
-        .keystrokes()
-        .iter()
-        .map(|keystroke| text_for_keystroke(keystroke, platform_style))
-        .collect::<Vec<_>>()
-        .join(" ")
-}
-
-/// Returns a textual representation of the given [`Keystroke`].
-pub fn text_for_keystroke(keystroke: &Keystroke, platform_style: PlatformStyle) -> String {
-    let mut text = String::new();
-
-    let delimiter = match platform_style {
-        PlatformStyle::Mac => '-',
-        PlatformStyle::Linux | PlatformStyle::Windows => '+',
-    };
-
-    if keystroke.modifiers.function {
-        match platform_style {
-            PlatformStyle::Mac => text.push_str("fn"),
-            PlatformStyle::Linux | PlatformStyle::Windows => text.push_str("Fn"),
-        }
-
-        text.push(delimiter);
-    }
-
-    if keystroke.modifiers.control {
-        match platform_style {
-            PlatformStyle::Mac => text.push_str("Control"),
-            PlatformStyle::Linux | PlatformStyle::Windows => text.push_str("Ctrl"),
-        }
-
-        text.push(delimiter);
-    }
-
-    if keystroke.modifiers.alt {
-        match platform_style {
-            PlatformStyle::Mac => text.push_str("Option"),
-            PlatformStyle::Linux | PlatformStyle::Windows => text.push_str("Alt"),
-        }
-
-        text.push(delimiter);
-    }
-
-    if keystroke.modifiers.platform {
-        match platform_style {
-            PlatformStyle::Mac => text.push_str("Command"),
-            PlatformStyle::Linux => text.push_str("Super"),
-            PlatformStyle::Windows => text.push_str("Win"),
-        }
-
-        text.push(delimiter);
-    }
-
-    if keystroke.modifiers.shift {
-        match platform_style {
-            PlatformStyle::Mac | PlatformStyle::Linux | PlatformStyle::Windows => {
-                text.push_str("Shift")
-            }
-        }
-
-        text.push(delimiter);
-    }
-
-    fn capitalize(str: &str) -> String {
-        let mut chars = str.chars();
-        match chars.next() {
-            None => String::new(),
-            Some(first_char) => first_char.to_uppercase().collect::<String>() + chars.as_str(),
-        }
-    }
-
-    let key = match keystroke.key.as_str() {
-        "pageup" => "PageUp",
-        "pagedown" => "PageDown",
-        key => &capitalize(key),
-    };
-
-    text.push_str(key);
-
-    text
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_text_for_keystroke() {
-        assert_eq!(
-            text_for_keystroke(&Keystroke::parse("cmd-c").unwrap(), PlatformStyle::Mac),
-            "Command-C".to_string()
-        );
-        assert_eq!(
-            text_for_keystroke(&Keystroke::parse("cmd-c").unwrap(), PlatformStyle::Linux),
-            "Super+C".to_string()
-        );
-        assert_eq!(
-            text_for_keystroke(&Keystroke::parse("cmd-c").unwrap(), PlatformStyle::Windows),
-            "Win+C".to_string()
-        );
-
-        assert_eq!(
-            text_for_keystroke(
-                &Keystroke::parse("ctrl-alt-delete").unwrap(),
-                PlatformStyle::Mac
-            ),
-            "Control-Option-Delete".to_string()
-        );
-        assert_eq!(
-            text_for_keystroke(
-                &Keystroke::parse("ctrl-alt-delete").unwrap(),
-                PlatformStyle::Linux
-            ),
-            "Ctrl+Alt+Delete".to_string()
-        );
-        assert_eq!(
-            text_for_keystroke(
-                &Keystroke::parse("ctrl-alt-delete").unwrap(),
-                PlatformStyle::Windows
-            ),
-            "Ctrl+Alt+Delete".to_string()
-        );
-
-        assert_eq!(
-            text_for_keystroke(
-                &Keystroke::parse("shift-pageup").unwrap(),
-                PlatformStyle::Mac
-            ),
-            "Shift-PageUp".to_string()
-        );
-        assert_eq!(
-            text_for_keystroke(
-                &Keystroke::parse("shift-pageup").unwrap(),
-                PlatformStyle::Linux
-            ),
-            "Shift+PageUp".to_string()
-        );
-        assert_eq!(
-            text_for_keystroke(
-                &Keystroke::parse("shift-pageup").unwrap(),
-                PlatformStyle::Windows
-            ),
-            "Shift+PageUp".to_string()
-        );
-    }
-}
diff --git a/crates/ui/src/prelude.rs b/crates/ui/src/prelude.rs
index 895c755c786c10..d01ac11bc3e43c 100644
--- a/crates/ui/src/prelude.rs
+++ b/crates/ui/src/prelude.rs
@@ -7,16 +7,17 @@ pub use gpui::{
     WindowContext,
 };
 
-pub use crate::clickable::*;
-pub use crate::disableable::*;
-pub use crate::fixed::*;
-pub use crate::selectable::*;
 pub use crate::styles::{rems_from_px, vh, vw, PlatformStyle, StyledTypography, TextSize};
-pub use crate::visible_on_hover::*;
+pub use crate::traits::clickable::*;
+pub use crate::traits::disableable::*;
+pub use crate::traits::fixed::*;
+pub use crate::traits::selectable::*;
+pub use crate::traits::styled_ext::*;
+pub use crate::traits::visible_on_hover::*;
 pub use crate::Spacing;
 pub use crate::{h_flex, v_flex};
 pub use crate::{Button, ButtonSize, ButtonStyle, IconButton, SelectableButton};
-pub use crate::{ButtonCommon, Color, StyledExt};
+pub use crate::{ButtonCommon, Color};
 pub use crate::{Headline, HeadlineSize};
 pub use crate::{Icon, IconName, IconPosition, IconSize};
 pub use crate::{Label, LabelCommon, LabelSize, LineHeightStyle};
diff --git a/crates/ui/src/styles/appearance.rs b/crates/ui/src/styles/appearance.rs
index 57d4757a3674e1..3b014b733c9fc2 100644
--- a/crates/ui/src/styles/appearance.rs
+++ b/crates/ui/src/styles/appearance.rs
@@ -1,14 +1,8 @@
 use crate::prelude::*;
 use gpui::{WindowBackgroundAppearance, WindowContext};
-use theme::Appearance;
-
-/// Returns the current [Appearance].
-pub fn appearance(cx: &WindowContext) -> Appearance {
-    cx.theme().appearance
-}
 
 /// Returns the [WindowBackgroundAppearance].
-pub fn window_appearance(cx: &WindowContext) -> WindowBackgroundAppearance {
+fn window_appearance(cx: &WindowContext) -> WindowBackgroundAppearance {
     cx.theme().styles.window_background_appearance
 }
 
diff --git a/crates/ui/src/styles/color.rs b/crates/ui/src/styles/color.rs
index b35728e478fb5e..fe8de2ff734966 100644
--- a/crates/ui/src/styles/color.rs
+++ b/crates/ui/src/styles/color.rs
@@ -5,28 +5,63 @@ use theme::ActiveTheme;
 #[derive(Debug, Default, PartialEq, Copy, Clone)]
 pub enum Color {
     #[default]
+    /// The default text color. Might be known as "foreground" or "primary" in
+    /// some theme systems.
+    ///
+    /// For less emphasis, consider using [`Color::Muted`] or [`Color::Hidden`].
     Default,
+    /// A text color used for accents, such as links or highlights.
     Accent,
+    /// A color used to indicate a conflict, such as a version control merge conflict, or a conflict between a file in the editor and the file system.
+    Conflict,
+    /// A color used to indicate a newly created item, such as a new file in
+    /// version control, or a new file on disk.
     Created,
+    /// It is highly, HIGHLY recommended not to use this! Using this color
+    /// means detaching it from any semantic meaning across themes.
+    ///
+    /// A custom color specified by an HSLA value.
+    Custom(Hsla),
+    /// A color used to indicate a deleted item, such as a file removed from version control.
     Deleted,
+    /// A color used for disabled UI elements or text, like a disabled button or menu item.
     Disabled,
+    /// A color used to indicate an error condition, or something the user
+    /// cannot do. In very rare cases, it might be used to indicate dangerous or
+    /// destructive action.
     Error,
+    /// A color used for elements that represent something that is hidden, like
+    /// a hidden file, or an element that should be visually de-emphasized.
     Hidden,
+    /// A color used for hint or suggestion text, often a blue color. Use this
+    /// color to represent helpful, or semantically neutral information.
     Hint,
+    /// A color used for items that are intentionally ignored, such as files ignored by version control.
+    Ignored,
+    /// A color used for informational messages or status indicators, often a blue color.
     Info,
+    /// A color used to indicate a modified item, such as an edited file, or a modified entry in version control.
     Modified,
-    Conflict,
-    Ignored,
+    /// A color used for text or UI elements that should be visually muted or de-emphasized.
+    ///
+    /// For more emphasis, consider using [`Color::Default`].
+    ///
+    /// For less emphasis, consider using [`Color::Hidden`].
     Muted,
+    /// A color used for placeholder text in input fields.
     Placeholder,
+    /// A color associated with a specific player number.
     Player(u32),
+    /// A color used to indicate selected text or UI elements.
     Selected,
+    /// A color used to indicate a successful operation or status.
     Success,
+    /// A color used to indicate a warning condition.
     Warning,
-    Custom(Hsla),
 }
 
 impl Color {
+    /// Returns the Color's HSLA value.
     pub fn color(&self, cx: &WindowContext) -> Hsla {
         match self {
             Color::Default => cx.theme().colors().text,
diff --git a/crates/ui/src/styles/docs/elevation.md b/crates/ui/src/styles/docs/elevation.md
deleted file mode 100644
index 677fd030fd9ba1..00000000000000
--- a/crates/ui/src/styles/docs/elevation.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# Elevation
-
-Elevation can be thought of as the physical closeness of an element to the user. Elements with lower elevations are physically further away from the user on the z-axis and appear to be underneath elements with higher elevations.
-
-Material Design 3 has a some great visualizations of elevation that may be helpful to understanding the mental modal of elevation. [Material Design – Elevation](https://m3.material.io/styles/elevation/overview)
-
-## Elevation Levels
-
-1. App Background (e.x.: Workspace, system window)
-1. UI Surface (e.x.: Title Bar, Panel, Tab Bar)
-1. Elevated Surface (e.x.: Palette, Notification, Floating Window)
-1. Wash
-1. Modal Surfaces (e.x.: Modal)
-1. Dragged Element (This is a special case, see Layer section below)
-
-### App Background
-
-The app background constitutes the lowest elevation layer, appearing behind all other surfaces and components. It is predominantly used for the background color of the app.
-
-### Surface
-
-The Surface elevation level, located above the app background, is the standard level for all elements
-
-Example Elements: Title Bar, Panel, Tab Bar, Editor
-
-### Elevated Surface
-
-Non-Modal Elevated Surfaces appear above the UI surface layer and is used for things that should appear above most UI elements like an editor or panel, but not elements like popovers, context menus, modals, etc.
-
-Examples: Notifications, Palettes, Detached/Floating Windows, Detached/Floating Panels
-
-You could imagine a variant of the assistant that floats in a window above the editor on this elevation, or a floating terminal window that becomes less opaque when not focused.
-
-### Wash
-
-Wash denotes a distinct elevation reserved to isolate app UI layers from high elevation components such as modals, notifications, and overlaid panels. The wash may not consistently be visible when these components are active. This layer is often referred to as a scrim or overlay and the background color of the wash is typically deployed in its design.
-
-### Modal Surfaces
-
-Modal Surfaces are used for elements that should appear above all other UI elements and are located above the wash layer. This is the maximum elevation at which UI elements can be rendered
-
-Elements rendered at this layer have an enforced behavior: Any interaction outside of the modal will either dismiss the modal or prompt an action (Save your progress, etc) then dismiss the modal.
-
-If the element does not have this behavior, it should be rendered at the Elevated Surface layer.
diff --git a/crates/ui/src/styles/elevation.rs b/crates/ui/src/styles/elevation.rs
index c067802119b1ee..722111b46c49ff 100644
--- a/crates/ui/src/styles/elevation.rs
+++ b/crates/ui/src/styles/elevation.rs
@@ -1,31 +1,32 @@
 use gpui::{hsla, point, px, BoxShadow};
 use smallvec::{smallvec, SmallVec};
 
-#[doc = include_str!("docs/elevation.md")]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Elevation {
-    ElevationIndex(ElevationIndex),
-    LayerIndex(LayerIndex),
-    ElementIndex(ElementIndex),
-}
-
-impl From<ElevationIndex> for Elevation {
-    fn from(val: ElevationIndex) -> Self {
-        Elevation::ElevationIndex(val)
-    }
-}
-
+/// Today, elevation is primarily used to add shadows to elements, and set the correct background for elements like buttons.
+///
+/// Elevation can be thought of as the physical closeness of an element to the
+/// user. Elements with lower elevations are physically further away on the
+/// z-axis and appear to be underneath elements with higher elevations.
+///
+/// In the future, a more complete approach to elevation may be added.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ElevationIndex {
+    /// On the layer of the app background. This is under panels, panes, and
+    /// other surfaces.
     Background,
+    /// The primary surface – Contains panels, panes, containers, etc.
     Surface,
+    /// A surface that is elevated above the primary surface. but below washes, models, and dragged elements.
     ElevatedSurface,
+    /// A surface that is above all non-modal surfaces, and separates the app from focused intents, like dialogs, alerts, modals, etc.
     Wash,
+    /// A surface above the [ElevationIndex::Wash] that is used for dialogs, alerts, modals, etc.
     ModalSurface,
+    /// A surface above all other surfaces, reserved exclusively for dragged elements, like a dragged file, tab or other draggable element.
     DraggedElement,
 }
 
 impl ElevationIndex {
+    /// Returns an appropriate shadow for the given elevation index.
     pub fn shadow(self) -> SmallVec<[BoxShadow; 2]> {
         match self {
             ElevationIndex::Surface => smallvec![],
@@ -62,21 +63,3 @@ impl ElevationIndex {
         }
     }
 }
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum LayerIndex {
-    BehindElement,
-    Element,
-    ElevatedElement,
-}
-
-/// An appropriate z-index for the given layer based on its intended usage.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ElementIndex {
-    Effect,
-    Background,
-    Tint,
-    Highlight,
-    Content,
-    Overlay,
-}
diff --git a/crates/ui/src/styles/spacing.rs b/crates/ui/src/styles/spacing.rs
index 282980fcaf5e1c..a2089d9586bd45 100644
--- a/crates/ui/src/styles/spacing.rs
+++ b/crates/ui/src/styles/spacing.rs
@@ -4,6 +4,11 @@ use theme::{ThemeSettings, UiDensity};
 
 use crate::{rems_from_px, BASE_REM_SIZE_IN_PX};
 
+/// A dynamic spacing system that adjusts spacing based on
+/// [UiDensity].
+///
+/// When possible, [Spacing] should be used over manual
+/// or built-in spacing values in places dynamic spacing is needed.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Spacing {
     /// No spacing
@@ -38,6 +43,7 @@ pub enum Spacing {
 }
 
 impl Spacing {
+    /// Returns the spacing's scaling ratio in pixels.
     pub fn spacing_ratio(self, cx: &WindowContext) -> f32 {
         match ThemeSettings::get_global(cx).ui_density {
             UiDensity::Compact => match self {
@@ -73,10 +79,12 @@ impl Spacing {
         }
     }
 
+    /// Returns the spacing's value in rems.
     pub fn rems(self, cx: &WindowContext) -> Rems {
         rems(self.spacing_ratio(cx))
     }
 
+    /// Returns the spacing's value in pixels.
     pub fn px(self, cx: &WindowContext) -> Pixels {
         let ui_font_size_f32: f32 = ThemeSettings::get_global(cx).ui_font_size.into();
 
@@ -84,10 +92,14 @@ impl Spacing {
     }
 }
 
-pub fn user_spacing_style(cx: &WindowContext) -> UiDensity {
+fn user_spacing_style(cx: &WindowContext) -> UiDensity {
     ThemeSettings::get_global(cx).ui_density
 }
 
+/// Returns a custom spacing value based on the current [`UiDensity`].
+///
+/// If you use this, talk to @iamnbutler and let me know what you're doing
+/// that needs custom spacing– I'd love to understand so we can extend the system further and remove the need for this.
 pub fn custom_spacing(cx: &WindowContext, size: f32) -> Rems {
     rems_from_px(size * user_spacing_style(cx).spacing_ratio())
 }
diff --git a/crates/ui/src/styles/typography.rs b/crates/ui/src/styles/typography.rs
index 4afd3b93036c2f..ef9c946ed54c04 100644
--- a/crates/ui/src/styles/typography.rs
+++ b/crates/ui/src/styles/typography.rs
@@ -87,6 +87,7 @@ pub trait StyledTypography: Styled + Sized {
 
 impl<E: Styled> StyledTypography for E {}
 
+/// A utility for getting the size of various semantic text sizes.
 #[derive(Debug, Default, Clone)]
 pub enum TextSize {
     /// The default size for UI text.
@@ -128,6 +129,7 @@ pub enum TextSize {
 }
 
 impl TextSize {
+    /// Returns the text size in rems.
     pub fn rems(self, cx: &WindowContext) -> Rems {
         let theme_settings = ThemeSettings::get_global(cx);
 
@@ -143,20 +145,27 @@ impl TextSize {
 }
 
 /// The size of a [`Headline`] element
+///
+/// Defaults to a Major Second scale.
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Default)]
 pub enum HeadlineSize {
+    /// An extra small headline - `~14px` @16px/rem
     XSmall,
+    /// A small headline - `16px` @16px/rem
     Small,
     #[default]
+    /// A medium headline - `~18px` @16px/rem
     Medium,
+    /// A large headline - `~20px` @16px/rem
     Large,
+    /// An extra large headline - `~22px` @16px/rem
     XLarge,
 }
 
 impl HeadlineSize {
-    pub fn size(self) -> Rems {
+    /// Returns the headline size in rems.
+    pub fn rems(self) -> Rems {
         match self {
-            // Based on the Major Second scale
             Self::XSmall => rems(0.88),
             Self::Small => rems(1.0),
             Self::Medium => rems(1.125),
@@ -165,6 +174,7 @@ impl HeadlineSize {
         }
     }
 
+    /// Returns the line height for the headline size.
     pub fn line_height(self) -> Rems {
         match self {
             Self::XSmall => rems(1.6),
@@ -176,6 +186,8 @@ impl HeadlineSize {
     }
 }
 
+/// A headline element, used to emphasize some text and
+/// create a visual hierarchy.
 #[derive(IntoElement)]
 pub struct Headline {
     size: HeadlineSize,
@@ -190,13 +202,14 @@ impl RenderOnce for Headline {
         div()
             .font(ui_font)
             .line_height(self.size.line_height())
-            .text_size(self.size.size())
+            .text_size(self.size.rems())
             .text_color(cx.theme().colors().text)
             .child(self.text)
     }
 }
 
 impl Headline {
+    /// Create a new headline element.
     pub fn new(text: impl Into<SharedString>) -> Self {
         Self {
             size: HeadlineSize::default(),
@@ -205,11 +218,13 @@ impl Headline {
         }
     }
 
+    /// Set the size of the headline.
     pub fn size(mut self, size: HeadlineSize) -> Self {
         self.size = size;
         self
     }
 
+    /// Set the color of the headline.
     pub fn color(mut self, color: Color) -> Self {
         self.color = color;
         self
diff --git a/crates/ui/src/tests.rs b/crates/ui/src/tests.rs
new file mode 100644
index 00000000000000..3f26326a056f39
--- /dev/null
+++ b/crates/ui/src/tests.rs
@@ -0,0 +1 @@
+mod path_str;
diff --git a/crates/ui/src/path_str.rs b/crates/ui/src/tests/path_str.rs
similarity index 54%
rename from crates/ui/src/path_str.rs
rename to crates/ui/src/tests/path_str.rs
index 2ebb3fedb36266..6c1545ec7104d0 100644
--- a/crates/ui/src/path_str.rs
+++ b/crates/ui/src/tests/path_str.rs
@@ -1,3 +1,5 @@
+// We need to test [ui_macros::DerivePathStr] here as we can't invoke it
+// in the `ui_macros` crate.
 #[cfg(test)]
 mod tests {
     use strum::EnumString;
@@ -8,26 +10,26 @@ mod tests {
         #[derive(Debug, EnumString, DerivePathStr)]
         #[strum(serialize_all = "snake_case")]
         #[path_str(prefix = "test_prefix")]
-        enum MyEnum {
+        enum SomeAsset {
             FooBar,
             Baz,
         }
 
-        assert_eq!(MyEnum::FooBar.path(), "test_prefix/foo_bar");
-        assert_eq!(MyEnum::Baz.path(), "test_prefix/baz");
+        assert_eq!(SomeAsset::FooBar.path(), "test_prefix/foo_bar");
+        assert_eq!(SomeAsset::Baz.path(), "test_prefix/baz");
     }
 
     #[test]
     fn test_derive_path_str_with_prefix_and_suffix() {
         #[derive(Debug, EnumString, DerivePathStr)]
         #[strum(serialize_all = "snake_case")]
-        #[path_str(prefix = "test_prefix", suffix = ".txt")]
-        enum MyEnum {
+        #[path_str(prefix = "test_prefix", suffix = ".svg")]
+        enum SomeAsset {
             FooBar,
             Baz,
         }
 
-        assert_eq!(MyEnum::FooBar.path(), "test_prefix/foo_bar.txt");
-        assert_eq!(MyEnum::Baz.path(), "test_prefix/baz.txt");
+        assert_eq!(SomeAsset::FooBar.path(), "test_prefix/foo_bar.svg");
+        assert_eq!(SomeAsset::Baz.path(), "test_prefix/baz.svg");
     }
 }
diff --git a/crates/ui/src/traits.rs b/crates/ui/src/traits.rs
new file mode 100644
index 00000000000000..7e52f2a8675647
--- /dev/null
+++ b/crates/ui/src/traits.rs
@@ -0,0 +1,6 @@
+pub mod clickable;
+pub mod disableable;
+pub mod fixed;
+pub mod selectable;
+pub mod styled_ext;
+pub mod visible_on_hover;
diff --git a/crates/ui/src/clickable.rs b/crates/ui/src/traits/clickable.rs
similarity index 100%
rename from crates/ui/src/clickable.rs
rename to crates/ui/src/traits/clickable.rs
diff --git a/crates/ui/src/disableable.rs b/crates/ui/src/traits/disableable.rs
similarity index 100%
rename from crates/ui/src/disableable.rs
rename to crates/ui/src/traits/disableable.rs
diff --git a/crates/ui/src/fixed.rs b/crates/ui/src/traits/fixed.rs
similarity index 100%
rename from crates/ui/src/fixed.rs
rename to crates/ui/src/traits/fixed.rs
diff --git a/crates/ui/src/selectable.rs b/crates/ui/src/traits/selectable.rs
similarity index 100%
rename from crates/ui/src/selectable.rs
rename to crates/ui/src/traits/selectable.rs
diff --git a/crates/ui/src/styled_ext.rs b/crates/ui/src/traits/styled_ext.rs
similarity index 100%
rename from crates/ui/src/styled_ext.rs
rename to crates/ui/src/traits/styled_ext.rs
diff --git a/crates/ui/src/visible_on_hover.rs b/crates/ui/src/traits/visible_on_hover.rs
similarity index 85%
rename from crates/ui/src/visible_on_hover.rs
rename to crates/ui/src/traits/visible_on_hover.rs
index aefa7ac10c5064..fc0bb837d74123 100644
--- a/crates/ui/src/visible_on_hover.rs
+++ b/crates/ui/src/traits/visible_on_hover.rs
@@ -1,5 +1,7 @@
 use gpui::{InteractiveElement, SharedString, Styled};
 
+/// A trait for elements that can be made visible on hover by
+/// tracking a specific group.
 pub trait VisibleOnHover {
     /// Sets the element to only be visible when the specified group is hovered.
     ///
diff --git a/crates/ui/src/ui.rs b/crates/ui/src/ui.rs
index 4f5d6314bea6a6..101de4f3efa1ad 100644
--- a/crates/ui/src/ui.rs
+++ b/crates/ui/src/ui.rs
@@ -1,28 +1,22 @@
+#![deny(missing_docs)]
+
 //! # UI – Zed UI Primitives & Components
 //!
 //! This crate provides a set of UI primitives and components that are used to build all of the elements in Zed's UI.
 //!
+//! ## Related Crates:
+//!
+//! - [`ui_macros`] - proc_macros support for this crate
+//! - [`ui_input`] - the single line input component
+//!
 
-mod clickable;
 mod components;
-mod disableable;
-mod fixed;
-mod key_bindings;
-mod path_str;
 pub mod prelude;
-mod selectable;
-mod styled_ext;
 mod styles;
+mod tests;
+mod traits;
 pub mod utils;
-mod visible_on_hover;
-mod with_rem_size;
 
-pub use clickable::*;
 pub use components::*;
-pub use disableable::*;
-pub use fixed::*;
-pub use key_bindings::*;
 pub use prelude::*;
-pub use styled_ext::*;
 pub use styles::*;
-pub use with_rem_size::*;
diff --git a/crates/ui/src/utils.rs b/crates/ui/src/utils.rs
index ed1fec690fc738..b68d6e6bbdba61 100644
--- a/crates/ui/src/utils.rs
+++ b/crates/ui/src/utils.rs
@@ -1,5 +1,7 @@
-//! UI-related utilities (e.g. converting dates to a human-readable form).
+//! UI-related utilities
 
 mod format_distance;
+mod with_rem_size;
 
 pub use format_distance::*;
+pub use with_rem_size::*;
diff --git a/crates/ui/src/utils/format_distance.rs b/crates/ui/src/utils/format_distance.rs
index 2abcee6684e300..af4f0d95052b28 100644
--- a/crates/ui/src/utils/format_distance.rs
+++ b/crates/ui/src/utils/format_distance.rs
@@ -1,3 +1,6 @@
+// This won't be documented further as it is intended to be removed, or merged with the `time_format` crate.
+#![allow(missing_docs)]
+
 use chrono::{DateTime, Local, NaiveDateTime};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
diff --git a/crates/ui/src/with_rem_size.rs b/crates/ui/src/utils/with_rem_size.rs
similarity index 95%
rename from crates/ui/src/with_rem_size.rs
rename to crates/ui/src/utils/with_rem_size.rs
index f286177efb6349..9011d1e28e95f0 100644
--- a/crates/ui/src/with_rem_size.rs
+++ b/crates/ui/src/utils/with_rem_size.rs
@@ -10,6 +10,8 @@ pub struct WithRemSize {
 }
 
 impl WithRemSize {
+    /// Create a new [WithRemSize] element, which sets a
+    /// particular rem size for its children.
     pub fn new(rem_size: impl Into<Pixels>) -> Self {
         Self {
             div: div(),

From 200b2bf70a548b2eec75897220d3f3e82691b499 Mon Sep 17 00:00:00 2001
From: Roman Zipp <ich@ich.wtf>
Date: Sun, 6 Oct 2024 16:11:21 +0200
Subject: [PATCH 492/762] php: Add syntax highlighting for Intelephense
 completions (#18774)

Release Notes:

- N/A

This PR introduces syntax highlighting for intelephense autocomple. The
styling was selected to roughly match PHPStorm's default scheme.

Please note that I'm not very familiar with writing Rust, but I'm happy
to adapt to any requested changes!

## Examples

### Object attributes, methods and constants

![Screenshot 2024-10-06 at 13 38
03](https://github.com/user-attachments/assets/a91634ff-0f2e-41f0-b548-ecb09c40947c)
![Screenshot 2024-10-06 at 13 38
11](https://github.com/user-attachments/assets/b6f179f4-898b-4d82-9d36-a3e82328325c)

### Typed enum members

![Screenshot 2024-10-06 at 13 38
53](https://github.com/user-attachments/assets/7133b981-4f68-4210-b233-403cdf3ec9bb)
![Screenshot 2024-10-06 at 13 38
41](https://github.com/user-attachments/assets/2e806f3d-3538-45f2-b075-b8be5902b786)

### Variables

Includes altered highlighting for [reserved variable
names](https://www.php.net/manual/en/reserved.variables.php).

![Screenshot 2024-10-06 at 13 39
30](https://github.com/user-attachments/assets/be426eb8-5879-432d-b302-391c2c68a7cb)

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 .../php/src/language_servers/intelephense.rs  | 102 ++++++++++++++++++
 extensions/php/src/php.rs                     |  14 +++
 2 files changed, 116 insertions(+)

diff --git a/extensions/php/src/language_servers/intelephense.rs b/extensions/php/src/language_servers/intelephense.rs
index 7bd66b24abfaff..23f47ac5c06344 100644
--- a/extensions/php/src/language_servers/intelephense.rs
+++ b/extensions/php/src/language_servers/intelephense.rs
@@ -1,5 +1,6 @@
 use std::{env, fs};
 
+use zed::{CodeLabel, CodeLabelSpan};
 use zed_extension_api::settings::LspSettings;
 use zed_extension_api::{self as zed, serde_json, LanguageServerId, Result};
 
@@ -104,4 +105,105 @@ impl Intelephense {
             "intelephense": settings
         })))
     }
+
+    pub fn label_for_completion(&self, completion: zed::lsp::Completion) -> Option<CodeLabel> {
+        let label = &completion.label;
+
+        match completion.kind? {
+            zed::lsp::CompletionKind::Method => {
+                // __construct method doesn't have a detail
+                if let Some(ref detail) = completion.detail {
+                    if detail.is_empty() {
+                        return Some(CodeLabel {
+                            spans: vec![
+                                CodeLabelSpan::literal(label, Some("function.method".to_string())),
+                                CodeLabelSpan::literal("()", None),
+                            ],
+                            filter_range: (0..label.len()).into(),
+                            code: completion.label,
+                        });
+                    }
+                }
+
+                let mut parts = completion.detail.as_ref()?.split(":");
+                // E.g., `foo(string $var)`
+                let name_and_params = parts.next()?;
+                let return_type = parts.next()?.trim();
+
+                let (_, params) = name_and_params.split_once("(")?;
+                let params = params.trim_end_matches(")");
+
+                Some(CodeLabel {
+                    spans: vec![
+                        CodeLabelSpan::literal(label, Some("function.method".to_string())),
+                        CodeLabelSpan::literal("(", None),
+                        CodeLabelSpan::literal(params, Some("comment".to_string())),
+                        CodeLabelSpan::literal("): ", None),
+                        CodeLabelSpan::literal(return_type, Some("type".to_string())),
+                    ],
+                    filter_range: (0..label.len()).into(),
+                    code: completion.label,
+                })
+            }
+            zed::lsp::CompletionKind::Constant | zed::lsp::CompletionKind::EnumMember => {
+                if let Some(ref detail) = completion.detail {
+                    if !detail.is_empty() {
+                        return Some(CodeLabel {
+                            spans: vec![
+                                CodeLabelSpan::literal(label, Some("constant".to_string())),
+                                CodeLabelSpan::literal(" ", None),
+                                CodeLabelSpan::literal(detail, Some("comment".to_string())),
+                            ],
+                            filter_range: (0..label.len()).into(),
+                            code: completion.label,
+                        });
+                    }
+                }
+
+                Some(CodeLabel {
+                    spans: vec![CodeLabelSpan::literal(label, Some("constant".to_string()))],
+                    filter_range: (0..label.len()).into(),
+                    code: completion.label,
+                })
+            }
+            zed::lsp::CompletionKind::Property => {
+                let return_type = completion.detail?;
+                Some(CodeLabel {
+                    spans: vec![
+                        CodeLabelSpan::literal(label, Some("attribute".to_string())),
+                        CodeLabelSpan::literal(": ", None),
+                        CodeLabelSpan::literal(return_type, Some("type".to_string())),
+                    ],
+                    filter_range: (0..label.len()).into(),
+                    code: completion.label,
+                })
+            }
+            zed::lsp::CompletionKind::Variable => {
+                // See https://www.php.net/manual/en/reserved.variables.php
+                const SYSTEM_VAR_NAMES: &[&str] =
+                    &["argc", "argv", "php_errormsg", "http_response_header"];
+
+                let var_name = completion.label.trim_start_matches("$");
+                let is_uppercase = var_name
+                    .chars()
+                    .filter(|c| c.is_alphabetic())
+                    .all(|c| c.is_uppercase());
+                let is_system_constant = var_name.starts_with("_");
+                let is_reserved = SYSTEM_VAR_NAMES.contains(&var_name);
+
+                let highlight = if is_uppercase || is_system_constant || is_reserved {
+                    Some("comment".to_string())
+                } else {
+                    None
+                };
+
+                Some(CodeLabel {
+                    spans: vec![CodeLabelSpan::literal(label, highlight)],
+                    filter_range: (0..label.len()).into(),
+                    code: completion.label,
+                })
+            }
+            _ => None,
+        }
+    }
 }
diff --git a/extensions/php/src/php.rs b/extensions/php/src/php.rs
index 7157bef07432f8..53b4c299516241 100644
--- a/extensions/php/src/php.rs
+++ b/extensions/php/src/php.rs
@@ -1,5 +1,6 @@
 mod language_servers;
 
+use zed::CodeLabel;
 use zed_extension_api::{self as zed, serde_json, LanguageServerId, Result};
 
 use crate::language_servers::{Intelephense, Phpactor};
@@ -53,6 +54,19 @@ impl zed::Extension for PhpExtension {
 
         Ok(None)
     }
+
+    fn label_for_completion(
+        &self,
+        language_server_id: &zed::LanguageServerId,
+        completion: zed::lsp::Completion,
+    ) -> Option<CodeLabel> {
+        match language_server_id.as_ref() {
+            Intelephense::LANGUAGE_SERVER_ID => {
+                self.intelephense.as_ref()?.label_for_completion(completion)
+            }
+            _ => None,
+        }
+    }
 }
 
 zed::register_extension!(PhpExtension);

From 06bd2431d2652d7cc5950ee3b823a6ad5bd28ce5 Mon Sep 17 00:00:00 2001
From: Peter <peter.kurfer@googlemail.com>
Date: Sun, 6 Oct 2024 16:12:06 +0200
Subject: [PATCH 493/762] proto: Add language server support (#18763)

Closes #18762

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 Cargo.lock                      |  7 ++++
 Cargo.toml                      |  1 +
 extensions/proto/Cargo.toml     | 16 +++++++++
 extensions/proto/LICENSE-APACHE |  1 +
 extensions/proto/extension.toml |  4 +++
 extensions/proto/src/proto.rs   | 64 +++++++++++++++++++++++++++++++++
 6 files changed, 93 insertions(+)
 create mode 100644 extensions/proto/Cargo.toml
 create mode 120000 extensions/proto/LICENSE-APACHE
 create mode 100644 extensions/proto/src/proto.rs

diff --git a/Cargo.lock b/Cargo.lock
index 9945b2df9ac87a..120f51ec93001a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14863,6 +14863,13 @@ dependencies = [
  "zed_extension_api 0.1.0",
 ]
 
+[[package]]
+name = "zed_proto"
+version = "0.1.0"
+dependencies = [
+ "zed_extension_api 0.1.0",
+]
+
 [[package]]
 name = "zed_purescript"
 version = "0.0.1"
diff --git a/Cargo.toml b/Cargo.toml
index d6f4279449c0bb..6fc22029e7a4f4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -154,6 +154,7 @@ members = [
     "extensions/php",
     "extensions/perplexity",
     "extensions/prisma",
+    "extensions/proto",
     "extensions/purescript",
     "extensions/ruff",
     "extensions/ruby",
diff --git a/extensions/proto/Cargo.toml b/extensions/proto/Cargo.toml
new file mode 100644
index 00000000000000..496099c52637f0
--- /dev/null
+++ b/extensions/proto/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "zed_proto"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "Apache-2.0"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/proto.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+zed_extension_api = "0.1.0"
diff --git a/extensions/proto/LICENSE-APACHE b/extensions/proto/LICENSE-APACHE
new file mode 120000
index 00000000000000..1cd601d0a3affa
--- /dev/null
+++ b/extensions/proto/LICENSE-APACHE
@@ -0,0 +1 @@
+../../LICENSE-APACHE
\ No newline at end of file
diff --git a/extensions/proto/extension.toml b/extensions/proto/extension.toml
index a49ba7a4c4a7ec..6ecf9bf33f2405 100644
--- a/extensions/proto/extension.toml
+++ b/extensions/proto/extension.toml
@@ -9,3 +9,7 @@ repository = "https://github.com/zed-industries/zed"
 [grammars.proto]
 repository = "https://github.com/zed-industries/tree-sitter-proto"
 commit = "0848bd30a64be48772e15fbb9d5ba8c0cc5772ad"
+
+[language_servers.protobuf-language-server]
+name = "Protobuf Language Server"
+languages = ["Proto"]
diff --git a/extensions/proto/src/proto.rs b/extensions/proto/src/proto.rs
new file mode 100644
index 00000000000000..c692a0932766b4
--- /dev/null
+++ b/extensions/proto/src/proto.rs
@@ -0,0 +1,64 @@
+use zed_extension_api::{self as zed, settings::LspSettings, Result};
+
+const PROTOBUF_LANGUAGE_SERVER_NAME: &str = "protobuf-language-server";
+
+struct ProtobufLanguageServerBinary {
+    path: String,
+    args: Option<Vec<String>>,
+}
+
+struct ProtobufExtension;
+
+impl ProtobufExtension {
+    fn language_server_binary(
+        &self,
+        _language_server_id: &zed::LanguageServerId,
+        worktree: &zed::Worktree,
+    ) -> Result<ProtobufLanguageServerBinary> {
+        let binary_settings = LspSettings::for_worktree("protobuf-language-server", worktree)
+            .ok()
+            .and_then(|lsp_settings| lsp_settings.binary);
+        let binary_args = binary_settings
+            .as_ref()
+            .and_then(|binary_settings| binary_settings.arguments.clone());
+
+        if let Some(path) = binary_settings.and_then(|binary_settings| binary_settings.path) {
+            return Ok(ProtobufLanguageServerBinary {
+                path,
+                args: binary_args,
+            });
+        }
+
+        if let Some(path) = worktree.which(PROTOBUF_LANGUAGE_SERVER_NAME) {
+            return Ok(ProtobufLanguageServerBinary {
+                path,
+                args: binary_args,
+            });
+        }
+
+        Err(format!("{PROTOBUF_LANGUAGE_SERVER_NAME} not found in PATH",))
+    }
+}
+
+impl zed::Extension for ProtobufExtension {
+    fn new() -> Self {
+        Self
+    }
+
+    fn language_server_command(
+        &mut self,
+        language_server_id: &zed_extension_api::LanguageServerId,
+        worktree: &zed_extension_api::Worktree,
+    ) -> zed_extension_api::Result<zed_extension_api::Command> {
+        let binary = self.language_server_binary(language_server_id, worktree)?;
+        Ok(zed::Command {
+            command: binary.path,
+            args: binary
+                .args
+                .unwrap_or_else(|| vec!["-logs".into(), "".into()]),
+            env: Default::default(),
+        })
+    }
+}
+
+zed::register_extension!(ProtobufExtension);

From 1b06c70a76c5fa1ac65073b35d2e8a335757dfb4 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Sun, 6 Oct 2024 10:26:26 -0400
Subject: [PATCH 494/762] Fix alt-t context (#18783)

- Fix incorrect context introduced in https://github.com/zed-industries/zed/pull/18749/

Release Notes:

- N/A
---
 assets/keymaps/default-macos.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index 234485bc38a282..de929b8dd17b22 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -444,7 +444,7 @@
     }
   },
   {
-    "context": "Editor && !Terminal",
+    "context": "Workspace && !Terminal",
     "bindings": {
       "alt-t": "task::Rerun",
       "alt-shift-t": "task::Spawn"

From bd746145b05a5bf7f5963ae01b40473a584c4632 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Sun, 6 Oct 2024 10:28:39 -0400
Subject: [PATCH 495/762] ci: Make docs-only PRs only trigger docs-related
 tests (#18744)

This should speed up any docs-only PRs so that they don't have to run the full 5 minute battery of tests.

Release Notes:

- N/A
---
 .github/workflows/ci.yml   | 4 ++++
 .github/workflows/docs.yml | 7 +++++--
 script/check-spelling      | 5 ++++-
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ef1570fbf2121a..6718b91ade4007 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -7,9 +7,13 @@ on:
       - "v[0-9]+.[0-9]+.x"
     tags:
       - "v*"
+    paths-ignore:
+      - "docs/**"
   pull_request:
     branches:
       - "**"
+    paths-ignore:
+      - "docs/**"
 
 concurrency:
   # Allow only one workflow per any non-`main` branch.
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 13fe0411a022ac..7d7b564a548831 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -20,11 +20,14 @@ jobs:
         with:
           version: 9
 
-      - run: |
+      - name: Prettier Check on /docs
+        working-directory: ./docs
+        run: |
           pnpm dlx prettier . --check || {
             echo "To fix, run from the root of the zed repo:"
             echo "  cd docs && pnpm dlx prettier . --write && cd .."
             false
           }
 
-        working-directory: ./docs
+      - name: Check spelling
+        run: script/check-spelling docs/
diff --git a/script/check-spelling b/script/check-spelling
index 65c674057f47f7..76ebf747286447 100755
--- a/script/check-spelling
+++ b/script/check-spelling
@@ -1,6 +1,9 @@
 #!/bin/sh
 
+set -eu
+
 TYPOS_CLI_VERSION=1.24.6
+TARGET_DIR=${1:-""}
 
 if ! cargo install --list | grep "typos-cli v$TYPOS_CLI_VERSION" > /dev/null; then
     echo "Installing typos-cli@$TYPOS_CLI_VERSION..."
@@ -8,4 +11,4 @@ if ! cargo install --list | grep "typos-cli v$TYPOS_CLI_VERSION" > /dev/null; th
 else
     echo "typos-cli@$TYPOS_CLI_VERSION is already installed."
 fi
-typos
+typos $TARGET_DIR

From 59f0f4ac4260d7e7bd4e901fdd8970caf960d9a5 Mon Sep 17 00:00:00 2001
From: Agustin Gomes <me@agustingomes.com>
Date: Sun, 6 Oct 2024 20:47:48 +0200
Subject: [PATCH 496/762] Fix script/linux on RHEL/Fedora (#18788)

- Add missing `/etc/os-release` from a grep call
- Remove typo `grep grep` from another.

Co-authored-by: Peter Tripp <peter@zed.dev>
---
 script/linux | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/script/linux b/script/linux
index 540bf063ec92ee..c69cd5a842eb85 100755
--- a/script/linux
+++ b/script/linux
@@ -89,7 +89,7 @@ if [[ -n $dnf ]] || [[ -n $yum ]]; then
       perl-File-Copy
       mold
     )
-  elif grep grep -qP '^ID="(rhel|rocky|alma|centos|ol)' /etc/os-release; then
+  elif grep -qP '^ID="(rhel|rocky|alma|centos|ol)' /etc/os-release; then
     deps+=( perl-interpreter )
   fi
 
@@ -102,7 +102,7 @@ if [[ -n $dnf ]] || [[ -n $yum ]]; then
   fi
 
   # libxkbcommon-x11-devel is in a non-default repo on RHEL 8.x/9.x (except on AmazonLinux)
-  if grep -qP '^VERSION_ID="(8|9)' && grep -qP '^ID="(rhel|rocky|centos|alma|ol)' /etc/os-release; then
+  if grep -qP '^VERSION_ID="(8|9)' /etc/os-release && grep -qP '^ID="(rhel|rocky|centos|alma|ol)' /etc/os-release; then
     $maysudo dnf install -y 'dnf-command(config-manager)'
     if grep -qP '^PRETTY_NAME="(AlmaLinux 8|Rocky Linux 8)' /etc/os-release; then
       $maysudo dnf config-manager --set-enabled powertools

From 03c84466c22390bce5802c6ba4f27108d2ab5d61 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Mon, 7 Oct 2024 01:29:58 +0200
Subject: [PATCH 497/762] chore: Fix some violations of
 'needless_pass_by_ref_mut' lint (#18795)

While this lint is allow-by-default, it seems pretty useful to get rid
of mutable borrows when they're not needed.

Closes #ISSUE

Release Notes:

- N/A
---
 clippy.toml                                   |  1 +
 crates/assistant/src/context.rs               |  2 +-
 crates/client/src/client.rs                   |  2 +-
 crates/client/src/telemetry.rs                |  2 +-
 crates/client/src/user.rs                     | 38 ++++-----
 crates/db/src/db.rs                           |  2 +-
 .../src/git_hosting_providers.rs              |  2 +-
 crates/gpui/src/app.rs                        | 22 +++--
 crates/gpui/src/app/async_context.rs          |  4 +-
 crates/gpui/src/app/model_context.rs          |  6 +-
 crates/gpui/src/elements/div.rs               |  4 +-
 crates/gpui/src/elements/text.rs              |  6 +-
 crates/gpui/src/elements/uniform_list.rs      |  2 +-
 crates/gpui/src/geometry.rs                   |  8 +-
 crates/gpui/src/key_dispatch.rs               |  4 +-
 crates/gpui/src/platform/app_menu.rs          |  2 +-
 .../gpui/src/platform/mac/metal_renderer.rs   | 18 ++---
 crates/gpui/src/platform/mac/platform.rs      |  2 +-
 crates/gpui/src/window.rs                     | 44 +++++-----
 crates/language/src/buffer.rs                 | 24 ++----
 crates/markdown/src/markdown.rs               | 18 ++---
 crates/multi_buffer/src/multi_buffer.rs       | 14 ++--
 crates/project/src/project_settings.rs        |  2 +-
 crates/remote/src/ssh_session.rs              |  6 +-
 crates/session/src/session.rs                 |  2 +-
 crates/settings/src/settings_file.rs          |  2 +-
 crates/snippet_provider/src/lib.rs            |  2 +-
 crates/task/src/static_source.rs              |  4 +-
 crates/terminal/src/terminal.rs               | 19 ++---
 crates/theme/src/registry.rs                  |  2 +-
 crates/theme/src/settings.rs                  |  6 +-
 crates/worktree/src/worktree.rs               | 80 ++++++++-----------
 crates/zed/src/reliability.rs                 |  2 +-
 crates/zed/src/zed.rs                         |  4 +-
 .../zed/src/zed/inline_completion_registry.rs |  2 +-
 crates/zed/src/zed/open_listener.rs           |  2 +-
 36 files changed, 158 insertions(+), 204 deletions(-)

diff --git a/clippy.toml b/clippy.toml
index 787620d865cc5e..8c8da03a26b63d 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -1 +1,2 @@
 allow-private-module-inception = true
+avoid-breaking-exported-api = false
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index c360c0cb69a7ec..c27d17f8c5cef7 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -549,7 +549,7 @@ impl Context {
         cx: &mut ModelContext<Self>,
     ) -> Self {
         let buffer = cx.new_model(|_cx| {
-            let mut buffer = Buffer::remote(
+            let buffer = Buffer::remote(
                 language::BufferId::new(1).unwrap(),
                 replica_id,
                 capability,
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 819bd7551f5965..03d81b117f37e6 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -394,7 +394,7 @@ pub struct PendingEntitySubscription<T: 'static> {
 }
 
 impl<T: 'static> PendingEntitySubscription<T> {
-    pub fn set_model(mut self, model: &Model<T>, cx: &mut AsyncAppContext) -> Subscription {
+    pub fn set_model(mut self, model: &Model<T>, cx: &AsyncAppContext) -> Subscription {
         self.consumed = true;
         let mut handlers = self.client.handler_set.lock();
         let id = (TypeId::of::<T>(), self.remote_id);
diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index 5ec2e5b1aa6dd4..ee6da64d222236 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -288,7 +288,7 @@ impl Telemetry {
         system_id: Option<String>,
         installation_id: Option<String>,
         session_id: String,
-        cx: &mut AppContext,
+        cx: &AppContext,
     ) {
         let mut state = self.state.lock();
         state.system_id = system_id.map(|id| id.into());
diff --git a/crates/client/src/user.rs b/crates/client/src/user.rs
index 0f53b35fc1fd49..a312dd349507f7 100644
--- a/crates/client/src/user.rs
+++ b/crates/client/src/user.rs
@@ -138,7 +138,7 @@ enum UpdateContacts {
 }
 
 impl UserStore {
-    pub fn new(client: Arc<Client>, cx: &mut ModelContext<Self>) -> Self {
+    pub fn new(client: Arc<Client>, cx: &ModelContext<Self>) -> Self {
         let (mut current_user_tx, current_user_rx) = watch::channel();
         let (update_contacts_tx, mut update_contacts_rx) = mpsc::unbounded();
         let rpc_subscriptions = vec![
@@ -310,7 +310,7 @@ impl UserStore {
     fn update_contacts(
         &mut self,
         message: UpdateContacts,
-        cx: &mut ModelContext<Self>,
+        cx: &ModelContext<Self>,
     ) -> Task<Result<()>> {
         match message {
             UpdateContacts::Wait(barrier) => {
@@ -525,9 +525,9 @@ impl UserStore {
     }
 
     pub fn dismiss_contact_request(
-        &mut self,
+        &self,
         requester_id: u64,
-        cx: &mut ModelContext<Self>,
+        cx: &ModelContext<Self>,
     ) -> Task<Result<()>> {
         let client = self.client.upgrade();
         cx.spawn(move |_, _| async move {
@@ -573,7 +573,7 @@ impl UserStore {
         })
     }
 
-    pub fn clear_contacts(&mut self) -> impl Future<Output = ()> {
+    pub fn clear_contacts(&self) -> impl Future<Output = ()> {
         let (tx, mut rx) = postage::barrier::channel();
         self.update_contacts_tx
             .unbounded_send(UpdateContacts::Clear(tx))
@@ -583,7 +583,7 @@ impl UserStore {
         }
     }
 
-    pub fn contact_updates_done(&mut self) -> impl Future<Output = ()> {
+    pub fn contact_updates_done(&self) -> impl Future<Output = ()> {
         let (tx, mut rx) = postage::barrier::channel();
         self.update_contacts_tx
             .unbounded_send(UpdateContacts::Wait(tx))
@@ -594,9 +594,9 @@ impl UserStore {
     }
 
     pub fn get_users(
-        &mut self,
+        &self,
         user_ids: Vec<u64>,
-        cx: &mut ModelContext<Self>,
+        cx: &ModelContext<Self>,
     ) -> Task<Result<Vec<Arc<User>>>> {
         let mut user_ids_to_fetch = user_ids.clone();
         user_ids_to_fetch.retain(|id| !self.users.contains_key(id));
@@ -629,9 +629,9 @@ impl UserStore {
     }
 
     pub fn fuzzy_search_users(
-        &mut self,
+        &self,
         query: String,
-        cx: &mut ModelContext<Self>,
+        cx: &ModelContext<Self>,
     ) -> Task<Result<Vec<Arc<User>>>> {
         self.load_users(proto::FuzzySearchUsers { query }, cx)
     }
@@ -640,11 +640,7 @@ impl UserStore {
         self.users.get(&user_id).cloned()
     }
 
-    pub fn get_user_optimistic(
-        &mut self,
-        user_id: u64,
-        cx: &mut ModelContext<Self>,
-    ) -> Option<Arc<User>> {
+    pub fn get_user_optimistic(&self, user_id: u64, cx: &ModelContext<Self>) -> Option<Arc<User>> {
         if let Some(user) = self.users.get(&user_id).cloned() {
             return Some(user);
         }
@@ -653,11 +649,7 @@ impl UserStore {
         None
     }
 
-    pub fn get_user(
-        &mut self,
-        user_id: u64,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<Arc<User>>> {
+    pub fn get_user(&self, user_id: u64, cx: &ModelContext<Self>) -> Task<Result<Arc<User>>> {
         if let Some(user) = self.users.get(&user_id).cloned() {
             return Task::ready(Ok(user));
         }
@@ -697,7 +689,7 @@ impl UserStore {
             .map(|accepted_tos_at| accepted_tos_at.is_some())
     }
 
-    pub fn accept_terms_of_service(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
+    pub fn accept_terms_of_service(&self, cx: &ModelContext<Self>) -> Task<Result<()>> {
         if self.current_user().is_none() {
             return Task::ready(Err(anyhow!("no current user")));
         };
@@ -726,9 +718,9 @@ impl UserStore {
     }
 
     fn load_users(
-        &mut self,
+        &self,
         request: impl RequestMessage<Response = UsersResponse>,
-        cx: &mut ModelContext<Self>,
+        cx: &ModelContext<Self>,
     ) -> Task<Result<Vec<Arc<User>>>> {
         let client = self.client.clone();
         cx.spawn(|this, mut cx| async move {
diff --git a/crates/db/src/db.rs b/crates/db/src/db.rs
index 4d87222c773ab1..98fca60d6312c9 100644
--- a/crates/db/src/db.rs
+++ b/crates/db/src/db.rs
@@ -188,7 +188,7 @@ macro_rules! define_connection {
     };
 }
 
-pub fn write_and_log<F>(cx: &mut AppContext, db_write: impl FnOnce() -> F + Send + 'static)
+pub fn write_and_log<F>(cx: &AppContext, db_write: impl FnOnce() -> F + Send + 'static)
 where
     F: Future<Output = anyhow::Result<()>> + Send,
 {
diff --git a/crates/git_hosting_providers/src/git_hosting_providers.rs b/crates/git_hosting_providers/src/git_hosting_providers.rs
index 7bb77c030796f7..864faa9b495d18 100644
--- a/crates/git_hosting_providers/src/git_hosting_providers.rs
+++ b/crates/git_hosting_providers/src/git_hosting_providers.rs
@@ -8,7 +8,7 @@ use gpui::AppContext;
 pub use crate::providers::*;
 
 /// Initializes the Git hosting providers.
-pub fn init(cx: &mut AppContext) {
+pub fn init(cx: &AppContext) {
     let provider_registry = GitHostingProviderRegistry::global(cx);
 
     // The providers are stored in a `BTreeMap`, so insertion order matters.
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index 540e459ce1a314..bba5f857b4f52c 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -348,7 +348,7 @@ impl AppContext {
     }
 
     /// Gracefully quit the application via the platform's standard routine.
-    pub fn quit(&mut self) {
+    pub fn quit(&self) {
         self.platform.quit();
     }
 
@@ -1004,11 +1004,7 @@ impl AppContext {
         self.globals_by_type.insert(global_type, lease.global);
     }
 
-    pub(crate) fn new_view_observer(
-        &mut self,
-        key: TypeId,
-        value: NewViewListener,
-    ) -> Subscription {
+    pub(crate) fn new_view_observer(&self, key: TypeId, value: NewViewListener) -> Subscription {
         let (subscription, activate) = self.new_view_observers.insert(key, value);
         activate();
         subscription
@@ -1016,7 +1012,7 @@ impl AppContext {
     /// Arrange for the given function to be invoked whenever a view of the specified type is created.
     /// The function will be passed a mutable reference to the view along with an appropriate context.
     pub fn observe_new_views<V: 'static>(
-        &mut self,
+        &self,
         on_new: impl 'static + Fn(&mut V, &mut ViewContext<V>),
     ) -> Subscription {
         self.new_view_observer(
@@ -1035,7 +1031,7 @@ impl AppContext {
     /// Observe the release of a model or view. The callback is invoked after the model or view
     /// has no more strong references but before it has been dropped.
     pub fn observe_release<E, T>(
-        &mut self,
+        &self,
         handle: &E,
         on_release: impl FnOnce(&mut T, &mut AppContext) + 'static,
     ) -> Subscription
@@ -1062,7 +1058,7 @@ impl AppContext {
         mut f: impl FnMut(&KeystrokeEvent, &mut WindowContext) + 'static,
     ) -> Subscription {
         fn inner(
-            keystroke_observers: &mut SubscriberSet<(), KeystrokeObserver>,
+            keystroke_observers: &SubscriberSet<(), KeystrokeObserver>,
             handler: KeystrokeObserver,
         ) -> Subscription {
             let (subscription, activate) = keystroke_observers.insert((), handler);
@@ -1140,7 +1136,7 @@ impl AppContext {
     /// Register a callback to be invoked when the application is about to quit.
     /// It is not possible to cancel the quit event at this point.
     pub fn on_app_quit<Fut>(
-        &mut self,
+        &self,
         mut on_quit: impl FnMut(&mut AppContext) -> Fut + 'static,
     ) -> Subscription
     where
@@ -1186,7 +1182,7 @@ impl AppContext {
     }
 
     /// Sets the menu bar for this application. This will replace any existing menu bar.
-    pub fn set_menus(&mut self, menus: Vec<Menu>) {
+    pub fn set_menus(&self, menus: Vec<Menu>) {
         self.platform.set_menus(menus, &self.keymap.borrow());
     }
 
@@ -1196,7 +1192,7 @@ impl AppContext {
     }
 
     /// Sets the right click menu for the app icon in the dock
-    pub fn set_dock_menu(&mut self, menus: Vec<MenuItem>) {
+    pub fn set_dock_menu(&self, menus: Vec<MenuItem>) {
         self.platform.set_dock_menu(menus, &self.keymap.borrow());
     }
 
@@ -1204,7 +1200,7 @@ impl AppContext {
     /// The list is usually shown on the application icon's context menu in the dock,
     /// and allows to open the recent files via that context menu.
     /// If the path is already in the list, it will be moved to the bottom of the list.
-    pub fn add_recent_document(&mut self, path: &Path) {
+    pub fn add_recent_document(&self, path: &Path) {
         self.platform.add_recent_document(path);
     }
 
diff --git a/crates/gpui/src/app/async_context.rs b/crates/gpui/src/app/async_context.rs
index 06e44e71a3e825..be357765957148 100644
--- a/crates/gpui/src/app/async_context.rs
+++ b/crates/gpui/src/app/async_context.rs
@@ -107,7 +107,7 @@ impl Context for AsyncAppContext {
 
 impl AsyncAppContext {
     /// Schedules all windows in the application to be redrawn.
-    pub fn refresh(&mut self) -> Result<()> {
+    pub fn refresh(&self) -> Result<()> {
         let app = self
             .app
             .upgrade()
@@ -205,7 +205,7 @@ impl AsyncAppContext {
     /// A convenience method for [AppContext::update_global]
     /// for updating the global state of the specified type.
     pub fn update_global<G: Global, R>(
-        &mut self,
+        &self,
         update: impl FnOnce(&mut G, &mut AppContext) -> R,
     ) -> Result<R> {
         let app = self
diff --git a/crates/gpui/src/app/model_context.rs b/crates/gpui/src/app/model_context.rs
index 3aebf8853999b6..d3f07b25ebaa2d 100644
--- a/crates/gpui/src/app/model_context.rs
+++ b/crates/gpui/src/app/model_context.rs
@@ -91,7 +91,7 @@ impl<'a, T: 'static> ModelContext<'a, T> {
 
     /// Register a callback to be invoked when GPUI releases this model.
     pub fn on_release(
-        &mut self,
+        &self,
         on_release: impl FnOnce(&mut T, &mut AppContext) + 'static,
     ) -> Subscription
     where
@@ -110,7 +110,7 @@ impl<'a, T: 'static> ModelContext<'a, T> {
 
     /// Register a callback to be run on the release of another model or view
     pub fn observe_release<T2, E>(
-        &mut self,
+        &self,
         entity: &E,
         on_release: impl FnOnce(&mut T, &mut T2, &mut ModelContext<'_, T>) + 'static,
     ) -> Subscription
@@ -154,7 +154,7 @@ impl<'a, T: 'static> ModelContext<'a, T> {
     /// Arrange for the given function to be invoked whenever the application is quit.
     /// The future returned from this callback will be polled for up to [crate::SHUTDOWN_TIMEOUT] until the app fully quits.
     pub fn on_app_quit<Fut>(
-        &mut self,
+        &self,
         mut on_quit: impl FnMut(&mut T, &mut ModelContext<T>) -> Fut + 'static,
     ) -> Subscription
     where
diff --git a/crates/gpui/src/elements/div.rs b/crates/gpui/src/elements/div.rs
index 284e574627631f..d24c5d25da9881 100644
--- a/crates/gpui/src/elements/div.rs
+++ b/crates/gpui/src/elements/div.rs
@@ -1418,7 +1418,7 @@ impl Interactivity {
     }
 
     fn clamp_scroll_position(
-        &mut self,
+        &self,
         bounds: Bounds<Pixels>,
         style: &Style,
         cx: &mut WindowContext,
@@ -1547,7 +1547,7 @@ impl Interactivity {
 
     #[cfg(debug_assertions)]
     fn paint_debug_info(
-        &mut self,
+        &self,
         global_id: Option<&GlobalElementId>,
         hitbox: &Hitbox,
         style: &Style,
diff --git a/crates/gpui/src/elements/text.rs b/crates/gpui/src/elements/text.rs
index 3fa142de9638df..56b551737aaa42 100644
--- a/crates/gpui/src/elements/text.rs
+++ b/crates/gpui/src/elements/text.rs
@@ -252,7 +252,7 @@ impl TextLayout {
     }
 
     fn layout(
-        &mut self,
+        &self,
         text: SharedString,
         runs: Option<Vec<TextRun>>,
         cx: &mut WindowContext,
@@ -350,7 +350,7 @@ impl TextLayout {
         layout_id
     }
 
-    fn prepaint(&mut self, bounds: Bounds<Pixels>, text: &str) {
+    fn prepaint(&self, bounds: Bounds<Pixels>, text: &str) {
         let mut element_state = self.lock();
         let element_state = element_state
             .as_mut()
@@ -359,7 +359,7 @@ impl TextLayout {
         element_state.bounds = Some(bounds);
     }
 
-    fn paint(&mut self, text: &str, cx: &mut WindowContext) {
+    fn paint(&self, text: &str, cx: &mut WindowContext) {
         let element_state = self.lock();
         let element_state = element_state
             .as_ref()
diff --git a/crates/gpui/src/elements/uniform_list.rs b/crates/gpui/src/elements/uniform_list.rs
index d17d0781845d15..b6fcf91e53d070 100644
--- a/crates/gpui/src/elements/uniform_list.rs
+++ b/crates/gpui/src/elements/uniform_list.rs
@@ -115,7 +115,7 @@ impl UniformListScrollHandle {
     }
 
     /// Scroll the list to the given item index.
-    pub fn scroll_to_item(&mut self, ix: usize) {
+    pub fn scroll_to_item(&self, ix: usize) {
         self.0.borrow_mut().deferred_scroll_to_item = Some(ix);
     }
 
diff --git a/crates/gpui/src/geometry.rs b/crates/gpui/src/geometry.rs
index 9b9b1698043919..9e0b9b90140391 100644
--- a/crates/gpui/src/geometry.rs
+++ b/crates/gpui/src/geometry.rs
@@ -706,11 +706,7 @@ pub struct Bounds<T: Clone + Default + Debug> {
 
 impl Bounds<Pixels> {
     /// Generate a centered bounds for the given display or primary display if none is provided
-    pub fn centered(
-        display_id: Option<DisplayId>,
-        size: Size<Pixels>,
-        cx: &mut AppContext,
-    ) -> Self {
+    pub fn centered(display_id: Option<DisplayId>, size: Size<Pixels>, cx: &AppContext) -> Self {
         let display = display_id
             .and_then(|id| cx.find_display(id))
             .or_else(|| cx.primary_display());
@@ -730,7 +726,7 @@ impl Bounds<Pixels> {
     }
 
     /// Generate maximized bounds for the given display or primary display if none is provided
-    pub fn maximized(display_id: Option<DisplayId>, cx: &mut AppContext) -> Self {
+    pub fn maximized(display_id: Option<DisplayId>, cx: &AppContext) -> Self {
         let display = display_id
             .and_then(|id| cx.find_display(id))
             .or_else(|| cx.primary_display());
diff --git a/crates/gpui/src/key_dispatch.rs b/crates/gpui/src/key_dispatch.rs
index d11b4b2cabad96..cb40a563674669 100644
--- a/crates/gpui/src/key_dispatch.rs
+++ b/crates/gpui/src/key_dispatch.rs
@@ -219,7 +219,7 @@ impl DispatchTree {
         self.focusable_node_ids.insert(focus_id, node_id);
     }
 
-    pub fn parent_view_id(&mut self) -> Option<EntityId> {
+    pub fn parent_view_id(&self) -> Option<EntityId> {
         self.view_stack.last().copied()
     }
 
@@ -484,7 +484,7 @@ impl DispatchTree {
 
     /// Converts the longest prefix of input to a replay event and returns the rest.
     fn replay_prefix(
-        &mut self,
+        &self,
         mut input: SmallVec<[Keystroke; 1]>,
         dispatch_path: &SmallVec<[DispatchNodeId; 32]>,
     ) -> (SmallVec<[Keystroke; 1]>, SmallVec<[Replay; 1]>) {
diff --git a/crates/gpui/src/platform/app_menu.rs b/crates/gpui/src/platform/app_menu.rs
index 15686956f2ed68..401cc1899cfc2e 100644
--- a/crates/gpui/src/platform/app_menu.rs
+++ b/crates/gpui/src/platform/app_menu.rs
@@ -171,7 +171,7 @@ pub enum OsAction {
     Redo,
 }
 
-pub(crate) fn init_app_menus(platform: &dyn Platform, cx: &mut AppContext) {
+pub(crate) fn init_app_menus(platform: &dyn Platform, cx: &AppContext) {
     platform.on_will_open_app_menu(Box::new({
         let cx = cx.to_async();
         move || {
diff --git a/crates/gpui/src/platform/mac/metal_renderer.rs b/crates/gpui/src/platform/mac/metal_renderer.rs
index 401734e2536c1b..f42a2e2df7b943 100644
--- a/crates/gpui/src/platform/mac/metal_renderer.rs
+++ b/crates/gpui/src/platform/mac/metal_renderer.rs
@@ -284,11 +284,11 @@ impl MetalRenderer {
         }
     }
 
-    pub fn update_transparency(&mut self, _transparent: bool) {
+    pub fn update_transparency(&self, _transparent: bool) {
         // todo(mac)?
     }
 
-    pub fn destroy(&mut self) {
+    pub fn destroy(&self) {
         // nothing to do
     }
 
@@ -486,7 +486,7 @@ impl MetalRenderer {
     }
 
     fn rasterize_paths(
-        &mut self,
+        &self,
         paths: &[Path<ScaledPixels>],
         instance_buffer: &mut InstanceBuffer,
         instance_offset: &mut usize,
@@ -576,7 +576,7 @@ impl MetalRenderer {
     }
 
     fn draw_shadows(
-        &mut self,
+        &self,
         shadows: &[Shadow],
         instance_buffer: &mut InstanceBuffer,
         instance_offset: &mut usize,
@@ -639,7 +639,7 @@ impl MetalRenderer {
     }
 
     fn draw_quads(
-        &mut self,
+        &self,
         quads: &[Quad],
         instance_buffer: &mut InstanceBuffer,
         instance_offset: &mut usize,
@@ -698,7 +698,7 @@ impl MetalRenderer {
     }
 
     fn draw_paths(
-        &mut self,
+        &self,
         paths: &[Path<ScaledPixels>],
         tiles_by_path_id: &HashMap<PathId, AtlasTile>,
         instance_buffer: &mut InstanceBuffer,
@@ -808,7 +808,7 @@ impl MetalRenderer {
     }
 
     fn draw_underlines(
-        &mut self,
+        &self,
         underlines: &[Underline],
         instance_buffer: &mut InstanceBuffer,
         instance_offset: &mut usize,
@@ -871,7 +871,7 @@ impl MetalRenderer {
     }
 
     fn draw_monochrome_sprites(
-        &mut self,
+        &self,
         texture_id: AtlasTextureId,
         sprites: &[MonochromeSprite],
         instance_buffer: &mut InstanceBuffer,
@@ -945,7 +945,7 @@ impl MetalRenderer {
     }
 
     fn draw_polychrome_sprites(
-        &mut self,
+        &self,
         texture_id: AtlasTextureId,
         sprites: &[PolychromeSprite],
         instance_buffer: &mut InstanceBuffer,
diff --git a/crates/gpui/src/platform/mac/platform.rs b/crates/gpui/src/platform/mac/platform.rs
index 5873d8fe396d71..50ef6dcf0f87c5 100644
--- a/crates/gpui/src/platform/mac/platform.rs
+++ b/crates/gpui/src/platform/mac/platform.rs
@@ -1432,7 +1432,7 @@ impl UTType {
         self.0
     }
 
-    fn inner_mut(&mut self) -> *mut Object {
+    fn inner_mut(&self) -> *mut Object {
         self.0 as *mut _
     }
 }
diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs
index af968c5a2c1239..98349f8c4945bf 100644
--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -835,10 +835,7 @@ impl Window {
             prompt: None,
         })
     }
-    fn new_focus_listener(
-        &mut self,
-        value: AnyWindowFocusListener,
-    ) -> (Subscription, impl FnOnce()) {
+    fn new_focus_listener(&self, value: AnyWindowFocusListener) -> (Subscription, impl FnOnce()) {
         self.focus_listeners.insert((), value)
     }
 }
@@ -929,7 +926,7 @@ impl<'a> WindowContext<'a> {
 
     /// Obtain a new [`FocusHandle`], which allows you to track and manipulate the keyboard focus
     /// for elements rendered within this window.
-    pub fn focus_handle(&mut self) -> FocusHandle {
+    pub fn focus_handle(&self) -> FocusHandle {
         FocusHandle::new(&self.window.focus_handles)
     }
 
@@ -1127,7 +1124,7 @@ impl<'a> WindowContext<'a> {
 
     /// Register a callback to be invoked when the given Model or View is released.
     pub fn observe_release<E, T>(
-        &mut self,
+        &self,
         entity: &E,
         mut on_release: impl FnOnce(&mut T, &mut WindowContext) + 'static,
     ) -> Subscription
@@ -1155,7 +1152,7 @@ impl<'a> WindowContext<'a> {
     }
 
     /// Schedule the given closure to be run directly after the current frame is rendered.
-    pub fn on_next_frame(&mut self, callback: impl FnOnce(&mut WindowContext) + 'static) {
+    pub fn on_next_frame(&self, callback: impl FnOnce(&mut WindowContext) + 'static) {
         RefCell::borrow_mut(&self.window.next_frame_callbacks).push(Box::new(callback));
     }
 
@@ -1165,7 +1162,7 @@ impl<'a> WindowContext<'a> {
     /// It will cause the window to redraw on the next frame, even if no other changes have occurred.
     ///
     /// If called from within a view, it will notify that view on the next frame. Otherwise, it will refresh the entire window.
-    pub fn request_animation_frame(&mut self) {
+    pub fn request_animation_frame(&self) {
         let parent_id = self.parent_view_id();
         self.on_next_frame(move |cx| {
             if let Some(parent_id) = parent_id {
@@ -1179,7 +1176,7 @@ impl<'a> WindowContext<'a> {
     /// Spawn the future returned by the given closure on the application thread pool.
     /// The closure is provided a handle to the current window and an `AsyncWindowContext` for
     /// use within your future.
-    pub fn spawn<Fut, R>(&mut self, f: impl FnOnce(AsyncWindowContext) -> Fut) -> Task<R>
+    pub fn spawn<Fut, R>(&self, f: impl FnOnce(AsyncWindowContext) -> Fut) -> Task<R>
     where
         R: 'static,
         Fut: Future<Output = R> + 'static,
@@ -2865,7 +2862,7 @@ impl<'a> WindowContext<'a> {
     }
 
     /// Get the last view id for the current element
-    pub fn parent_view_id(&mut self) -> Option<EntityId> {
+    pub fn parent_view_id(&self) -> Option<EntityId> {
         self.window.next_frame.dispatch_tree.parent_view_id()
     }
 
@@ -3606,7 +3603,7 @@ impl<'a> WindowContext<'a> {
     }
 
     /// Updates the IME panel position suggestions for languages like japanese, chinese.
-    pub fn invalidate_character_coordinates(&mut self) {
+    pub fn invalidate_character_coordinates(&self) {
         self.on_next_frame(|cx| {
             if let Some(mut input_handler) = cx.window.platform_window.take_input_handler() {
                 if let Some(bounds) = input_handler.selected_bounds(cx) {
@@ -3752,7 +3749,7 @@ impl<'a> WindowContext<'a> {
 
     /// Register a callback that can interrupt the closing of the current window based the returned boolean.
     /// If the callback returns false, the window won't be closed.
-    pub fn on_window_should_close(&mut self, f: impl Fn(&mut WindowContext) -> bool + 'static) {
+    pub fn on_window_should_close(&self, f: impl Fn(&mut WindowContext) -> bool + 'static) {
         let mut this = self.to_async();
         self.window
             .platform_window
@@ -4070,7 +4067,7 @@ impl<'a, V: 'static> ViewContext<'a, V> {
     }
 
     /// Sets a given callback to be run on the next frame.
-    pub fn on_next_frame(&mut self, f: impl FnOnce(&mut V, &mut ViewContext<V>) + 'static)
+    pub fn on_next_frame(&self, f: impl FnOnce(&mut V, &mut ViewContext<V>) + 'static)
     where
         V: 'static,
     {
@@ -4162,7 +4159,7 @@ impl<'a, V: 'static> ViewContext<'a, V> {
     /// The callback receives a handle to the view's window. This handle may be
     /// invalid, if the window was closed before the view was released.
     pub fn on_release(
-        &mut self,
+        &self,
         on_release: impl FnOnce(&mut V, AnyWindowHandle, &mut AppContext) + 'static,
     ) -> Subscription {
         let window_handle = self.window.handle;
@@ -4179,7 +4176,7 @@ impl<'a, V: 'static> ViewContext<'a, V> {
 
     /// Register a callback to be invoked when the given Model or View is released.
     pub fn observe_release<V2, E>(
-        &mut self,
+        &self,
         entity: &E,
         mut on_release: impl FnMut(&mut V, &mut V2, &mut ViewContext<'_, V>) + 'static,
     ) -> Subscription
@@ -4212,7 +4209,7 @@ impl<'a, V: 'static> ViewContext<'a, V> {
 
     /// Register a callback to be invoked when the window is resized.
     pub fn observe_window_bounds(
-        &mut self,
+        &self,
         mut callback: impl FnMut(&mut V, &mut ViewContext<V>) + 'static,
     ) -> Subscription {
         let view = self.view.downgrade();
@@ -4226,7 +4223,7 @@ impl<'a, V: 'static> ViewContext<'a, V> {
 
     /// Register a callback to be invoked when the window is activated or deactivated.
     pub fn observe_window_activation(
-        &mut self,
+        &self,
         mut callback: impl FnMut(&mut V, &mut ViewContext<V>) + 'static,
     ) -> Subscription {
         let view = self.view.downgrade();
@@ -4240,7 +4237,7 @@ impl<'a, V: 'static> ViewContext<'a, V> {
 
     /// Registers a callback to be invoked when the window appearance changes.
     pub fn observe_window_appearance(
-        &mut self,
+        &self,
         mut callback: impl FnMut(&mut V, &mut ViewContext<V>) + 'static,
     ) -> Subscription {
         let view = self.view.downgrade();
@@ -4260,7 +4257,7 @@ impl<'a, V: 'static> ViewContext<'a, V> {
         mut f: impl FnMut(&mut V, &KeystrokeEvent, &mut ViewContext<V>) + 'static,
     ) -> Subscription {
         fn inner(
-            keystroke_observers: &mut SubscriberSet<(), KeystrokeObserver>,
+            keystroke_observers: &SubscriberSet<(), KeystrokeObserver>,
             handler: KeystrokeObserver,
         ) -> Subscription {
             let (subscription, activate) = keystroke_observers.insert((), handler);
@@ -4284,7 +4281,7 @@ impl<'a, V: 'static> ViewContext<'a, V> {
 
     /// Register a callback to be invoked when the window's pending input changes.
     pub fn observe_pending_input(
-        &mut self,
+        &self,
         mut callback: impl FnMut(&mut V, &mut ViewContext<V>) + 'static,
     ) -> Subscription {
         let view = self.view.downgrade();
@@ -4372,7 +4369,7 @@ impl<'a, V: 'static> ViewContext<'a, V> {
     /// and this callback lets you chose a default place to restore the users focus.
     /// Returns a subscription and persists until the subscription is dropped.
     pub fn on_focus_lost(
-        &mut self,
+        &self,
         mut listener: impl FnMut(&mut V, &mut ViewContext<V>) + 'static,
     ) -> Subscription {
         let view = self.view.downgrade();
@@ -4418,10 +4415,7 @@ impl<'a, V: 'static> ViewContext<'a, V> {
     /// The given callback is invoked with a [`WeakView<V>`] to avoid leaking the view for a long-running process.
     /// It's also given an [`AsyncWindowContext`], which can be used to access the state of the view across await points.
     /// The returned future will be polled on the main thread.
-    pub fn spawn<Fut, R>(
-        &mut self,
-        f: impl FnOnce(WeakView<V>, AsyncWindowContext) -> Fut,
-    ) -> Task<R>
+    pub fn spawn<Fut, R>(&self, f: impl FnOnce(WeakView<V>, AsyncWindowContext) -> Fut) -> Task<R>
     where
         R: 'static,
         Fut: Future<Output = R> + 'static,
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 1f4c56ecc86ff6..4990b9074ff1df 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -588,7 +588,7 @@ impl IndentGuide {
 
 impl Buffer {
     /// Create a new buffer with the given base text.
-    pub fn local<T: Into<String>>(base_text: T, cx: &mut ModelContext<Self>) -> Self {
+    pub fn local<T: Into<String>>(base_text: T, cx: &ModelContext<Self>) -> Self {
         Self::build(
             TextBuffer::new(0, cx.entity_id().as_non_zero_u64().into(), base_text.into()),
             None,
@@ -601,7 +601,7 @@ impl Buffer {
     pub fn local_normalized(
         base_text_normalized: Rope,
         line_ending: LineEnding,
-        cx: &mut ModelContext<Self>,
+        cx: &ModelContext<Self>,
     ) -> Self {
         Self::build(
             TextBuffer::new_normalized(
@@ -934,7 +934,7 @@ impl Buffer {
 
     /// Assign a language registry to the buffer. This allows the buffer to retrieve
     /// other languages if parts of the buffer are written in different languages.
-    pub fn set_language_registry(&mut self, language_registry: Arc<LanguageRegistry>) {
+    pub fn set_language_registry(&self, language_registry: Arc<LanguageRegistry>) {
         self.syntax_map
             .lock()
             .set_language_registry(language_registry);
@@ -967,16 +967,13 @@ impl Buffer {
     }
 
     /// This method is called to signal that the buffer has been discarded.
-    pub fn discarded(&mut self, cx: &mut ModelContext<Self>) {
+    pub fn discarded(&self, cx: &mut ModelContext<Self>) {
         cx.emit(BufferEvent::Discarded);
         cx.notify();
     }
 
     /// Reloads the contents of the buffer from disk.
-    pub fn reload(
-        &mut self,
-        cx: &mut ModelContext<Self>,
-    ) -> oneshot::Receiver<Option<Transaction>> {
+    pub fn reload(&mut self, cx: &ModelContext<Self>) -> oneshot::Receiver<Option<Transaction>> {
         let (tx, rx) = futures::channel::oneshot::channel();
         let prev_version = self.text.version();
         self.reload_task = Some(cx.spawn(|this, mut cx| async move {
@@ -1085,7 +1082,7 @@ impl Buffer {
 
     /// Sets the text that will be used to compute a Git diff
     /// against the buffer text.
-    pub fn set_diff_base(&mut self, diff_base: Option<String>, cx: &mut ModelContext<Self>) {
+    pub fn set_diff_base(&mut self, diff_base: Option<String>, cx: &ModelContext<Self>) {
         self.diff_base = diff_base.map(|mut raw_diff_base| {
             LineEnding::normalize(&mut raw_diff_base);
             BufferDiffBase::Git(Rope::from(raw_diff_base))
@@ -1117,7 +1114,7 @@ impl Buffer {
     }
 
     /// Recomputes the diff.
-    pub fn recalculate_diff(&mut self, cx: &mut ModelContext<Self>) -> Option<Task<()>> {
+    pub fn recalculate_diff(&self, cx: &ModelContext<Self>) -> Option<Task<()>> {
         let diff_base_rope = match self.diff_base.as_ref()? {
             BufferDiffBase::Git(rope) => rope.clone(),
             BufferDiffBase::PastBufferVersion { buffer, .. } => buffer.read(cx).as_rope().clone(),
@@ -2249,12 +2246,7 @@ impl Buffer {
         }
     }
 
-    fn send_operation(
-        &mut self,
-        operation: Operation,
-        is_local: bool,
-        cx: &mut ModelContext<Self>,
-    ) {
+    fn send_operation(&self, operation: Operation, is_local: bool, cx: &mut ModelContext<Self>) {
         cx.emit(BufferEvent::Operation {
             operation,
             is_local,
diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs
index 7fff4895400124..47a0e03c2a80a6 100644
--- a/crates/markdown/src/markdown.rs
+++ b/crates/markdown/src/markdown.rs
@@ -71,7 +71,7 @@ impl Markdown {
         source: String,
         style: MarkdownStyle,
         language_registry: Option<Arc<LanguageRegistry>>,
-        cx: &mut ViewContext<Self>,
+        cx: &ViewContext<Self>,
         fallback_code_block_language: Option<String>,
     ) -> Self {
         let focus_handle = cx.focus_handle();
@@ -97,7 +97,7 @@ impl Markdown {
         source: String,
         style: MarkdownStyle,
         language_registry: Option<Arc<LanguageRegistry>>,
-        cx: &mut ViewContext<Self>,
+        cx: &ViewContext<Self>,
         fallback_code_block_language: Option<String>,
     ) -> Self {
         let focus_handle = cx.focus_handle();
@@ -119,12 +119,12 @@ impl Markdown {
         this
     }
 
-    pub fn append(&mut self, text: &str, cx: &mut ViewContext<Self>) {
+    pub fn append(&mut self, text: &str, cx: &ViewContext<Self>) {
         self.source.push_str(text);
         self.parse(cx);
     }
 
-    pub fn reset(&mut self, source: String, cx: &mut ViewContext<Self>) {
+    pub fn reset(&mut self, source: String, cx: &ViewContext<Self>) {
         if source == self.source() {
             return;
         }
@@ -145,7 +145,7 @@ impl Markdown {
         &self.parsed_markdown
     }
 
-    fn copy(&self, text: &RenderedText, cx: &mut ViewContext<Self>) {
+    fn copy(&self, text: &RenderedText, cx: &ViewContext<Self>) {
         if self.selection.end <= self.selection.start {
             return;
         }
@@ -153,7 +153,7 @@ impl Markdown {
         cx.write_to_clipboard(ClipboardItem::new_string(text));
     }
 
-    fn parse(&mut self, cx: &mut ViewContext<Self>) {
+    fn parse(&mut self, cx: &ViewContext<Self>) {
         if self.source.is_empty() {
             return;
         }
@@ -319,7 +319,7 @@ impl MarkdownElement {
     }
 
     fn paint_selection(
-        &mut self,
+        &self,
         bounds: Bounds<Pixels>,
         rendered_text: &RenderedText,
         cx: &mut WindowContext,
@@ -382,7 +382,7 @@ impl MarkdownElement {
     }
 
     fn paint_mouse_listeners(
-        &mut self,
+        &self,
         hitbox: &Hitbox,
         rendered_text: &RenderedText,
         cx: &mut WindowContext,
@@ -487,7 +487,7 @@ impl MarkdownElement {
         });
     }
 
-    fn autoscroll(&mut self, rendered_text: &RenderedText, cx: &mut WindowContext) -> Option<()> {
+    fn autoscroll(&self, rendered_text: &RenderedText, cx: &mut WindowContext) -> Option<()> {
         let autoscroll_index = self
             .markdown
             .update(cx, |markdown, _| markdown.autoscroll_request.take())?;
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index 7aa733ba8fa373..18af28498fbe51 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -515,7 +515,7 @@ impl MultiBuffer {
     }
 
     pub fn edit<I, S, T>(
-        &mut self,
+        &self,
         edits: I,
         mut autoindent_mode: Option<AutoindentMode>,
         cx: &mut ModelContext<Self>,
@@ -664,7 +664,7 @@ impl MultiBuffer {
         drop(snapshot);
         // Non-generic part of edit, hoisted out to avoid blowing up LLVM IR.
         fn tail(
-            this: &mut MultiBuffer,
+            this: &MultiBuffer,
             buffer_edits: HashMap<BufferId, Vec<BufferEdit>>,
             autoindent_mode: Option<AutoindentMode>,
             edited_excerpt_ids: Vec<ExcerptId>,
@@ -928,7 +928,7 @@ impl MultiBuffer {
         }
     }
 
-    pub fn push_transaction<'a, T>(&mut self, buffer_transactions: T, cx: &mut ModelContext<Self>)
+    pub fn push_transaction<'a, T>(&mut self, buffer_transactions: T, cx: &ModelContext<Self>)
     where
         T: IntoIterator<Item = (&'a Model<Buffer>, &'a language::Transaction)>,
     {
@@ -952,7 +952,7 @@ impl MultiBuffer {
     }
 
     pub fn set_active_selections(
-        &mut self,
+        &self,
         selections: &[Selection<Anchor>],
         line_mode: bool,
         cursor_shape: CursorShape,
@@ -1028,7 +1028,7 @@ impl MultiBuffer {
         }
     }
 
-    pub fn remove_active_selections(&mut self, cx: &mut ModelContext<Self>) {
+    pub fn remove_active_selections(&self, cx: &mut ModelContext<Self>) {
         for buffer in self.buffers.borrow().values() {
             buffer
                 .buffer
@@ -1180,7 +1180,7 @@ impl MultiBuffer {
     }
 
     pub fn push_multiple_excerpts_with_context_lines(
-        &mut self,
+        &self,
         buffers_with_ranges: Vec<(Model<Buffer>, Vec<Range<text::Anchor>>)>,
         context_line_count: u32,
         cx: &mut ModelContext<Self>,
@@ -4208,7 +4208,7 @@ impl History {
         &mut self,
         buffer_transactions: T,
         now: Instant,
-        cx: &mut ModelContext<MultiBuffer>,
+        cx: &ModelContext<MultiBuffer>,
     ) where
         T: IntoIterator<Item = (&'a Model<Buffer>, &'a language::Transaction)>,
     {
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index 87150587b3607e..e956f672607298 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -321,7 +321,7 @@ impl SettingsObserver {
     pub async fn handle_update_user_settings(
         _: Model<Self>,
         envelope: TypedEnvelope<proto::UpdateUserSettings>,
-        mut cx: AsyncAppContext,
+        cx: AsyncAppContext,
     ) -> anyhow::Result<()> {
         cx.update_global(move |settings_store: &mut SettingsStore, cx| {
             settings_store.set_user_settings(&envelope.payload.content, cx)
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 89ec5db949aa70..32d5536b324ea8 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -188,7 +188,7 @@ impl ChannelForwarder {
     fn new(
         mut incoming_tx: UnboundedSender<Envelope>,
         mut outgoing_rx: UnboundedReceiver<Envelope>,
-        cx: &mut AsyncAppContext,
+        cx: &AsyncAppContext,
     ) -> (Self, UnboundedSender<Envelope>, UnboundedReceiver<Envelope>) {
         let (quit_tx, mut quit_rx) = mpsc::unbounded::<()>();
 
@@ -298,7 +298,7 @@ impl SshRemoteClient {
         Ok(this)
     }
 
-    fn reconnect(this: Arc<Self>, cx: &mut AsyncAppContext) -> Result<()> {
+    fn reconnect(this: Arc<Self>, cx: &AsyncAppContext) -> Result<()> {
         let Some(state) = this.inner_state.lock().take() else {
             return Err(anyhow!("reconnect is already in progress"));
         };
@@ -355,7 +355,7 @@ impl SshRemoteClient {
         mut ssh_process: Child,
         incoming_tx: UnboundedSender<Envelope>,
         mut outgoing_rx: UnboundedReceiver<Envelope>,
-        cx: &mut AsyncAppContext,
+        cx: &AsyncAppContext,
     ) -> Task<Result<()>> {
         let mut child_stderr = ssh_process.stderr.take().unwrap();
         let mut child_stdout = ssh_process.stdout.take().unwrap();
diff --git a/crates/session/src/session.rs b/crates/session/src/session.rs
index 01646b6f7a117f..47b4a2e181f948 100644
--- a/crates/session/src/session.rs
+++ b/crates/session/src/session.rs
@@ -64,7 +64,7 @@ pub struct AppSession {
 }
 
 impl AppSession {
-    pub fn new(session: Session, cx: &mut ModelContext<Self>) -> Self {
+    pub fn new(session: Session, cx: &ModelContext<Self>) -> Self {
         let _subscriptions = vec![cx.on_app_quit(Self::app_will_quit)];
 
         let _serialization_task = Some(cx.spawn(|_, cx| async move {
diff --git a/crates/settings/src/settings_file.rs b/crates/settings/src/settings_file.rs
index 823b75ef42ae17..2c46732fbc9359 100644
--- a/crates/settings/src/settings_file.rs
+++ b/crates/settings/src/settings_file.rs
@@ -77,7 +77,7 @@ pub fn handle_settings_file_changes(
             .set_user_settings(&user_settings_content, cx)
             .log_err();
     });
-    cx.spawn(move |mut cx| async move {
+    cx.spawn(move |cx| async move {
         while let Some(user_settings_content) = user_settings_file_rx.next().await {
             let result = cx.update_global(|store: &mut SettingsStore, cx| {
                 let result = store.set_user_settings(&user_settings_content, cx);
diff --git a/crates/snippet_provider/src/lib.rs b/crates/snippet_provider/src/lib.rs
index a18f9ff1b6f899..17d60d25a031f3 100644
--- a/crates/snippet_provider/src/lib.rs
+++ b/crates/snippet_provider/src/lib.rs
@@ -179,7 +179,7 @@ impl SnippetProvider {
     }
 
     /// Add directory to be watched for content changes
-    fn watch_directory(&mut self, path: &Path, cx: &mut ModelContext<Self>) {
+    fn watch_directory(&mut self, path: &Path, cx: &ModelContext<Self>) {
         let path: Arc<Path> = Arc::from(path);
 
         self.watch_tasks.push(cx.spawn(|this, mut cx| async move {
diff --git a/crates/task/src/static_source.rs b/crates/task/src/static_source.rs
index 3ae9ee0b7036a7..48f8fdfa010731 100644
--- a/crates/task/src/static_source.rs
+++ b/crates/task/src/static_source.rs
@@ -27,7 +27,7 @@ impl<T: PartialEq + 'static + Sync> TrackedFile<T> {
     pub fn new(
         mut tracker: UnboundedReceiver<String>,
         notification_outlet: UnboundedSender<()>,
-        cx: &mut AppContext,
+        cx: &AppContext,
     ) -> Self
     where
         T: for<'a> Deserialize<'a> + Default + Send,
@@ -69,7 +69,7 @@ impl<T: PartialEq + 'static + Sync> TrackedFile<T> {
     pub fn new_convertible<U: for<'a> Deserialize<'a> + TryInto<T, Error = anyhow::Error>>(
         mut tracker: UnboundedReceiver<String>,
         notification_outlet: UnboundedSender<()>,
-        cx: &mut AppContext,
+        cx: &AppContext,
     ) -> Self
     where
         T: Default + Send,
diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs
index b51308df378845..9412999cbfa0a9 100644
--- a/crates/terminal/src/terminal.rs
+++ b/crates/terminal/src/terminal.rs
@@ -320,7 +320,7 @@ impl TerminalBuilder {
         max_scroll_history_lines: Option<usize>,
         window: AnyWindowHandle,
         completion_tx: Sender<()>,
-        cx: &mut AppContext,
+        cx: &AppContext,
     ) -> Result<TerminalBuilder> {
         // TODO: Properly set the current locale,
         env.entry("LC_ALL".to_string())
@@ -455,7 +455,7 @@ impl TerminalBuilder {
         })
     }
 
-    pub fn subscribe(mut self, cx: &mut ModelContext<Terminal>) -> Terminal {
+    pub fn subscribe(mut self, cx: &ModelContext<Terminal>) -> Terminal {
         //Event loop
         cx.spawn(|terminal, mut cx| async move {
             while let Some(event) = self.events_rx.next().await {
@@ -1280,7 +1280,7 @@ impl Terminal {
         }
     }
 
-    fn drag_line_delta(&mut self, e: &MouseMoveEvent, region: Bounds<Pixels>) -> Option<Pixels> {
+    fn drag_line_delta(&self, e: &MouseMoveEvent, region: Bounds<Pixels>) -> Option<Pixels> {
         //TODO: Why do these need to be doubled? Probably the same problem that the IME has
         let top = region.origin.y + (self.last_content.size.line_height * 2.);
         let bottom = region.lower_left().y - (self.last_content.size.line_height * 2.);
@@ -1351,12 +1351,7 @@ impl Terminal {
         }
     }
 
-    pub fn mouse_up(
-        &mut self,
-        e: &MouseUpEvent,
-        origin: Point<Pixels>,
-        cx: &mut ModelContext<Self>,
-    ) {
+    pub fn mouse_up(&mut self, e: &MouseUpEvent, origin: Point<Pixels>, cx: &ModelContext<Self>) {
         let setting = TerminalSettings::get_global(cx);
 
         let position = e.position - origin;
@@ -1458,9 +1453,9 @@ impl Terminal {
     }
 
     pub fn find_matches(
-        &mut self,
+        &self,
         mut searcher: RegexSearch,
-        cx: &mut ModelContext<Self>,
+        cx: &ModelContext<Self>,
     ) -> Task<Vec<RangeInclusive<AlacPoint>>> {
         let term = self.term.clone();
         cx.background_executor().spawn(async move {
@@ -1530,7 +1525,7 @@ impl Terminal {
         self.task.as_ref()
     }
 
-    pub fn wait_for_completed_task(&self, cx: &mut AppContext) -> Task<()> {
+    pub fn wait_for_completed_task(&self, cx: &AppContext) -> Task<()> {
         if let Some(task) = self.task() {
             if task.status == TaskStatus::Running {
                 let mut completion_receiver = task.completion_rx.clone();
diff --git a/crates/theme/src/registry.rs b/crates/theme/src/registry.rs
index 771511973f5743..9f95d199375003 100644
--- a/crates/theme/src/registry.rs
+++ b/crates/theme/src/registry.rs
@@ -189,7 +189,7 @@ impl ThemeRegistry {
     }
 
     /// Removes all themes from the registry.
-    pub fn clear(&mut self) {
+    pub fn clear(&self) {
         self.state.write().themes.clear();
     }
 
diff --git a/crates/theme/src/settings.rs b/crates/theme/src/settings.rs
index d126ec058c2c62..e4be957a1b0553 100644
--- a/crates/theme/src/settings.rs
+++ b/crates/theme/src/settings.rs
@@ -498,7 +498,7 @@ pub fn observe_buffer_font_size_adjustment<V: 'static>(
 }
 
 /// Sets the adjusted buffer font size.
-pub fn adjusted_font_size(size: Pixels, cx: &mut AppContext) -> Pixels {
+pub fn adjusted_font_size(size: Pixels, cx: &AppContext) -> Pixels {
     if let Some(AdjustedBufferFontSize(adjusted_size)) = cx.try_global::<AdjustedBufferFontSize>() {
         let buffer_font_size = ThemeSettings::get_global(cx).buffer_font_size;
         let delta = *adjusted_size - buffer_font_size;
@@ -530,7 +530,7 @@ pub fn adjust_buffer_font_size(cx: &mut AppContext, f: fn(&mut Pixels)) {
 }
 
 /// Returns whether the buffer font size has been adjusted.
-pub fn has_adjusted_buffer_font_size(cx: &mut AppContext) -> bool {
+pub fn has_adjusted_buffer_font_size(cx: &AppContext) -> bool {
     cx.has_global::<AdjustedBufferFontSize>()
 }
 
@@ -576,7 +576,7 @@ pub fn adjust_ui_font_size(cx: &mut AppContext, f: fn(&mut Pixels)) {
 }
 
 /// Returns whether the UI font size has been adjusted.
-pub fn has_adjusted_ui_font_size(cx: &mut AppContext) -> bool {
+pub fn has_adjusted_ui_font_size(cx: &AppContext) -> bool {
     cx.has_global::<AdjustedUiFontSize>()
 }
 
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index 40cd465d9ba7d5..3a5ba2c276c5ba 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -622,7 +622,7 @@ impl Worktree {
         }
     }
 
-    pub fn root_file(&self, cx: &mut ModelContext<Self>) -> Option<Arc<File>> {
+    pub fn root_file(&self, cx: &ModelContext<Self>) -> Option<Arc<File>> {
         let entry = self.root_entry()?;
         Some(File::for_entry(entry.clone(), cx.handle()))
     }
@@ -630,7 +630,7 @@ impl Worktree {
     pub fn observe_updates<F, Fut>(
         &mut self,
         project_id: u64,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
         callback: F,
     ) where
         F: 'static + Send + Fn(proto::UpdateWorktree) -> Fut,
@@ -661,11 +661,7 @@ impl Worktree {
         }
     }
 
-    pub fn load_file(
-        &self,
-        path: &Path,
-        cx: &mut ModelContext<Worktree>,
-    ) -> Task<Result<LoadedFile>> {
+    pub fn load_file(&self, path: &Path, cx: &ModelContext<Worktree>) -> Task<Result<LoadedFile>> {
         match self {
             Worktree::Local(this) => this.load_file(path, cx),
             Worktree::Remote(_) => {
@@ -679,7 +675,7 @@ impl Worktree {
         path: &Path,
         text: Rope,
         line_ending: LineEnding,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Task<Result<Arc<File>>> {
         match self {
             Worktree::Local(this) => this.write_file(path, text, line_ending, cx),
@@ -693,7 +689,7 @@ impl Worktree {
         &mut self,
         path: impl Into<Arc<Path>>,
         is_directory: bool,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Task<Result<CreatedEntry>> {
         let path = path.into();
         let worktree_id = self.id();
@@ -773,7 +769,7 @@ impl Worktree {
         &mut self,
         entry_id: ProjectEntryId,
         new_path: impl Into<Arc<Path>>,
-        cx: &mut ModelContext<Self>,
+        cx: &ModelContext<Self>,
     ) -> Task<Result<CreatedEntry>> {
         let new_path = new_path.into();
         match self {
@@ -787,7 +783,7 @@ impl Worktree {
         entry_id: ProjectEntryId,
         relative_worktree_source_path: Option<PathBuf>,
         new_path: impl Into<Arc<Path>>,
-        cx: &mut ModelContext<Self>,
+        cx: &ModelContext<Self>,
     ) -> Task<Result<Option<Entry>>> {
         let new_path = new_path.into();
         match self {
@@ -830,7 +826,7 @@ impl Worktree {
         target_directory: PathBuf,
         paths: Vec<Arc<Path>>,
         overwrite_existing_files: bool,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Task<Result<Vec<ProjectEntryId>>> {
         match self {
             Worktree::Local(this) => {
@@ -845,7 +841,7 @@ impl Worktree {
     pub fn expand_entry(
         &mut self,
         entry_id: ProjectEntryId,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Option<Task<Result<()>>> {
         match self {
             Worktree::Local(this) => this.expand_entry(entry_id, cx),
@@ -987,7 +983,7 @@ impl LocalWorktree {
         !self.share_private_files && self.settings.is_path_private(path)
     }
 
-    fn restart_background_scanners(&mut self, cx: &mut ModelContext<Worktree>) {
+    fn restart_background_scanners(&mut self, cx: &ModelContext<Worktree>) {
         let (scan_requests_tx, scan_requests_rx) = channel::unbounded();
         let (path_prefixes_to_scan_tx, path_prefixes_to_scan_rx) = channel::unbounded();
         self.scan_requests_tx = scan_requests_tx;
@@ -999,7 +995,7 @@ impl LocalWorktree {
         &mut self,
         scan_requests_rx: channel::Receiver<ScanRequest>,
         path_prefixes_to_scan_rx: channel::Receiver<Arc<Path>>,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) {
         let snapshot = self.snapshot();
         let share_private_files = self.share_private_files;
@@ -1236,7 +1232,7 @@ impl LocalWorktree {
         self.git_repositories.get(&repo.work_directory.0)
     }
 
-    fn load_file(&self, path: &Path, cx: &mut ModelContext<Worktree>) -> Task<Result<LoadedFile>> {
+    fn load_file(&self, path: &Path, cx: &ModelContext<Worktree>) -> Task<Result<LoadedFile>> {
         let path = Arc::from(path);
         let abs_path = self.absolutize(&path);
         let fs = self.fs.clone();
@@ -1318,7 +1314,7 @@ impl LocalWorktree {
         &self,
         path: impl Into<Arc<Path>>,
         is_dir: bool,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Task<Result<CreatedEntry>> {
         let path = path.into();
         let abs_path = match self.absolutize(&path) {
@@ -1383,7 +1379,7 @@ impl LocalWorktree {
         path: impl Into<Arc<Path>>,
         text: Rope,
         line_ending: LineEnding,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Task<Result<Arc<File>>> {
         let path = path.into();
         let fs = self.fs.clone();
@@ -1437,7 +1433,7 @@ impl LocalWorktree {
         &self,
         entry_id: ProjectEntryId,
         trash: bool,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Option<Task<Result<()>>> {
         let entry = self.entry_for_id(entry_id)?.clone();
         let abs_path = self.absolutize(&entry.path);
@@ -1489,7 +1485,7 @@ impl LocalWorktree {
         &self,
         entry_id: ProjectEntryId,
         new_path: impl Into<Arc<Path>>,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Task<Result<CreatedEntry>> {
         let old_path = match self.entry_for_id(entry_id) {
             Some(entry) => entry.path.clone(),
@@ -1547,7 +1543,7 @@ impl LocalWorktree {
         entry_id: ProjectEntryId,
         relative_worktree_source_path: Option<PathBuf>,
         new_path: impl Into<Arc<Path>>,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Task<Result<Option<Entry>>> {
         let old_path = match self.entry_for_id(entry_id) {
             Some(entry) => entry.path.clone(),
@@ -1584,11 +1580,11 @@ impl LocalWorktree {
     }
 
     pub fn copy_external_entries(
-        &mut self,
+        &self,
         target_directory: PathBuf,
         paths: Vec<Arc<Path>>,
         overwrite_existing_files: bool,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Task<Result<Vec<ProjectEntryId>>> {
         let worktree_path = self.abs_path().clone();
         let fs = self.fs.clone();
@@ -1665,9 +1661,9 @@ impl LocalWorktree {
     }
 
     fn expand_entry(
-        &mut self,
+        &self,
         entry_id: ProjectEntryId,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Option<Task<Result<()>>> {
         let path = self.entry_for_id(entry_id)?.path.clone();
         let mut refresh = self.refresh_entries_for_paths(vec![path]);
@@ -1696,7 +1692,7 @@ impl LocalWorktree {
         &self,
         path: Arc<Path>,
         old_path: Option<Arc<Path>>,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Task<Result<Option<Entry>>> {
         if self.settings.is_path_excluded(&path) {
             return Task::ready(Ok(None));
@@ -1720,12 +1716,8 @@ impl LocalWorktree {
         })
     }
 
-    fn observe_updates<F, Fut>(
-        &mut self,
-        project_id: u64,
-        cx: &mut ModelContext<Worktree>,
-        callback: F,
-    ) where
+    fn observe_updates<F, Fut>(&mut self, project_id: u64, cx: &ModelContext<Worktree>, callback: F)
+    where
         F: 'static + Send + Fn(proto::UpdateWorktree) -> Fut,
         Fut: Send + Future<Output = bool>,
     {
@@ -1784,7 +1776,7 @@ impl LocalWorktree {
         });
     }
 
-    pub fn share_private_files(&mut self, cx: &mut ModelContext<Worktree>) {
+    pub fn share_private_files(&mut self, cx: &ModelContext<Worktree>) {
         self.share_private_files = true;
         self.restart_background_scanners(cx);
     }
@@ -1805,7 +1797,7 @@ impl RemoteWorktree {
         self.disconnected = true;
     }
 
-    pub fn update_from_remote(&mut self, update: proto::UpdateWorktree) {
+    pub fn update_from_remote(&self, update: proto::UpdateWorktree) {
         if let Some(updates_tx) = &self.updates_tx {
             updates_tx
                 .unbounded_send(update)
@@ -1813,12 +1805,8 @@ impl RemoteWorktree {
         }
     }
 
-    fn observe_updates<F, Fut>(
-        &mut self,
-        project_id: u64,
-        cx: &mut ModelContext<Worktree>,
-        callback: F,
-    ) where
+    fn observe_updates<F, Fut>(&mut self, project_id: u64, cx: &ModelContext<Worktree>, callback: F)
+    where
         F: 'static + Send + Fn(proto::UpdateWorktree) -> Fut,
         Fut: 'static + Send + Future<Output = bool>,
     {
@@ -1879,7 +1867,7 @@ impl RemoteWorktree {
         &mut self,
         entry: proto::Entry,
         scan_id: usize,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Task<Result<Entry>> {
         let wait_for_snapshot = self.wait_for_snapshot(scan_id);
         cx.spawn(|this, mut cx| async move {
@@ -1895,10 +1883,10 @@ impl RemoteWorktree {
     }
 
     fn delete_entry(
-        &mut self,
+        &self,
         entry_id: ProjectEntryId,
         trash: bool,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Option<Task<Result<()>>> {
         let response = self.client.request(proto::DeleteProjectEntry {
             project_id: self.project_id,
@@ -1924,10 +1912,10 @@ impl RemoteWorktree {
     }
 
     fn rename_entry(
-        &mut self,
+        &self,
         entry_id: ProjectEntryId,
         new_path: impl Into<Arc<Path>>,
-        cx: &mut ModelContext<Worktree>,
+        cx: &ModelContext<Worktree>,
     ) -> Task<Result<CreatedEntry>> {
         let new_path = new_path.into();
         let response = self.client.request(proto::RenameProjectEntry {
@@ -3692,7 +3680,7 @@ impl BackgroundScanner {
         self.send_status_update(scanning, request.done)
     }
 
-    async fn process_events(&mut self, mut abs_paths: Vec<PathBuf>) {
+    async fn process_events(&self, mut abs_paths: Vec<PathBuf>) {
         let root_path = self.state.lock().snapshot.abs_path.clone();
         let root_canonical_path = match self.fs.canonicalize(&root_path).await {
             Ok(path) => path,
diff --git a/crates/zed/src/reliability.rs b/crates/zed/src/reliability.rs
index b40bbc78bdb479..9d76a6c47f78a2 100644
--- a/crates/zed/src/reliability.rs
+++ b/crates/zed/src/reliability.rs
@@ -347,7 +347,7 @@ pub fn monitor_main_thread_hangs(
 fn upload_panics_and_crashes(
     http: Arc<HttpClientWithUrl>,
     installation_id: Option<String>,
-    cx: &mut AppContext,
+    cx: &AppContext,
 ) {
     let telemetry_settings = *client::TelemetrySettings::get_global(cx);
     cx.background_executor()
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index 4dc378a755bdae..eb60ab9fa8b69a 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -573,7 +573,7 @@ fn feature_gate_zed_pro_actions(cx: &mut AppContext) {
     .detach();
 }
 
-fn initialize_pane(workspace: &mut Workspace, pane: &View<Pane>, cx: &mut ViewContext<Workspace>) {
+fn initialize_pane(workspace: &Workspace, pane: &View<Pane>, cx: &mut ViewContext<Workspace>) {
     pane.update(cx, |pane, cx| {
         pane.toolbar().update(cx, |toolbar, cx| {
             let multibuffer_hint = cx.new_view(|_| MultibufferHint::new());
@@ -981,7 +981,7 @@ fn open_telemetry_log_file(workspace: &mut Workspace, cx: &mut ViewContext<Works
 }
 
 fn open_bundled_file(
-    workspace: &mut Workspace,
+    workspace: &Workspace,
     text: Cow<'static, str>,
     title: &'static str,
     language: &'static str,
diff --git a/crates/zed/src/zed/inline_completion_registry.rs b/crates/zed/src/zed/inline_completion_registry.rs
index ff84297b581782..aa0707d851f94c 100644
--- a/crates/zed/src/zed/inline_completion_registry.rs
+++ b/crates/zed/src/zed/inline_completion_registry.rs
@@ -64,7 +64,7 @@ pub fn init(telemetry: Arc<Telemetry>, cx: &mut AppContext) {
     .detach();
 }
 
-fn register_backward_compatible_actions(editor: &mut Editor, cx: &mut ViewContext<Editor>) {
+fn register_backward_compatible_actions(editor: &mut Editor, cx: &ViewContext<Editor>) {
     // We renamed some of these actions to not be copilot-specific, but that
     // would have not been backwards-compatible. So here we are re-registering
     // the actions with the old names to not break people's keymaps.
diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs
index c5fd2b2e78e6b4..7746337df1bbe2 100644
--- a/crates/zed/src/zed/open_listener.rs
+++ b/crates/zed/src/zed/open_listener.rs
@@ -661,7 +661,7 @@ mod tests {
         path: &str,
         open_new_workspace: Option<bool>,
         app_state: Arc<AppState>,
-        cx: &mut TestAppContext,
+        cx: &TestAppContext,
     ) {
         let (response_tx, _) = ipc::channel::<CliResponse>().unwrap();
 

From 67fbdbbed62ddb01b734f77f347d7295c462ce7a Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Mon, 7 Oct 2024 10:42:48 +0200
Subject: [PATCH 498/762] Put back code that makes the avatar rounded (#18799)

Follow-up to https://github.com/zed-industries/zed/pull/18768

---

Release Notes:

- N/A
---
 crates/ui/src/components/avatar/avatar.rs | 36 +++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/crates/ui/src/components/avatar/avatar.rs b/crates/ui/src/components/avatar/avatar.rs
index 4106b17452fd25..f0e516c7b19c7a 100644
--- a/crates/ui/src/components/avatar/avatar.rs
+++ b/crates/ui/src/components/avatar/avatar.rs
@@ -2,6 +2,16 @@ use crate::prelude::*;
 
 use gpui::{img, AnyElement, Hsla, ImageSource, Img, IntoElement, Styled};
 
+/// The shape of an [`Avatar`].
+#[derive(Debug, Default, PartialEq, Clone)]
+pub enum AvatarShape {
+    /// The avatar is shown in a circle.
+    #[default]
+    Circle,
+    /// The avatar is shown in a rectangle with rounded corners.
+    RoundedRectangle,
+}
+
 /// An element that renders a user avatar with customizable appearance options.
 ///
 /// # Examples
@@ -10,6 +20,7 @@ use gpui::{img, AnyElement, Hsla, ImageSource, Img, IntoElement, Styled};
 /// use ui::{Avatar, AvatarShape};
 ///
 /// Avatar::new("path/to/image.png")
+///     .shape(AvatarShape::Circle)
 ///     .grayscale(true)
 ///     .border_color(gpui::red());
 /// ```
@@ -32,6 +43,27 @@ impl Avatar {
         }
     }
 
+    /// Sets the shape of the avatar image.
+    ///
+    /// This method allows the shape of the avatar to be specified using an [`AvatarShape`].
+    /// It modifies the corner radius of the image to match the specified shape.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use ui::{Avatar, AvatarShape};
+    ///
+    /// Avatar::new("path/to/image.png").shape(AvatarShape::Circle);
+    /// ```
+    ///
+    pub fn shape(mut self, shape: AvatarShape) -> Self {
+        self.image = match shape {
+            AvatarShape::Circle => self.image.rounded_full(),
+            AvatarShape::RoundedRectangle => self.image.rounded_md(),
+        };
+        self
+    }
+
     /// Applies a grayscale filter to the avatar image.
     ///
     /// # Examples
@@ -71,6 +103,10 @@ impl Avatar {
 
 impl RenderOnce for Avatar {
     fn render(mut self, cx: &mut WindowContext) -> impl IntoElement {
+        if self.image.style().corner_radii.top_left.is_none() {
+            self = self.shape(AvatarShape::Circle);
+        }
+
         let border_width = if self.border_color.is_some() {
             px(2.)
         } else {

From c03b8d6c48b9f961ed30cb4d0ef97169fb30c1c4 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Mon, 7 Oct 2024 11:40:59 +0200
Subject: [PATCH 499/762] ssh remoting: Enable reconnecting after connection
 losses (#18586)

Release Notes:

- N/A

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 Cargo.lock                                    |   2 +
 crates/collab/src/tests/test_server.rs        |   2 +-
 crates/project/src/project.rs                 |  72 ++--
 crates/project/src/terminals.rs               |   2 +-
 crates/proto/proto/zed.proto                  |   6 +-
 crates/proto/src/proto.rs                     |   6 +-
 crates/recent_projects/src/dev_servers.rs     |  22 +-
 crates/recent_projects/src/ssh_connections.rs |  58 +--
 crates/remote/src/protocol.rs                 |  14 +
 crates/remote/src/ssh_session.rs              | 191 ++++++----
 crates/remote_server/Cargo.toml               |  11 +-
 crates/remote_server/src/headless_project.rs  |  19 +
 crates/remote_server/src/main.rs              | 134 +++----
 .../remote_server/src/remote_editing_tests.rs |   2 +-
 crates/remote_server/src/remote_server.rs     |   3 +
 crates/remote_server/src/unix.rs              | 336 ++++++++++++++++++
 crates/title_bar/src/title_bar.rs             |   2 +-
 crates/workspace/Cargo.toml                   |   1 +
 crates/workspace/src/workspace.rs             |  84 +++--
 19 files changed, 727 insertions(+), 240 deletions(-)
 create mode 100644 crates/remote_server/src/unix.rs

diff --git a/Cargo.lock b/Cargo.lock
index 120f51ec93001a..1cac85e0c7e709 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9165,6 +9165,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "cargo_toml",
+ "clap",
  "client",
  "clock",
  "env_logger",
@@ -14324,6 +14325,7 @@ dependencies = [
  "parking_lot",
  "postage",
  "project",
+ "release_channel",
  "remote",
  "schemars",
  "serde",
diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs
index 5e7d935c364382..8d2396eef08181 100644
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -835,7 +835,7 @@ impl TestClient {
     pub async fn build_ssh_project(
         &self,
         root_path: impl AsRef<Path>,
-        ssh: Arc<SshRemoteClient>,
+        ssh: Model<SshRemoteClient>,
         cx: &mut TestAppContext,
     ) -> (Model<Project>, WorktreeId) {
         let project = cx.update(|cx| {
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 4b8c0509644747..f2a8d59c6ffd83 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -141,7 +141,7 @@ pub struct Project {
     join_project_response_message_id: u32,
     user_store: Model<UserStore>,
     fs: Arc<dyn Fs>,
-    ssh_client: Option<Arc<SshRemoteClient>>,
+    ssh_client: Option<Model<SshRemoteClient>>,
     client_state: ProjectClientState,
     collaborators: HashMap<proto::PeerId, Collaborator>,
     client_subscriptions: Vec<client::Subscription>,
@@ -667,7 +667,7 @@ impl Project {
     }
 
     pub fn ssh(
-        ssh: Arc<SshRemoteClient>,
+        ssh: Model<SshRemoteClient>,
         client: Arc<Client>,
         node: NodeRuntime,
         user_store: Model<UserStore>,
@@ -684,15 +684,16 @@ impl Project {
             let snippets =
                 SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
 
+            let ssh_proto = ssh.read(cx).to_proto_client();
             let worktree_store =
-                cx.new_model(|_| WorktreeStore::remote(false, ssh.to_proto_client(), 0, None));
+                cx.new_model(|_| WorktreeStore::remote(false, ssh_proto.clone(), 0, None));
             cx.subscribe(&worktree_store, Self::on_worktree_store_event)
                 .detach();
 
             let buffer_store = cx.new_model(|cx| {
                 BufferStore::remote(
                     worktree_store.clone(),
-                    ssh.to_proto_client(),
+                    ssh.read(cx).to_proto_client(),
                     SSH_PROJECT_ID,
                     cx,
                 )
@@ -701,7 +702,7 @@ impl Project {
                 .detach();
 
             let settings_observer = cx.new_model(|cx| {
-                SettingsObserver::new_ssh(ssh.to_proto_client(), worktree_store.clone(), cx)
+                SettingsObserver::new_ssh(ssh_proto.clone(), worktree_store.clone(), cx)
             });
             cx.subscribe(&settings_observer, Self::on_settings_observer_event)
                 .detach();
@@ -712,13 +713,24 @@ impl Project {
                     buffer_store.clone(),
                     worktree_store.clone(),
                     languages.clone(),
-                    ssh.to_proto_client(),
+                    ssh_proto.clone(),
                     SSH_PROJECT_ID,
                     cx,
                 )
             });
             cx.subscribe(&lsp_store, Self::on_lsp_store_event).detach();
 
+            cx.on_release(|this, cx| {
+                if let Some(ssh_client) = this.ssh_client.as_ref() {
+                    ssh_client
+                        .read(cx)
+                        .to_proto_client()
+                        .send(proto::ShutdownRemoteServer {})
+                        .log_err();
+                }
+            })
+            .detach();
+
             let this = Self {
                 buffer_ordered_messages_tx: tx,
                 collaborators: Default::default(),
@@ -754,20 +766,20 @@ impl Project {
                 search_excluded_history: Self::new_search_history(),
             };
 
-            let client: AnyProtoClient = ssh.to_proto_client();
-
+            let ssh = ssh.read(cx);
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &cx.handle());
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.buffer_store);
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.worktree_store);
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.lsp_store);
             ssh.subscribe_to_entity(SSH_PROJECT_ID, &this.settings_observer);
-            client.add_model_message_handler(Self::handle_create_buffer_for_peer);
-            client.add_model_message_handler(Self::handle_update_worktree);
-            client.add_model_message_handler(Self::handle_update_project);
-            client.add_model_request_handler(BufferStore::handle_update_buffer);
-            BufferStore::init(&client);
-            LspStore::init(&client);
-            SettingsObserver::init(&client);
+
+            ssh_proto.add_model_message_handler(Self::handle_create_buffer_for_peer);
+            ssh_proto.add_model_message_handler(Self::handle_update_worktree);
+            ssh_proto.add_model_message_handler(Self::handle_update_project);
+            ssh_proto.add_model_request_handler(BufferStore::handle_update_buffer);
+            BufferStore::init(&ssh_proto);
+            LspStore::init(&ssh_proto);
+            SettingsObserver::init(&ssh_proto);
 
             this
         })
@@ -1222,7 +1234,7 @@ impl Project {
 
     pub fn ssh_connection_string(&self, cx: &AppContext) -> Option<SharedString> {
         if let Some(ssh_state) = &self.ssh_client {
-            return Some(ssh_state.connection_string().into());
+            return Some(ssh_state.read(cx).connection_string().into());
         }
         let dev_server_id = self.dev_server_project_id()?;
         dev_server_projects::Store::global(cx)
@@ -1232,8 +1244,8 @@ impl Project {
             .clone()
     }
 
-    pub fn ssh_is_connected(&self) -> Option<bool> {
-        Some(!self.ssh_client.as_ref()?.is_reconnect_underway())
+    pub fn ssh_is_connected(&self, cx: &AppContext) -> Option<bool> {
+        Some(!self.ssh_client.as_ref()?.read(cx).is_reconnect_underway())
     }
 
     pub fn replica_id(&self) -> ReplicaId {
@@ -1945,6 +1957,7 @@ impl Project {
             BufferStoreEvent::BufferDropped(buffer_id) => {
                 if let Some(ref ssh_client) = self.ssh_client {
                     ssh_client
+                        .read(cx)
                         .to_proto_client()
                         .send(proto::CloseBuffer {
                             project_id: 0,
@@ -2151,7 +2164,8 @@ impl Project {
                 let operation = language::proto::serialize_operation(operation);
 
                 if let Some(ssh) = &self.ssh_client {
-                    ssh.to_proto_client()
+                    ssh.read(cx)
+                        .to_proto_client()
                         .send(proto::UpdateBuffer {
                             project_id: 0,
                             buffer_id: buffer_id.to_proto(),
@@ -2838,7 +2852,7 @@ impl Project {
         let (tx, rx) = smol::channel::unbounded();
 
         let (client, remote_id): (AnyProtoClient, _) = if let Some(ssh_client) = &self.ssh_client {
-            (ssh_client.to_proto_client(), 0)
+            (ssh_client.read(cx).to_proto_client(), 0)
         } else if let Some(remote_id) = self.remote_id() {
             (self.client.clone().into(), remote_id)
         } else {
@@ -2973,12 +2987,14 @@ impl Project {
                     exists.then(|| ResolvedPath::AbsPath(expanded))
                 })
             } else if let Some(ssh_client) = self.ssh_client.as_ref() {
-                let request = ssh_client
-                    .to_proto_client()
-                    .request(proto::CheckFileExists {
-                        project_id: SSH_PROJECT_ID,
-                        path: path.to_string(),
-                    });
+                let request =
+                    ssh_client
+                        .read(cx)
+                        .to_proto_client()
+                        .request(proto::CheckFileExists {
+                            project_id: SSH_PROJECT_ID,
+                            path: path.to_string(),
+                        });
                 cx.background_executor().spawn(async move {
                     let response = request.await.log_err()?;
                     if response.exists {
@@ -3054,7 +3070,7 @@ impl Project {
                 path: query,
             };
 
-            let response = session.to_proto_client().request(request);
+            let response = session.read(cx).to_proto_client().request(request);
             cx.background_executor().spawn(async move {
                 let response = response.await?;
                 Ok(response.entries.into_iter().map(PathBuf::from).collect())
@@ -3482,7 +3498,7 @@ impl Project {
                 let mut payload = envelope.payload.clone();
                 payload.project_id = 0;
                 cx.background_executor()
-                    .spawn(ssh.to_proto_client().request(payload))
+                    .spawn(ssh.read(cx).to_proto_client().request(payload))
                     .detach_and_log_err(cx);
             }
             this.buffer_store.clone()
diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs
index 7175b75e22a323..ecac58fb858666 100644
--- a/crates/project/src/terminals.rs
+++ b/crates/project/src/terminals.rs
@@ -70,7 +70,7 @@ impl Project {
         if let Some(args) = self
             .ssh_client
             .as_ref()
-            .and_then(|session| session.ssh_args())
+            .and_then(|session| session.read(cx).ssh_args())
         {
             return Some(SshCommand::Direct(args));
         }
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index f6e9645e9c11ac..4e101f4305f044 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -282,7 +282,9 @@ message Envelope {
         UpdateUserSettings update_user_settings = 246;
 
         CheckFileExists check_file_exists = 255;
-        CheckFileExistsResponse check_file_exists_response = 256; // current max
+        CheckFileExistsResponse check_file_exists_response = 256;
+
+        ShutdownRemoteServer shutdown_remote_server = 257; // current max
     }
 
     reserved 87 to 88;
@@ -2511,3 +2513,5 @@ message CheckFileExistsResponse {
     bool exists = 1;
     string path = 2;
 }
+
+message ShutdownRemoteServer {}
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index fe1725e0d1c964..48733c449c69f6 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -364,7 +364,8 @@ messages!(
     (CloseBuffer, Foreground),
     (UpdateUserSettings, Foreground),
     (CheckFileExists, Background),
-    (CheckFileExistsResponse, Background)
+    (CheckFileExistsResponse, Background),
+    (ShutdownRemoteServer, Foreground),
 );
 
 request_messages!(
@@ -487,7 +488,8 @@ request_messages!(
     (SynchronizeContexts, SynchronizeContextsResponse),
     (LspExtSwitchSourceHeader, LspExtSwitchSourceHeaderResponse),
     (AddWorktree, AddWorktreeResponse),
-    (CheckFileExists, CheckFileExistsResponse)
+    (CheckFileExists, CheckFileExistsResponse),
+    (ShutdownRemoteServer, Ack)
 );
 
 entity_messages!(
diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 2038d069b4c68a..722743e0ff8770 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -305,13 +305,19 @@ impl DevServerProjects {
 
         let connection_options = remote::SshConnectionOptions {
             host: host.to_string(),
-            username,
+            username: username.clone(),
             port,
             password: None,
         };
         let ssh_prompt = cx.new_view(|cx| SshPrompt::new(&connection_options, cx));
-        let connection = connect_over_ssh(connection_options.clone(), ssh_prompt.clone(), cx)
-            .prompt_err("Failed to connect", cx, |_, _| None);
+
+        let connection = connect_over_ssh(
+            connection_options.dev_server_identifier(),
+            connection_options.clone(),
+            ssh_prompt.clone(),
+            cx,
+        )
+        .prompt_err("Failed to connect", cx, |_, _| None);
 
         let creating = cx.spawn(move |this, mut cx| async move {
             match connection.await {
@@ -363,11 +369,13 @@ impl DevServerProjects {
                     .prompt
                     .clone();
 
-                let connect = connect_over_ssh(connection_options, prompt, cx).prompt_err(
-                    "Failed to connect",
+                let connect = connect_over_ssh(
+                    connection_options.dev_server_identifier(),
+                    connection_options,
+                    prompt,
                     cx,
-                    |_, _| None,
-                );
+                )
+                .prompt_err("Failed to connect", cx, |_, _| None);
                 cx.spawn(|workspace, mut cx| async move {
                     let Some(session) = connect.await else {
                         workspace
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index d0fffc031f0bff..9e505237738a6a 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -4,12 +4,12 @@ use anyhow::Result;
 use auto_update::AutoUpdater;
 use editor::Editor;
 use futures::channel::oneshot;
-use gpui::AppContext;
 use gpui::{
     percentage, px, Animation, AnimationExt, AnyWindowHandle, AsyncAppContext, DismissEvent,
     EventEmitter, FocusableView, ParentElement as _, Render, SemanticVersion, SharedString, Task,
     Transformation, View,
 };
+use gpui::{AppContext, Model};
 use release_channel::{AppVersion, ReleaseChannel};
 use remote::{SshConnectionOptions, SshPlatform, SshRemoteClient};
 use schemars::JsonSchema;
@@ -373,25 +373,24 @@ impl SshClientDelegate {
 }
 
 pub fn connect_over_ssh(
+    unique_identifier: String,
     connection_options: SshConnectionOptions,
     ui: View<SshPrompt>,
     cx: &mut WindowContext,
-) -> Task<Result<Arc<SshRemoteClient>>> {
+) -> Task<Result<Model<SshRemoteClient>>> {
     let window = cx.window_handle();
     let known_password = connection_options.password.clone();
 
-    cx.spawn(|mut cx| async move {
-        remote::SshRemoteClient::new(
-            connection_options,
-            Arc::new(SshClientDelegate {
-                window,
-                ui,
-                known_password,
-            }),
-            &mut cx,
-        )
-        .await
-    })
+    remote::SshRemoteClient::new(
+        unique_identifier,
+        connection_options,
+        Arc::new(SshClientDelegate {
+            window,
+            ui,
+            known_password,
+        }),
+        cx,
+    )
 }
 
 pub async fn open_ssh_project(
@@ -420,22 +419,25 @@ pub async fn open_ssh_project(
         })?
     };
 
-    let session = window
-        .update(cx, |workspace, cx| {
-            cx.activate_window();
-            workspace.toggle_modal(cx, |cx| SshConnectionModal::new(&connection_options, cx));
-            let ui = workspace
-                .active_modal::<SshConnectionModal>(cx)
-                .unwrap()
-                .read(cx)
-                .prompt
-                .clone();
-            connect_over_ssh(connection_options.clone(), ui, cx)
-        })?
-        .await?;
+    let delegate = window.update(cx, |workspace, cx| {
+        cx.activate_window();
+        workspace.toggle_modal(cx, |cx| SshConnectionModal::new(&connection_options, cx));
+        let ui = workspace
+            .active_modal::<SshConnectionModal>(cx)
+            .unwrap()
+            .read(cx)
+            .prompt
+            .clone();
+
+        Arc::new(SshClientDelegate {
+            window: cx.window_handle(),
+            ui,
+            known_password: connection_options.password.clone(),
+        })
+    })?;
 
     cx.update(|cx| {
-        workspace::open_ssh_project(window, connection_options, session, app_state, paths, cx)
+        workspace::open_ssh_project(window, connection_options, delegate, app_state, paths, cx)
     })?
     .await
 }
diff --git a/crates/remote/src/protocol.rs b/crates/remote/src/protocol.rs
index bc495be4e7b5c3..311385f73b15b0 100644
--- a/crates/remote/src/protocol.rs
+++ b/crates/remote/src/protocol.rs
@@ -49,3 +49,17 @@ pub async fn write_message<S: AsyncWrite + Unpin>(
     stream.write_all(buffer).await?;
     Ok(())
 }
+
+pub async fn read_message_raw<S: AsyncRead + Unpin>(
+    stream: &mut S,
+    buffer: &mut Vec<u8>,
+) -> Result<()> {
+    buffer.resize(MESSAGE_LEN_SIZE, 0);
+    stream.read_exact(buffer).await?;
+
+    let message_len = message_len_from_buffer(buffer);
+    buffer.resize(message_len as usize, 0);
+    stream.read_exact(buffer).await?;
+
+    Ok(())
+}
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 32d5536b324ea8..05208dabd738b9 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -15,7 +15,9 @@ use futures::{
     select_biased, AsyncReadExt as _, AsyncWriteExt as _, Future, FutureExt as _, SinkExt,
     StreamExt as _,
 };
-use gpui::{AppContext, AsyncAppContext, Model, SemanticVersion, Task};
+use gpui::{
+    AppContext, AsyncAppContext, Context, Model, ModelContext, SemanticVersion, Task, WeakModel,
+};
 use parking_lot::Mutex;
 use rpc::{
     proto::{self, build_typed_envelope, Envelope, EnvelopedMessage, PeerId, RequestMessage},
@@ -28,10 +30,11 @@ use smol::{
 use std::{
     any::TypeId,
     ffi::OsStr,
+    mem,
     path::{Path, PathBuf},
     sync::{
         atomic::{AtomicU32, Ordering::SeqCst},
-        Arc, Weak,
+        Arc,
     },
     time::Instant,
 };
@@ -92,6 +95,17 @@ impl SshConnectionOptions {
             host
         }
     }
+
+    // Uniquely identifies dev server projects on a remote host. Needs to be
+    // stable for the same dev server project.
+    pub fn dev_server_identifier(&self) -> String {
+        let mut identifier = format!("dev-server-{:?}", self.host);
+        if let Some(username) = self.username.as_ref() {
+            identifier.push('-');
+            identifier.push_str(&username);
+        }
+        identifier
+    }
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -250,59 +264,101 @@ struct SshRemoteClientState {
 
 pub struct SshRemoteClient {
     client: Arc<ChannelClient>,
-    inner_state: Mutex<Option<SshRemoteClientState>>,
+    unique_identifier: String,
     connection_options: SshConnectionOptions,
+    inner_state: Arc<Mutex<Option<SshRemoteClientState>>>,
+}
+
+impl Drop for SshRemoteClient {
+    fn drop(&mut self) {
+        self.shutdown_processes();
+    }
 }
 
 impl SshRemoteClient {
-    pub async fn new(
+    pub fn new(
+        unique_identifier: String,
         connection_options: SshConnectionOptions,
         delegate: Arc<dyn SshClientDelegate>,
-        cx: &mut AsyncAppContext,
-    ) -> Result<Arc<Self>> {
-        let (outgoing_tx, outgoing_rx) = mpsc::unbounded::<Envelope>();
-        let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();
+        cx: &AppContext,
+    ) -> Task<Result<Model<Self>>> {
+        cx.spawn(|mut cx| async move {
+            let (outgoing_tx, outgoing_rx) = mpsc::unbounded::<Envelope>();
+            let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();
 
-        let client = cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx))?;
-        let this = Arc::new(Self {
-            client,
-            inner_state: Mutex::new(None),
-            connection_options: connection_options.clone(),
-        });
+            let this = cx.new_model(|cx| {
+                cx.on_app_quit(|this: &mut Self, _| {
+                    this.shutdown_processes();
+                    futures::future::ready(())
+                })
+                .detach();
 
-        let inner_state = {
-            let (proxy, proxy_incoming_tx, proxy_outgoing_rx) =
-                ChannelForwarder::new(incoming_tx, outgoing_rx, cx);
+                let client = ChannelClient::new(incoming_rx, outgoing_tx, cx);
+                Self {
+                    client,
+                    unique_identifier: unique_identifier.clone(),
+                    connection_options: SshConnectionOptions::default(),
+                    inner_state: Arc::new(Mutex::new(None)),
+                }
+            })?;
 
-            let (ssh_connection, ssh_process) =
-                Self::establish_connection(connection_options, delegate.clone(), cx).await?;
+            let inner_state = {
+                let (proxy, proxy_incoming_tx, proxy_outgoing_rx) =
+                    ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
 
-            let multiplex_task = Self::multiplex(
-                Arc::downgrade(&this),
-                ssh_process,
-                proxy_incoming_tx,
-                proxy_outgoing_rx,
-                cx,
-            );
+                let (ssh_connection, ssh_proxy_process) = Self::establish_connection(
+                    unique_identifier,
+                    connection_options,
+                    delegate.clone(),
+                    &mut cx,
+                )
+                .await?;
 
-            SshRemoteClientState {
-                ssh_connection,
-                delegate,
-                forwarder: proxy,
-                multiplex_task,
-            }
-        };
+                let multiplex_task = Self::multiplex(
+                    this.downgrade(),
+                    ssh_proxy_process,
+                    proxy_incoming_tx,
+                    proxy_outgoing_rx,
+                    &mut cx,
+                );
 
-        this.inner_state.lock().replace(inner_state);
+                SshRemoteClientState {
+                    ssh_connection,
+                    delegate,
+                    forwarder: proxy,
+                    multiplex_task,
+                }
+            };
+
+            this.update(&mut cx, |this, cx| {
+                this.inner_state.lock().replace(inner_state);
+                cx.notify();
+            })?;
+
+            Ok(this)
+        })
+    }
 
-        Ok(this)
+    fn shutdown_processes(&self) {
+        let Some(mut state) = self.inner_state.lock().take() else {
+            return;
+        };
+        log::info!("shutting down ssh processes");
+        // Drop `multiplex_task` because it owns our ssh_proxy_process, which is a
+        // child of master_process.
+        let task = mem::replace(&mut state.multiplex_task, Task::ready(Ok(())));
+        drop(task);
+        // Now drop the rest of state, which kills master process.
+        drop(state);
     }
 
-    fn reconnect(this: Arc<Self>, cx: &AsyncAppContext) -> Result<()> {
-        let Some(state) = this.inner_state.lock().take() else {
+    fn reconnect(&self, cx: &ModelContext<Self>) -> Result<()> {
+        let Some(state) = self.inner_state.lock().take() else {
             return Err(anyhow!("reconnect is already in progress"));
         };
 
+        let workspace_identifier = self.unique_identifier.clone();
+
         let SshRemoteClientState {
             mut ssh_connection,
             delegate,
@@ -311,7 +367,7 @@ impl SshRemoteClient {
         } = state;
         drop(multiplex_task);
 
-        cx.spawn(|mut cx| async move {
+        cx.spawn(|this, mut cx| async move {
             let (incoming_tx, outgoing_rx) = proxy.into_channels().await;
 
             ssh_connection.master_process.kill()?;
@@ -323,8 +379,13 @@ impl SshRemoteClient {
 
             let connection_options = ssh_connection.socket.connection_options.clone();
 
-            let (ssh_connection, ssh_process) =
-                Self::establish_connection(connection_options, delegate.clone(), &mut cx).await?;
+            let (ssh_connection, ssh_process) = Self::establish_connection(
+                workspace_identifier,
+                connection_options,
+                delegate.clone(),
+                &mut cx,
+            )
+            .await?;
 
             let (proxy, proxy_incoming_tx, proxy_outgoing_rx) =
                 ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
@@ -334,32 +395,32 @@ impl SshRemoteClient {
                 delegate,
                 forwarder: proxy,
                 multiplex_task: Self::multiplex(
-                    Arc::downgrade(&this),
+                    this.clone(),
                     ssh_process,
                     proxy_incoming_tx,
                     proxy_outgoing_rx,
                     &mut cx,
                 ),
             };
-            this.inner_state.lock().replace(inner_state);
 
-            anyhow::Ok(())
+            this.update(&mut cx, |this, _| {
+                this.inner_state.lock().replace(inner_state);
+            })
         })
         .detach();
-
-        anyhow::Ok(())
+        Ok(())
     }
 
     fn multiplex(
-        this: Weak<Self>,
-        mut ssh_process: Child,
+        this: WeakModel<Self>,
+        mut ssh_proxy_process: Child,
         incoming_tx: UnboundedSender<Envelope>,
         mut outgoing_rx: UnboundedReceiver<Envelope>,
         cx: &AsyncAppContext,
     ) -> Task<Result<()>> {
-        let mut child_stderr = ssh_process.stderr.take().unwrap();
-        let mut child_stdout = ssh_process.stdout.take().unwrap();
-        let mut child_stdin = ssh_process.stdin.take().unwrap();
+        let mut child_stderr = ssh_proxy_process.stderr.take().unwrap();
+        let mut child_stdout = ssh_proxy_process.stdout.take().unwrap();
+        let mut child_stdin = ssh_proxy_process.stdin.take().unwrap();
 
         let io_task = cx.background_executor().spawn(async move {
             let mut stdin_buffer = Vec::new();
@@ -385,7 +446,7 @@ impl SshRemoteClient {
                             Ok(0) => {
                                 child_stdin.close().await?;
                                 outgoing_rx.close();
-                                let status = ssh_process.status().await?;
+                                let status = ssh_proxy_process.status().await?;
                                 if !status.success() {
                                     log::error!("ssh process exited with status: {status:?}");
                                     return Err(anyhow!("ssh process exited with non-zero status code: {:?}", status.code()));
@@ -446,9 +507,9 @@ impl SshRemoteClient {
 
             if let Err(error) = result {
                 log::warn!("ssh io task died with error: {:?}. reconnecting...", error);
-                if let Some(this) = this.upgrade() {
-                    Self::reconnect(this, &mut cx).ok();
-                }
+                this.update(&mut cx, |this, cx| {
+                    this.reconnect(cx).ok();
+                })?;
             }
 
             Ok(())
@@ -456,6 +517,7 @@ impl SshRemoteClient {
     }
 
     async fn establish_connection(
+        unique_identifier: String,
         connection_options: SshConnectionOptions,
         delegate: Arc<dyn SshClientDelegate>,
         cx: &mut AsyncAppContext,
@@ -479,17 +541,22 @@ impl SshRemoteClient {
         let socket = ssh_connection.socket.clone();
         run_cmd(socket.ssh_command(&remote_binary_path).arg("version")).await?;
 
-        let ssh_process = socket
+        delegate.set_status(Some("Starting proxy"), cx);
+
+        let ssh_proxy_process = socket
             .ssh_command(format!(
-                "RUST_LOG={} RUST_BACKTRACE={} {:?} run",
+                "RUST_LOG={} RUST_BACKTRACE={} {:?} proxy --identifier {}",
                 std::env::var("RUST_LOG").unwrap_or_default(),
                 std::env::var("RUST_BACKTRACE").unwrap_or_default(),
                 remote_binary_path,
+                unique_identifier,
             ))
+            // IMPORTANT: we kill this process when we drop the task that uses it.
+            .kill_on_drop(true)
             .spawn()
             .context("failed to spawn remote server")?;
 
-        Ok((ssh_connection, ssh_process))
+        Ok((ssh_connection, ssh_proxy_process))
     }
 
     pub fn subscribe_to_entity<E: 'static>(&self, remote_id: u64, entity: &Model<E>) {
@@ -514,21 +581,25 @@ impl SshRemoteClient {
     pub fn is_reconnect_underway(&self) -> bool {
         maybe!({ Some(self.inner_state.try_lock()?.is_none()) }).unwrap_or_default()
     }
+
     #[cfg(any(test, feature = "test-support"))]
     pub fn fake(
         client_cx: &mut gpui::TestAppContext,
         server_cx: &mut gpui::TestAppContext,
-    ) -> (Arc<Self>, Arc<ChannelClient>) {
+    ) -> (Model<Self>, Arc<ChannelClient>) {
+        use gpui::Context;
+
         let (server_to_client_tx, server_to_client_rx) = mpsc::unbounded();
         let (client_to_server_tx, client_to_server_rx) = mpsc::unbounded();
 
         (
             client_cx.update(|cx| {
                 let client = ChannelClient::new(server_to_client_rx, client_to_server_tx, cx);
-                Arc::new(Self {
+                cx.new_model(|_| Self {
                     client,
-                    inner_state: Mutex::new(None),
+                    unique_identifier: "fake".to_string(),
                     connection_options: SshConnectionOptions::default(),
+                    inner_state: Arc::new(Mutex::new(None)),
                 })
             }),
             server_cx.update(|cx| ChannelClient::new(client_to_server_rx, server_to_client_tx, cx)),
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index b15970042d0f7f..211b76e0917ae7 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -22,25 +22,26 @@ test-support = ["fs/test-support"]
 
 [dependencies]
 anyhow.workspace = true
+clap.workspace = true
 client.workspace = true
 env_logger.workspace = true
 fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
-node_runtime.workspace = true
+language.workspace = true
+languages.workspace = true
 log.workspace = true
+node_runtime.workspace = true
 project.workspace = true
 remote.workspace = true
 rpc.workspace = true
-settings.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+settings.workspace = true
 shellexpand.workspace = true
 smol.workspace = true
-worktree.workspace = true
-language.workspace = true
-languages.workspace = true
 util.workspace = true
+worktree.workspace = true
 
 [dev-dependencies]
 client = { workspace = true, features = ["test-support"] }
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 39540b04e04cb8..66f9ca7ed5e06a 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -112,6 +112,7 @@ impl HeadlessProject {
 
         client.add_request_handler(cx.weak_model(), Self::handle_list_remote_directory);
         client.add_request_handler(cx.weak_model(), Self::handle_check_file_exists);
+        client.add_request_handler(cx.weak_model(), Self::handle_shutdown_remote_server);
 
         client.add_model_request_handler(Self::handle_add_worktree);
         client.add_model_request_handler(Self::handle_open_buffer_by_path);
@@ -335,4 +336,22 @@ impl HeadlessProject {
             path: expanded,
         })
     }
+
+    pub async fn handle_shutdown_remote_server(
+        _this: Model<Self>,
+        _envelope: TypedEnvelope<proto::ShutdownRemoteServer>,
+        cx: AsyncAppContext,
+    ) -> Result<proto::Ack> {
+        cx.spawn(|cx| async move {
+            cx.update(|cx| {
+                // TODO: This is a hack, because in a headless project, shutdown isn't executed
+                // when calling quit, but it should be.
+                cx.shutdown();
+                cx.quit();
+            })
+        })
+        .detach();
+
+        Ok(proto::Ack {})
+    }
 }
diff --git a/crates/remote_server/src/main.rs b/crates/remote_server/src/main.rs
index 73b8a91da1876f..e5582d9b1fc55c 100644
--- a/crates/remote_server/src/main.rs
+++ b/crates/remote_server/src/main.rs
@@ -1,20 +1,34 @@
 #![cfg_attr(target_os = "windows", allow(unused, dead_code))]
 
-use fs::RealFs;
-use futures::channel::mpsc;
-use gpui::Context as _;
-use remote::{
-    json_log::LogRecord,
-    protocol::{read_message, write_message},
-};
-use remote_server::HeadlessProject;
-use smol::{io::AsyncWriteExt, stream::StreamExt as _, Async};
-use std::{
-    env,
-    io::{self, Write},
-    mem, process,
-    sync::Arc,
-};
+use anyhow::Result;
+use clap::{Parser, Subcommand};
+use std::path::PathBuf;
+
+#[derive(Parser)]
+#[command(disable_version_flag = true)]
+struct Cli {
+    #[command(subcommand)]
+    command: Option<Commands>,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    Run {
+        #[arg(long)]
+        log_file: PathBuf,
+        #[arg(long)]
+        pid_file: PathBuf,
+        #[arg(long)]
+        stdin_socket: PathBuf,
+        #[arg(long)]
+        stdout_socket: PathBuf,
+    },
+    Proxy {
+        #[arg(long)]
+        identifier: String,
+    },
+    Version,
+}
 
 #[cfg(windows)]
 fn main() {
@@ -22,76 +36,32 @@ fn main() {
 }
 
 #[cfg(not(windows))]
-fn main() {
-    use remote::ssh_session::ChannelClient;
+fn main() -> Result<()> {
+    use remote_server::unix::{execute_proxy, execute_run, init_logging};
 
-    env_logger::builder()
-        .format(|buf, record| {
-            serde_json::to_writer(&mut *buf, &LogRecord::new(record))?;
-            buf.write_all(b"\n")?;
-            Ok(())
-        })
-        .init();
+    let cli = Cli::parse();
 
-    let subcommand = std::env::args().nth(1);
-    match subcommand.as_deref() {
-        Some("run") => {}
-        Some("version") => {
-            println!("{}", env!("ZED_PKG_VERSION"));
-            return;
+    match cli.command {
+        Some(Commands::Run {
+            log_file,
+            pid_file,
+            stdin_socket,
+            stdout_socket,
+        }) => {
+            init_logging(Some(log_file))?;
+            execute_run(pid_file, stdin_socket, stdout_socket)
+        }
+        Some(Commands::Proxy { identifier }) => {
+            init_logging(None)?;
+            execute_proxy(identifier)
+        }
+        Some(Commands::Version) => {
+            eprintln!("{}", env!("ZED_PKG_VERSION"));
+            Ok(())
         }
-        _ => {
-            eprintln!("usage: remote <run|version>");
-            process::exit(1);
+        None => {
+            eprintln!("usage: remote <run|proxy|version>");
+            std::process::exit(1);
         }
     }
-
-    gpui::App::headless().run(move |cx| {
-        settings::init(cx);
-        HeadlessProject::init(cx);
-
-        let (incoming_tx, incoming_rx) = mpsc::unbounded();
-        let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded();
-
-        let mut stdin = Async::new(io::stdin()).unwrap();
-        let mut stdout = Async::new(io::stdout()).unwrap();
-
-        let session = ChannelClient::new(incoming_rx, outgoing_tx, cx);
-        let project = cx.new_model(|cx| {
-            HeadlessProject::new(
-                session.clone(),
-                Arc::new(RealFs::new(Default::default(), None)),
-                cx,
-            )
-        });
-
-        cx.background_executor()
-            .spawn(async move {
-                let mut output_buffer = Vec::new();
-                while let Some(message) = outgoing_rx.next().await {
-                    write_message(&mut stdout, &mut output_buffer, message).await?;
-                    stdout.flush().await?;
-                }
-                anyhow::Ok(())
-            })
-            .detach();
-
-        cx.background_executor()
-            .spawn(async move {
-                let mut input_buffer = Vec::new();
-                loop {
-                    let message = match read_message(&mut stdin, &mut input_buffer).await {
-                        Ok(message) => message,
-                        Err(error) => {
-                            log::warn!("error reading message: {:?}", error);
-                            process::exit(0);
-                        }
-                    };
-                    incoming_tx.unbounded_send(message).ok();
-                }
-            })
-            .detach();
-
-        mem::forget(project);
-    });
 }
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 960b7c248c0e26..6e962a134a3f16 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -655,7 +655,7 @@ async fn init_test(
     (project, headless, fs)
 }
 
-fn build_project(ssh: Arc<SshRemoteClient>, cx: &mut TestAppContext) -> Model<Project> {
+fn build_project(ssh: Model<SshRemoteClient>, cx: &mut TestAppContext) -> Model<Project> {
     cx.update(|cx| {
         let settings_store = SettingsStore::test(cx);
         cx.set_global(settings_store);
diff --git a/crates/remote_server/src/remote_server.rs b/crates/remote_server/src/remote_server.rs
index 0aa36b0cd1381a..2321ee1c6eb52a 100644
--- a/crates/remote_server/src/remote_server.rs
+++ b/crates/remote_server/src/remote_server.rs
@@ -1,5 +1,8 @@
 mod headless_project;
 
+#[cfg(not(windows))]
+pub mod unix;
+
 #[cfg(test)]
 mod remote_editing_tests;
 
diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs
new file mode 100644
index 00000000000000..74b71a2277bc11
--- /dev/null
+++ b/crates/remote_server/src/unix.rs
@@ -0,0 +1,336 @@
+use crate::HeadlessProject;
+use anyhow::{anyhow, Context, Result};
+use fs::RealFs;
+use futures::channel::mpsc;
+use futures::{select, select_biased, AsyncRead, AsyncWrite, FutureExt, SinkExt};
+use gpui::{AppContext, Context as _};
+use remote::ssh_session::ChannelClient;
+use remote::{
+    json_log::LogRecord,
+    protocol::{read_message, write_message},
+};
+use rpc::proto::Envelope;
+use smol::Async;
+use smol::{io::AsyncWriteExt, net::unix::UnixListener, stream::StreamExt as _};
+use std::{
+    env,
+    io::Write,
+    mem,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+pub fn init_logging(log_file: Option<PathBuf>) -> Result<()> {
+    if let Some(log_file) = log_file {
+        let target = Box::new(if log_file.exists() {
+            std::fs::OpenOptions::new()
+                .append(true)
+                .open(&log_file)
+                .context("Failed to open log file in append mode")?
+        } else {
+            std::fs::File::create(&log_file).context("Failed to create log file")?
+        });
+
+        env_logger::Builder::from_default_env()
+            .target(env_logger::Target::Pipe(target))
+            .init();
+    } else {
+        env_logger::builder()
+            .format(|buf, record| {
+                serde_json::to_writer(&mut *buf, &LogRecord::new(record))?;
+                buf.write_all(b"\n")?;
+                Ok(())
+            })
+            .init();
+    }
+    Ok(())
+}
+
+fn start_server(
+    stdin_listener: UnixListener,
+    stdout_listener: UnixListener,
+    cx: &mut AppContext,
+) -> Arc<ChannelClient> {
+    // This is the server idle timeout. If no connection comes in in this timeout, the server will shut down.
+    const IDLE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10 * 60);
+
+    let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();
+    let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded::<Envelope>();
+    let (app_quit_tx, mut app_quit_rx) = mpsc::unbounded::<()>();
+
+    cx.on_app_quit(move |_| {
+        let mut app_quit_tx = app_quit_tx.clone();
+        async move {
+            app_quit_tx.send(()).await.ok();
+        }
+    })
+    .detach();
+
+    cx.spawn(|cx| async move {
+        let mut stdin_incoming = stdin_listener.incoming();
+        let mut stdout_incoming = stdout_listener.incoming();
+
+        loop {
+            let streams = futures::future::join(stdin_incoming.next(), stdout_incoming.next());
+
+            log::info!("server: accepting new connections");
+            let result = select! {
+                streams = streams.fuse() => {
+                    let (Some(Ok(stdin_stream)), Some(Ok(stdout_stream))) = streams else {
+                        break;
+                    };
+                    anyhow::Ok((stdin_stream, stdout_stream))
+                }
+                _ = futures::FutureExt::fuse(smol::Timer::after(IDLE_TIMEOUT)) => {
+                    log::warn!("server: timed out waiting for new connections after {:?}. exiting.", IDLE_TIMEOUT);
+                    cx.update(|cx| {
+                        // TODO: This is a hack, because in a headless project, shutdown isn't executed
+                        // when calling quit, but it should be.
+                        cx.shutdown();
+                        cx.quit();
+                    })?;
+                    break;
+                }
+                _ = app_quit_rx.next().fuse() => {
+                    break;
+                }
+            };
+
+            let Ok((mut stdin_stream, mut stdout_stream)) = result else {
+                break;
+            };
+
+            let mut input_buffer = Vec::new();
+            let mut output_buffer = Vec::new();
+            loop {
+                select_biased! {
+                    _ = app_quit_rx.next().fuse() => {
+                        return anyhow::Ok(());
+                    }
+
+                    stdin_message = read_message(&mut stdin_stream, &mut input_buffer).fuse() => {
+                        let message = match stdin_message {
+                            Ok(message) => message,
+                            Err(error) => {
+                                log::warn!("server: error reading message on stdin: {}. exiting.", error);
+                                break;
+                            }
+                        };
+                        if let Err(error) = incoming_tx.unbounded_send(message) {
+                            log::error!("server: failed to send message to application: {:?}. exiting.", error);
+                            return Err(anyhow!(error));
+                        }
+                    }
+
+                    outgoing_message  = outgoing_rx.next().fuse() => {
+                        let Some(message) = outgoing_message else {
+                            log::error!("server: stdout handler, no message");
+                            break;
+                        };
+
+                        if let Err(error) =
+                            write_message(&mut stdout_stream, &mut output_buffer, message).await
+                        {
+                            log::error!("server: failed to write stdout message: {:?}", error);
+                            break;
+                        }
+                        if let Err(error) = stdout_stream.flush().await {
+                            log::error!("server: failed to flush stdout message: {:?}", error);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        anyhow::Ok(())
+    })
+    .detach();
+
+    ChannelClient::new(incoming_rx, outgoing_tx, cx)
+}
+
+pub fn execute_run(pid_file: PathBuf, stdin_socket: PathBuf, stdout_socket: PathBuf) -> Result<()> {
+    write_pid_file(&pid_file)
+        .with_context(|| format!("failed to write pid file: {:?}", &pid_file))?;
+
+    let stdin_listener = UnixListener::bind(stdin_socket).context("failed to bind stdin socket")?;
+    let stdout_listener =
+        UnixListener::bind(stdout_socket).context("failed to bind stdout socket")?;
+
+    gpui::App::headless().run(move |cx| {
+        settings::init(cx);
+        HeadlessProject::init(cx);
+
+        let session = start_server(stdin_listener, stdout_listener, cx);
+        let project = cx.new_model(|cx| {
+            HeadlessProject::new(session, Arc::new(RealFs::new(Default::default(), None)), cx)
+        });
+
+        mem::forget(project);
+    });
+    log::info!("server: gpui app is shut down. quitting.");
+    Ok(())
+}
+
+pub fn execute_proxy(identifier: String) -> Result<()> {
+    log::debug!("proxy: starting up. PID: {}", std::process::id());
+
+    let project_dir = ensure_project_dir(&identifier)?;
+
+    let pid_file = project_dir.join("server.pid");
+    let stdin_socket = project_dir.join("stdin.sock");
+    let stdout_socket = project_dir.join("stdout.sock");
+    let log_file = project_dir.join("server.log");
+
+    let server_running = check_pid_file(&pid_file)?;
+    if !server_running {
+        spawn_server(&log_file, &pid_file, &stdin_socket, &stdout_socket)?;
+    };
+
+    let stdin_task = smol::spawn(async move {
+        let stdin = Async::new(std::io::stdin())?;
+        let stream = smol::net::unix::UnixStream::connect(stdin_socket).await?;
+        handle_io(stdin, stream, "stdin").await
+    });
+
+    let stdout_task: smol::Task<Result<()>> = smol::spawn(async move {
+        let stdout = Async::new(std::io::stdout())?;
+        let stream = smol::net::unix::UnixStream::connect(stdout_socket).await?;
+        handle_io(stream, stdout, "stdout").await
+    });
+
+    if let Err(forwarding_result) =
+        smol::block_on(async move { smol::future::race(stdin_task, stdout_task).await })
+    {
+        log::error!(
+            "proxy: failed to forward messages: {:?}, terminating...",
+            forwarding_result
+        );
+        return Err(forwarding_result);
+    }
+
+    Ok(())
+}
+
+fn ensure_project_dir(identifier: &str) -> Result<PathBuf> {
+    let project_dir = env::var("HOME").unwrap_or_else(|_| ".".to_string());
+    let project_dir = PathBuf::from(project_dir)
+        .join(".local")
+        .join("state")
+        .join("zed-remote-server")
+        .join(identifier);
+
+    std::fs::create_dir_all(&project_dir)?;
+
+    Ok(project_dir)
+}
+
+fn spawn_server(
+    log_file: &Path,
+    pid_file: &Path,
+    stdin_socket: &Path,
+    stdout_socket: &Path,
+) -> Result<()> {
+    if stdin_socket.exists() {
+        std::fs::remove_file(&stdin_socket)?;
+    }
+    if stdout_socket.exists() {
+        std::fs::remove_file(&stdout_socket)?;
+    }
+
+    let binary_name = std::env::current_exe()?;
+    let server_process = std::process::Command::new(binary_name)
+        .arg("run")
+        .arg("--log-file")
+        .arg(log_file)
+        .arg("--pid-file")
+        .arg(pid_file)
+        .arg("--stdin-socket")
+        .arg(stdin_socket)
+        .arg("--stdout-socket")
+        .arg(stdout_socket)
+        .spawn()?;
+
+    log::debug!("proxy: server started. PID: {:?}", server_process.id());
+
+    let mut total_time_waited = std::time::Duration::from_secs(0);
+    let wait_duration = std::time::Duration::from_millis(20);
+    while !stdout_socket.exists() || !stdin_socket.exists() {
+        log::debug!("proxy: waiting for server to be ready to accept connections...");
+        std::thread::sleep(wait_duration);
+        total_time_waited += wait_duration;
+    }
+
+    log::info!(
+        "proxy: server ready to accept connections. total time waited: {:?}",
+        total_time_waited
+    );
+    Ok(())
+}
+
+fn check_pid_file(path: &Path) -> Result<bool> {
+    let Some(pid) = std::fs::read_to_string(&path)
+        .ok()
+        .and_then(|contents| contents.parse::<u32>().ok())
+    else {
+        return Ok(false);
+    };
+
+    log::debug!("proxy: Checking if process with PID {} exists...", pid);
+    match std::process::Command::new("kill")
+        .arg("-0")
+        .arg(pid.to_string())
+        .output()
+    {
+        Ok(output) if output.status.success() => {
+            log::debug!("proxy: Process with PID {} exists. NOT spawning new server, but attaching to existing one.", pid);
+            Ok(true)
+        }
+        _ => {
+            log::debug!("proxy: Found PID file, but process with that PID does not exist. Removing PID file.");
+            std::fs::remove_file(&path).context("proxy: Failed to remove PID file")?;
+            Ok(false)
+        }
+    }
+}
+
+fn write_pid_file(path: &Path) -> Result<()> {
+    if path.exists() {
+        std::fs::remove_file(path)?;
+    }
+
+    std::fs::write(path, std::process::id().to_string()).context("Failed to write PID file")
+}
+
+async fn handle_io<R, W>(mut reader: R, mut writer: W, socket_name: &str) -> Result<()>
+where
+    R: AsyncRead + Unpin,
+    W: AsyncWrite + Unpin,
+{
+    use remote::protocol::read_message_raw;
+
+    let mut buffer = Vec::new();
+    loop {
+        read_message_raw(&mut reader, &mut buffer)
+            .await
+            .with_context(|| format!("proxy: failed to read message from {}", socket_name))?;
+
+        write_size_prefixed_buffer(&mut writer, &mut buffer)
+            .await
+            .with_context(|| format!("proxy: failed to write message to {}", socket_name))?;
+
+        writer.flush().await?;
+
+        buffer.clear();
+    }
+}
+
+async fn write_size_prefixed_buffer<S: AsyncWrite + Unpin>(
+    stream: &mut S,
+    buffer: &mut Vec<u8>,
+) -> Result<()> {
+    let len = buffer.len() as u32;
+    stream.write_all(len.to_le_bytes().as_slice()).await?;
+    stream.write_all(buffer).await?;
+    Ok(())
+}
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index 81f908ce797902..52dab68a2adfba 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -265,7 +265,7 @@ impl TitleBar {
     fn render_ssh_project_host(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
         let host = self.project.read(cx).ssh_connection_string(cx)?;
         let meta = SharedString::from(format!("Connected to: {host}"));
-        let indicator_color = if self.project.read(cx).ssh_is_connected()? {
+        let indicator_color = if self.project.read(cx).ssh_is_connected(cx)? {
             Color::Success
         } else {
             Color::Warning
diff --git a/crates/workspace/Cargo.toml b/crates/workspace/Cargo.toml
index 1b998eeabe5373..47f6c138c82366 100644
--- a/crates/workspace/Cargo.toml
+++ b/crates/workspace/Cargo.toml
@@ -51,6 +51,7 @@ postage.workspace = true
 project.workspace = true
 dev_server_projects.workspace = true
 task.workspace = true
+release_channel.workspace = true
 remote.workspace = true
 schemars.workspace = true
 serde.workspace = true
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index b668a5802c3b14..d2ccd9cd4a5708 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -61,7 +61,8 @@ use postage::stream::Stream;
 use project::{
     DirectoryLister, Project, ProjectEntryId, ProjectPath, ResolvedPath, Worktree, WorktreeId,
 };
-use remote::{SshConnectionOptions, SshRemoteClient};
+use release_channel::ReleaseChannel;
+use remote::{SshClientDelegate, SshConnectionOptions};
 use serde::Deserialize;
 use session::AppSession;
 use settings::{InvalidSettingsError, Settings};
@@ -5514,22 +5515,31 @@ pub fn join_hosted_project(
 pub fn open_ssh_project(
     window: WindowHandle<Workspace>,
     connection_options: SshConnectionOptions,
-    session: Arc<SshRemoteClient>,
+    delegate: Arc<dyn SshClientDelegate>,
     app_state: Arc<AppState>,
     paths: Vec<PathBuf>,
     cx: &mut AppContext,
 ) -> Task<Result<()>> {
+    let release_channel = ReleaseChannel::global(cx);
+
     cx.spawn(|mut cx| async move {
-        let serialized_ssh_project = persistence::DB
-            .get_or_create_ssh_project(
-                connection_options.host.clone(),
-                connection_options.port,
-                paths
-                    .iter()
-                    .map(|path| path.to_string_lossy().to_string())
-                    .collect::<Vec<_>>(),
-                connection_options.username.clone(),
-            )
+        let (serialized_ssh_project, workspace_id, serialized_workspace) =
+            serialize_ssh_project(connection_options.clone(), paths.clone(), &cx).await?;
+
+        let identifier_prefix = match release_channel {
+            ReleaseChannel::Stable => None,
+            _ => Some(format!("{}-", release_channel.dev_name())),
+        };
+        let unique_identifier = format!(
+            "{}workspace-{}",
+            identifier_prefix.unwrap_or_default(),
+            workspace_id.0
+        );
+
+        let session = cx
+            .update(|cx| {
+                remote::SshRemoteClient::new(unique_identifier, connection_options, delegate, cx)
+            })?
             .await?;
 
         let project = cx.update(|cx| {
@@ -5561,17 +5571,6 @@ pub fn open_ssh_project(
             };
         }
 
-        let serialized_workspace =
-            persistence::DB.workspace_for_ssh_project(&serialized_ssh_project);
-
-        let workspace_id = if let Some(workspace_id) =
-            serialized_workspace.as_ref().map(|workspace| workspace.id)
-        {
-            workspace_id
-        } else {
-            persistence::DB.next_id().await?
-        };
-
         cx.update_window(window.into(), |_, cx| {
             cx.replace_root_view(|cx| {
                 let mut workspace =
@@ -5603,6 +5602,45 @@ pub fn open_ssh_project(
     })
 }
 
+fn serialize_ssh_project(
+    connection_options: SshConnectionOptions,
+    paths: Vec<PathBuf>,
+    cx: &AsyncAppContext,
+) -> Task<
+    Result<(
+        SerializedSshProject,
+        WorkspaceId,
+        Option<SerializedWorkspace>,
+    )>,
+> {
+    cx.background_executor().spawn(async move {
+        let serialized_ssh_project = persistence::DB
+            .get_or_create_ssh_project(
+                connection_options.host.clone(),
+                connection_options.port,
+                paths
+                    .iter()
+                    .map(|path| path.to_string_lossy().to_string())
+                    .collect::<Vec<_>>(),
+                connection_options.username.clone(),
+            )
+            .await?;
+
+        let serialized_workspace =
+            persistence::DB.workspace_for_ssh_project(&serialized_ssh_project);
+
+        let workspace_id = if let Some(workspace_id) =
+            serialized_workspace.as_ref().map(|workspace| workspace.id)
+        {
+            workspace_id
+        } else {
+            persistence::DB.next_id().await?
+        };
+
+        Ok((serialized_ssh_project, workspace_id, serialized_workspace))
+    })
+}
+
 pub fn join_dev_server_project(
     dev_server_project_id: DevServerProjectId,
     project_id: ProjectId,

From 9c5bec5efba4927bd872bc4cb5909733062ecbbe Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Mon, 7 Oct 2024 12:24:12 +0200
Subject: [PATCH 500/762] formatting: Use project environment to find external
 formatters (#18611)

Closes #18261

This makes sure that we find external formatters in the project
environment.

TODO:

- [x] Use a different type for the triplet of `(buffer_handle,
buffer_path, buffer_env)`. Something like `FormattableBuffer`.
- [x] Test this!!

Release Notes:

- Fixed external formatters not being found, even when they were
available in the `$PATH` of a project.

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/project/src/lsp_store.rs | 135 ++++++++++++++++++++------------
 1 file changed, 87 insertions(+), 48 deletions(-)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index a3763810e1a262..b33416228e0d81 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -158,7 +158,7 @@ impl LocalLspStore {
 
     async fn format_locally(
         lsp_store: WeakModel<LspStore>,
-        mut buffers_with_paths: Vec<(Model<Buffer>, Option<PathBuf>)>,
+        mut buffers: Vec<FormattableBuffer>,
         push_to_history: bool,
         trigger: FormatTrigger,
         mut cx: AsyncAppContext,
@@ -167,22 +167,22 @@ impl LocalLspStore {
         // same buffer.
         lsp_store.update(&mut cx, |this, cx| {
             let this = this.as_local_mut().unwrap();
-            buffers_with_paths.retain(|(buffer, _)| {
+            buffers.retain(|buffer| {
                 this.buffers_being_formatted
-                    .insert(buffer.read(cx).remote_id())
+                    .insert(buffer.handle.read(cx).remote_id())
             });
         })?;
 
         let _cleanup = defer({
             let this = lsp_store.clone();
             let mut cx = cx.clone();
-            let buffers = &buffers_with_paths;
+            let buffers = &buffers;
             move || {
                 this.update(&mut cx, |this, cx| {
                     let this = this.as_local_mut().unwrap();
-                    for (buffer, _) in buffers {
+                    for buffer in buffers {
                         this.buffers_being_formatted
-                            .remove(&buffer.read(cx).remote_id());
+                            .remove(&buffer.handle.read(cx).remote_id());
                     }
                 })
                 .ok();
@@ -190,10 +190,10 @@ impl LocalLspStore {
         });
 
         let mut project_transaction = ProjectTransaction::default();
-        for (buffer, buffer_abs_path) in &buffers_with_paths {
+        for buffer in &buffers {
             let (primary_adapter_and_server, adapters_and_servers) =
                 lsp_store.update(&mut cx, |lsp_store, cx| {
-                    let buffer = buffer.read(cx);
+                    let buffer = buffer.handle.read(cx);
 
                     let adapters_and_servers = lsp_store
                         .language_servers_for_buffer(buffer, cx)
@@ -207,7 +207,7 @@ impl LocalLspStore {
                     (primary_adapter, adapters_and_servers)
                 })?;
 
-            let settings = buffer.update(&mut cx, |buffer, cx| {
+            let settings = buffer.handle.update(&mut cx, |buffer, cx| {
                 language_settings(buffer.language(), buffer.file(), cx).clone()
             })?;
 
@@ -218,13 +218,14 @@ impl LocalLspStore {
             let trailing_whitespace_diff = if remove_trailing_whitespace {
                 Some(
                     buffer
+                        .handle
                         .update(&mut cx, |b, cx| b.remove_trailing_whitespace(cx))?
                         .await,
                 )
             } else {
                 None
             };
-            let whitespace_transaction_id = buffer.update(&mut cx, |buffer, cx| {
+            let whitespace_transaction_id = buffer.handle.update(&mut cx, |buffer, cx| {
                 buffer.finalize_last_transaction();
                 buffer.start_transaction();
                 if let Some(diff) = trailing_whitespace_diff {
@@ -246,7 +247,7 @@ impl LocalLspStore {
                     &lsp_store,
                     &adapters_and_servers,
                     code_actions,
-                    buffer,
+                    &buffer.handle,
                     push_to_history,
                     &mut project_transaction,
                     &mut cx,
@@ -261,9 +262,9 @@ impl LocalLspStore {
                 primary_adapter_and_server.map(|(_adapter, server)| server.clone());
             let server_and_buffer = primary_language_server
                 .as_ref()
-                .zip(buffer_abs_path.as_ref());
+                .zip(buffer.abs_path.as_ref());
 
-            let prettier_settings = buffer.read_with(&cx, |buffer, cx| {
+            let prettier_settings = buffer.handle.read_with(&cx, |buffer, cx| {
                 language_settings(buffer.language(), buffer.file(), cx)
                     .prettier
                     .clone()
@@ -288,7 +289,6 @@ impl LocalLspStore {
                                                     server_and_buffer,
                                                     lsp_store.clone(),
                                                     buffer,
-                                                    buffer_abs_path,
                                                     &settings,
                                                     &adapters_and_servers,
                                                     push_to_history,
@@ -302,7 +302,6 @@ impl LocalLspStore {
                                                     server_and_buffer,
                                                     lsp_store.clone(),
                                                     buffer,
-                                                    buffer_abs_path,
                                                     &settings,
                                                     &adapters_and_servers,
                                                     push_to_history,
@@ -325,7 +324,6 @@ impl LocalLspStore {
                                                 server_and_buffer,
                                                 lsp_store.clone(),
                                                 buffer,
-                                                buffer_abs_path,
                                                 &settings,
                                                 &adapters_and_servers,
                                                 push_to_history,
@@ -351,7 +349,6 @@ impl LocalLspStore {
                                         server_and_buffer,
                                         lsp_store.clone(),
                                         buffer,
-                                        buffer_abs_path,
                                         &settings,
                                         &adapters_and_servers,
                                         push_to_history,
@@ -379,7 +376,6 @@ impl LocalLspStore {
                                             server_and_buffer,
                                             lsp_store.clone(),
                                             buffer,
-                                            buffer_abs_path,
                                             &settings,
                                             &adapters_and_servers,
                                             push_to_history,
@@ -393,7 +389,6 @@ impl LocalLspStore {
                                             server_and_buffer,
                                             lsp_store.clone(),
                                             buffer,
-                                            buffer_abs_path,
                                             &settings,
                                             &adapters_and_servers,
                                             push_to_history,
@@ -418,7 +413,6 @@ impl LocalLspStore {
                                         server_and_buffer,
                                         lsp_store.clone(),
                                         buffer,
-                                        buffer_abs_path,
                                         &settings,
                                         &adapters_and_servers,
                                         push_to_history,
@@ -438,7 +432,7 @@ impl LocalLspStore {
                 }
             }
 
-            buffer.update(&mut cx, |b, cx| {
+            buffer.handle.update(&mut cx, |b, cx| {
                 // If the buffer had its whitespace formatted and was edited while the language-specific
                 // formatting was being computed, avoid applying the language-specific formatting, because
                 // it can't be grouped with the whitespace formatting in the undo history.
@@ -467,7 +461,7 @@ impl LocalLspStore {
 
                     if let Some(transaction_id) = whitespace_transaction_id {
                         b.group_until_transaction(transaction_id);
-                    } else if let Some(transaction) = project_transaction.0.get(buffer) {
+                    } else if let Some(transaction) = project_transaction.0.get(&buffer.handle) {
                         b.group_until_transaction(transaction.id)
                     }
                 }
@@ -476,7 +470,9 @@ impl LocalLspStore {
                     if !push_to_history {
                         b.forget_transaction(transaction.id);
                     }
-                    project_transaction.0.insert(buffer.clone(), transaction);
+                    project_transaction
+                        .0
+                        .insert(buffer.handle.clone(), transaction);
                 }
             })?;
         }
@@ -489,8 +485,7 @@ impl LocalLspStore {
         formatter: &Formatter,
         primary_server_and_buffer: Option<(&Arc<LanguageServer>, &PathBuf)>,
         lsp_store: WeakModel<LspStore>,
-        buffer: &Model<Buffer>,
-        buffer_abs_path: &Option<PathBuf>,
+        buffer: &FormattableBuffer,
         settings: &LanguageSettings,
         adapters_and_servers: &[(Arc<CachedLspAdapter>, Arc<LanguageServer>)],
         push_to_history: bool,
@@ -514,7 +509,7 @@ impl LocalLspStore {
                     Some(FormatOperation::Lsp(
                         LspStore::format_via_lsp(
                             &lsp_store,
-                            buffer,
+                            &buffer.handle,
                             buffer_abs_path,
                             language_server,
                             settings,
@@ -531,27 +526,20 @@ impl LocalLspStore {
                 let prettier = lsp_store.update(cx, |lsp_store, _cx| {
                     lsp_store.prettier_store().unwrap().downgrade()
                 })?;
-                prettier_store::format_with_prettier(&prettier, buffer, cx)
+                prettier_store::format_with_prettier(&prettier, &buffer.handle, cx)
                     .await
                     .transpose()
                     .ok()
                     .flatten()
             }
             Formatter::External { command, arguments } => {
-                let buffer_abs_path = buffer_abs_path.as_ref().map(|path| path.as_path());
-                Self::format_via_external_command(
-                    buffer,
-                    buffer_abs_path,
-                    command,
-                    arguments.as_deref(),
-                    cx,
-                )
-                .await
-                .context(format!(
-                    "failed to format via external command {:?}",
-                    command
-                ))?
-                .map(FormatOperation::External)
+                Self::format_via_external_command(buffer, command, arguments.as_deref(), cx)
+                    .await
+                    .context(format!(
+                        "failed to format via external command {:?}",
+                        command
+                    ))?
+                    .map(FormatOperation::External)
             }
             Formatter::CodeActions(code_actions) => {
                 let code_actions = deserialize_code_actions(code_actions);
@@ -560,7 +548,7 @@ impl LocalLspStore {
                         &lsp_store,
                         adapters_and_servers,
                         code_actions,
-                        buffer,
+                        &buffer.handle,
                         push_to_history,
                         transaction,
                         cx,
@@ -574,13 +562,12 @@ impl LocalLspStore {
     }
 
     async fn format_via_external_command(
-        buffer: &Model<Buffer>,
-        buffer_abs_path: Option<&Path>,
+        buffer: &FormattableBuffer,
         command: &str,
         arguments: Option<&[String]>,
         cx: &mut AsyncAppContext,
     ) -> Result<Option<Diff>> {
-        let working_dir_path = buffer.update(cx, |buffer, cx| {
+        let working_dir_path = buffer.handle.update(cx, |buffer, cx| {
             let file = File::from_dyn(buffer.file())?;
             let worktree = file.worktree.read(cx);
             let mut worktree_path = worktree.abs_path().to_path_buf();
@@ -597,13 +584,17 @@ impl LocalLspStore {
             child.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
         }
 
+        if let Some(buffer_env) = buffer.env.as_ref() {
+            child.envs(buffer_env);
+        }
+
         if let Some(working_dir_path) = working_dir_path {
             child.current_dir(working_dir_path);
         }
 
         if let Some(arguments) = arguments {
             child.args(arguments.iter().map(|arg| {
-                if let Some(buffer_abs_path) = buffer_abs_path {
+                if let Some(buffer_abs_path) = buffer.abs_path.as_ref() {
                     arg.replace("{buffer_path}", &buffer_abs_path.to_string_lossy())
                 } else {
                     arg.replace("{buffer_path}", "Untitled")
@@ -621,7 +612,9 @@ impl LocalLspStore {
             .stdin
             .as_mut()
             .ok_or_else(|| anyhow!("failed to acquire stdin"))?;
-        let text = buffer.update(cx, |buffer, _| buffer.as_rope().clone())?;
+        let text = buffer
+            .handle
+            .update(cx, |buffer, _| buffer.as_rope().clone())?;
         for chunk in text.chunks() {
             stdin.write_all(chunk.as_bytes()).await?;
         }
@@ -640,12 +633,19 @@ impl LocalLspStore {
         let stdout = String::from_utf8(output.stdout)?;
         Ok(Some(
             buffer
+                .handle
                 .update(cx, |buffer, cx| buffer.diff(stdout, cx))?
                 .await,
         ))
     }
 }
 
+pub struct FormattableBuffer {
+    handle: Model<Buffer>,
+    abs_path: Option<PathBuf>,
+    env: Option<HashMap<String, String>>,
+}
+
 pub struct RemoteLspStore {
     upstream_client: AnyProtoClient,
     upstream_project_id: u64,
@@ -5028,6 +5028,28 @@ impl LspStore {
             .and_then(|local| local.last_formatting_failure.as_deref())
     }
 
+    pub fn environment_for_buffer(
+        &self,
+        buffer: &Model<Buffer>,
+        cx: &mut ModelContext<Self>,
+    ) -> Shared<Task<Option<HashMap<String, String>>>> {
+        let worktree_id = buffer.read(cx).file().map(|file| file.worktree_id(cx));
+        let worktree_abs_path = worktree_id.and_then(|worktree_id| {
+            self.worktree_store
+                .read(cx)
+                .worktree_for_id(worktree_id, cx)
+                .map(|entry| entry.read(cx).abs_path().clone())
+        });
+
+        if let Some(environment) = &self.as_local().map(|local| local.environment.clone()) {
+            environment.update(cx, |env, cx| {
+                env.get_environment(worktree_id, worktree_abs_path, cx)
+            })
+        } else {
+            Task::ready(None).shared()
+        }
+    }
+
     pub fn format(
         &mut self,
         buffers: HashSet<Model<Buffer>>,
@@ -5042,14 +5064,31 @@ impl LspStore {
                     let buffer = buffer_handle.read(cx);
                     let buffer_abs_path = File::from_dyn(buffer.file())
                         .and_then(|file| file.as_local().map(|f| f.abs_path(cx)));
+
                     (buffer_handle, buffer_abs_path)
                 })
                 .collect::<Vec<_>>();
 
             cx.spawn(move |lsp_store, mut cx| async move {
+                let mut formattable_buffers = Vec::with_capacity(buffers_with_paths.len());
+
+                for (handle, abs_path) in buffers_with_paths {
+                    let env = lsp_store
+                        .update(&mut cx, |lsp_store, cx| {
+                            lsp_store.environment_for_buffer(&handle, cx)
+                        })?
+                        .await;
+
+                    formattable_buffers.push(FormattableBuffer {
+                        handle,
+                        abs_path,
+                        env,
+                    });
+                }
+
                 let result = LocalLspStore::format_locally(
                     lsp_store.clone(),
-                    buffers_with_paths,
+                    formattable_buffers,
                     push_to_history,
                     trigger,
                     cx.clone(),

From 5aa165c530d74afc22ca54c07f5bdfaab01847e7 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Mon, 7 Oct 2024 15:01:50 +0200
Subject: [PATCH 501/762] ssh: Overhaul remoting UI (#18727)

Release Notes:

- N/A

---------

Co-authored-by: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
---
 Cargo.lock                                    |   1 -
 assets/icons/trash_alt.svg                    |   1 +
 crates/recent_projects/Cargo.toml             |   1 -
 crates/recent_projects/src/dev_servers.rs     | 591 +++++++-----------
 crates/recent_projects/src/ssh_connections.rs | 127 ++--
 crates/ui/src/components/icon.rs              |   1 +
 crates/ui/src/components/modal.rs             |  36 +-
 crates/ui/src/traits/styled_ext.rs            |  20 +-
 8 files changed, 356 insertions(+), 422 deletions(-)
 create mode 100644 assets/icons/trash_alt.svg

diff --git a/Cargo.lock b/Cargo.lock
index 1cac85e0c7e709..f682d76ad5f597 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9002,7 +9002,6 @@ dependencies = [
  "gpui",
  "language",
  "log",
- "markdown",
  "menu",
  "ordered-float 2.10.1",
  "picker",
diff --git a/assets/icons/trash_alt.svg b/assets/icons/trash_alt.svg
new file mode 100644
index 00000000000000..6867b421475a6e
--- /dev/null
+++ b/assets/icons/trash_alt.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-trash"><path d="M3 6h18"/><path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6"/><path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2"/></svg>
diff --git a/crates/recent_projects/Cargo.toml b/crates/recent_projects/Cargo.toml
index da4ee210e1acfe..2eea6321a07769 100644
--- a/crates/recent_projects/Cargo.toml
+++ b/crates/recent_projects/Cargo.toml
@@ -22,7 +22,6 @@ futures.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
 log.workspace = true
-markdown.workspace = true
 menu.workspace = true
 ordered-float.workspace = true
 picker.workspace = true
diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 722743e0ff8770..7761461ab51abe 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -8,17 +8,18 @@ use anyhow::Result;
 use client::Client;
 use dev_server_projects::{DevServer, DevServerId, DevServerProject, DevServerProjectId};
 use editor::Editor;
+use gpui::pulsating_between;
 use gpui::AsyncWindowContext;
+use gpui::ClipboardItem;
 use gpui::PathPromptOptions;
 use gpui::Subscription;
 use gpui::Task;
 use gpui::WeakView;
 use gpui::{
-    percentage, Animation, AnimationExt, AnyElement, AppContext, DismissEvent, EventEmitter,
-    FocusHandle, FocusableView, Model, ScrollHandle, Transformation, View, ViewContext,
+    percentage, Action, Animation, AnimationExt, AnyElement, AppContext, DismissEvent,
+    EventEmitter, FocusHandle, FocusableView, Model, ScrollHandle, Transformation, View,
+    ViewContext,
 };
-use markdown::Markdown;
-use markdown::MarkdownStyle;
 use project::terminals::wrap_for_ssh;
 use project::terminals::SshCommand;
 use rpc::proto::RegenerateDevServerTokenResponse;
@@ -35,8 +36,8 @@ use terminal_view::terminal_panel::TerminalPanel;
 use ui::ElevationIndex;
 use ui::Section;
 use ui::{
-    prelude::*, Indicator, List, ListHeader, ListItem, Modal, ModalFooter, ModalHeader,
-    RadioWithLabel, Tooltip,
+    prelude::*, IconButtonShape, Indicator, List, ListItem, Modal, ModalFooter, ModalHeader,
+    Tooltip,
 };
 use ui_input::{FieldLabelLayout, TextField};
 use util::ResultExt;
@@ -62,7 +63,6 @@ pub struct DevServerProjects {
     workspace: WeakView<Workspace>,
     project_path_input: View<Editor>,
     dev_server_name_input: View<TextField>,
-    markdown: View<Markdown>,
     _dev_server_subscription: Subscription,
 }
 
@@ -132,26 +132,6 @@ impl DevServerProjects {
             ..Default::default()
         });
 
-        let markdown_style = MarkdownStyle {
-            base_text_style: base_style,
-            code_block: gpui::StyleRefinement {
-                text: Some(gpui::TextStyleRefinement {
-                    font_family: Some("Zed Plex Mono".into()),
-                    ..Default::default()
-                }),
-                ..Default::default()
-            },
-            link: gpui::TextStyleRefinement {
-                color: Some(Color::Accent.color(cx)),
-                ..Default::default()
-            },
-            syntax: cx.theme().syntax().clone(),
-            selection_background_color: cx.theme().players().local().selection,
-            ..Default::default()
-        };
-        let markdown =
-            cx.new_view(|cx| Markdown::new("".to_string(), markdown_style, None, cx, None));
-
         Self {
             mode: Mode::Default(None),
             focus_handle,
@@ -159,7 +139,6 @@ impl DevServerProjects {
             dev_server_store,
             project_path_input,
             dev_server_name_input,
-            markdown,
             workspace,
             _dev_server_subscription: subscription,
         }
@@ -845,7 +824,7 @@ impl DevServerProjects {
                                 })
                                 .child({
                                     let dev_server_id = dev_server.id;
-                                    IconButton::new("remove-dev-server", IconName::Trash)
+                                    IconButton::new("remove-dev-server", IconName::TrashAlt)
                                         .on_click(cx.listener(move |this, _, cx| {
                                             this.delete_dev_server(dev_server_id, cx)
                                         }))
@@ -913,40 +892,73 @@ impl DevServerProjects {
     ) -> impl IntoElement {
         v_flex()
             .w_full()
+            .px(Spacing::Small.rems(cx) + Spacing::Small.rems(cx))
             .child(
-                h_flex().group("ssh-server").justify_between().child(
-                    h_flex()
-                        .gap_2()
-                        .child(
-                            div()
-                                .id(("status", ix))
-                                .relative()
-                                .child(Icon::new(IconName::Server).size(IconSize::Small)),
-                        )
-                        .child(
-                            div()
-                                .max_w(rems(26.))
-                                .overflow_hidden()
-                                .whitespace_nowrap()
-                                .child(Label::new(ssh_connection.host.clone())),
-                        )
-                        .child(h_flex().visible_on_hover("ssh-server").gap_1().child({
-                            IconButton::new("remove-dev-server", IconName::Trash)
-                                .on_click(
-                                    cx.listener(move |this, _, cx| this.delete_ssh_server(ix, cx)),
-                                )
-                                .tooltip(|cx| Tooltip::text("Remove Dev Server", cx))
-                        })),
-                ),
+                h_flex()
+                    .w_full()
+                    .group("ssh-server")
+                    .justify_between()
+                    .child(
+                        h_flex()
+                            .gap_2()
+                            .w_full()
+                            .child(
+                                div()
+                                    .id(("status", ix))
+                                    .relative()
+                                    .child(Icon::new(IconName::Server).size(IconSize::Small)),
+                            )
+                            .child(
+                                h_flex()
+                                    .max_w(rems(26.))
+                                    .overflow_hidden()
+                                    .whitespace_nowrap()
+                                    .child(Label::new(ssh_connection.host.clone())),
+                            ),
+                    )
+                    .child(
+                        h_flex()
+                            .visible_on_hover("ssh-server")
+                            .gap_1()
+                            .child({
+                                IconButton::new("copy-dev-server-address", IconName::Copy)
+                                    .icon_size(IconSize::Small)
+                                    .on_click(cx.listener(move |this, _, cx| {
+                                        this.update_settings_file(cx, move |servers, cx| {
+                                            if let Some(content) = servers
+                                                .ssh_connections
+                                                .as_ref()
+                                                .and_then(|connections| {
+                                                    connections
+                                                        .get(ix)
+                                                        .map(|connection| connection.host.clone())
+                                                })
+                                            {
+                                                cx.write_to_clipboard(ClipboardItem::new_string(
+                                                    content,
+                                                ));
+                                            }
+                                        });
+                                    }))
+                                    .tooltip(|cx| Tooltip::text("Copy Server Address", cx))
+                            })
+                            .child({
+                                IconButton::new("remove-dev-server", IconName::TrashAlt)
+                                    .icon_size(IconSize::Small)
+                                    .on_click(cx.listener(move |this, _, cx| {
+                                        this.delete_ssh_server(ix, cx)
+                                    }))
+                                    .tooltip(|cx| Tooltip::text("Remove Dev Server", cx))
+                            }),
+                    ),
             )
             .child(
                 v_flex()
                     .w_full()
-                    .bg(cx.theme().colors().background)
-                    .border_1()
+                    .border_l_1()
                     .border_color(cx.theme().colors().border_variant)
-                    .rounded_md()
                     .my_1()
+                    .mx_1p5()
                     .py_0p5()
                     .px_3()
                     .child(
@@ -956,12 +968,17 @@ impl DevServerProjects {
                                 self.render_ssh_project(ix, &ssh_connection, pix, p, cx)
                             }))
                             .child(
-                                ListItem::new("new-remote_project")
-                                    .start_slot(Icon::new(IconName::Plus))
-                                    .child(Label::new("Open folder…"))
-                                    .on_click(cx.listener(move |this, _, cx| {
-                                        this.create_ssh_project(ix, ssh_connection.clone(), cx);
-                                    })),
+                                h_flex().child(
+                                    Button::new("new-remote_project", "Open Folder…")
+                                        .icon(IconName::Plus)
+                                        .size(ButtonSize::Default)
+                                        .style(ButtonStyle::Filled)
+                                        .layer(ElevationIndex::ModalSurface)
+                                        .icon_position(IconPosition::Start)
+                                        .on_click(cx.listener(move |this, _, cx| {
+                                            this.create_ssh_project(ix, ssh_connection.clone(), cx);
+                                        })),
+                                ),
                             ),
                     ),
             )
@@ -978,7 +995,8 @@ impl DevServerProjects {
         let project = project.clone();
         let server = server.clone();
         ListItem::new(("remote-project", ix))
-            .start_slot(Icon::new(IconName::FileTree))
+            .spacing(ui::ListItemSpacing::Sparse)
+            .start_slot(Icon::new(IconName::Folder).color(Color::Muted))
             .child(Label::new(project.paths.join(", ")))
             .on_click(cx.listener(move |this, _, cx| {
                 let Some(app_state) = this
@@ -1014,7 +1032,7 @@ impl DevServerProjects {
                 .detach();
             }))
             .end_hover_slot::<AnyElement>(Some(
-                IconButton::new("remove-remote-project", IconName::Trash)
+                IconButton::new("remove-remote-project", IconName::TrashAlt)
                     .on_click(
                         cx.listener(move |this, _, cx| this.delete_ssh_project(server_ix, ix, cx)),
                     )
@@ -1026,7 +1044,7 @@ impl DevServerProjects {
     fn update_settings_file(
         &mut self,
         cx: &mut ViewContext<Self>,
-        f: impl FnOnce(&mut RemoteSettingsContent) + Send + Sync + 'static,
+        f: impl FnOnce(&mut RemoteSettingsContent, &AppContext) + Send + Sync + 'static,
     ) {
         let Some(fs) = self
             .workspace
@@ -1035,11 +1053,11 @@ impl DevServerProjects {
         else {
             return;
         };
-        update_settings_file::<SshSettings>(fs, cx, move |setting, _| f(setting));
+        update_settings_file::<SshSettings>(fs, cx, move |setting, cx| f(setting, cx));
     }
 
     fn delete_ssh_server(&mut self, server: usize, cx: &mut ViewContext<Self>) {
-        self.update_settings_file(cx, move |setting| {
+        self.update_settings_file(cx, move |setting, _| {
             if let Some(connections) = setting.ssh_connections.as_mut() {
                 connections.remove(server);
             }
@@ -1047,7 +1065,7 @@ impl DevServerProjects {
     }
 
     fn delete_ssh_project(&mut self, server: usize, project: usize, cx: &mut ViewContext<Self>) {
-        self.update_settings_file(cx, move |setting| {
+        self.update_settings_file(cx, move |setting, _| {
             if let Some(server) = setting
                 .ssh_connections
                 .as_mut()
@@ -1063,7 +1081,7 @@ impl DevServerProjects {
         connection_options: remote::SshConnectionOptions,
         cx: &mut ViewContext<Self>,
     ) {
-        self.update_settings_file(cx, move |setting| {
+        self.update_settings_file(cx, move |setting, _| {
             setting
                 .ssh_connections
                 .get_or_insert(Default::default())
@@ -1124,7 +1142,7 @@ impl DevServerProjects {
                     }).detach();
                 }
             }))
-            .end_hover_slot::<AnyElement>(Some(IconButton::new("remove-remote-project", IconName::Trash)
+            .end_hover_slot::<AnyElement>(Some(IconButton::new("remove-remote-project", IconName::TrashAlt)
                 .on_click(cx.listener(move |this, _, cx| {
                     this.delete_dev_server_project(dev_server_project_id, cx)
                 }))
@@ -1148,250 +1166,109 @@ impl DevServerProjects {
             kind = NewServerKind::DirectSSH;
         }
 
-        let status = dev_server_id
-            .map(|id| self.dev_server_store.read(cx).dev_server_status(id))
-            .unwrap_or_default();
-
-        let name = self.dev_server_name_input.update(cx, |input, cx| {
+        self.dev_server_name_input.update(cx, |input, cx| {
             input.editor().update(cx, |editor, cx| {
                 if editor.text(cx).is_empty() {
-                    match kind {
-                        NewServerKind::DirectSSH => editor.set_placeholder_text("ssh host", cx),
-                        NewServerKind::LegacySSH => editor.set_placeholder_text("ssh host", cx),
-                        NewServerKind::Manual => editor.set_placeholder_text("example-host", cx),
-                    }
+                    editor.set_placeholder_text("ssh me@my.server / ssh@secret-box:2222", cx);
                 }
-                editor.text(cx)
             })
         });
-
-        const MANUAL_SETUP_MESSAGE: &str =
-            "Generate a token for this server and follow the steps to set Zed up on that machine.";
-        const SSH_SETUP_MESSAGE: &str =
-            "Enter the command you use to SSH into this server.\nFor example: `ssh me@my.server` or `ssh me@secret-box:2222`.";
-
-        Modal::new("create-dev-server", Some(self.scroll_handle.clone()))
-            .header(
-                ModalHeader::new()
-                    .headline("Create Dev Server")
-                    .show_back_button(true),
-            )
-            .section(
-                Section::new()
-                    .header(if kind == NewServerKind::Manual {
-                        "Server Name".into()
-                    } else {
-                        "SSH arguments".into()
-                    })
+        let theme = cx.theme();
+        v_flex()
+            .id("create-dev-server")
+            .overflow_hidden()
+            .size_full()
+            .flex_1()
+            .child(
+                h_flex()
+                    .p_2()
+                    .gap_2()
+                    .items_center()
+                    .border_b_1()
+                    .border_color(theme.colors().border_variant)
                     .child(
-                        div()
-                            .max_w(rems(16.))
-                            .child(self.dev_server_name_input.clone()),
-                    ),
+                        IconButton::new("cancel-dev-server-creation", IconName::ArrowLeft)
+                            .shape(IconButtonShape::Square)
+                            .on_click(|_, cx| {
+                                cx.dispatch_action(menu::Cancel.boxed_clone());
+                            }),
+                    )
+                    .child(Label::new("Connect New Dev Server")),
             )
-            .section(
-                Section::new_contained()
-                    .header("Connection Method".into())
+            .child(
+                v_flex()
+                    .p_3()
+                    .border_b_1()
+                    .border_color(theme.colors().border_variant)
+                    .child(Label::new("SSH Arguments"))
+                    .child(
+                        Label::new("Enter the command you use to SSH into this server.")
+                            .size(LabelSize::Small)
+                            .color(Color::Muted),
+                    )
                     .child(
-                        v_flex()
+                        h_flex()
+                            .mt_2()
                             .w_full()
-                            .px_2()
-                            .gap_y(Spacing::Large.rems(cx))
-                            .when(ssh_prompt.is_none(), |el| {
-                                el.child(
-                                    v_flex()
-                                        .when(use_direct_ssh, |el| {
-                                            el.child(RadioWithLabel::new(
-                                                "use-server-name-in-ssh",
-                                                Label::new("Connect via SSH (default)"),
-                                                NewServerKind::DirectSSH == kind,
-                                                cx.listener({
-                                                    move |this, _, cx| {
-                                                        if let Mode::CreateDevServer(
-                                                            CreateDevServer { kind, .. },
-                                                        ) = &mut this.mode
-                                                        {
-                                                            *kind = NewServerKind::DirectSSH;
-                                                        }
-                                                        cx.notify()
-                                                    }
-                                                }),
-                                            ))
-                                        })
-                                        .when(!use_direct_ssh, |el| {
-                                            el.child(RadioWithLabel::new(
-                                                "use-server-name-in-ssh",
-                                                Label::new("Configure over SSH (default)"),
-                                                kind == NewServerKind::LegacySSH,
-                                                cx.listener({
-                                                    move |this, _, cx| {
-                                                        if let Mode::CreateDevServer(
-                                                            CreateDevServer { kind, .. },
-                                                        ) = &mut this.mode
-                                                        {
-                                                            *kind = NewServerKind::LegacySSH;
-                                                        }
-                                                        cx.notify()
-                                                    }
-                                                }),
-                                            ))
-                                        })
-                                        .child(RadioWithLabel::new(
-                                            "use-server-name-in-ssh",
-                                            Label::new("Configure manually"),
-                                            kind == NewServerKind::Manual,
-                                            cx.listener({
-                                                move |this, _, cx| {
-                                                    if let Mode::CreateDevServer(
-                                                        CreateDevServer { kind, .. },
-                                                    ) = &mut this.mode
-                                                    {
-                                                        *kind = NewServerKind::Manual;
-                                                    }
-                                                    cx.notify()
-                                                }
-                                            }),
-                                        )),
-                                )
-                            })
-                            .when(dev_server_id.is_none() && ssh_prompt.is_none(), |el| {
-                                el.child(
-                                    if kind == NewServerKind::Manual {
-                                        Label::new(MANUAL_SETUP_MESSAGE)
-                                    } else {
-                                        Label::new(SSH_SETUP_MESSAGE)
-                                    }
-                                    .size(LabelSize::Small)
-                                    .color(Color::Muted),
-                                )
-                            })
-                            .when_some(ssh_prompt, |el, ssh_prompt| el.child(ssh_prompt))
-                            .when(dev_server_id.is_some() && access_token.is_none(), |el| {
-                                el.child(
-                                    if kind == NewServerKind::Manual {
-                                        Label::new(
-                                            "Note: updating the dev server generate a new token",
-                                        )
-                                    } else {
-                                        Label::new(SSH_SETUP_MESSAGE)
-                                    }
-                                    .size(LabelSize::Small)
-                                    .color(Color::Muted),
-                                )
-                            })
-                            .when_some(access_token.clone(), {
-                                |el, access_token| {
-                                    el.child(self.render_dev_server_token_creating(
-                                        access_token,
-                                        name,
-                                        kind,
-                                        status,
-                                        creating,
-                                        cx,
-                                    ))
-                                }
-                            }),
+                            .gap_2()
+                            .child(self.dev_server_name_input.clone())
+                            .child(
+                                Button::new("create-dev-server", "Connect Server")
+                                    .style(ButtonStyle::Filled)
+                                    .layer(ElevationIndex::ModalSurface)
+                                    .disabled(creating && dev_server_id.is_none())
+                                    .on_click(cx.listener({
+                                        let access_token = access_token.clone();
+                                        move |this, _, cx| {
+                                            if kind == NewServerKind::DirectSSH {
+                                                this.create_ssh_server(cx);
+                                                return;
+                                            }
+                                            this.create_or_update_dev_server(
+                                                kind,
+                                                dev_server_id,
+                                                access_token.clone(),
+                                                cx,
+                                            );
+                                        }
+                                    })),
+                            ),
                     ),
             )
-            .footer(
-                ModalFooter::new().end_slot(if status == DevServerStatus::Online {
-                    Button::new("create-dev-server", "Done")
-                        .style(ButtonStyle::Filled)
-                        .layer(ElevationIndex::ModalSurface)
-                        .on_click(cx.listener(move |this, _, cx| {
-                            cx.focus(&this.focus_handle);
-                            this.mode = Mode::Default(None);
-                            cx.notify();
-                        }))
-                } else {
-                    Button::new(
-                        "create-dev-server",
-                        if kind == NewServerKind::Manual {
-                            if dev_server_id.is_some() {
-                                "Update"
-                            } else {
-                                "Create"
-                            }
-                        } else if dev_server_id.is_some() {
-                            "Reconnect"
+            .child(
+                h_flex()
+                    .bg(theme.colors().editor_background)
+                    .w_full()
+                    .map(|this| {
+                        if let Some(ssh_prompt) = ssh_prompt {
+                            this.child(h_flex().w_full().child(ssh_prompt))
                         } else {
-                            "Connect"
-                        },
-                    )
-                    .style(ButtonStyle::Filled)
-                    .layer(ElevationIndex::ModalSurface)
-                    .disabled(creating && dev_server_id.is_none())
-                    .on_click(cx.listener({
-                        let access_token = access_token.clone();
-                        move |this, _, cx| {
-                            if kind == NewServerKind::DirectSSH {
-                                this.create_ssh_server(cx);
-                                return;
-                            }
-                            this.create_or_update_dev_server(
-                                kind,
-                                dev_server_id,
-                                access_token.clone(),
-                                cx,
-                            );
+                            let color = Color::Muted.color(cx);
+                            this.child(
+                                h_flex()
+                                    .p_2()
+                                    .w_full()
+                                    .content_center()
+                                    .gap_2()
+                                    .child(h_flex().w_full())
+                                    .child(
+                                        div().p_1().rounded_lg().bg(color).with_animation(
+                                            "pulse-ssh-waiting-for-connection",
+                                            Animation::new(Duration::from_secs(2))
+                                                .repeat()
+                                                .with_easing(pulsating_between(0.2, 0.5)),
+                                            move |this, progress| this.bg(color.opacity(progress)),
+                                        ),
+                                    )
+                                    .child(
+                                        Label::new("Waiting for connection…")
+                                            .size(LabelSize::Small),
+                                    )
+                                    .child(h_flex().w_full()),
+                            )
                         }
-                    }))
-                }),
-            )
-    }
-
-    fn render_dev_server_token_creating(
-        &self,
-        access_token: String,
-        dev_server_name: String,
-        kind: NewServerKind,
-        status: DevServerStatus,
-        creating: bool,
-        cx: &mut ViewContext<Self>,
-    ) -> Div {
-        self.markdown.update(cx, |markdown, cx| {
-            if kind == NewServerKind::Manual {
-                markdown.reset(format!("Please log into '{}'. If you don't yet have Zed installed, run:\n```\ncurl https://zed.dev/install.sh | bash\n```\nThen, to start Zed in headless mode:\n```\nzed --dev-server-token {}\n```", dev_server_name, access_token), cx);
-            } else {
-                markdown.reset("Please wait while we connect over SSH.\n\nIf you run into problems, please [file a bug](https://github.com/zed-industries/zed), and in the meantime try using the manual setup.".to_string(), cx);
-            }
-        });
-
-        v_flex()
-            .pl_2()
-            .pt_2()
-            .gap_2()
-            .child(v_flex().w_full().text_sm().child(self.markdown.clone()))
-            .map(|el| {
-                if status == DevServerStatus::Offline && kind != NewServerKind::Manual && !creating
-                {
-                    el.child(
-                        h_flex()
-                            .gap_2()
-                            .child(Icon::new(IconName::Disconnected).size(IconSize::Medium))
-                            .child(Label::new("Not connected")),
-                    )
-                } else if status == DevServerStatus::Offline {
-                    el.child(Self::render_loading_spinner("Waiting for connection…"))
-                } else {
-                    el.child(Label::new("🎊 Connection established!"))
-                }
-            })
-    }
-
-    fn render_loading_spinner(label: impl Into<SharedString>) -> Div {
-        h_flex()
-            .gap_2()
-            .child(
-                Icon::new(IconName::ArrowCircle)
-                    .size(IconSize::Medium)
-                    .with_animation(
-                        "arrow-circle",
-                        Animation::new(Duration::from_secs(2)).repeat(),
-                        |icon, delta| icon.transform(Transformation::rotate(percentage(delta))),
-                    ),
+                    }),
             )
-            .child(Label::new(label))
     }
 
     fn render_default(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
@@ -1416,64 +1293,73 @@ impl DevServerProjects {
             creating_dev_server = Some(*dev_server_id);
         };
 
+        let footer = format!("Connections: {}", ssh_connections.len() + dev_servers.len());
         Modal::new("remote-projects", Some(self.scroll_handle.clone()))
             .header(
-                ModalHeader::new()
-                    .show_dismiss_button(true)
-                    .child(Headline::new("Remote Projects (alpha)").size(HeadlineSize::Small)),
+                ModalHeader::new().child(
+                    h_flex()
+                        .justify_between()
+                        .child(Headline::new("Remote Projects (alpha)").size(HeadlineSize::XSmall))
+                        .child(
+                            Button::new("register-dev-server-button", "Connect New Server")
+                                .style(ButtonStyle::Filled)
+                                .layer(ElevationIndex::ModalSurface)
+                                .icon(IconName::Plus)
+                                .icon_position(IconPosition::Start)
+                                .icon_color(Color::Muted)
+                                .on_click(cx.listener(|this, _, cx| {
+                                    this.mode = Mode::CreateDevServer(CreateDevServer {
+                                        kind: if SshSettings::get_global(cx).use_direct_ssh() {
+                                            NewServerKind::DirectSSH
+                                        } else {
+                                            NewServerKind::LegacySSH
+                                        },
+                                        ..Default::default()
+                                    });
+                                    this.dev_server_name_input.update(cx, |text_field, cx| {
+                                        text_field.editor().update(cx, |editor, cx| {
+                                            editor.set_text("", cx);
+                                        });
+                                    });
+                                    cx.notify();
+                                })),
+                        ),
+                ),
             )
             .section(
-                Section::new().child(
-                    div().child(
-                        List::new()
-                            .empty_message("No dev servers registered yet.")
-                            .header(Some(
-                                ListHeader::new("Connections").end_slot(
-                                    Button::new("register-dev-server-button", "Connect New Server")
-                                        .icon(IconName::Plus)
-                                        .icon_position(IconPosition::Start)
-                                        .icon_color(Color::Muted)
-                                        .on_click(cx.listener(|this, _, cx| {
-                                            this.mode = Mode::CreateDevServer(CreateDevServer {
-                                                kind: if SshSettings::get_global(cx)
-                                                    .use_direct_ssh()
-                                                {
-                                                    NewServerKind::DirectSSH
-                                                } else {
-                                                    NewServerKind::LegacySSH
-                                                },
-                                                ..Default::default()
-                                            });
-                                            this.dev_server_name_input.update(
-                                                cx,
-                                                |text_field, cx| {
-                                                    text_field.editor().update(cx, |editor, cx| {
-                                                        editor.set_text("", cx);
-                                                    });
-                                                },
-                                            );
-                                            cx.notify();
-                                        })),
-                                ),
-                            ))
-                            .children(ssh_connections.iter().cloned().enumerate().map(
-                                |(ix, connection)| {
-                                    self.render_ssh_connection(ix, connection, cx)
-                                        .into_any_element()
-                                },
-                            ))
-                            .children(dev_servers.iter().map(|dev_server| {
-                                let creating = if creating_dev_server == Some(dev_server.id) {
-                                    is_creating
-                                } else {
-                                    None
-                                };
-                                self.render_dev_server(dev_server, creating, cx)
-                                    .into_any_element()
-                            })),
-                    ),
+                Section::new().padded(false).child(
+                    div()
+                        .border_y_1()
+                        .border_color(cx.theme().colors().border_variant)
+                        .w_full()
+                        .child(
+                            div().p_2().child(
+                                List::new()
+                                    .empty_message("No dev servers registered yet.")
+                                    .children(ssh_connections.iter().cloned().enumerate().map(
+                                        |(ix, connection)| {
+                                            self.render_ssh_connection(ix, connection, cx)
+                                                .into_any_element()
+                                        },
+                                    ))
+                                    .children(dev_servers.iter().map(|dev_server| {
+                                        let creating = if creating_dev_server == Some(dev_server.id)
+                                        {
+                                            is_creating
+                                        } else {
+                                            None
+                                        };
+                                        self.render_dev_server(dev_server, creating, cx)
+                                            .into_any_element()
+                                    })),
+                            ),
+                        ),
                 ),
             )
+            .footer(
+                ModalFooter::new()
+                    .start_slot(div().child(Label::new(footer).size(LabelSize::Small))),
+            )
     }
 }
 
@@ -1501,7 +1387,6 @@ impl Render for DevServerProjects {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         div()
             .track_focus(&self.focus_handle)
-            .p_2()
             .elevation_3(cx)
             .key_context("DevServerModal")
             .on_action(cx.listener(Self::cancel))
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 9e505237738a6a..554146eab2d183 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -5,9 +5,9 @@ use auto_update::AutoUpdater;
 use editor::Editor;
 use futures::channel::oneshot;
 use gpui::{
-    percentage, px, Animation, AnimationExt, AnyWindowHandle, AsyncAppContext, DismissEvent,
-    EventEmitter, FocusableView, ParentElement as _, Render, SemanticVersion, SharedString, Task,
-    Transformation, View,
+    percentage, px, Action, Animation, AnimationExt, AnyWindowHandle, AsyncAppContext,
+    DismissEvent, EventEmitter, FocusableView, ParentElement as _, Render, SemanticVersion,
+    SharedString, Task, Transformation, View,
 };
 use gpui::{AppContext, Model};
 use release_channel::{AppVersion, ReleaseChannel};
@@ -16,9 +16,9 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 use ui::{
-    h_flex, v_flex, Color, FluentBuilder as _, Icon, IconName, IconSize, InteractiveElement,
-    IntoElement, Label, LabelCommon, Styled, StyledExt as _, ViewContext, VisualContext,
-    WindowContext,
+    div, h_flex, v_flex, ActiveTheme, ButtonCommon, Clickable, Color, FluentBuilder as _, Icon,
+    IconButton, IconName, IconSize, InteractiveElement, IntoElement, Label, LabelCommon, Styled,
+    StyledExt as _, Tooltip, ViewContext, VisualContext, WindowContext,
 };
 use workspace::{AppState, ModalView, Workspace};
 
@@ -140,47 +140,57 @@ impl SshPrompt {
 }
 
 impl Render for SshPrompt {
-    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+    fn render(&mut self, _: &mut ViewContext<Self>) -> impl IntoElement {
         v_flex()
+            .w_full()
             .key_context("PasswordPrompt")
-            .p_4()
-            .size_full()
+            .justify_start()
             .child(
-                h_flex()
-                    .gap_2()
-                    .child(if self.error_message.is_some() {
-                        Icon::new(IconName::XCircle)
-                            .size(IconSize::Medium)
-                            .color(Color::Error)
-                            .into_any_element()
-                    } else {
-                        Icon::new(IconName::ArrowCircle)
-                            .size(IconSize::Medium)
-                            .with_animation(
-                                "arrow-circle",
-                                Animation::new(Duration::from_secs(2)).repeat(),
-                                |icon, delta| {
-                                    icon.transform(Transformation::rotate(percentage(delta)))
-                                },
-                            )
-                            .into_any_element()
-                    })
+                v_flex()
+                    .p_4()
+                    .size_full()
                     .child(
-                        Label::new(format!("ssh {}…", self.connection_string))
-                            .size(ui::LabelSize::Large),
-                    ),
-            )
-            .when_some(self.error_message.as_ref(), |el, error| {
-                el.child(Label::new(error.clone()))
-            })
-            .when(
-                self.error_message.is_none() && self.status_message.is_some(),
-                |el| el.child(Label::new(self.status_message.clone().unwrap())),
+                        h_flex()
+                            .gap_2()
+                            .justify_between()
+                            .child(h_flex().w_full())
+                            .child(if self.error_message.is_some() {
+                                Icon::new(IconName::XCircle)
+                                    .size(IconSize::Medium)
+                                    .color(Color::Error)
+                                    .into_any_element()
+                            } else {
+                                Icon::new(IconName::ArrowCircle)
+                                    .size(IconSize::Medium)
+                                    .with_animation(
+                                        "arrow-circle",
+                                        Animation::new(Duration::from_secs(2)).repeat(),
+                                        |icon, delta| {
+                                            icon.transform(Transformation::rotate(percentage(
+                                                delta,
+                                            )))
+                                        },
+                                    )
+                                    .into_any_element()
+                            })
+                            .child(Label::new(format!(
+                                "Connecting to {}…",
+                                self.connection_string
+                            )))
+                            .child(h_flex().w_full()),
+                    )
+                    .when_some(self.error_message.as_ref(), |el, error| {
+                        el.child(Label::new(error.clone()))
+                    })
+                    .when(
+                        self.error_message.is_none() && self.status_message.is_some(),
+                        |el| el.child(Label::new(self.status_message.clone().unwrap())),
+                    )
+                    .when_some(self.prompt.as_ref(), |el, prompt| {
+                        el.child(Label::new(prompt.0.clone()))
+                            .child(self.editor.clone())
+                    }),
             )
-            .when_some(self.prompt.as_ref(), |el, prompt| {
-                el.child(Label::new(prompt.0.clone()))
-                    .child(self.editor.clone())
-            })
     }
 }
 
@@ -202,14 +212,41 @@ impl SshConnectionModal {
 
 impl Render for SshConnectionModal {
     fn render(&mut self, cx: &mut ui::ViewContext<Self>) -> impl ui::IntoElement {
+        let connection_string = self.prompt.read(cx).connection_string.clone();
+        let theme = cx.theme();
+        let header_color = theme.colors().element_background;
+        let body_color = theme.colors().background;
         v_flex()
             .elevation_3(cx)
-            .p_4()
-            .gap_2()
             .on_action(cx.listener(Self::dismiss))
             .on_action(cx.listener(Self::confirm))
             .w(px(400.))
-            .child(self.prompt.clone())
+            .child(
+                h_flex()
+                    .p_1()
+                    .border_b_1()
+                    .border_color(theme.colors().border)
+                    .bg(header_color)
+                    .justify_between()
+                    .child(
+                        IconButton::new("ssh-connection-cancel", IconName::ArrowLeft)
+                            .icon_size(IconSize::XSmall)
+                            .on_click(|_, cx| cx.dispatch_action(menu::Cancel.boxed_clone()))
+                            .tooltip(|cx| Tooltip::for_action("Back", &menu::Cancel, cx)),
+                    )
+                    .child(
+                        h_flex()
+                            .gap_2()
+                            .child(Icon::new(IconName::Server).size(IconSize::XSmall))
+                            .child(
+                                Label::new(connection_string)
+                                    .size(ui::LabelSize::Small)
+                                    .single_line(),
+                            ),
+                    )
+                    .child(div()),
+            )
+            .child(h_flex().bg(body_color).w_full().child(self.prompt.clone()))
     }
 }
 
diff --git a/crates/ui/src/components/icon.rs b/crates/ui/src/components/icon.rs
index 693caaaafdacc7..8d374ef67ca410 100644
--- a/crates/ui/src/components/icon.rs
+++ b/crates/ui/src/components/icon.rs
@@ -275,6 +275,7 @@ pub enum IconName {
     Tab,
     Terminal,
     Trash,
+    TrashAlt,
     TriangleRight,
     Undo,
     Unpin,
diff --git a/crates/ui/src/components/modal.rs b/crates/ui/src/components/modal.rs
index 11611f9c0ffc92..512f9601a86b48 100644
--- a/crates/ui/src/components/modal.rs
+++ b/crates/ui/src/components/modal.rs
@@ -262,6 +262,7 @@ impl RenderOnce for ModalFooter {
 #[derive(IntoElement)]
 pub struct Section {
     contained: bool,
+    padded: bool,
     header: Option<SectionHeader>,
     meta: Option<SharedString>,
     children: SmallVec<[AnyElement; 2]>,
@@ -277,6 +278,7 @@ impl Section {
     pub fn new() -> Self {
         Self {
             contained: false,
+            padded: true,
             header: None,
             meta: None,
             children: SmallVec::new(),
@@ -286,6 +288,7 @@ impl Section {
     pub fn new_contained() -> Self {
         Self {
             contained: true,
+            padded: true,
             header: None,
             meta: None,
             children: SmallVec::new(),
@@ -306,6 +309,10 @@ impl Section {
         self.meta = Some(meta.into());
         self
     }
+    pub fn padded(mut self, padded: bool) -> Self {
+        self.padded = padded;
+        self
+    }
 }
 
 impl ParentElement for Section {
@@ -320,22 +327,27 @@ impl RenderOnce for Section {
         section_bg.fade_out(0.96);
 
         let children = if self.contained {
-            v_flex().flex_1().px(Spacing::XLarge.rems(cx)).child(
-                v_flex()
-                    .w_full()
-                    .rounded_md()
-                    .border_1()
-                    .border_color(cx.theme().colors().border)
-                    .bg(section_bg)
-                    .py(Spacing::Medium.rems(cx))
-                    .gap_y(Spacing::Small.rems(cx))
-                    .child(div().flex().flex_1().size_full().children(self.children)),
-            )
+            v_flex()
+                .flex_1()
+                .when(self.padded, |this| this.px(Spacing::XLarge.rems(cx)))
+                .child(
+                    v_flex()
+                        .w_full()
+                        .rounded_md()
+                        .border_1()
+                        .border_color(cx.theme().colors().border)
+                        .bg(section_bg)
+                        .py(Spacing::Medium.rems(cx))
+                        .gap_y(Spacing::Small.rems(cx))
+                        .child(div().flex().flex_1().size_full().children(self.children)),
+                )
         } else {
             v_flex()
                 .w_full()
                 .gap_y(Spacing::Small.rems(cx))
-                .px(Spacing::Medium.rems(cx) + Spacing::Medium.rems(cx))
+                .when(self.padded, |this| {
+                    this.px(Spacing::Medium.rems(cx) + Spacing::Medium.rems(cx))
+                })
                 .children(self.children)
         };
 
diff --git a/crates/ui/src/traits/styled_ext.rs b/crates/ui/src/traits/styled_ext.rs
index 997e80ca8642e6..09d8a4f74f5696 100644
--- a/crates/ui/src/traits/styled_ext.rs
+++ b/crates/ui/src/traits/styled_ext.rs
@@ -3,7 +3,7 @@ use gpui::{hsla, Styled, WindowContext};
 use crate::prelude::*;
 use crate::ElevationIndex;
 
-fn elevated<E: Styled>(this: E, cx: &mut WindowContext, index: ElevationIndex) -> E {
+fn elevated<E: Styled>(this: E, cx: &WindowContext, index: ElevationIndex) -> E {
     this.bg(cx.theme().colors().elevated_surface_background)
         .rounded_lg()
         .border_1()
@@ -11,7 +11,7 @@ fn elevated<E: Styled>(this: E, cx: &mut WindowContext, index: ElevationIndex) -
         .shadow(index.shadow())
 }
 
-fn elevated_borderless<E: Styled>(this: E, cx: &mut WindowContext, index: ElevationIndex) -> E {
+fn elevated_borderless<E: Styled>(this: E, cx: &WindowContext, index: ElevationIndex) -> E {
     this.bg(cx.theme().colors().elevated_surface_background)
         .rounded_lg()
         .shadow(index.shadow())
@@ -38,14 +38,14 @@ pub trait StyledExt: Styled + Sized {
     /// Sets `bg()`, `rounded_lg()`, `border()`, `border_color()`, `shadow()`
     ///
     /// Example Elements: Title Bar, Panel, Tab Bar, Editor
-    fn elevation_1(self, cx: &mut WindowContext) -> Self {
+    fn elevation_1(self, cx: &WindowContext) -> Self {
         elevated(self, cx, ElevationIndex::Surface)
     }
 
     /// See [`elevation_1`].
     ///
     /// Renders a borderless version [`elevation_1`].
-    fn elevation_1_borderless(self, cx: &mut WindowContext) -> Self {
+    fn elevation_1_borderless(self, cx: &WindowContext) -> Self {
         elevated_borderless(self, cx, ElevationIndex::Surface)
     }
 
@@ -54,14 +54,14 @@ pub trait StyledExt: Styled + Sized {
     /// Sets `bg()`, `rounded_lg()`, `border()`, `border_color()`, `shadow()`
     ///
     /// Examples: Notifications, Palettes, Detached/Floating Windows, Detached/Floating Panels
-    fn elevation_2(self, cx: &mut WindowContext) -> Self {
+    fn elevation_2(self, cx: &WindowContext) -> Self {
         elevated(self, cx, ElevationIndex::ElevatedSurface)
     }
 
     /// See [`elevation_2`].
     ///
     /// Renders a borderless version [`elevation_2`].
-    fn elevation_2_borderless(self, cx: &mut WindowContext) -> Self {
+    fn elevation_2_borderless(self, cx: &WindowContext) -> Self {
         elevated_borderless(self, cx, ElevationIndex::ElevatedSurface)
     }
 
@@ -74,24 +74,24 @@ pub trait StyledExt: Styled + Sized {
     /// Sets `bg()`, `rounded_lg()`, `border()`, `border_color()`, `shadow()`
     ///
     /// Examples: Settings Modal, Channel Management, Wizards/Setup UI, Dialogs
-    fn elevation_3(self, cx: &mut WindowContext) -> Self {
+    fn elevation_3(self, cx: &WindowContext) -> Self {
         elevated(self, cx, ElevationIndex::ModalSurface)
     }
 
     /// See [`elevation_3`].
     ///
     /// Renders a borderless version [`elevation_3`].
-    fn elevation_3_borderless(self, cx: &mut WindowContext) -> Self {
+    fn elevation_3_borderless(self, cx: &WindowContext) -> Self {
         elevated_borderless(self, cx, ElevationIndex::ModalSurface)
     }
 
     /// The theme's primary border color.
-    fn border_primary(self, cx: &mut WindowContext) -> Self {
+    fn border_primary(self, cx: &WindowContext) -> Self {
         self.border_color(cx.theme().colors().border)
     }
 
     /// The theme's secondary or muted border color.
-    fn border_muted(self, cx: &mut WindowContext) -> Self {
+    fn border_muted(self, cx: &WindowContext) -> Self {
         self.border_color(cx.theme().colors().border_variant)
     }
 

From 25a97a6a2be277c2c0897a651658254de34d0bcd Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Mon, 7 Oct 2024 15:08:16 +0200
Subject: [PATCH 502/762] ssh: Detect timeouts when server is unresponsive
 (#18808)

To detect connection timeouts we ping the remote server every X seconds
and attempt to reconnect if the server failed to respond.
Next up is showing some feedback in the UI to make this visible to the
user, and stop reconnecting after X amount of retries.

Release Notes:

- N/A

---------

Co-authored-by: Thorsten <thorsten@zed.dev>
---
 crates/remote/src/ssh_session.rs             | 75 +++++++++++++++++++-
 crates/remote_server/src/headless_project.rs | 10 +++
 2 files changed, 82 insertions(+), 3 deletions(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 05208dabd738b9..0a1cd009927078 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -26,6 +26,7 @@ use rpc::{
 use smol::{
     fs,
     process::{self, Child, Stdio},
+    Timer,
 };
 use std::{
     any::TypeId,
@@ -36,7 +37,7 @@ use std::{
         atomic::{AtomicU32, Ordering::SeqCst},
         Arc,
     },
-    time::Instant,
+    time::{Duration, Instant},
 };
 use tempfile::TempDir;
 use util::maybe;
@@ -173,7 +174,7 @@ async fn run_cmd(command: &mut process::Command) -> Result<String> {
 #[cfg(unix)]
 async fn read_with_timeout(
     stdout: &mut process::ChildStdout,
-    timeout: std::time::Duration,
+    timeout: Duration,
     output: &mut Vec<u8>,
 ) -> Result<(), std::io::Error> {
     smol::future::or(
@@ -260,6 +261,7 @@ struct SshRemoteClientState {
     delegate: Arc<dyn SshClientDelegate>,
     forwarder: ChannelForwarder,
     multiplex_task: Task<Result<()>>,
+    heartbeat_task: Task<Result<()>>,
 }
 
 pub struct SshRemoteClient {
@@ -327,6 +329,7 @@ impl SshRemoteClient {
                     delegate,
                     forwarder: proxy,
                     multiplex_task,
+                    heartbeat_task: Self::heartbeat(this.downgrade(), &mut cx),
                 }
             };
 
@@ -353,6 +356,7 @@ impl SshRemoteClient {
     }
 
     fn reconnect(&self, cx: &ModelContext<Self>) -> Result<()> {
+        log::info!("Trying to reconnect to ssh server...");
         let Some(state) = self.inner_state.lock().take() else {
             return Err(anyhow!("reconnect is already in progress"));
         };
@@ -364,8 +368,10 @@ impl SshRemoteClient {
             delegate,
             forwarder: proxy,
             multiplex_task,
+            heartbeat_task,
         } = state;
         drop(multiplex_task);
+        drop(heartbeat_task);
 
         cx.spawn(|this, mut cx| async move {
             let (incoming_tx, outgoing_rx) = proxy.into_channels().await;
@@ -401,6 +407,7 @@ impl SshRemoteClient {
                     proxy_outgoing_rx,
                     &mut cx,
                 ),
+                heartbeat_task: Self::heartbeat(this.clone(), &mut cx),
             };
 
             this.update(&mut cx, |this, _| {
@@ -411,6 +418,68 @@ impl SshRemoteClient {
         Ok(())
     }
 
+    fn heartbeat(this: WeakModel<Self>, cx: &mut AsyncAppContext) -> Task<Result<()>> {
+        let Ok(client) = this.update(cx, |this, _| this.client.clone()) else {
+            return Task::ready(Err(anyhow!("SshRemoteClient lost")));
+        };
+        cx.spawn(|mut cx| {
+            let this = this.clone();
+            async move {
+                const MAX_MISSED_HEARTBEATS: usize = 5;
+                const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(5);
+                const HEARTBEAT_TIMEOUT: Duration = Duration::from_secs(5);
+
+                let mut missed_heartbeats = 0;
+
+                let mut timer = Timer::interval(HEARTBEAT_INTERVAL);
+                loop {
+                    timer.next().await;
+
+                    log::info!("Sending heartbeat to server...");
+
+                    let result = smol::future::or(
+                        async {
+                            client.request(proto::Ping {}).await?;
+                            Ok(())
+                        },
+                        async {
+                            smol::Timer::after(HEARTBEAT_TIMEOUT).await;
+
+                            Err(anyhow!("Timeout detected"))
+                        },
+                    )
+                    .await;
+
+                    if result.is_err() {
+                        missed_heartbeats += 1;
+                        log::warn!(
+                            "No heartbeat from server after {:?}. Missed heartbeat {} out of {}.",
+                            HEARTBEAT_TIMEOUT,
+                            missed_heartbeats,
+                            MAX_MISSED_HEARTBEATS
+                        );
+                    } else {
+                        missed_heartbeats = 0;
+                    }
+
+                    if missed_heartbeats >= MAX_MISSED_HEARTBEATS {
+                        log::error!(
+                            "Missed last {} hearbeats. Reconnecting...",
+                            missed_heartbeats
+                        );
+
+                        this.update(&mut cx, |this, cx| {
+                            this.reconnect(cx)
+                                .context("failed to reconnect after missing heartbeats")
+                        })
+                        .context("failed to update weak reference, SshRemoteClient lost?")??;
+                        return Ok(());
+                    }
+                }
+            }
+        })
+    }
+
     fn multiplex(
         this: WeakModel<Self>,
         mut ssh_proxy_process: Child,
@@ -712,7 +781,7 @@ impl SshRemoteConnection {
         // has completed.
         let stdout = master_process.stdout.as_mut().unwrap();
         let mut output = Vec::new();
-        let connection_timeout = std::time::Duration::from_secs(10);
+        let connection_timeout = Duration::from_secs(10);
         let result = read_with_timeout(stdout, connection_timeout, &mut output).await;
         if let Err(e) = result {
             let error_message = if e.kind() == std::io::ErrorKind::TimedOut {
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 66f9ca7ed5e06a..0ad16caacc3cdc 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -113,6 +113,7 @@ impl HeadlessProject {
         client.add_request_handler(cx.weak_model(), Self::handle_list_remote_directory);
         client.add_request_handler(cx.weak_model(), Self::handle_check_file_exists);
         client.add_request_handler(cx.weak_model(), Self::handle_shutdown_remote_server);
+        client.add_request_handler(cx.weak_model(), Self::handle_ping);
 
         client.add_model_request_handler(Self::handle_add_worktree);
         client.add_model_request_handler(Self::handle_open_buffer_by_path);
@@ -354,4 +355,13 @@ impl HeadlessProject {
 
         Ok(proto::Ack {})
     }
+
+    pub async fn handle_ping(
+        _this: Model<Self>,
+        _envelope: TypedEnvelope<proto::Ping>,
+        _cx: AsyncAppContext,
+    ) -> Result<proto::Ack> {
+        log::debug!("Received ping from client");
+        Ok(proto::Ack {})
+    }
 }

From 65c9b157969a8db7e722c3be9f80f4dc8ad43f97 Mon Sep 17 00:00:00 2001
From: Nate Butler <iamnbutler@gmail.com>
Date: Mon, 7 Oct 2024 09:23:40 -0400
Subject: [PATCH 503/762] Remove avatar shape (#18810)

This PR re-removes `AvatarShape` as it is unused. The previous time it
was removed incorrectly, resulting in square avatars!

Release Notes:

- N/A
---
 crates/ui/src/components/avatar/avatar.rs | 44 +++--------------------
 1 file changed, 4 insertions(+), 40 deletions(-)

diff --git a/crates/ui/src/components/avatar/avatar.rs b/crates/ui/src/components/avatar/avatar.rs
index f0e516c7b19c7a..ebacd334fc9a23 100644
--- a/crates/ui/src/components/avatar/avatar.rs
+++ b/crates/ui/src/components/avatar/avatar.rs
@@ -2,16 +2,6 @@ use crate::prelude::*;
 
 use gpui::{img, AnyElement, Hsla, ImageSource, Img, IntoElement, Styled};
 
-/// The shape of an [`Avatar`].
-#[derive(Debug, Default, PartialEq, Clone)]
-pub enum AvatarShape {
-    /// The avatar is shown in a circle.
-    #[default]
-    Circle,
-    /// The avatar is shown in a rectangle with rounded corners.
-    RoundedRectangle,
-}
-
 /// An element that renders a user avatar with customizable appearance options.
 ///
 /// # Examples
@@ -43,27 +33,6 @@ impl Avatar {
         }
     }
 
-    /// Sets the shape of the avatar image.
-    ///
-    /// This method allows the shape of the avatar to be specified using an [`AvatarShape`].
-    /// It modifies the corner radius of the image to match the specified shape.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use ui::{Avatar, AvatarShape};
-    ///
-    /// Avatar::new("path/to/image.png").shape(AvatarShape::Circle);
-    /// ```
-    ///
-    pub fn shape(mut self, shape: AvatarShape) -> Self {
-        self.image = match shape {
-            AvatarShape::Circle => self.image.rounded_full(),
-            AvatarShape::RoundedRectangle => self.image.rounded_md(),
-        };
-        self
-    }
-
     /// Applies a grayscale filter to the avatar image.
     ///
     /// # Examples
@@ -102,11 +71,7 @@ impl Avatar {
 }
 
 impl RenderOnce for Avatar {
-    fn render(mut self, cx: &mut WindowContext) -> impl IntoElement {
-        if self.image.style().corner_radii.top_left.is_none() {
-            self = self.shape(AvatarShape::Circle);
-        }
-
+    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
         let border_width = if self.border_color.is_some() {
             px(2.)
         } else {
@@ -118,16 +83,15 @@ impl RenderOnce for Avatar {
 
         div()
             .size(container_size)
-            .map(|mut div| {
-                div.style().corner_radii = self.image.style().corner_radii.clone();
-                div
-            })
+            .rounded_full()
+            .overflow_hidden()
             .when_some(self.border_color, |this, color| {
                 this.border(border_width).border_color(color)
             })
             .child(
                 self.image
                     .size(image_size)
+                    .rounded_full()
                     .bg(cx.theme().colors().ghost_element_background),
             )
             .children(self.indicator.map(|indicator| div().child(indicator)))

From a3b63448df2ff3e934b7600196572ac44ecf2c56 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Mon, 7 Oct 2024 15:53:32 +0200
Subject: [PATCH 504/762] ssh: Do not cancel connection process if user is
 typing password (#18812)

Previously, the connection process would be cancelled after 10 seconds,
even if the connection was established successfully but the user was
still typing in a password.
We know recognize when the user is prompted for a password, and cancel
the timeout task.

Co-Authored-by: Thorsten <thorsten@zed.dev>

Release Notes:

- N/A

---------

Co-authored-by: Thorsten <thorsten@zed.dev>
---
 crates/remote/src/ssh_session.rs | 67 ++++++++++++++------------------
 1 file changed, 30 insertions(+), 37 deletions(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 0a1cd009927078..26ef8626ec6e20 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -171,28 +171,6 @@ async fn run_cmd(command: &mut process::Command) -> Result<String> {
         ))
     }
 }
-#[cfg(unix)]
-async fn read_with_timeout(
-    stdout: &mut process::ChildStdout,
-    timeout: Duration,
-    output: &mut Vec<u8>,
-) -> Result<(), std::io::Error> {
-    smol::future::or(
-        async {
-            stdout.read_to_end(output).await?;
-            Ok::<_, std::io::Error>(())
-        },
-        async {
-            smol::Timer::after(timeout).await;
-
-            Err(std::io::Error::new(
-                std::io::ErrorKind::TimedOut,
-                "Read operation timed out",
-            ))
-        },
-    )
-    .await
-}
 
 struct ChannelForwarder {
     quit_tx: UnboundedSender<()>,
@@ -725,13 +703,19 @@ impl SshRemoteConnection {
 
         // Create a domain socket listener to handle requests from the askpass program.
         let askpass_socket = temp_dir.path().join("askpass.sock");
+        let (askpass_opened_tx, askpass_opened_rx) = oneshot::channel::<()>();
         let listener =
             UnixListener::bind(&askpass_socket).context("failed to create askpass socket")?;
 
         let askpass_task = cx.spawn({
             let delegate = delegate.clone();
             |mut cx| async move {
+                let mut askpass_opened_tx = Some(askpass_opened_tx);
+
                 while let Ok((mut stream, _)) = listener.accept().await {
+                    if let Some(askpass_opened_tx) = askpass_opened_tx.take() {
+                        askpass_opened_tx.send(()).ok();
+                    }
                     let mut buffer = Vec::new();
                     let mut reader = BufReader::new(&mut stream);
                     if reader.read_until(b'\0', &mut buffer).await.is_err() {
@@ -782,19 +766,28 @@ impl SshRemoteConnection {
         let stdout = master_process.stdout.as_mut().unwrap();
         let mut output = Vec::new();
         let connection_timeout = Duration::from_secs(10);
-        let result = read_with_timeout(stdout, connection_timeout, &mut output).await;
-        if let Err(e) = result {
-            let error_message = if e.kind() == std::io::ErrorKind::TimedOut {
-                format!(
-                    "Failed to connect to host. Timed out after {:?}.",
-                    connection_timeout
-                )
-            } else {
-                format!("Failed to connect to host: {}.", e)
-            };
 
+        let result = select_biased! {
+            _ = askpass_opened_rx.fuse() => {
+                // If the askpass script has opened, that means the user is typing
+                // their password, in which case we don't want to timeout anymore,
+                // since we know a connection has been established.
+                stdout.read_to_end(&mut output).await?;
+                Ok(())
+            }
+            result = stdout.read_to_end(&mut output).fuse() => {
+                result?;
+                Ok(())
+            }
+            _ = futures::FutureExt::fuse(smol::Timer::after(connection_timeout)) => {
+                Err(anyhow!("Exceeded {:?} timeout trying to connect to host", connection_timeout))
+            }
+        };
+
+        if let Err(e) = result {
+            let error_message = format!("Failed to connect to host: {}.", e);
             delegate.set_error(error_message, cx);
-            return Err(e.into());
+            return Err(e);
         }
 
         drop(askpass_task);
@@ -803,10 +796,10 @@ impl SshRemoteConnection {
             output.clear();
             let mut stderr = master_process.stderr.take().unwrap();
             stderr.read_to_end(&mut output).await?;
-            Err(anyhow!(
-                "failed to connect: {}",
-                String::from_utf8_lossy(&output)
-            ))?;
+
+            let error_message = format!("failed to connect: {}", String::from_utf8_lossy(&output));
+            delegate.set_error(error_message.clone(), cx);
+            Err(anyhow!(error_message))?;
         }
 
         Ok(Self {

From 7c7151551a69bd6c925d2b896f84ec8fd2411476 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 7 Oct 2024 10:11:12 -0400
Subject: [PATCH 505/762] proto: Bump to v0.2.0 (#18814)

This PR bumps the Protobuf extension to v0.2.0.

Changes:

- https://github.com/zed-industries/zed/pull/18763

Release Notes:

- N/A
---
 Cargo.lock                      | 2 +-
 extensions/proto/Cargo.toml     | 2 +-
 extensions/proto/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f682d76ad5f597..d3e76eefd2d9c7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14866,7 +14866,7 @@ dependencies = [
 
 [[package]]
 name = "zed_proto"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/proto/Cargo.toml b/extensions/proto/Cargo.toml
index 496099c52637f0..215a09f896c1df 100644
--- a/extensions/proto/Cargo.toml
+++ b/extensions/proto/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_proto"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/proto/extension.toml b/extensions/proto/extension.toml
index 6ecf9bf33f2405..f26aee7dde5c3c 100644
--- a/extensions/proto/extension.toml
+++ b/extensions/proto/extension.toml
@@ -1,7 +1,7 @@
 id = "proto"
 name = "Proto"
 description = "Protocol Buffers support."
-version = "0.1.0"
+version = "0.2.0"
 schema_version = 1
 authors = ["Zed Industries <support@zed.dev>"]
 repository = "https://github.com/zed-industries/zed"

From d1a758708dcb7b93afa02c06b7159a0776c66111 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 7 Oct 2024 10:23:16 -0400
Subject: [PATCH 506/762] php: Bump to v0.2.1 (#18815)

This PR bumps the PHP extension to v0.2.1.

Changes:

- https://github.com/zed-industries/zed/pull/18368
- https://github.com/zed-industries/zed/pull/18774

Release Notes:

- N/A
---
 Cargo.lock                    | 2 +-
 extensions/php/Cargo.toml     | 2 +-
 extensions/php/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d3e76eefd2d9c7..0715c64984713e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14852,7 +14852,7 @@ dependencies = [
 
 [[package]]
 name = "zed_php"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/php/Cargo.toml b/extensions/php/Cargo.toml
index d4a8f36cbdf83e..9726c6f0d59e90 100644
--- a/extensions/php/Cargo.toml
+++ b/extensions/php/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_php"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/php/extension.toml b/extensions/php/extension.toml
index 92bd7ed85bc465..a59c5bab53784c 100644
--- a/extensions/php/extension.toml
+++ b/extensions/php/extension.toml
@@ -1,7 +1,7 @@
 id = "php"
 name = "PHP"
 description = "PHP support."
-version = "0.2.0"
+version = "0.2.1"
 schema_version = 1
 authors = ["Piotr Osiewicz <piotr@zed.dev>"]
 repository = "https://github.com/zed-industries/zed"

From c83690ff140da4a42ba9cb9f4691799e81d0664a Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 7 Oct 2024 12:29:10 -0400
Subject: [PATCH 507/762] storybook: Wire up HTTP client (#18818)

This PR wires up the HTTP client in the Storybook.

Release Notes:

- N/A
---
 Cargo.lock                        |  1 +
 crates/storybook/Cargo.toml       |  1 +
 crates/storybook/src/storybook.rs | 10 ++++++++++
 3 files changed, 12 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 0715c64984713e..9deb937370f952 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10998,6 +10998,7 @@ dependencies = [
  "theme",
  "title_bar",
  "ui",
+ "ureq_client",
 ]
 
 [[package]]
diff --git a/crates/storybook/Cargo.toml b/crates/storybook/Cargo.toml
index 3b10d6331b6890..b05c7692f9529b 100644
--- a/crates/storybook/Cargo.toml
+++ b/crates/storybook/Cargo.toml
@@ -35,6 +35,7 @@ strum = { workspace = true, features = ["derive"] }
 theme.workspace = true
 title_bar = { workspace = true, features = ["stories"] }
 ui = { workspace = true, features = ["stories"] }
+ureq_client.workspace = true
 
 [dev-dependencies]
 gpui = { workspace = true, features = ["test-support"] }
diff --git a/crates/storybook/src/storybook.rs b/crates/storybook/src/storybook.rs
index a8997498a57768..a77602efcca8b5 100644
--- a/crates/storybook/src/storybook.rs
+++ b/crates/storybook/src/storybook.rs
@@ -4,6 +4,8 @@ mod assets;
 mod stories;
 mod story_selector;
 
+use std::sync::Arc;
+
 use clap::Parser;
 use dialoguer::FuzzySelect;
 use gpui::{
@@ -17,6 +19,7 @@ use simplelog::SimpleLogger;
 use strum::IntoEnumIterator;
 use theme::{ThemeRegistry, ThemeSettings};
 use ui::prelude::*;
+use ureq_client::UreqClient;
 
 use crate::app_menus::app_menus;
 use crate::assets::Assets;
@@ -65,6 +68,13 @@ fn main() {
     gpui::App::new().with_assets(Assets).run(move |cx| {
         load_embedded_fonts(cx).unwrap();
 
+        let http_client = UreqClient::new(
+            None,
+            "zed_storybook".to_string(),
+            cx.background_executor().clone(),
+        );
+        cx.set_http_client(Arc::new(http_client));
+
         settings::init(cx);
         theme::init(theme::LoadThemes::All(Box::new(Assets)), cx);
 

From 11206a84449d29c77cd2f4d1e7b7982538bbe77d Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 7 Oct 2024 12:53:11 -0400
Subject: [PATCH 508/762] ui: Fix avatar indicators getting cut off (#18821)

This PR fixes an issue introduced in #18810 that was causing the avatar
indicators to get cut off.

Release Notes:

- N/A
---
 crates/ui/src/components/avatar/avatar.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/ui/src/components/avatar/avatar.rs b/crates/ui/src/components/avatar/avatar.rs
index ebacd334fc9a23..302658b55c6312 100644
--- a/crates/ui/src/components/avatar/avatar.rs
+++ b/crates/ui/src/components/avatar/avatar.rs
@@ -84,7 +84,6 @@ impl RenderOnce for Avatar {
         div()
             .size(container_size)
             .rounded_full()
-            .overflow_hidden()
             .when_some(self.border_color, |this, color| {
                 this.border(border_width).border_color(color)
             })

From 60c12a8d0679b98309e0b9f54e8b98572b59e478 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Mon, 7 Oct 2024 19:18:44 +0200
Subject: [PATCH 509/762] ssh: Remove old dev servers code paths (#18823)

Closes #ISSUE

Release Notes:

- N/A
---
 crates/recent_projects/src/dev_servers.rs     | 547 +-----------------
 crates/recent_projects/src/ssh_connections.rs |   4 -
 2 files changed, 13 insertions(+), 538 deletions(-)

diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 7761461ab51abe..0a05b6a1e9e0ac 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -5,8 +5,7 @@ use std::time::Duration;
 use anyhow::anyhow;
 use anyhow::Context;
 use anyhow::Result;
-use client::Client;
-use dev_server_projects::{DevServer, DevServerId, DevServerProject, DevServerProjectId};
+use dev_server_projects::{DevServer, DevServerId, DevServerProjectId};
 use editor::Editor;
 use gpui::pulsating_between;
 use gpui::AsyncWindowContext;
@@ -16,17 +15,12 @@ use gpui::Subscription;
 use gpui::Task;
 use gpui::WeakView;
 use gpui::{
-    percentage, Action, Animation, AnimationExt, AnyElement, AppContext, DismissEvent,
-    EventEmitter, FocusHandle, FocusableView, Model, ScrollHandle, Transformation, View,
-    ViewContext,
+    Action, Animation, AnimationExt, AnyElement, AppContext, DismissEvent, EventEmitter,
+    FocusHandle, FocusableView, Model, ScrollHandle, View, ViewContext,
 };
 use project::terminals::wrap_for_ssh;
 use project::terminals::SshCommand;
-use rpc::proto::RegenerateDevServerTokenResponse;
-use rpc::{
-    proto::{CreateDevServerResponse, DevServerStatus},
-    ErrorCode, ErrorExt,
-};
+use rpc::{proto::DevServerStatus, ErrorCode, ErrorExt};
 use settings::update_settings_file;
 use settings::Settings;
 use task::HideStrategy;
@@ -35,14 +29,11 @@ use task::SpawnInTerminal;
 use terminal_view::terminal_panel::TerminalPanel;
 use ui::ElevationIndex;
 use ui::Section;
-use ui::{
-    prelude::*, IconButtonShape, Indicator, List, ListItem, Modal, ModalFooter, ModalHeader,
-    Tooltip,
-};
+use ui::{prelude::*, IconButtonShape, List, ListItem, Modal, ModalFooter, ModalHeader, Tooltip};
 use ui_input::{FieldLabelLayout, TextField};
 use util::ResultExt;
 use workspace::OpenOptions;
-use workspace::{notifications::DetachAndPromptErr, AppState, ModalView, Workspace, WORKSPACE_DB};
+use workspace::{notifications::DetachAndPromptErr, AppState, ModalView, Workspace};
 
 use crate::open_dev_server_project;
 use crate::ssh_connections::connect_over_ssh;
@@ -69,15 +60,11 @@ pub struct DevServerProjects {
 #[derive(Default)]
 struct CreateDevServer {
     creating: Option<Task<Option<()>>>,
-    dev_server_id: Option<DevServerId>,
-    access_token: Option<String>,
     ssh_prompt: Option<View<SshPrompt>>,
-    kind: NewServerKind,
 }
 
 struct CreateDevServerProject {
     dev_server_id: DevServerId,
-    creating: bool,
     _opening: Option<Subscription>,
 }
 
@@ -86,14 +73,6 @@ enum Mode {
     CreateDevServer(CreateDevServer),
 }
 
-#[derive(Default, PartialEq, Eq, Clone, Copy)]
-enum NewServerKind {
-    DirectSSH,
-    #[default]
-    LegacySSH,
-    Manual,
-}
-
 impl DevServerProjects {
     pub fn register(workspace: &mut Workspace, _: &mut ViewContext<Workspace>) {
         workspace.register_action(|workspace, _: &OpenRemote, cx| {
@@ -223,14 +202,12 @@ impl DevServerProjects {
 
                         this.mode = Mode::Default(Some(CreateDevServerProject {
                             dev_server_id,
-                            creating: true,
                             _opening: Some(subscription),
                         }));
                     }
                 } else {
                     this.mode = Mode::Default(Some(CreateDevServerProject {
                         dev_server_id,
-                        creating: false,
                         _opening: None,
                     }));
                 }
@@ -253,7 +230,7 @@ impl DevServerProjects {
 
         self.mode = Mode::Default(Some(CreateDevServerProject {
             dev_server_id,
-            creating: true,
+
             _opening: None,
         }));
     }
@@ -309,10 +286,7 @@ impl DevServerProjects {
                     .log_err(),
                 None => this
                     .update(&mut cx, |this, cx| {
-                        this.mode = Mode::CreateDevServer(CreateDevServer {
-                            kind: NewServerKind::DirectSSH,
-                            ..Default::default()
-                        });
+                        this.mode = Mode::CreateDevServer(CreateDevServer::default());
                         cx.notify()
                     })
                     .log_err(),
@@ -320,10 +294,8 @@ impl DevServerProjects {
             None
         });
         self.mode = Mode::CreateDevServer(CreateDevServer {
-            kind: NewServerKind::DirectSSH,
             ssh_prompt: Some(ssh_prompt.clone()),
             creating: Some(creating),
-            ..Default::default()
         });
     }
 
@@ -460,228 +432,6 @@ impl DevServerProjects {
         })
     }
 
-    fn create_or_update_dev_server(
-        &mut self,
-        kind: NewServerKind,
-        existing_id: Option<DevServerId>,
-        access_token: Option<String>,
-        cx: &mut ViewContext<Self>,
-    ) {
-        let name = get_text(&self.dev_server_name_input, cx);
-        if name.is_empty() {
-            return;
-        }
-
-        let manual_setup = match kind {
-            NewServerKind::DirectSSH => unreachable!(),
-            NewServerKind::LegacySSH => false,
-            NewServerKind::Manual => true,
-        };
-
-        let ssh_connection_string = if manual_setup {
-            None
-        } else if name.contains(' ') {
-            Some(name.clone())
-        } else {
-            Some(format!("ssh {}", name))
-        };
-
-        let dev_server = self.dev_server_store.update(cx, {
-            let access_token = access_token.clone();
-            |store, cx| {
-                let ssh_connection_string = ssh_connection_string.clone();
-                if let Some(dev_server_id) = existing_id {
-                    let rename = store.rename_dev_server(
-                        dev_server_id,
-                        name.clone(),
-                        ssh_connection_string,
-                        cx,
-                    );
-                    let token = if let Some(access_token) = access_token {
-                        Task::ready(Ok(RegenerateDevServerTokenResponse {
-                            dev_server_id: dev_server_id.0,
-                            access_token,
-                        }))
-                    } else {
-                        store.regenerate_dev_server_token(dev_server_id, cx)
-                    };
-                    cx.spawn(|_, _| async move {
-                        rename.await?;
-                        let response = token.await?;
-                        Ok(CreateDevServerResponse {
-                            dev_server_id: dev_server_id.0,
-                            name,
-                            access_token: response.access_token,
-                        })
-                    })
-                } else {
-                    store.create_dev_server(name, ssh_connection_string.clone(), cx)
-                }
-            }
-        });
-
-        let workspace = self.workspace.clone();
-        let store = dev_server_projects::Store::global(cx);
-
-        let task = cx
-            .spawn({
-                |this, mut cx| async move {
-                    let result = dev_server.await;
-
-                    match result {
-                        Ok(dev_server) => {
-                            if let Some(ssh_connection_string) = ssh_connection_string {
-                                this.update(&mut cx, |this, cx| {
-                                    if let Mode::CreateDevServer(CreateDevServer {
-                                        access_token,
-                                        dev_server_id,
-                                        ..
-                                    }) = &mut this.mode
-                                    {
-                                        access_token.replace(dev_server.access_token.clone());
-                                        dev_server_id
-                                            .replace(DevServerId(dev_server.dev_server_id));
-                                    }
-                                    cx.notify();
-                                })?;
-
-                                spawn_ssh_task(
-                                    workspace
-                                        .upgrade()
-                                        .ok_or_else(|| anyhow!("workspace dropped"))?,
-                                    store,
-                                    DevServerId(dev_server.dev_server_id),
-                                    ssh_connection_string,
-                                    dev_server.access_token.clone(),
-                                    &mut cx,
-                                )
-                                .await
-                                .log_err();
-                            }
-
-                            this.update(&mut cx, |this, cx| {
-                                this.focus_handle.focus(cx);
-                                this.mode = Mode::CreateDevServer(CreateDevServer {
-                                    dev_server_id: Some(DevServerId(dev_server.dev_server_id)),
-                                    access_token: Some(dev_server.access_token),
-                                    kind,
-                                    ..Default::default()
-                                });
-                                cx.notify();
-                            })?;
-                            Ok(())
-                        }
-                        Err(e) => {
-                            this.update(&mut cx, |this, cx| {
-                                this.mode = Mode::CreateDevServer(CreateDevServer {
-                                    dev_server_id: existing_id,
-                                    access_token: None,
-                                    kind,
-                                    ..Default::default()
-                                });
-                                cx.notify()
-                            })
-                            .log_err();
-
-                            Err(e)
-                        }
-                    }
-                }
-            })
-            .prompt_err("Failed to create server", cx, |_, _| None);
-
-        self.mode = Mode::CreateDevServer(CreateDevServer {
-            creating: Some(task),
-            dev_server_id: existing_id,
-            access_token,
-            kind,
-            ..Default::default()
-        });
-        cx.notify()
-    }
-
-    fn delete_dev_server(&mut self, id: DevServerId, cx: &mut ViewContext<Self>) {
-        let store = self.dev_server_store.read(cx);
-        let prompt = if store.projects_for_server(id).is_empty()
-            && store
-                .dev_server(id)
-                .is_some_and(|server| server.status == DevServerStatus::Offline)
-        {
-            None
-        } else {
-            Some(cx.prompt(
-                gpui::PromptLevel::Warning,
-                "Are you sure?",
-                Some("This will delete the dev server and all of its remote projects."),
-                &["Delete", "Cancel"],
-            ))
-        };
-
-        cx.spawn(|this, mut cx| async move {
-            if let Some(prompt) = prompt {
-                if prompt.await? != 0 {
-                    return Ok(());
-                }
-            }
-
-            let project_ids: Vec<DevServerProjectId> = this.update(&mut cx, |this, cx| {
-                this.dev_server_store.update(cx, |store, _| {
-                    store
-                        .projects_for_server(id)
-                        .into_iter()
-                        .map(|project| project.id)
-                        .collect()
-                })
-            })?;
-
-            this.update(&mut cx, |this, cx| {
-                this.dev_server_store
-                    .update(cx, |store, cx| store.delete_dev_server(id, cx))
-            })?
-            .await?;
-
-            for id in project_ids {
-                WORKSPACE_DB
-                    .delete_workspace_by_dev_server_project_id(id)
-                    .await
-                    .log_err();
-            }
-            Ok(())
-        })
-        .detach_and_prompt_err("Failed to delete dev server", cx, |_, _| None);
-    }
-
-    fn delete_dev_server_project(&mut self, id: DevServerProjectId, cx: &mut ViewContext<Self>) {
-        let answer = cx.prompt(
-            gpui::PromptLevel::Warning,
-            "Delete this project?",
-            Some("This will delete the remote project. You can always re-add it later."),
-            &["Delete", "Cancel"],
-        );
-
-        cx.spawn(|this, mut cx| async move {
-            let answer = answer.await?;
-
-            if answer != 0 {
-                return Ok(());
-            }
-
-            this.update(&mut cx, |this, cx| {
-                this.dev_server_store
-                    .update(cx, |store, cx| store.delete_dev_server_project(id, cx))
-            })?
-            .await?;
-
-            WORKSPACE_DB
-                .delete_workspace_by_dev_server_project_id(id)
-                .await
-                .log_err();
-
-            Ok(())
-        })
-        .detach_and_prompt_err("Failed to delete dev server project", cx, |_, _| None);
-    }
-
     fn confirm(&mut self, _: &menu::Confirm, cx: &mut ViewContext<Self>) {
         match &self.mode {
             Mode::Default(None) => {}
@@ -695,18 +445,8 @@ impl DevServerProjects {
                     });
                     return;
                 }
-                if state.kind == NewServerKind::DirectSSH {
-                    self.create_ssh_server(cx);
-                    return;
-                }
-                if state.creating.is_none() || state.dev_server_id.is_some() {
-                    self.create_or_update_dev_server(
-                        state.kind,
-                        state.dev_server_id,
-                        state.access_token.clone(),
-                        cx,
-                    );
-                }
+
+                self.create_ssh_server(cx);
             }
         }
     }
@@ -716,7 +456,6 @@ impl DevServerProjects {
             Mode::Default(None) => cx.emit(DismissEvent),
             Mode::CreateDevServer(state) if state.ssh_prompt.is_some() => {
                 self.mode = Mode::CreateDevServer(CreateDevServer {
-                    kind: NewServerKind::DirectSSH,
                     ..Default::default()
                 });
                 cx.notify();
@@ -729,161 +468,6 @@ impl DevServerProjects {
         }
     }
 
-    fn render_dev_server(
-        &mut self,
-        dev_server: &DevServer,
-        create_project: Option<bool>,
-        cx: &mut ViewContext<Self>,
-    ) -> impl IntoElement {
-        let dev_server_id = dev_server.id;
-        let status = dev_server.status;
-        let dev_server_name = dev_server.name.clone();
-        let kind = if dev_server.ssh_connection_string.is_some() {
-            NewServerKind::LegacySSH
-        } else {
-            NewServerKind::Manual
-        };
-
-        v_flex()
-            .w_full()
-            .child(
-                h_flex().group("dev-server").justify_between().child(
-                    h_flex()
-                        .gap_2()
-                        .child(
-                            div()
-                                .id(("status", dev_server.id.0))
-                                .relative()
-                                .child(Icon::new(IconName::Server).size(IconSize::Small))
-                                .child(div().absolute().bottom_0().left(rems_from_px(8.0)).child(
-                                    Indicator::dot().color(match status {
-                                        DevServerStatus::Online => Color::Created,
-                                        DevServerStatus::Offline => Color::Hidden,
-                                    }),
-                                ))
-                                .tooltip(move |cx| {
-                                    Tooltip::text(
-                                        match status {
-                                            DevServerStatus::Online => "Online",
-                                            DevServerStatus::Offline => "Offline",
-                                        },
-                                        cx,
-                                    )
-                                }),
-                        )
-                        .child(
-                            div()
-                                .max_w(rems(26.))
-                                .overflow_hidden()
-                                .whitespace_nowrap()
-                                .child(Label::new(dev_server_name.clone())),
-                        )
-                        .child(
-                            h_flex()
-                                .visible_on_hover("dev-server")
-                                .gap_1()
-                                .child(if dev_server.ssh_connection_string.is_some() {
-                                    let dev_server = dev_server.clone();
-                                    IconButton::new("reconnect-dev-server", IconName::ArrowCircle)
-                                        .on_click(cx.listener(move |this, _, cx| {
-                                            let Some(workspace) = this.workspace.upgrade() else {
-                                                return;
-                                            };
-
-                                            reconnect_to_dev_server(
-                                                workspace,
-                                                dev_server.clone(),
-                                                cx,
-                                            )
-                                            .detach_and_prompt_err(
-                                                "Failed to reconnect",
-                                                cx,
-                                                |_, _| None,
-                                            );
-                                        }))
-                                        .tooltip(|cx| Tooltip::text("Reconnect", cx))
-                                } else {
-                                    IconButton::new("edit-dev-server", IconName::Pencil)
-                                        .on_click(cx.listener(move |this, _, cx| {
-                                            this.mode = Mode::CreateDevServer(CreateDevServer {
-                                                dev_server_id: Some(dev_server_id),
-                                                kind,
-                                                ..Default::default()
-                                            });
-                                            let dev_server_name = dev_server_name.clone();
-                                            this.dev_server_name_input.update(
-                                                cx,
-                                                move |input, cx| {
-                                                    input.editor().update(cx, move |editor, cx| {
-                                                        editor.set_text(dev_server_name, cx)
-                                                    })
-                                                },
-                                            )
-                                        }))
-                                        .tooltip(|cx| Tooltip::text("Edit dev server", cx))
-                                })
-                                .child({
-                                    let dev_server_id = dev_server.id;
-                                    IconButton::new("remove-dev-server", IconName::TrashAlt)
-                                        .on_click(cx.listener(move |this, _, cx| {
-                                            this.delete_dev_server(dev_server_id, cx)
-                                        }))
-                                        .tooltip(|cx| Tooltip::text("Remove dev server", cx))
-                                }),
-                        ),
-                ),
-            )
-            .child(
-                v_flex()
-                    .w_full()
-                    .bg(cx.theme().colors().background)
-                    .border_1()
-                    .border_color(cx.theme().colors().border_variant)
-                    .rounded_md()
-                    .my_1()
-                    .py_0p5()
-                    .px_3()
-                    .child(
-                        List::new()
-                            .empty_message("No projects.")
-                            .children(
-                                self.dev_server_store
-                                    .read(cx)
-                                    .projects_for_server(dev_server.id)
-                                    .iter()
-                                    .map(|p| self.render_dev_server_project(p, cx)),
-                            )
-                            .when(
-                                create_project.is_none()
-                                    && dev_server.status == DevServerStatus::Online,
-                                |el| {
-                                    el.child(
-                                        ListItem::new("new-remote_project")
-                                            .start_slot(Icon::new(IconName::Plus))
-                                            .child(Label::new("Open folder…"))
-                                            .on_click(cx.listener(move |this, _, cx| {
-                                                this.mode =
-                                                    Mode::Default(Some(CreateDevServerProject {
-                                                        dev_server_id,
-                                                        creating: false,
-                                                        _opening: None,
-                                                    }));
-                                                this.project_path_input
-                                                    .read(cx)
-                                                    .focus_handle(cx)
-                                                    .focus(cx);
-                                                cx.notify();
-                                            })),
-                                    )
-                                },
-                            )
-                            .when_some(create_project, |el, creating| {
-                                el.child(self.render_create_new_project(creating, cx))
-                            }),
-                    ),
-            )
-    }
-
     fn render_ssh_connection(
         &mut self,
         ix: usize,
@@ -1094,77 +678,13 @@ impl DevServerProjects {
         });
     }
 
-    fn render_create_new_project(
-        &mut self,
-        creating: bool,
-        _: &mut ViewContext<Self>,
-    ) -> impl IntoElement {
-        ListItem::new("create-remote-project")
-            .disabled(true)
-            .start_slot(Icon::new(IconName::FileTree).color(Color::Muted))
-            .child(self.project_path_input.clone())
-            .child(div().w(IconSize::Medium.rems()).when(creating, |el| {
-                el.child(
-                    Icon::new(IconName::ArrowCircle)
-                        .size(IconSize::Medium)
-                        .with_animation(
-                            "arrow-circle",
-                            Animation::new(Duration::from_secs(2)).repeat(),
-                            |icon, delta| icon.transform(Transformation::rotate(percentage(delta))),
-                        ),
-                )
-            }))
-    }
-
-    fn render_dev_server_project(
-        &mut self,
-        project: &DevServerProject,
-        cx: &mut ViewContext<Self>,
-    ) -> impl IntoElement {
-        let dev_server_project_id = project.id;
-        let project_id = project.project_id;
-        let is_online = project_id.is_some();
-
-        ListItem::new(("remote-project", dev_server_project_id.0))
-            .start_slot(Icon::new(IconName::FileTree).when(!is_online, |icon| icon.color(Color::Muted)))
-            .child(
-                    Label::new(project.paths.join(", "))
-            )
-            .on_click(cx.listener(move |_, _, cx| {
-                if let Some(project_id) = project_id {
-                    if let Some(app_state) = AppState::global(cx).upgrade() {
-                        workspace::join_dev_server_project(dev_server_project_id, project_id, app_state, None, cx)
-                            .detach_and_prompt_err("Could not join project", cx, |_, _| None)
-                    }
-                } else {
-                    cx.spawn(|_, mut cx| async move {
-                        cx.prompt(gpui::PromptLevel::Critical, "This project is offline", Some("The `zed` instance running on this dev server is not connected. You will have to restart it."), &["Ok"]).await.log_err();
-                    }).detach();
-                }
-            }))
-            .end_hover_slot::<AnyElement>(Some(IconButton::new("remove-remote-project", IconName::TrashAlt)
-                .on_click(cx.listener(move |this, _, cx| {
-                    this.delete_dev_server_project(dev_server_project_id, cx)
-                }))
-                .tooltip(|cx| Tooltip::text("Delete remote project", cx)).into_any_element()))
-    }
-
     fn render_create_dev_server(
         &self,
         state: &CreateDevServer,
         cx: &mut ViewContext<Self>,
     ) -> impl IntoElement {
         let creating = state.creating.is_some();
-        let dev_server_id = state.dev_server_id;
-        let access_token = state.access_token.clone();
         let ssh_prompt = state.ssh_prompt.clone();
-        let use_direct_ssh = SshSettings::get_global(cx).use_direct_ssh()
-            || Client::global(cx).status().borrow().is_signed_out();
-
-        let mut kind = state.kind;
-        if use_direct_ssh && kind == NewServerKind::LegacySSH {
-            kind = NewServerKind::DirectSSH;
-        }
 
         self.dev_server_name_input.update(cx, |input, cx| {
             input.editor().update(cx, |editor, cx| {
@@ -1216,20 +736,10 @@ impl DevServerProjects {
                                 Button::new("create-dev-server", "Connect Server")
                                     .style(ButtonStyle::Filled)
                                     .layer(ElevationIndex::ModalSurface)
-                                    .disabled(creating && dev_server_id.is_none())
+                                    .disabled(creating)
                                     .on_click(cx.listener({
-                                        let access_token = access_token.clone();
                                         move |this, _, cx| {
-                                            if kind == NewServerKind::DirectSSH {
-                                                this.create_ssh_server(cx);
-                                                return;
-                                            }
-                                            this.create_or_update_dev_server(
-                                                kind,
-                                                dev_server_id,
-                                                access_token.clone(),
-                                                cx,
-                                            );
+                                            this.create_ssh_server(cx);
                                         }
                                     })),
                             ),
@@ -1277,22 +787,6 @@ impl DevServerProjects {
             .ssh_connections()
             .collect::<Vec<_>>();
 
-        let Mode::Default(create_dev_server_project) = &self.mode else {
-            unreachable!()
-        };
-
-        let mut is_creating = None;
-        let mut creating_dev_server = None;
-        if let Some(CreateDevServerProject {
-            creating,
-            dev_server_id,
-            ..
-        }) = create_dev_server_project
-        {
-            is_creating = Some(*creating);
-            creating_dev_server = Some(*dev_server_id);
-        };
-
         let footer = format!("Connections: {}", ssh_connections.len() + dev_servers.len());
         Modal::new("remote-projects", Some(self.scroll_handle.clone()))
             .header(
@@ -1309,11 +803,6 @@ impl DevServerProjects {
                                 .icon_color(Color::Muted)
                                 .on_click(cx.listener(|this, _, cx| {
                                     this.mode = Mode::CreateDevServer(CreateDevServer {
-                                        kind: if SshSettings::get_global(cx).use_direct_ssh() {
-                                            NewServerKind::DirectSSH
-                                        } else {
-                                            NewServerKind::LegacySSH
-                                        },
                                         ..Default::default()
                                     });
                                     this.dev_server_name_input.update(cx, |text_field, cx| {
@@ -1341,17 +830,7 @@ impl DevServerProjects {
                                             self.render_ssh_connection(ix, connection, cx)
                                                 .into_any_element()
                                         },
-                                    ))
-                                    .children(dev_servers.iter().map(|dev_server| {
-                                        let creating = if creating_dev_server == Some(dev_server.id)
-                                        {
-                                            is_creating
-                                        } else {
-                                            None
-                                        };
-                                        self.render_dev_server(dev_server, creating, cx)
-                                            .into_any_element()
-                                    })),
+                                    )),
                             ),
                         ),
                 ),
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 554146eab2d183..5862d48e8182b5 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -28,10 +28,6 @@ pub struct SshSettings {
 }
 
 impl SshSettings {
-    pub fn use_direct_ssh(&self) -> bool {
-        self.ssh_connections.is_some()
-    }
-
     pub fn ssh_connections(&self) -> impl Iterator<Item = SshConnection> {
         self.ssh_connections.clone().into_iter().flatten()
     }

From 7d380e9e187d732a37daa88db85cae48f99af33d Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 7 Oct 2024 14:31:23 -0400
Subject: [PATCH 510/762] Temporarily prevent deploying collab to production
 (#18825)

This PR adds a temporary measure to prevent deploying collab to
production, while we investigate some issues stemming from the HTTP
client change.

Release Notes:

- N/A
---
 .github/workflows/deploy_collab.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/deploy_collab.yml b/.github/workflows/deploy_collab.yml
index 1e6e6cf2803e20..cf3ffb4dbc6d63 100644
--- a/.github/workflows/deploy_collab.yml
+++ b/.github/workflows/deploy_collab.yml
@@ -3,7 +3,8 @@ name: Publish Collab Server Image
 on:
   push:
     tags:
-      - collab-production
+      # Pause production deploys while we investigate an issue.
+      # - collab-production
       - collab-staging
 
 env:

From 8cdb9d6b8590eb5565b858e10d6ea37e1648b737 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Mon, 7 Oct 2024 12:03:02 -0700
Subject: [PATCH 511/762] Fix a bug where HTTP errors where being reported
 incorrectly (#18828)

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 crates/gpui/src/app.rs                      |  4 +++
 crates/http_client/src/http_client.rs       | 27 +++++++++++++++++++++
 crates/reqwest_client/src/reqwest_client.rs |  6 ++++-
 crates/ureq_client/src/ureq_client.rs       | 15 +++++++++++-
 4 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index bba5f857b4f52c..f81a2092d56af6 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -1533,4 +1533,8 @@ impl HttpClient for NullHttpClient {
     fn proxy(&self) -> Option<&http_client::Uri> {
         None
     }
+
+    fn type_name(&self) -> &'static str {
+        type_name::<Self>()
+    }
 }
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index 015c73a448c5b8..bf1046d88ee820 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -11,6 +11,7 @@ use http::request::Builder;
 #[cfg(feature = "test-support")]
 use std::fmt;
 use std::{
+    any::type_name,
     sync::{Arc, LazyLock, Mutex},
     time::Duration,
 };
@@ -72,6 +73,8 @@ impl HttpRequestExt for http::request::Builder {
 }
 
 pub trait HttpClient: 'static + Send + Sync {
+    fn type_name(&self) -> &'static str;
+
     fn send(
         &self,
         req: http::Request<AsyncBody>,
@@ -154,6 +157,10 @@ impl HttpClient for HttpClientWithProxy {
     fn proxy(&self) -> Option<&Uri> {
         self.proxy.as_ref()
     }
+
+    fn type_name(&self) -> &'static str {
+        self.client.type_name()
+    }
 }
 
 impl HttpClient for Arc<HttpClientWithProxy> {
@@ -167,6 +174,10 @@ impl HttpClient for Arc<HttpClientWithProxy> {
     fn proxy(&self) -> Option<&Uri> {
         self.proxy.as_ref()
     }
+
+    fn type_name(&self) -> &'static str {
+        self.client.type_name()
+    }
 }
 
 /// An [`HttpClient`] that has a base URL.
@@ -278,6 +289,10 @@ impl HttpClient for Arc<HttpClientWithUrl> {
     fn proxy(&self) -> Option<&Uri> {
         self.client.proxy.as_ref()
     }
+
+    fn type_name(&self) -> &'static str {
+        self.client.type_name()
+    }
 }
 
 impl HttpClient for HttpClientWithUrl {
@@ -291,6 +306,10 @@ impl HttpClient for HttpClientWithUrl {
     fn proxy(&self) -> Option<&Uri> {
         self.client.proxy.as_ref()
     }
+
+    fn type_name(&self) -> &'static str {
+        self.client.type_name()
+    }
 }
 
 pub fn read_proxy_from_env() -> Option<Uri> {
@@ -331,6 +350,10 @@ impl HttpClient for BlockedHttpClient {
     fn proxy(&self) -> Option<&Uri> {
         None
     }
+
+    fn type_name(&self) -> &'static str {
+        type_name::<Self>()
+    }
 }
 
 #[cfg(feature = "test-support")]
@@ -403,4 +426,8 @@ impl HttpClient for FakeHttpClient {
     fn proxy(&self) -> Option<&Uri> {
         None
     }
+
+    fn type_name(&self) -> &'static str {
+        type_name::<Self>()
+    }
 }
diff --git a/crates/reqwest_client/src/reqwest_client.rs b/crates/reqwest_client/src/reqwest_client.rs
index 6e84c58954ab12..b5c274d5994deb 100644
--- a/crates/reqwest_client/src/reqwest_client.rs
+++ b/crates/reqwest_client/src/reqwest_client.rs
@@ -1,4 +1,4 @@
-use std::{borrow::Cow, io::Read, pin::Pin, task::Poll};
+use std::{any::type_name, borrow::Cow, io::Read, pin::Pin, task::Poll};
 
 use anyhow::anyhow;
 use bytes::{BufMut, Bytes, BytesMut};
@@ -183,6 +183,10 @@ impl http_client::HttpClient for ReqwestClient {
         None
     }
 
+    fn type_name(&self) -> &'static str {
+        type_name::<Self>()
+    }
+
     fn send(
         &self,
         req: http::Request<http_client::AsyncBody>,
diff --git a/crates/ureq_client/src/ureq_client.rs b/crates/ureq_client/src/ureq_client.rs
index 8951e80ac2df5e..d3d8d3aedc502f 100644
--- a/crates/ureq_client/src/ureq_client.rs
+++ b/crates/ureq_client/src/ureq_client.rs
@@ -1,3 +1,4 @@
+use std::any::type_name;
 use std::collections::HashMap;
 use std::io::Read;
 use std::sync::Arc;
@@ -74,6 +75,10 @@ impl HttpClient for UreqClient {
         self.proxy_url.as_ref()
     }
 
+    fn type_name(&self) -> &'static str {
+        type_name::<Self>()
+    }
+
     fn send(
         &self,
         request: http::Request<AsyncBody>,
@@ -100,7 +105,15 @@ impl HttpClient for UreqClient {
 
         self.background_executor
             .spawn(async move {
-                let response = req.send(body)?;
+                let response = match req.send(body) {
+                    Ok(response) => response,
+                    Err(e) => match e {
+                        ureq::Error::Status(_, response) => response,
+                        ureq::Error::Transport(transport) => {
+                            anyhow::bail!(transport)
+                        }
+                    },
+                };
 
                 let mut builder = http::Response::builder()
                     .status(response.status())

From 5387a6f7f93e7b7ddd9877e00efd89195b469e4c Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Mon, 7 Oct 2024 13:03:26 -0700
Subject: [PATCH 512/762] Fix an issue where LLM requests would block forever
 (#18830)

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 .github/workflows/deploy_collab.yml         |  3 +--
 crates/reqwest_client/src/reqwest_client.rs | 27 +++++++++++++++++++--
 2 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/deploy_collab.yml b/.github/workflows/deploy_collab.yml
index cf3ffb4dbc6d63..1e6e6cf2803e20 100644
--- a/.github/workflows/deploy_collab.yml
+++ b/.github/workflows/deploy_collab.yml
@@ -3,8 +3,7 @@ name: Publish Collab Server Image
 on:
   push:
     tags:
-      # Pause production deploys while we investigate an issue.
-      # - collab-production
+      - collab-production
       - collab-staging
 
 env:
diff --git a/crates/reqwest_client/src/reqwest_client.rs b/crates/reqwest_client/src/reqwest_client.rs
index b5c274d5994deb..f8698b908096b8 100644
--- a/crates/reqwest_client/src/reqwest_client.rs
+++ b/crates/reqwest_client/src/reqwest_client.rs
@@ -163,8 +163,12 @@ impl futures::stream::Stream for WrappedBody {
             WrappedBodyInner::SyncReader(cursor) => {
                 let mut buf = Vec::new();
                 match cursor.read_to_end(&mut buf) {
-                    Ok(_) => {
-                        return Poll::Ready(Some(Ok(Bytes::from(buf))));
+                    Ok(bytes) => {
+                        if bytes == 0 {
+                            return Poll::Ready(None);
+                        } else {
+                            return Poll::Ready(Some(Ok(Bytes::from(buf))));
+                        }
                     }
                     Err(e) => return Poll::Ready(Some(Err(e))),
                 }
@@ -234,3 +238,22 @@ impl http_client::HttpClient for ReqwestClient {
         .boxed()
     }
 }
+
+#[cfg(test)]
+mod test {
+
+    use core::str;
+
+    use http_client::AsyncBody;
+    use smol::stream::StreamExt;
+
+    use crate::WrappedBody;
+
+    #[tokio::test]
+    async fn test_sync_streaming_upload() {
+        let mut body = WrappedBody::new(AsyncBody::from("hello there".to_string())).fuse();
+        let result = body.next().await.unwrap().unwrap();
+        assert!(body.next().await.is_none());
+        assert_eq!(str::from_utf8(&result).unwrap(), "hello there");
+    }
+}

From a15b10986a70c9b2fdff48926ffe55a6edc17337 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Mon, 7 Oct 2024 16:17:43 -0400
Subject: [PATCH 513/762] Add ssh initialization events (#18831)

Release Notes:

- N/A
---
 crates/client/src/telemetry.rs            |  6 +++---
 crates/recent_projects/src/dev_servers.rs | 17 ++++++++++++++++-
 crates/workspace/src/workspace.rs         |  6 ++++++
 crates/zed/src/main.rs                    |  2 ++
 4 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index ee6da64d222236..a8912c2f205e37 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -485,7 +485,7 @@ impl Telemetry {
         worktree_id: WorktreeId,
         updated_entries_set: &UpdatedEntriesSet,
     ) {
-        let project_names: Vec<String> = {
+        let project_type_names: Vec<String> = {
             let mut state = self.state.lock();
             state
                 .worktree_id_map
@@ -521,8 +521,8 @@ impl Telemetry {
         };
 
         // Done on purpose to avoid calling `self.state.lock()` multiple times
-        for project_name in project_names {
-            self.report_app_event(format!("open {} project", project_name));
+        for project_type_name in project_type_names {
+            self.report_app_event(format!("open {} project", project_type_name));
         }
     }
 
diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 0a05b6a1e9e0ac..fa1d511791f87f 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -279,6 +279,13 @@ impl DevServerProjects {
             match connection.await {
                 Some(_) => this
                     .update(&mut cx, |this, cx| {
+                        let _ = this.workspace.update(cx, |workspace, _| {
+                            workspace
+                                .client()
+                                .telemetry()
+                                .report_app_event("create ssh server".to_string())
+                        });
+
                         this.add_ssh_server(connection_options, cx);
                         this.mode = Mode::Default(None);
                         cx.notify()
@@ -422,7 +429,15 @@ impl DevServerProjects {
                         );
 
                         cx.new_view(|cx| {
-                            Workspace::new(None, project.clone(), app_state.clone(), cx)
+                            let workspace =
+                                Workspace::new(None, project.clone(), app_state.clone(), cx);
+
+                            workspace
+                                .client()
+                                .telemetry()
+                                .report_app_event("create ssh project".to_string());
+
+                            workspace
                         })
                     })
                     .log_err();
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index d2ccd9cd4a5708..814c7fa91510d7 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -5575,6 +5575,12 @@ pub fn open_ssh_project(
             cx.replace_root_view(|cx| {
                 let mut workspace =
                     Workspace::new(Some(workspace_id), project, app_state.clone(), cx);
+
+                workspace
+                    .client()
+                    .telemetry()
+                    .report_app_event("open ssh project".to_string());
+
                 workspace.set_serialized_ssh_project(serialized_ssh_project);
                 workspace
             });
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index adb5feb9fe5bdc..535cafbccba662 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -528,6 +528,8 @@ fn main() {
             session_id,
             cx,
         );
+
+        // We should rename these in the future to `first app open`, `first app open for release channel`, and `app open`
         if let (Some(system_id), Some(installation_id)) = (&system_id, &installation_id) {
             match (&system_id, &installation_id) {
                 (IdType::New(_), IdType::New(_)) => {

From c5d252b83713a708b907a8619ee79dbba9f4be4b Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 7 Oct 2024 16:25:17 -0400
Subject: [PATCH 514/762] collab: Add missing `cmake` dependency to Dockerfile
 (#18832)

This PR adds the missing `cmake` dependency to the Docker image that is
now needed in order to build collab.

Release Notes:

- N/A
---
 Dockerfile-collab | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Dockerfile-collab b/Dockerfile-collab
index 2fb5f0414787f8..7945eb426d925f 100644
--- a/Dockerfile-collab
+++ b/Dockerfile-collab
@@ -31,10 +31,12 @@ ENV GITHUB_SHA=$GITHUB_SHA
 # - Staging: `4f408ec65a3867278322a189b4eb20f1ab51f508`
 # - Production: `fc4c533d0a8c489e5636a4249d2b52a80039fbd7`
 #
+# Also add `cmake`, since we need it to build `wasmtime`.
+#
 # Installing these as a temporary workaround, but I think ideally we'd want to figure
 # out what caused them to be included in the first place.
 RUN apt-get update; \
-    apt-get install -y --no-install-recommends libxkbcommon-dev libxkbcommon-x11-dev
+    apt-get install -y --no-install-recommends libxkbcommon-dev libxkbcommon-x11-dev cmake
 
 RUN --mount=type=cache,target=./script/node_modules \
     --mount=type=cache,target=/usr/local/cargo/registry \

From d55f0259060a4461cf04ef60c04701285763bb28 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 7 Oct 2024 17:32:49 -0400
Subject: [PATCH 515/762] collab: Track cache writes/reads in LLM usage
 (#18834)

This PR extends the LLM usage tracking to support tracking usage for
cache writes and reads for Anthropic models.

Release Notes:

- N/A

---------

Co-authored-by: Antonio Scandurra <me@as-cii.com>
Co-authored-by: Antonio <antonio@zed.dev>
---
 crates/anthropic/src/anthropic.rs             |   4 +
 .../20241007173634_add_cache_token_counts.sql |  11 ++
 crates/collab/src/llm.rs                      |  80 +++++++++----
 crates/collab/src/llm/db/queries/usages.rs    | 113 +++++++++++++++---
 .../src/llm/db/tables/lifetime_usage.rs       |   2 +
 crates/collab/src/llm/db/tables/model.rs      |   2 +
 .../collab/src/llm/db/tables/usage_measure.rs |   2 +
 crates/collab/src/llm/db/tests/usage_tests.rs |  62 +++++++++-
 crates/collab/src/llm/telemetry.rs            |   4 +
 9 files changed, 241 insertions(+), 39 deletions(-)
 create mode 100644 crates/collab/migrations_llm/20241007173634_add_cache_token_counts.sql

diff --git a/crates/anthropic/src/anthropic.rs b/crates/anthropic/src/anthropic.rs
index 6b8972284208a1..08c8f27bd90276 100644
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -521,6 +521,10 @@ pub struct Usage {
     pub input_tokens: Option<u32>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub output_tokens: Option<u32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cache_creation_input_tokens: Option<u32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cache_read_input_tokens: Option<u32>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
diff --git a/crates/collab/migrations_llm/20241007173634_add_cache_token_counts.sql b/crates/collab/migrations_llm/20241007173634_add_cache_token_counts.sql
new file mode 100644
index 00000000000000..855e46ab0224dc
--- /dev/null
+++ b/crates/collab/migrations_llm/20241007173634_add_cache_token_counts.sql
@@ -0,0 +1,11 @@
+alter table models
+    add column price_per_million_cache_creation_input_tokens integer not null default 0,
+    add column price_per_million_cache_read_input_tokens integer not null default 0;
+
+alter table usages
+    add column cache_creation_input_tokens_this_month bigint not null default 0,
+    add column cache_read_input_tokens_this_month bigint not null default 0;
+
+alter table lifetime_usages
+    add column cache_creation_input_tokens bigint not null default 0,
+    add column cache_read_input_tokens bigint not null default 0;
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index 2d040cfa28e1a9..9809985ac72b23 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -318,22 +318,31 @@ async fn perform_completion(
             chunks
                 .map(move |event| {
                     let chunk = event?;
-                    let (input_tokens, output_tokens) = match &chunk {
+                    let (
+                        input_tokens,
+                        output_tokens,
+                        cache_creation_input_tokens,
+                        cache_read_input_tokens,
+                    ) = match &chunk {
                         anthropic::Event::MessageStart {
                             message: anthropic::Response { usage, .. },
                         }
                         | anthropic::Event::MessageDelta { usage, .. } => (
                             usage.input_tokens.unwrap_or(0) as usize,
                             usage.output_tokens.unwrap_or(0) as usize,
+                            usage.cache_creation_input_tokens.unwrap_or(0) as usize,
+                            usage.cache_read_input_tokens.unwrap_or(0) as usize,
                         ),
-                        _ => (0, 0),
+                        _ => (0, 0, 0, 0),
                     };
 
-                    anyhow::Ok((
-                        serde_json::to_vec(&chunk).unwrap(),
+                    anyhow::Ok(CompletionChunk {
+                        bytes: serde_json::to_vec(&chunk).unwrap(),
                         input_tokens,
                         output_tokens,
-                    ))
+                        cache_creation_input_tokens,
+                        cache_read_input_tokens,
+                    })
                 })
                 .boxed()
         }
@@ -359,11 +368,13 @@ async fn perform_completion(
                             chunk.usage.as_ref().map_or(0, |u| u.prompt_tokens) as usize;
                         let output_tokens =
                             chunk.usage.as_ref().map_or(0, |u| u.completion_tokens) as usize;
-                        (
-                            serde_json::to_vec(&chunk).unwrap(),
+                        CompletionChunk {
+                            bytes: serde_json::to_vec(&chunk).unwrap(),
                             input_tokens,
                             output_tokens,
-                        )
+                            cache_creation_input_tokens: 0,
+                            cache_read_input_tokens: 0,
+                        }
                     })
                 })
                 .boxed()
@@ -387,13 +398,13 @@ async fn perform_completion(
                 .map(|event| {
                     event.map(|chunk| {
                         // TODO - implement token counting for Google AI
-                        let input_tokens = 0;
-                        let output_tokens = 0;
-                        (
-                            serde_json::to_vec(&chunk).unwrap(),
-                            input_tokens,
-                            output_tokens,
-                        )
+                        CompletionChunk {
+                            bytes: serde_json::to_vec(&chunk).unwrap(),
+                            input_tokens: 0,
+                            output_tokens: 0,
+                            cache_creation_input_tokens: 0,
+                            cache_read_input_tokens: 0,
+                        }
                     })
                 })
                 .boxed()
@@ -407,6 +418,8 @@ async fn perform_completion(
         model,
         input_tokens: 0,
         output_tokens: 0,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0,
         inner_stream: stream,
     })))
 }
@@ -551,6 +564,14 @@ async fn check_usage_limit(
     Ok(())
 }
 
+struct CompletionChunk {
+    bytes: Vec<u8>,
+    input_tokens: usize,
+    output_tokens: usize,
+    cache_creation_input_tokens: usize,
+    cache_read_input_tokens: usize,
+}
+
 struct TokenCountingStream<S> {
     state: Arc<LlmState>,
     claims: LlmTokenClaims,
@@ -558,22 +579,26 @@ struct TokenCountingStream<S> {
     model: String,
     input_tokens: usize,
     output_tokens: usize,
+    cache_creation_input_tokens: usize,
+    cache_read_input_tokens: usize,
     inner_stream: S,
 }
 
 impl<S> Stream for TokenCountingStream<S>
 where
-    S: Stream<Item = Result<(Vec<u8>, usize, usize), anyhow::Error>> + Unpin,
+    S: Stream<Item = Result<CompletionChunk, anyhow::Error>> + Unpin,
 {
     type Item = Result<Vec<u8>, anyhow::Error>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         match Pin::new(&mut self.inner_stream).poll_next(cx) {
-            Poll::Ready(Some(Ok((mut bytes, input_tokens, output_tokens)))) => {
-                bytes.push(b'\n');
-                self.input_tokens += input_tokens;
-                self.output_tokens += output_tokens;
-                Poll::Ready(Some(Ok(bytes)))
+            Poll::Ready(Some(Ok(mut chunk))) => {
+                chunk.bytes.push(b'\n');
+                self.input_tokens += chunk.input_tokens;
+                self.output_tokens += chunk.output_tokens;
+                self.cache_creation_input_tokens += chunk.cache_creation_input_tokens;
+                self.cache_read_input_tokens += chunk.cache_read_input_tokens;
+                Poll::Ready(Some(Ok(chunk.bytes)))
             }
             Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(e))),
             Poll::Ready(None) => Poll::Ready(None),
@@ -590,6 +615,8 @@ impl<S> Drop for TokenCountingStream<S> {
         let model = std::mem::take(&mut self.model);
         let input_token_count = self.input_tokens;
         let output_token_count = self.output_tokens;
+        let cache_creation_input_token_count = self.cache_creation_input_tokens;
+        let cache_read_input_token_count = self.cache_read_input_tokens;
         self.state.executor.spawn_detached(async move {
             let usage = state
                 .db
@@ -599,6 +626,8 @@ impl<S> Drop for TokenCountingStream<S> {
                     provider,
                     &model,
                     input_token_count,
+                    cache_creation_input_token_count,
+                    cache_read_input_token_count,
                     output_token_count,
                     Utc::now(),
                 )
@@ -630,11 +659,20 @@ impl<S> Drop for TokenCountingStream<S> {
                             model,
                             provider: provider.to_string(),
                             input_token_count: input_token_count as u64,
+                            cache_creation_input_token_count: cache_creation_input_token_count
+                                as u64,
+                            cache_read_input_token_count: cache_read_input_token_count as u64,
                             output_token_count: output_token_count as u64,
                             requests_this_minute: usage.requests_this_minute as u64,
                             tokens_this_minute: usage.tokens_this_minute as u64,
                             tokens_this_day: usage.tokens_this_day as u64,
                             input_tokens_this_month: usage.input_tokens_this_month as u64,
+                            cache_creation_input_tokens_this_month: usage
+                                .cache_creation_input_tokens_this_month
+                                as u64,
+                            cache_read_input_tokens_this_month: usage
+                                .cache_read_input_tokens_this_month
+                                as u64,
                             output_tokens_this_month: usage.output_tokens_this_month as u64,
                             spending_this_month: usage.spending_this_month as u64,
                             lifetime_spending: usage.lifetime_spending as u64,
diff --git a/crates/collab/src/llm/db/queries/usages.rs b/crates/collab/src/llm/db/queries/usages.rs
index 65a0bd67345bd0..128a42bc58791d 100644
--- a/crates/collab/src/llm/db/queries/usages.rs
+++ b/crates/collab/src/llm/db/queries/usages.rs
@@ -14,6 +14,8 @@ pub struct Usage {
     pub tokens_this_minute: usize,
     pub tokens_this_day: usize,
     pub input_tokens_this_month: usize,
+    pub cache_creation_input_tokens_this_month: usize,
+    pub cache_read_input_tokens_this_month: usize,
     pub output_tokens_this_month: usize,
     pub spending_this_month: usize,
     pub lifetime_spending: usize,
@@ -160,17 +162,14 @@ impl LlmDatabase {
                 .all(&*tx)
                 .await?;
 
-            let (lifetime_input_tokens, lifetime_output_tokens) = lifetime_usage::Entity::find()
+            let lifetime_usage = lifetime_usage::Entity::find()
                 .filter(
                     lifetime_usage::Column::UserId
                         .eq(user_id)
                         .and(lifetime_usage::Column::ModelId.eq(model.id)),
                 )
                 .one(&*tx)
-                .await?
-                .map_or((0, 0), |usage| {
-                    (usage.input_tokens as usize, usage.output_tokens as usize)
-                });
+                .await?;
 
             let requests_this_minute =
                 self.get_usage_for_measure(&usages, now, UsageMeasure::RequestsPerMinute)?;
@@ -180,18 +179,44 @@ impl LlmDatabase {
                 self.get_usage_for_measure(&usages, now, UsageMeasure::TokensPerDay)?;
             let input_tokens_this_month =
                 self.get_usage_for_measure(&usages, now, UsageMeasure::InputTokensPerMonth)?;
+            let cache_creation_input_tokens_this_month = self.get_usage_for_measure(
+                &usages,
+                now,
+                UsageMeasure::CacheCreationInputTokensPerMonth,
+            )?;
+            let cache_read_input_tokens_this_month = self.get_usage_for_measure(
+                &usages,
+                now,
+                UsageMeasure::CacheReadInputTokensPerMonth,
+            )?;
             let output_tokens_this_month =
                 self.get_usage_for_measure(&usages, now, UsageMeasure::OutputTokensPerMonth)?;
-            let spending_this_month =
-                calculate_spending(model, input_tokens_this_month, output_tokens_this_month);
-            let lifetime_spending =
-                calculate_spending(model, lifetime_input_tokens, lifetime_output_tokens);
+            let spending_this_month = calculate_spending(
+                model,
+                input_tokens_this_month,
+                cache_creation_input_tokens_this_month,
+                cache_read_input_tokens_this_month,
+                output_tokens_this_month,
+            );
+            let lifetime_spending = if let Some(lifetime_usage) = lifetime_usage {
+                calculate_spending(
+                    model,
+                    lifetime_usage.input_tokens as usize,
+                    lifetime_usage.cache_creation_input_tokens as usize,
+                    lifetime_usage.cache_read_input_tokens as usize,
+                    lifetime_usage.output_tokens as usize,
+                )
+            } else {
+                0
+            };
 
             Ok(Usage {
                 requests_this_minute,
                 tokens_this_minute,
                 tokens_this_day,
                 input_tokens_this_month,
+                cache_creation_input_tokens_this_month,
+                cache_read_input_tokens_this_month,
                 output_tokens_this_month,
                 spending_this_month,
                 lifetime_spending,
@@ -208,6 +233,8 @@ impl LlmDatabase {
         provider: LanguageModelProvider,
         model_name: &str,
         input_token_count: usize,
+        cache_creation_input_tokens: usize,
+        cache_read_input_tokens: usize,
         output_token_count: usize,
         now: DateTimeUtc,
     ) -> Result<Usage> {
@@ -235,6 +262,10 @@ impl LlmDatabase {
                     &tx,
                 )
                 .await?;
+            let total_token_count = input_token_count
+                + cache_read_input_tokens
+                + cache_creation_input_tokens
+                + output_token_count;
             let tokens_this_minute = self
                 .update_usage_for_measure(
                     user_id,
@@ -243,7 +274,7 @@ impl LlmDatabase {
                     &usages,
                     UsageMeasure::TokensPerMinute,
                     now,
-                    input_token_count + output_token_count,
+                    total_token_count,
                     &tx,
                 )
                 .await?;
@@ -255,7 +286,7 @@ impl LlmDatabase {
                     &usages,
                     UsageMeasure::TokensPerDay,
                     now,
-                    input_token_count + output_token_count,
+                    total_token_count,
                     &tx,
                 )
                 .await?;
@@ -271,6 +302,30 @@ impl LlmDatabase {
                     &tx,
                 )
                 .await?;
+            let cache_creation_input_tokens_this_month = self
+                .update_usage_for_measure(
+                    user_id,
+                    is_staff,
+                    model.id,
+                    &usages,
+                    UsageMeasure::CacheCreationInputTokensPerMonth,
+                    now,
+                    cache_creation_input_tokens,
+                    &tx,
+                )
+                .await?;
+            let cache_read_input_tokens_this_month = self
+                .update_usage_for_measure(
+                    user_id,
+                    is_staff,
+                    model.id,
+                    &usages,
+                    UsageMeasure::CacheReadInputTokensPerMonth,
+                    now,
+                    cache_read_input_tokens,
+                    &tx,
+                )
+                .await?;
             let output_tokens_this_month = self
                 .update_usage_for_measure(
                     user_id,
@@ -283,8 +338,13 @@ impl LlmDatabase {
                     &tx,
                 )
                 .await?;
-            let spending_this_month =
-                calculate_spending(model, input_tokens_this_month, output_tokens_this_month);
+            let spending_this_month = calculate_spending(
+                model,
+                input_tokens_this_month,
+                cache_creation_input_tokens_this_month,
+                cache_read_input_tokens_this_month,
+                output_tokens_this_month,
+            );
 
             // Update lifetime usage
             let lifetime_usage = lifetime_usage::Entity::find()
@@ -303,6 +363,12 @@ impl LlmDatabase {
                         input_tokens: ActiveValue::set(
                             usage.input_tokens + input_token_count as i64,
                         ),
+                        cache_creation_input_tokens: ActiveValue::set(
+                            usage.cache_creation_input_tokens + cache_creation_input_tokens as i64,
+                        ),
+                        cache_read_input_tokens: ActiveValue::set(
+                            usage.cache_read_input_tokens + cache_read_input_tokens as i64,
+                        ),
                         output_tokens: ActiveValue::set(
                             usage.output_tokens + output_token_count as i64,
                         ),
@@ -327,6 +393,8 @@ impl LlmDatabase {
             let lifetime_spending = calculate_spending(
                 model,
                 lifetime_usage.input_tokens as usize,
+                lifetime_usage.cache_creation_input_tokens as usize,
+                lifetime_usage.cache_read_input_tokens as usize,
                 lifetime_usage.output_tokens as usize,
             );
 
@@ -335,6 +403,8 @@ impl LlmDatabase {
                 tokens_this_minute,
                 tokens_this_day,
                 input_tokens_this_month,
+                cache_creation_input_tokens_this_month,
+                cache_read_input_tokens_this_month,
                 output_tokens_this_month,
                 spending_this_month,
                 lifetime_spending,
@@ -501,13 +571,24 @@ impl LlmDatabase {
 fn calculate_spending(
     model: &model::Model,
     input_tokens_this_month: usize,
+    cache_creation_input_tokens_this_month: usize,
+    cache_read_input_tokens_this_month: usize,
     output_tokens_this_month: usize,
 ) -> usize {
     let input_token_cost =
         input_tokens_this_month * model.price_per_million_input_tokens as usize / 1_000_000;
+    let cache_creation_input_token_cost = cache_creation_input_tokens_this_month
+        * model.price_per_million_cache_creation_input_tokens as usize
+        / 1_000_000;
+    let cache_read_input_token_cost = cache_read_input_tokens_this_month
+        * model.price_per_million_cache_read_input_tokens as usize
+        / 1_000_000;
     let output_token_cost =
         output_tokens_this_month * model.price_per_million_output_tokens as usize / 1_000_000;
-    input_token_cost + output_token_cost
+    input_token_cost
+        + cache_creation_input_token_cost
+        + cache_read_input_token_cost
+        + output_token_cost
 }
 
 const MINUTE_BUCKET_COUNT: usize = 12;
@@ -521,6 +602,8 @@ impl UsageMeasure {
             UsageMeasure::TokensPerMinute => MINUTE_BUCKET_COUNT,
             UsageMeasure::TokensPerDay => DAY_BUCKET_COUNT,
             UsageMeasure::InputTokensPerMonth => MONTH_BUCKET_COUNT,
+            UsageMeasure::CacheCreationInputTokensPerMonth => MONTH_BUCKET_COUNT,
+            UsageMeasure::CacheReadInputTokensPerMonth => MONTH_BUCKET_COUNT,
             UsageMeasure::OutputTokensPerMonth => MONTH_BUCKET_COUNT,
         }
     }
@@ -531,6 +614,8 @@ impl UsageMeasure {
             UsageMeasure::TokensPerMinute => Duration::minutes(1),
             UsageMeasure::TokensPerDay => Duration::hours(24),
             UsageMeasure::InputTokensPerMonth => Duration::days(30),
+            UsageMeasure::CacheCreationInputTokensPerMonth => Duration::days(30),
+            UsageMeasure::CacheReadInputTokensPerMonth => Duration::days(30),
             UsageMeasure::OutputTokensPerMonth => Duration::days(30),
         }
     }
diff --git a/crates/collab/src/llm/db/tables/lifetime_usage.rs b/crates/collab/src/llm/db/tables/lifetime_usage.rs
index 05ad2d5e94c1fa..fc8354699b2309 100644
--- a/crates/collab/src/llm/db/tables/lifetime_usage.rs
+++ b/crates/collab/src/llm/db/tables/lifetime_usage.rs
@@ -9,6 +9,8 @@ pub struct Model {
     pub user_id: UserId,
     pub model_id: ModelId,
     pub input_tokens: i64,
+    pub cache_creation_input_tokens: i64,
+    pub cache_read_input_tokens: i64,
     pub output_tokens: i64,
 }
 
diff --git a/crates/collab/src/llm/db/tables/model.rs b/crates/collab/src/llm/db/tables/model.rs
index c87789f27e2fc6..4d7d2d8da9bce3 100644
--- a/crates/collab/src/llm/db/tables/model.rs
+++ b/crates/collab/src/llm/db/tables/model.rs
@@ -14,6 +14,8 @@ pub struct Model {
     pub max_tokens_per_minute: i64,
     pub max_tokens_per_day: i64,
     pub price_per_million_input_tokens: i32,
+    pub price_per_million_cache_creation_input_tokens: i32,
+    pub price_per_million_cache_read_input_tokens: i32,
     pub price_per_million_output_tokens: i32,
 }
 
diff --git a/crates/collab/src/llm/db/tables/usage_measure.rs b/crates/collab/src/llm/db/tables/usage_measure.rs
index 1105d997c2bcea..50c9501e54f1d6 100644
--- a/crates/collab/src/llm/db/tables/usage_measure.rs
+++ b/crates/collab/src/llm/db/tables/usage_measure.rs
@@ -10,6 +10,8 @@ pub enum UsageMeasure {
     TokensPerMinute,
     TokensPerDay,
     InputTokensPerMonth,
+    CacheCreationInputTokensPerMonth,
+    CacheReadInputTokensPerMonth,
     OutputTokensPerMonth,
 }
 
diff --git a/crates/collab/src/llm/db/tests/usage_tests.rs b/crates/collab/src/llm/db/tests/usage_tests.rs
index 905a3dda08101f..97bcc20e44d1f3 100644
--- a/crates/collab/src/llm/db/tests/usage_tests.rs
+++ b/crates/collab/src/llm/db/tests/usage_tests.rs
@@ -33,12 +33,12 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
     let user_id = UserId::from_proto(123);
 
     let now = t0;
-    db.record_usage(user_id, false, provider, model, 1000, 0, now)
+    db.record_usage(user_id, false, provider, model, 1000, 0, 0, 0, now)
         .await
         .unwrap();
 
     let now = t0 + Duration::seconds(10);
-    db.record_usage(user_id, false, provider, model, 2000, 0, now)
+    db.record_usage(user_id, false, provider, model, 2000, 0, 0, 0, now)
         .await
         .unwrap();
 
@@ -50,6 +50,8 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             tokens_this_minute: 3000,
             tokens_this_day: 3000,
             input_tokens_this_month: 3000,
+            cache_creation_input_tokens_this_month: 0,
+            cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
             spending_this_month: 0,
             lifetime_spending: 0,
@@ -65,6 +67,8 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             tokens_this_minute: 2000,
             tokens_this_day: 3000,
             input_tokens_this_month: 3000,
+            cache_creation_input_tokens_this_month: 0,
+            cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
             spending_this_month: 0,
             lifetime_spending: 0,
@@ -72,7 +76,7 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
     );
 
     let now = t0 + Duration::seconds(60);
-    db.record_usage(user_id, false, provider, model, 3000, 0, now)
+    db.record_usage(user_id, false, provider, model, 3000, 0, 0, 0, now)
         .await
         .unwrap();
 
@@ -84,6 +88,8 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             tokens_this_minute: 5000,
             tokens_this_day: 6000,
             input_tokens_this_month: 6000,
+            cache_creation_input_tokens_this_month: 0,
+            cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
             spending_this_month: 0,
             lifetime_spending: 0,
@@ -100,13 +106,15 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             tokens_this_minute: 0,
             tokens_this_day: 5000,
             input_tokens_this_month: 6000,
+            cache_creation_input_tokens_this_month: 0,
+            cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
             spending_this_month: 0,
             lifetime_spending: 0,
         }
     );
 
-    db.record_usage(user_id, false, provider, model, 4000, 0, now)
+    db.record_usage(user_id, false, provider, model, 4000, 0, 0, 0, now)
         .await
         .unwrap();
 
@@ -118,6 +126,8 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             tokens_this_minute: 4000,
             tokens_this_day: 9000,
             input_tokens_this_month: 10000,
+            cache_creation_input_tokens_this_month: 0,
+            cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
             spending_this_month: 0,
             lifetime_spending: 0,
@@ -134,6 +144,50 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             tokens_this_minute: 0,
             tokens_this_day: 0,
             input_tokens_this_month: 9000,
+            cache_creation_input_tokens_this_month: 0,
+            cache_read_input_tokens_this_month: 0,
+            output_tokens_this_month: 0,
+            spending_this_month: 0,
+            lifetime_spending: 0,
+        }
+    );
+
+    // Test cache creation input tokens
+    db.record_usage(user_id, false, provider, model, 1000, 500, 0, 0, now)
+        .await
+        .unwrap();
+
+    let usage = db.get_usage(user_id, provider, model, now).await.unwrap();
+    assert_eq!(
+        usage,
+        Usage {
+            requests_this_minute: 1,
+            tokens_this_minute: 1500,
+            tokens_this_day: 1500,
+            input_tokens_this_month: 10000,
+            cache_creation_input_tokens_this_month: 500,
+            cache_read_input_tokens_this_month: 0,
+            output_tokens_this_month: 0,
+            spending_this_month: 0,
+            lifetime_spending: 0,
+        }
+    );
+
+    // Test cache read input tokens
+    db.record_usage(user_id, false, provider, model, 1000, 0, 300, 0, now)
+        .await
+        .unwrap();
+
+    let usage = db.get_usage(user_id, provider, model, now).await.unwrap();
+    assert_eq!(
+        usage,
+        Usage {
+            requests_this_minute: 2,
+            tokens_this_minute: 2800,
+            tokens_this_day: 2800,
+            input_tokens_this_month: 11000,
+            cache_creation_input_tokens_this_month: 500,
+            cache_read_input_tokens_this_month: 300,
             output_tokens_this_month: 0,
             spending_this_month: 0,
             lifetime_spending: 0,
diff --git a/crates/collab/src/llm/telemetry.rs b/crates/collab/src/llm/telemetry.rs
index 17a2cb9cd3389d..9daaaf3032090e 100644
--- a/crates/collab/src/llm/telemetry.rs
+++ b/crates/collab/src/llm/telemetry.rs
@@ -12,11 +12,15 @@ pub struct LlmUsageEventRow {
     pub model: String,
     pub provider: String,
     pub input_token_count: u64,
+    pub cache_creation_input_token_count: u64,
+    pub cache_read_input_token_count: u64,
     pub output_token_count: u64,
     pub requests_this_minute: u64,
     pub tokens_this_minute: u64,
     pub tokens_this_day: u64,
     pub input_tokens_this_month: u64,
+    pub cache_creation_input_tokens_this_month: u64,
+    pub cache_read_input_tokens_this_month: u64,
     pub output_tokens_this_month: u64,
     pub spending_this_month: u64,
     pub lifetime_spending: u64,

From 3c91184726381df24321036dada8c5f626cecbc6 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Mon, 7 Oct 2024 18:21:48 -0400
Subject: [PATCH 516/762] collab: Drop mistakenly-added columns from the
 `usages` table (#18835)

This PR drops the `cache_creation_input_tokens_this_month ` and
`cache_read_input_tokens_this_month ` columns from the `usages` table in
the LLM database.

We mistakenly added these in #18834, but these aren't necessary due to
the structure of the `usages` table. We weren't actually using these
columns anywhere.

Release Notes:

- N/A
---
 .../20241007220716_drop_incorrect_usages_columns.sql           | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 crates/collab/migrations_llm/20241007220716_drop_incorrect_usages_columns.sql

diff --git a/crates/collab/migrations_llm/20241007220716_drop_incorrect_usages_columns.sql b/crates/collab/migrations_llm/20241007220716_drop_incorrect_usages_columns.sql
new file mode 100644
index 00000000000000..c204451b7538d8
--- /dev/null
+++ b/crates/collab/migrations_llm/20241007220716_drop_incorrect_usages_columns.sql
@@ -0,0 +1,3 @@
+alter table usages
+    drop column cache_creation_input_tokens_this_month,
+    drop column cache_read_input_tokens_this_month;

From b0a16a760146e9e07d134572364fac850daa9624 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Mon, 7 Oct 2024 16:28:33 -0700
Subject: [PATCH 517/762] Fix bugs with applying hunks from branch buffers
 (#18721)

Release Notes:

- N/A

---------

Co-authored-by: Marshall <marshall@zed.dev>
---
 crates/clock/src/clock.rs           |  9 +--
 crates/language/src/buffer.rs       | 96 +++++++++++++++--------------
 crates/language/src/buffer_tests.rs | 66 ++++++++++++++++++--
 crates/text/src/text.rs             | 18 ++++--
 4 files changed, 128 insertions(+), 61 deletions(-)

diff --git a/crates/clock/src/clock.rs b/crates/clock/src/clock.rs
index 2b45e4a8fad850..acbde90dc1ad91 100644
--- a/crates/clock/src/clock.rs
+++ b/crates/clock/src/clock.rs
@@ -216,10 +216,11 @@ impl fmt::Debug for Global {
             if timestamp.replica_id > 0 {
                 write!(f, ", ")?;
             }
-            write!(f, "{}: {}", timestamp.replica_id, timestamp.value)?;
-        }
-        if self.local_branch_value > 0 {
-            write!(f, "<branch>: {}", self.local_branch_value)?;
+            if timestamp.replica_id == LOCAL_BRANCH_REPLICA_ID {
+                write!(f, "<branch>: {}", timestamp.value)?;
+            } else {
+                write!(f, "{}: {}", timestamp.replica_id, timestamp.value)?;
+            }
         }
         write!(f, "}}")
     }
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 4990b9074ff1df..160e8b3ba9aa96 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -18,6 +18,7 @@ use crate::{
 };
 use anyhow::{anyhow, Context, Result};
 use async_watch as watch;
+use clock::Lamport;
 pub use clock::ReplicaId;
 use futures::channel::oneshot;
 use gpui::{
@@ -90,7 +91,7 @@ enum BufferDiffBase {
     PastBufferVersion {
         buffer: Model<Buffer>,
         rope: Rope,
-        operations_to_ignore: Vec<clock::Lamport>,
+        merged_operations: Vec<Lamport>,
     },
 }
 
@@ -802,7 +803,7 @@ impl Buffer {
                 diff_base: Some(BufferDiffBase::PastBufferVersion {
                     buffer: this.clone(),
                     rope: self.as_rope().clone(),
-                    operations_to_ignore: Vec::new(),
+                    merged_operations: Default::default(),
                 }),
                 language: self.language.clone(),
                 has_conflict: self.has_conflict,
@@ -834,34 +835,32 @@ impl Buffer {
             return;
         };
 
-        base_buffer.update(cx, |base_buffer, cx| {
-            let edits = self
-                .edits_since::<usize>(&base_buffer.version)
-                .filter_map(|edit| {
-                    if range
-                        .as_ref()
-                        .map_or(true, |range| range.overlaps(&edit.new))
-                    {
-                        Some((edit.old, self.text_for_range(edit.new).collect::<String>()))
-                    } else {
-                        None
-                    }
-                })
-                .collect::<Vec<_>>();
+        let mut edits = Vec::new();
+        for edit in self.edits_since::<usize>(&base_buffer.read(cx).version()) {
+            if let Some(range) = &range {
+                if range.start > edit.new.end || edit.new.start > range.end {
+                    continue;
+                }
+            }
+            edits.push((
+                edit.old.clone(),
+                self.text_for_range(edit.new.clone()).collect::<String>(),
+            ));
+        }
 
-            let operation = base_buffer.edit(edits, None, cx);
+        let operation = base_buffer.update(cx, |base_buffer, cx| {
+            cx.emit(BufferEvent::DiffBaseChanged);
+            base_buffer.edit(edits, None, cx)
+        });
 
-            // Prevent this operation from being reapplied to the branch.
+        if let Some(operation) = operation {
             if let Some(BufferDiffBase::PastBufferVersion {
-                operations_to_ignore,
-                ..
+                merged_operations, ..
             }) = &mut self.diff_base
             {
-                operations_to_ignore.extend(operation);
+                merged_operations.push(operation);
             }
-
-            cx.emit(BufferEvent::DiffBaseChanged);
-        });
+        }
     }
 
     fn on_base_buffer_event(
@@ -870,31 +869,34 @@ impl Buffer {
         event: &BufferEvent,
         cx: &mut ModelContext<Self>,
     ) {
-        if let BufferEvent::Operation { operation, .. } = event {
-            if let Some(BufferDiffBase::PastBufferVersion {
-                operations_to_ignore,
-                ..
-            }) = &mut self.diff_base
-            {
-                let mut is_ignored = false;
-                if let Operation::Buffer(text::Operation::Edit(buffer_operation)) = &operation {
-                    operations_to_ignore.retain(|operation_to_ignore| {
-                        match buffer_operation.timestamp.cmp(&operation_to_ignore) {
-                            Ordering::Less => true,
-                            Ordering::Equal => {
-                                is_ignored = true;
-                                false
-                            }
-                            Ordering::Greater => false,
-                        }
-                    });
-                }
-                if !is_ignored {
-                    self.apply_ops([operation.clone()], cx);
-                    self.diff_base_version += 1;
-                }
+        let BufferEvent::Operation { operation, .. } = event else {
+            return;
+        };
+        let Some(BufferDiffBase::PastBufferVersion {
+            merged_operations, ..
+        }) = &mut self.diff_base
+        else {
+            return;
+        };
+
+        let mut operation_to_undo = None;
+        if let Operation::Buffer(text::Operation::Edit(operation)) = &operation {
+            if let Ok(ix) = merged_operations.binary_search(&operation.timestamp) {
+                merged_operations.remove(ix);
+                operation_to_undo = Some(operation.timestamp);
             }
         }
+
+        self.apply_ops([operation.clone()], cx);
+
+        if let Some(timestamp) = operation_to_undo {
+            let operation = self
+                .text
+                .undo_operations([(timestamp, u32::MAX)].into_iter().collect());
+            self.send_operation(Operation::Buffer(operation), true, cx);
+        }
+
+        self.diff_base_version += 1;
     }
 
     #[cfg(test)]
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index da53d5a7637b99..fe390d55101b0b 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -2485,15 +2485,73 @@ fn test_branch_and_merge(cx: &mut TestAppContext) {
 }
 
 #[gpui::test]
-fn test_merge_into_base(cx: &mut AppContext) {
-    init_settings(cx, |_| {});
+fn test_merge_into_base(cx: &mut TestAppContext) {
+    cx.update(|cx| init_settings(cx, |_| {}));
+
     let base = cx.new_model(|cx| Buffer::local("abcdefghijk", cx));
     let branch = base.update(cx, |buffer, cx| buffer.branch(cx));
+
+    // Make 3 edits, merge one into the base.
     branch.update(cx, |branch, cx| {
-        branch.edit([(0..3, "ABC"), (7..9, "HI")], None, cx);
+        branch.edit([(0..3, "ABC"), (7..9, "HI"), (11..11, "LMN")], None, cx);
         branch.merge_into_base(Some(5..8), cx);
     });
-    assert_eq!(base.read(cx).text(), "abcdefgHIjk");
+
+    branch.read_with(cx, |branch, _| assert_eq!(branch.text(), "ABCdefgHIjkLMN"));
+    base.read_with(cx, |base, _| assert_eq!(base.text(), "abcdefgHIjk"));
+
+    // Undo the one already-merged edit. Merge that into the base.
+    branch.update(cx, |branch, cx| {
+        branch.edit([(7..9, "hi")], None, cx);
+        branch.merge_into_base(Some(5..8), cx);
+    });
+    base.read_with(cx, |base, _| assert_eq!(base.text(), "abcdefghijk"));
+
+    // Merge an insertion into the base.
+    branch.update(cx, |branch, cx| {
+        branch.merge_into_base(Some(11..11), cx);
+    });
+
+    branch.read_with(cx, |branch, _| assert_eq!(branch.text(), "ABCdefghijkLMN"));
+    base.read_with(cx, |base, _| assert_eq!(base.text(), "abcdefghijkLMN"));
+
+    // Deleted the inserted text and merge that into the base.
+    branch.update(cx, |branch, cx| {
+        branch.edit([(11..14, "")], None, cx);
+        branch.merge_into_base(Some(10..11), cx);
+    });
+
+    base.read_with(cx, |base, _| assert_eq!(base.text(), "abcdefghijk"));
+}
+
+#[gpui::test]
+fn test_undo_after_merge_into_base(cx: &mut TestAppContext) {
+    cx.update(|cx| init_settings(cx, |_| {}));
+
+    let base = cx.new_model(|cx| Buffer::local("abcdefghijk", cx));
+    let branch = base.update(cx, |buffer, cx| buffer.branch(cx));
+
+    // Make 2 edits, merge one into the base.
+    branch.update(cx, |branch, cx| {
+        branch.edit([(0..3, "ABC"), (7..9, "HI")], None, cx);
+        branch.merge_into_base(Some(7..7), cx);
+    });
+    base.read_with(cx, |base, _| assert_eq!(base.text(), "abcdefgHIjk"));
+    branch.read_with(cx, |branch, _| assert_eq!(branch.text(), "ABCdefgHIjk"));
+
+    // Undo the merge in the base buffer.
+    base.update(cx, |base, cx| {
+        base.undo(cx);
+    });
+    base.read_with(cx, |base, _| assert_eq!(base.text(), "abcdefghijk"));
+    branch.read_with(cx, |branch, _| assert_eq!(branch.text(), "ABCdefgHIjk"));
+
+    // Merge that operation into the base again.
+    branch.update(cx, |branch, cx| {
+        branch.merge_into_base(Some(7..7), cx);
+    });
+    base.read_with(cx, |base, _| assert_eq!(base.text(), "abcdefgHIjk"));
+    branch.read_with(cx, |branch, _| assert_eq!(branch.text(), "ABCdefgHIjk"));
 }
 
 fn start_recalculating_diff(buffer: &Model<Buffer>, cx: &mut TestAppContext) {
diff --git a/crates/text/src/text.rs b/crates/text/src/text.rs
index 80eafcf4eba2d5..6c941401be37cb 100644
--- a/crates/text/src/text.rs
+++ b/crates/text/src/text.rs
@@ -1430,16 +1430,22 @@ impl Buffer {
             counts.insert(edit_id, self.undo_map.undo_count(edit_id) + 1);
         }
 
+        let operation = self.undo_operations(counts);
+        self.history.push(operation.clone());
+        operation
+    }
+
+    pub fn undo_operations(&mut self, counts: HashMap<clock::Lamport, u32>) -> Operation {
+        let timestamp = self.lamport_clock.tick();
+        let version = self.version();
+        self.snapshot.version.observe(timestamp);
         let undo = UndoOperation {
-            timestamp: self.lamport_clock.tick(),
-            version: self.version(),
+            timestamp,
+            version,
             counts,
         };
         self.apply_undo(&undo);
-        self.snapshot.version.observe(undo.timestamp);
-        let operation = Operation::Undo(undo);
-        self.history.push(operation.clone());
-        operation
+        Operation::Undo(undo)
     }
 
     pub fn push_transaction(&mut self, transaction: Transaction, now: Instant) {

From 87cc208f9f08ddd3c799135d74be76bdf4c8a8c1 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Mon, 7 Oct 2024 21:04:36 -0400
Subject: [PATCH 518/762] docs: Fix ollama available_models example (#18842)

---
 docs/src/assistant/configuration.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/src/assistant/configuration.md b/docs/src/assistant/configuration.md
index 9d9c62d8c6bc56..b4d364dc20743d 100644
--- a/docs/src/assistant/configuration.md
+++ b/docs/src/assistant/configuration.md
@@ -142,8 +142,8 @@ Depending on your hardware or use-case you may wish to limit or increase the con
       "low_speed_timeout_in_seconds": 120,
       "available_models": [
         {
-          "provider": "ollama",
-          "name": "mistral:latest",
+          "name": "qwen2.5-coder",
+          "display_name": "qwen 2.5 coder 32K",
           "max_tokens": 32768
         }
       ]

From 910a773b895f84331683d198f9f3c118fb3e4c5a Mon Sep 17 00:00:00 2001
From: Stanislav Alekseev <43210583+WeetHet@users.noreply.github.com>
Date: Tue, 8 Oct 2024 12:36:18 +0300
Subject: [PATCH 519/762] Display environment loading failures in the activity
 indicator (#18567)

As @maan2003 noted in #18473, we should warn the user if direnv call
fails

Release Notes:

- Show a notice in the activity indicator if an error occurs while
loading the shell environment
---
 .../src/activity_indicator.rs                 |  25 +++-
 crates/project/src/direnv.rs                  |  72 +++++++++
 crates/project/src/environment.rs             | 138 ++++++++++--------
 crates/project/src/project.rs                 |  19 +++
 4 files changed, 193 insertions(+), 61 deletions(-)
 create mode 100644 crates/project/src/direnv.rs

diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs
index ace972bf877183..2a4f233db1aea4 100644
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -10,7 +10,7 @@ use gpui::{
 use language::{
     LanguageRegistry, LanguageServerBinaryStatus, LanguageServerId, LanguageServerName,
 };
-use project::{LanguageServerProgress, Project};
+use project::{EnvironmentErrorMessage, LanguageServerProgress, Project, WorktreeId};
 use smallvec::SmallVec;
 use std::{cmp::Reverse, fmt::Write, sync::Arc, time::Duration};
 use ui::{prelude::*, ButtonLike, ContextMenu, PopoverMenu, PopoverMenuHandle};
@@ -175,7 +175,30 @@ impl ActivityIndicator {
             .flatten()
     }
 
+    fn pending_environment_errors<'a>(
+        &'a self,
+        cx: &'a AppContext,
+    ) -> impl Iterator<Item = (&'a WorktreeId, &'a EnvironmentErrorMessage)> {
+        self.project.read(cx).shell_environment_errors(cx)
+    }
+
     fn content_to_render(&mut self, cx: &mut ViewContext<Self>) -> Option<Content> {
+        // Show if any direnv calls failed
+        if let Some((&worktree_id, error)) = self.pending_environment_errors(cx).next() {
+            return Some(Content {
+                icon: Some(
+                    Icon::new(IconName::Warning)
+                        .size(IconSize::Small)
+                        .into_any_element(),
+                ),
+                message: error.0.clone(),
+                on_click: Some(Arc::new(move |this, cx| {
+                    this.project.update(cx, |project, cx| {
+                        project.remove_environment_error(cx, worktree_id);
+                    })
+                })),
+            });
+        }
         // Show any language server has pending activity.
         let mut pending_work = self.pending_language_server_work(cx);
         if let Some(PendingWork {
diff --git a/crates/project/src/direnv.rs b/crates/project/src/direnv.rs
new file mode 100644
index 00000000000000..682cb4b6090f56
--- /dev/null
+++ b/crates/project/src/direnv.rs
@@ -0,0 +1,72 @@
+use crate::environment::EnvironmentErrorMessage;
+use std::process::ExitStatus;
+
+#[cfg(not(any(test, feature = "test-support")))]
+use {collections::HashMap, std::path::Path, util::ResultExt};
+
+#[derive(Clone)]
+pub enum DirenvError {
+    NotFound,
+    FailedRun,
+    NonZeroExit(ExitStatus, Vec<u8>),
+    EmptyOutput,
+    InvalidJson,
+}
+
+impl From<DirenvError> for Option<EnvironmentErrorMessage> {
+    fn from(value: DirenvError) -> Self {
+        match value {
+            DirenvError::NotFound => None,
+            DirenvError::FailedRun | DirenvError::NonZeroExit(_, _) => {
+                Some(EnvironmentErrorMessage(String::from(
+                    "Failed to run direnv. See logs for more info",
+                )))
+            }
+            DirenvError::EmptyOutput => None,
+            DirenvError::InvalidJson => Some(EnvironmentErrorMessage(String::from(
+                "Direnv returned invalid json. See logs for more info",
+            ))),
+        }
+    }
+}
+
+#[cfg(not(any(test, feature = "test-support")))]
+pub async fn load_direnv_environment(dir: &Path) -> Result<HashMap<String, String>, DirenvError> {
+    let Ok(direnv_path) = which::which("direnv") else {
+        return Err(DirenvError::NotFound);
+    };
+
+    let Some(direnv_output) = smol::process::Command::new(direnv_path)
+        .args(["export", "json"])
+        .env("TERM", "dumb")
+        .current_dir(dir)
+        .output()
+        .await
+        .log_err()
+    else {
+        return Err(DirenvError::FailedRun);
+    };
+
+    if !direnv_output.status.success() {
+        log::error!(
+            "Loading direnv environment failed ({}), stderr: {}",
+            direnv_output.status,
+            String::from_utf8_lossy(&direnv_output.stderr)
+        );
+        return Err(DirenvError::NonZeroExit(
+            direnv_output.status,
+            direnv_output.stderr,
+        ));
+    }
+
+    let output = String::from_utf8_lossy(&direnv_output.stdout);
+    if output.is_empty() {
+        return Err(DirenvError::EmptyOutput);
+    }
+
+    let Some(env) = serde_json::from_str(&output).log_err() else {
+        return Err(DirenvError::InvalidJson);
+    };
+
+    Ok(env)
+}
diff --git a/crates/project/src/environment.rs b/crates/project/src/environment.rs
index 23d23c9dc6bb01..1f6d5ba3d17468 100644
--- a/crates/project/src/environment.rs
+++ b/crates/project/src/environment.rs
@@ -1,4 +1,3 @@
-use anyhow::Result;
 use futures::{future::Shared, FutureExt};
 use std::{path::Path, sync::Arc};
 use util::ResultExt;
@@ -17,6 +16,7 @@ pub struct ProjectEnvironment {
     cli_environment: Option<HashMap<String, String>>,
     get_environment_task: Option<Shared<Task<Option<HashMap<String, String>>>>>,
     cached_shell_environments: HashMap<WorktreeId, HashMap<String, String>>,
+    environment_error_messages: HashMap<WorktreeId, EnvironmentErrorMessage>,
 }
 
 impl ProjectEnvironment {
@@ -37,6 +37,7 @@ impl ProjectEnvironment {
                 cli_environment,
                 get_environment_task: None,
                 cached_shell_environments: Default::default(),
+                environment_error_messages: Default::default(),
             }
         })
     }
@@ -54,6 +55,7 @@ impl ProjectEnvironment {
 
     pub(crate) fn remove_worktree_environment(&mut self, worktree_id: WorktreeId) {
         self.cached_shell_environments.remove(&worktree_id);
+        self.environment_error_messages.remove(&worktree_id);
     }
 
     /// Returns the inherited CLI environment, if this project was opened from the Zed CLI.
@@ -66,6 +68,18 @@ impl ProjectEnvironment {
         }
     }
 
+    /// Returns an iterator over all pairs `(worktree_id, error_message)` of
+    /// environment errors associated with this project environment.
+    pub(crate) fn environment_errors(
+        &self,
+    ) -> impl Iterator<Item = (&WorktreeId, &EnvironmentErrorMessage)> {
+        self.environment_error_messages.iter()
+    }
+
+    pub(crate) fn remove_environment_error(&mut self, worktree_id: WorktreeId) {
+        self.environment_error_messages.remove(&worktree_id);
+    }
+
     /// Returns the project environment, if possible.
     /// If the project was opened from the CLI, then the inherited CLI environment is returned.
     /// If it wasn't opened from the CLI, and a worktree is given, then a shell is spawned in
@@ -120,25 +134,31 @@ impl ProjectEnvironment {
             let load_direnv = ProjectSettings::get_global(cx).load_direnv.clone();
 
             cx.spawn(|this, mut cx| async move {
-                let mut shell_env = cx
+                let (mut shell_env, error) = cx
                     .background_executor()
                     .spawn({
                         let cwd = worktree_abs_path.clone();
                         async move { load_shell_environment(&cwd, &load_direnv).await }
                     })
-                    .await
-                    .ok();
+                    .await;
 
                 if let Some(shell_env) = shell_env.as_mut() {
                     this.update(&mut cx, |this, _| {
                         this.cached_shell_environments
-                            .insert(worktree_id, shell_env.clone())
+                            .insert(worktree_id, shell_env.clone());
                     })
                     .log_err();
 
                     set_origin_marker(shell_env, EnvironmentOrigin::WorktreeShell);
                 }
 
+                if let Some(error) = error {
+                    this.update(&mut cx, |this, _| {
+                        this.environment_error_messages.insert(worktree_id, error);
+                    })
+                    .log_err();
+                }
+
                 shell_env
             })
         }
@@ -165,64 +185,62 @@ impl From<EnvironmentOrigin> for String {
     }
 }
 
+pub struct EnvironmentErrorMessage(pub String);
+
+impl EnvironmentErrorMessage {
+    #[allow(dead_code)]
+    fn from_str(s: &str) -> Self {
+        Self(String::from(s))
+    }
+}
+
 #[cfg(any(test, feature = "test-support"))]
 async fn load_shell_environment(
     _dir: &Path,
     _load_direnv: &DirenvSettings,
-) -> Result<HashMap<String, String>> {
-    Ok([("ZED_FAKE_TEST_ENV".into(), "true".into())]
+) -> (
+    Option<HashMap<String, String>>,
+    Option<EnvironmentErrorMessage>,
+) {
+    let fake_env = [("ZED_FAKE_TEST_ENV".into(), "true".into())]
         .into_iter()
-        .collect())
+        .collect();
+    (Some(fake_env), None)
 }
 
 #[cfg(not(any(test, feature = "test-support")))]
 async fn load_shell_environment(
     dir: &Path,
     load_direnv: &DirenvSettings,
-) -> Result<HashMap<String, String>> {
-    use anyhow::{anyhow, Context};
+) -> (
+    Option<HashMap<String, String>>,
+    Option<EnvironmentErrorMessage>,
+) {
+    use crate::direnv::{load_direnv_environment, DirenvError};
     use std::path::PathBuf;
     use util::parse_env_output;
 
-    async fn load_direnv_environment(dir: &Path) -> Result<Option<HashMap<String, String>>> {
-        let Ok(direnv_path) = which::which("direnv") else {
-            return Ok(None);
-        };
-
-        let direnv_output = smol::process::Command::new(direnv_path)
-            .args(["export", "json"])
-            .current_dir(dir)
-            .output()
-            .await
-            .context("failed to spawn direnv to get local environment variables")?;
-
-        anyhow::ensure!(
-            direnv_output.status.success(),
-            "direnv exited with error {:?}. Stderr:\n{}",
-            direnv_output.status,
-            String::from_utf8_lossy(&direnv_output.stderr)
-        );
-
-        let output = String::from_utf8_lossy(&direnv_output.stdout);
-        if output.is_empty() {
-            return Ok(None);
-        }
-
-        Ok(Some(
-            serde_json::from_str(&output).context("failed to parse direnv output")?,
-        ))
+    fn message<T>(with: &str) -> (Option<T>, Option<EnvironmentErrorMessage>) {
+        let message = EnvironmentErrorMessage::from_str(with);
+        (None, Some(message))
     }
 
-    let direnv_environment = match load_direnv {
-        DirenvSettings::ShellHook => None,
-        DirenvSettings::Direct => load_direnv_environment(dir).await.log_err().flatten(),
-    }
-    .unwrap_or(HashMap::default());
+    let (direnv_environment, direnv_error) = match load_direnv {
+        DirenvSettings::ShellHook => (None, None),
+        DirenvSettings::Direct => match load_direnv_environment(dir).await {
+            Ok(env) => (Some(env), None),
+            Err(err) => (
+                None,
+                <Option<EnvironmentErrorMessage> as From<DirenvError>>::from(err),
+            ),
+        },
+    };
+    let direnv_environment = direnv_environment.unwrap_or(HashMap::default());
 
     let marker = "ZED_SHELL_START";
-    let shell = std::env::var("SHELL").context(
-        "SHELL environment variable is not assigned so we can't source login environment variables",
-    )?;
+    let Some(shell) = std::env::var("SHELL").log_err() else {
+        return message("Failed to get login environment. SHELL environment variable is not set");
+    };
 
     // What we're doing here is to spawn a shell and then `cd` into
     // the project directory to get the env in there as if the user
@@ -259,26 +277,26 @@ async fn load_shell_environment(
         additional_command.unwrap_or("")
     );
 
-    let output = smol::process::Command::new(&shell)
+    let Some(output) = smol::process::Command::new(&shell)
         .args(["-l", "-i", "-c", &command])
         .envs(direnv_environment)
         .output()
         .await
-        .context("failed to spawn login shell to source login environment variables")?;
-
-    anyhow::ensure!(
-        output.status.success(),
-        "login shell exited with error {:?}",
-        output.status
-    );
+        .log_err()
+    else {
+        return message("Failed to spawn login shell to source login environment variables. See logs for details");
+    };
+
+    if !output.status.success() {
+        log::error!("login shell exited with {}", output.status);
+        return message("Login shell exited with nonzero exit code. See logs for details");
+    }
 
     let stdout = String::from_utf8_lossy(&output.stdout);
-    let env_output_start = stdout.find(marker).ok_or_else(|| {
-        anyhow!(
-            "failed to parse output of `env` command in login shell: {}",
-            stdout
-        )
-    })?;
+    let Some(env_output_start) = stdout.find(marker) else {
+        log::error!("failed to parse output of `env` command in login shell: {stdout}");
+        return message("Failed to parse stdout of env command. See logs for the output");
+    };
 
     let mut parsed_env = HashMap::default();
     let env_output = &stdout[env_output_start + marker.len()..];
@@ -287,5 +305,5 @@ async fn load_shell_environment(
         parsed_env.insert(key, value);
     });
 
-    Ok(parsed_env)
+    (Some(parsed_env), direnv_error)
 }
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index f2a8d59c6ffd83..a0164dd981547c 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -15,7 +15,9 @@ pub mod worktree_store;
 #[cfg(test)]
 mod project_tests;
 
+mod direnv;
 mod environment;
+pub use environment::EnvironmentErrorMessage;
 pub mod search_history;
 mod yarn;
 
@@ -1185,6 +1187,23 @@ impl Project {
         self.environment.read(cx).get_cli_environment()
     }
 
+    pub fn shell_environment_errors<'a>(
+        &'a self,
+        cx: &'a AppContext,
+    ) -> impl Iterator<Item = (&'a WorktreeId, &'a EnvironmentErrorMessage)> {
+        self.environment.read(cx).environment_errors()
+    }
+
+    pub fn remove_environment_error(
+        &mut self,
+        cx: &mut ModelContext<Self>,
+        worktree_id: WorktreeId,
+    ) {
+        self.environment.update(cx, |environment, _| {
+            environment.remove_environment_error(worktree_id);
+        });
+    }
+
     #[cfg(any(test, feature = "test-support"))]
     pub fn has_open_buffer(&self, path: impl Into<ProjectPath>, cx: &AppContext) -> bool {
         self.buffer_store

From fa85238c6970ce828858535d1a0799af51500b03 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Tue, 8 Oct 2024 11:37:54 +0200
Subject: [PATCH 520/762] ssh: Limit amount of reconnect attempts (#18819)

Co-Authored-by: Thorsten <thorsten@zed.dev>

Release Notes:

- N/A

---------

Co-authored-by: Thorsten <thorsten@zed.dev>
---
 Cargo.lock                        |   1 +
 crates/project/src/project.rs     |   6 +-
 crates/remote/src/remote.rs       |   4 +-
 crates/remote/src/ssh_session.rs  | 514 +++++++++++++++++++++++-------
 crates/title_bar/Cargo.toml       |   1 +
 crates/title_bar/src/title_bar.rs |  10 +-
 6 files changed, 412 insertions(+), 124 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9deb937370f952..dada7d97f80033 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11885,6 +11885,7 @@ dependencies = [
  "pretty_assertions",
  "project",
  "recent_projects",
+ "remote",
  "rpc",
  "serde",
  "settings",
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index a0164dd981547c..8c2b4bd2a067df 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -1263,8 +1263,10 @@ impl Project {
             .clone()
     }
 
-    pub fn ssh_is_connected(&self, cx: &AppContext) -> Option<bool> {
-        Some(!self.ssh_client.as_ref()?.read(cx).is_reconnect_underway())
+    pub fn ssh_connection_state(&self, cx: &AppContext) -> Option<remote::ConnectionState> {
+        self.ssh_client
+            .as_ref()
+            .map(|ssh| ssh.read(cx).connection_state())
     }
 
     pub fn replica_id(&self) -> ReplicaId {
diff --git a/crates/remote/src/remote.rs b/crates/remote/src/remote.rs
index c3d9e8f9cc125e..3cfaf48a88c4a9 100644
--- a/crates/remote/src/remote.rs
+++ b/crates/remote/src/remote.rs
@@ -2,4 +2,6 @@ pub mod json_log;
 pub mod protocol;
 pub mod ssh_session;
 
-pub use ssh_session::{SshClientDelegate, SshConnectionOptions, SshPlatform, SshRemoteClient};
+pub use ssh_session::{
+    ConnectionState, SshClientDelegate, SshConnectionOptions, SshPlatform, SshRemoteClient,
+};
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 26ef8626ec6e20..cf2a70223134d1 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -31,7 +31,8 @@ use smol::{
 use std::{
     any::TypeId,
     ffi::OsStr,
-    mem,
+    fmt,
+    ops::ControlFlow,
     path::{Path, PathBuf},
     sync::{
         atomic::{AtomicU32, Ordering::SeqCst},
@@ -40,7 +41,7 @@ use std::{
     time::{Duration, Instant},
 };
 use tempfile::TempDir;
-use util::maybe;
+use util::ResultExt;
 
 #[derive(
     Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, serde::Serialize, serde::Deserialize,
@@ -234,19 +235,157 @@ impl ChannelForwarder {
     }
 }
 
-struct SshRemoteClientState {
-    ssh_connection: SshRemoteConnection,
-    delegate: Arc<dyn SshClientDelegate>,
-    forwarder: ChannelForwarder,
-    multiplex_task: Task<Result<()>>,
-    heartbeat_task: Task<Result<()>>,
+const MAX_MISSED_HEARTBEATS: usize = 5;
+const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(5);
+const HEARTBEAT_TIMEOUT: Duration = Duration::from_secs(5);
+
+const MAX_RECONNECT_ATTEMPTS: usize = 3;
+
+enum State {
+    Connecting,
+    Connected {
+        ssh_connection: SshRemoteConnection,
+        delegate: Arc<dyn SshClientDelegate>,
+        forwarder: ChannelForwarder,
+
+        multiplex_task: Task<Result<()>>,
+        heartbeat_task: Task<Result<()>>,
+    },
+    HeartbeatMissed {
+        missed_heartbeats: usize,
+
+        ssh_connection: SshRemoteConnection,
+        delegate: Arc<dyn SshClientDelegate>,
+        forwarder: ChannelForwarder,
+
+        multiplex_task: Task<Result<()>>,
+        heartbeat_task: Task<Result<()>>,
+    },
+    Reconnecting,
+    ReconnectFailed {
+        ssh_connection: SshRemoteConnection,
+        delegate: Arc<dyn SshClientDelegate>,
+        forwarder: ChannelForwarder,
+
+        error: anyhow::Error,
+        attempts: usize,
+    },
+    ReconnectExhausted,
+}
+
+impl fmt::Display for State {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Connecting => write!(f, "connecting"),
+            Self::Connected { .. } => write!(f, "connected"),
+            Self::Reconnecting => write!(f, "reconnecting"),
+            Self::ReconnectFailed { .. } => write!(f, "reconnect failed"),
+            Self::ReconnectExhausted => write!(f, "reconnect exhausted"),
+            Self::HeartbeatMissed { .. } => write!(f, "heartbeat missed"),
+        }
+    }
+}
+
+impl State {
+    fn ssh_connection(&self) -> Option<&SshRemoteConnection> {
+        match self {
+            Self::Connected { ssh_connection, .. } => Some(ssh_connection),
+            Self::HeartbeatMissed { ssh_connection, .. } => Some(ssh_connection),
+            Self::ReconnectFailed { ssh_connection, .. } => Some(ssh_connection),
+            _ => None,
+        }
+    }
+
+    fn can_reconnect(&self) -> bool {
+        matches!(
+            self,
+            Self::Connected { .. } | Self::HeartbeatMissed { .. } | Self::ReconnectFailed { .. }
+        )
+    }
+
+    fn heartbeat_recovered(self) -> Self {
+        match self {
+            Self::HeartbeatMissed {
+                ssh_connection,
+                delegate,
+                forwarder,
+                multiplex_task,
+                heartbeat_task,
+                ..
+            } => Self::Connected {
+                ssh_connection,
+                delegate,
+                forwarder,
+                multiplex_task,
+                heartbeat_task,
+            },
+            _ => self,
+        }
+    }
+
+    fn heartbeat_missed(self) -> Self {
+        match self {
+            Self::Connected {
+                ssh_connection,
+                delegate,
+                forwarder,
+                multiplex_task,
+                heartbeat_task,
+            } => Self::HeartbeatMissed {
+                missed_heartbeats: 1,
+                ssh_connection,
+                delegate,
+                forwarder,
+                multiplex_task,
+                heartbeat_task,
+            },
+            Self::HeartbeatMissed {
+                missed_heartbeats,
+                ssh_connection,
+                delegate,
+                forwarder,
+                multiplex_task,
+                heartbeat_task,
+            } => Self::HeartbeatMissed {
+                missed_heartbeats: missed_heartbeats + 1,
+                ssh_connection,
+                delegate,
+                forwarder,
+                multiplex_task,
+                heartbeat_task,
+            },
+            _ => self,
+        }
+    }
+}
+
+/// The state of the ssh connection.
+#[derive(Clone, Copy, Debug)]
+pub enum ConnectionState {
+    Connecting,
+    Connected,
+    HeartbeatMissed,
+    Reconnecting,
+    Disconnected,
+}
+
+impl From<&State> for ConnectionState {
+    fn from(value: &State) -> Self {
+        match value {
+            State::Connecting => Self::Connecting,
+            State::Connected { .. } => Self::Connected,
+            State::Reconnecting | State::ReconnectFailed { .. } => Self::Reconnecting,
+            State::HeartbeatMissed { .. } => Self::HeartbeatMissed,
+            State::ReconnectExhausted => Self::Disconnected,
+        }
+    }
 }
 
 pub struct SshRemoteClient {
     client: Arc<ChannelClient>,
     unique_identifier: String,
     connection_options: SshConnectionOptions,
-    inner_state: Arc<Mutex<Option<SshRemoteClientState>>>,
+    state: Arc<Mutex<Option<State>>>,
 }
 
 impl Drop for SshRemoteClient {
@@ -266,6 +405,7 @@ impl SshRemoteClient {
             let (outgoing_tx, outgoing_rx) = mpsc::unbounded::<Envelope>();
             let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();
 
+            let client = cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx))?;
             let this = cx.new_model(|cx| {
                 cx.on_app_quit(|this: &mut Self, _| {
                     this.shutdown_processes();
@@ -273,47 +413,49 @@ impl SshRemoteClient {
                 })
                 .detach();
 
-                let client = ChannelClient::new(incoming_rx, outgoing_tx, cx);
                 Self {
-                    client,
+                    client: client.clone(),
                     unique_identifier: unique_identifier.clone(),
-                    connection_options: SshConnectionOptions::default(),
-                    inner_state: Arc::new(Mutex::new(None)),
+                    connection_options: connection_options.clone(),
+                    state: Arc::new(Mutex::new(Some(State::Connecting))),
                 }
             })?;
 
-            let inner_state = {
-                let (proxy, proxy_incoming_tx, proxy_outgoing_rx) =
-                    ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
-
-                let (ssh_connection, ssh_proxy_process) = Self::establish_connection(
-                    unique_identifier,
-                    connection_options,
-                    delegate.clone(),
-                    &mut cx,
-                )
-                .await?;
-
-                let multiplex_task = Self::multiplex(
-                    this.downgrade(),
-                    ssh_proxy_process,
-                    proxy_incoming_tx,
-                    proxy_outgoing_rx,
-                    &mut cx,
-                );
-
-                SshRemoteClientState {
+            let (proxy, proxy_incoming_tx, proxy_outgoing_rx) =
+                ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
+
+            let (ssh_connection, ssh_proxy_process) = Self::establish_connection(
+                unique_identifier,
+                connection_options,
+                delegate.clone(),
+                &mut cx,
+            )
+            .await?;
+
+            let multiplex_task = Self::multiplex(
+                this.downgrade(),
+                ssh_proxy_process,
+                proxy_incoming_tx,
+                proxy_outgoing_rx,
+                &mut cx,
+            );
+
+            if let Err(error) = client.ping(HEARTBEAT_TIMEOUT).await {
+                log::error!("failed to establish connection: {}", error);
+                delegate.set_error(error.to_string(), &mut cx);
+                return Err(error);
+            }
+
+            let heartbeat_task = Self::heartbeat(this.downgrade(), &mut cx);
+
+            this.update(&mut cx, |this, _| {
+                *this.state.lock() = Some(State::Connected {
                     ssh_connection,
                     delegate,
                     forwarder: proxy,
                     multiplex_task,
-                    heartbeat_task: Self::heartbeat(this.downgrade(), &mut cx),
-                }
-            };
-
-            this.update(&mut cx, |this, cx| {
-                this.inner_state.lock().replace(inner_state);
-                cx.notify();
+                    heartbeat_task,
+                });
             })?;
 
             Ok(this)
@@ -321,78 +463,192 @@ impl SshRemoteClient {
     }
 
     fn shutdown_processes(&self) {
-        let Some(mut state) = self.inner_state.lock().take() else {
+        let Some(state) = self.state.lock().take() else {
             return;
         };
         log::info!("shutting down ssh processes");
+
+        let State::Connected {
+            multiplex_task,
+            heartbeat_task,
+            ..
+        } = state
+        else {
+            return;
+        };
         // Drop `multiplex_task` because it owns our ssh_proxy_process, which is a
         // child of master_process.
-        let task = mem::replace(&mut state.multiplex_task, Task::ready(Ok(())));
-        drop(task);
+        drop(multiplex_task);
         // Now drop the rest of state, which kills master process.
-        drop(state);
+        drop(heartbeat_task);
     }
 
-    fn reconnect(&self, cx: &ModelContext<Self>) -> Result<()> {
-        log::info!("Trying to reconnect to ssh server...");
-        let Some(state) = self.inner_state.lock().take() else {
-            return Err(anyhow!("reconnect is already in progress"));
-        };
+    fn reconnect(&mut self, cx: &mut ModelContext<Self>) -> Result<()> {
+        let mut lock = self.state.lock();
 
-        let workspace_identifier = self.unique_identifier.clone();
+        let can_reconnect = lock
+            .as_ref()
+            .map(|state| state.can_reconnect())
+            .unwrap_or(false);
+        if !can_reconnect {
+            let error = if let Some(state) = lock.as_ref() {
+                format!("invalid state, cannot reconnect while in state {state}")
+            } else {
+                "no state set".to_string()
+            };
+            return Err(anyhow!(error));
+        }
 
-        let SshRemoteClientState {
-            mut ssh_connection,
-            delegate,
-            forwarder: proxy,
-            multiplex_task,
-            heartbeat_task,
-        } = state;
-        drop(multiplex_task);
-        drop(heartbeat_task);
+        let state = lock.take().unwrap();
+        let (attempts, mut ssh_connection, delegate, forwarder) = match state {
+            State::Connected {
+                ssh_connection,
+                delegate,
+                forwarder,
+                multiplex_task,
+                heartbeat_task,
+            }
+            | State::HeartbeatMissed {
+                ssh_connection,
+                delegate,
+                forwarder,
+                multiplex_task,
+                heartbeat_task,
+                ..
+            } => {
+                drop(multiplex_task);
+                drop(heartbeat_task);
+                (0, ssh_connection, delegate, forwarder)
+            }
+            State::ReconnectFailed {
+                attempts,
+                ssh_connection,
+                delegate,
+                forwarder,
+                ..
+            } => (attempts, ssh_connection, delegate, forwarder),
+            State::Connecting | State::Reconnecting | State::ReconnectExhausted => unreachable!(),
+        };
 
-        cx.spawn(|this, mut cx| async move {
-            let (incoming_tx, outgoing_rx) = proxy.into_channels().await;
+        let attempts = attempts + 1;
+        if attempts > MAX_RECONNECT_ATTEMPTS {
+            log::error!(
+                "Failed to reconnect to after {} attempts, giving up",
+                MAX_RECONNECT_ATTEMPTS
+            );
+            *lock = Some(State::ReconnectExhausted);
+            return Ok(());
+        }
+        *lock = Some(State::Reconnecting);
+        drop(lock);
+
+        log::info!("Trying to reconnect to ssh server... Attempt {}", attempts);
+
+        let identifier = self.unique_identifier.clone();
+        let client = self.client.clone();
+        let reconnect_task = cx.spawn(|this, mut cx| async move {
+            macro_rules! failed {
+                ($error:expr, $attempts:expr, $ssh_connection:expr, $delegate:expr, $forwarder:expr) => {
+                    return State::ReconnectFailed {
+                        error: anyhow!($error),
+                        attempts: $attempts,
+                        ssh_connection: $ssh_connection,
+                        delegate: $delegate,
+                        forwarder: $forwarder,
+                    };
+                };
+            }
 
-            ssh_connection.master_process.kill()?;
-            ssh_connection
+            if let Err(error) = ssh_connection.master_process.kill() {
+                failed!(error, attempts, ssh_connection, delegate, forwarder);
+            };
+
+            if let Err(error) = ssh_connection
                 .master_process
                 .status()
                 .await
-                .context("Failed to kill ssh process")?;
+                .context("Failed to kill ssh process")
+            {
+                failed!(error, attempts, ssh_connection, delegate, forwarder);
+            }
 
             let connection_options = ssh_connection.socket.connection_options.clone();
 
-            let (ssh_connection, ssh_process) = Self::establish_connection(
-                workspace_identifier,
+            let (incoming_tx, outgoing_rx) = forwarder.into_channels().await;
+            let (forwarder, proxy_incoming_tx, proxy_outgoing_rx) =
+                ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
+
+            let (ssh_connection, ssh_process) = match Self::establish_connection(
+                identifier,
                 connection_options,
                 delegate.clone(),
                 &mut cx,
             )
-            .await?;
+            .await
+            {
+                Ok((ssh_connection, ssh_process)) => (ssh_connection, ssh_process),
+                Err(error) => {
+                    failed!(error, attempts, ssh_connection, delegate, forwarder);
+                }
+            };
 
-            let (proxy, proxy_incoming_tx, proxy_outgoing_rx) =
-                ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
+            let multiplex_task = Self::multiplex(
+                this.clone(),
+                ssh_process,
+                proxy_incoming_tx,
+                proxy_outgoing_rx,
+                &mut cx,
+            );
 
-            let inner_state = SshRemoteClientState {
+            if let Err(error) = client.ping(HEARTBEAT_TIMEOUT).await {
+                failed!(error, attempts, ssh_connection, delegate, forwarder);
+            };
+
+            State::Connected {
                 ssh_connection,
                 delegate,
-                forwarder: proxy,
-                multiplex_task: Self::multiplex(
-                    this.clone(),
-                    ssh_process,
-                    proxy_incoming_tx,
-                    proxy_outgoing_rx,
-                    &mut cx,
-                ),
+                forwarder,
+                multiplex_task,
                 heartbeat_task: Self::heartbeat(this.clone(), &mut cx),
-            };
+            }
+        });
 
-            this.update(&mut cx, |this, _| {
-                this.inner_state.lock().replace(inner_state);
+        cx.spawn(|this, mut cx| async move {
+            let new_state = reconnect_task.await;
+            this.update(&mut cx, |this, cx| {
+                match &new_state {
+                    State::Connecting
+                    | State::Reconnecting { .. }
+                    | State::HeartbeatMissed { .. } => {}
+                    State::Connected { .. } => {
+                        log::info!("Successfully reconnected");
+                    }
+                    State::ReconnectFailed {
+                        error, attempts, ..
+                    } => {
+                        log::error!(
+                            "Reconnect attempt {} failed: {:?}. Starting new attempt...",
+                            attempts,
+                            error
+                        );
+                    }
+                    State::ReconnectExhausted => {
+                        log::error!("Reconnect attempt failed and all attempts exhausted");
+                    }
+                }
+
+                let reconnect_failed = matches!(new_state, State::ReconnectFailed { .. });
+                *this.state.lock() = Some(new_state);
+                cx.notify();
+                if reconnect_failed {
+                    this.reconnect(cx)
+                } else {
+                    Ok(())
+                }
             })
         })
-        .detach();
+        .detach_and_log_err(cx);
+
         Ok(())
     }
 
@@ -403,10 +659,6 @@ impl SshRemoteClient {
         cx.spawn(|mut cx| {
             let this = this.clone();
             async move {
-                const MAX_MISSED_HEARTBEATS: usize = 5;
-                const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(5);
-                const HEARTBEAT_TIMEOUT: Duration = Duration::from_secs(5);
-
                 let mut missed_heartbeats = 0;
 
                 let mut timer = Timer::interval(HEARTBEAT_INTERVAL);
@@ -415,19 +667,7 @@ impl SshRemoteClient {
 
                     log::info!("Sending heartbeat to server...");
 
-                    let result = smol::future::or(
-                        async {
-                            client.request(proto::Ping {}).await?;
-                            Ok(())
-                        },
-                        async {
-                            smol::Timer::after(HEARTBEAT_TIMEOUT).await;
-
-                            Err(anyhow!("Timeout detected"))
-                        },
-                    )
-                    .await;
-
+                    let result = client.ping(HEARTBEAT_TIMEOUT).await;
                     if result.is_err() {
                         missed_heartbeats += 1;
                         log::warn!(
@@ -440,17 +680,10 @@ impl SshRemoteClient {
                         missed_heartbeats = 0;
                     }
 
-                    if missed_heartbeats >= MAX_MISSED_HEARTBEATS {
-                        log::error!(
-                            "Missed last {} hearbeats. Reconnecting...",
-                            missed_heartbeats
-                        );
-
-                        this.update(&mut cx, |this, cx| {
-                            this.reconnect(cx)
-                                .context("failed to reconnect after missing heartbeats")
-                        })
-                        .context("failed to update weak reference, SshRemoteClient lost?")??;
+                    let result = this.update(&mut cx, |this, mut cx| {
+                        this.handle_heartbeat_result(missed_heartbeats, &mut cx)
+                    })?;
+                    if result.is_break() {
                         return Ok(());
                     }
                 }
@@ -458,6 +691,34 @@ impl SshRemoteClient {
         })
     }
 
+    fn handle_heartbeat_result(
+        &mut self,
+        missed_heartbeats: usize,
+        cx: &mut ModelContext<Self>,
+    ) -> ControlFlow<()> {
+        let state = self.state.lock().take().unwrap();
+        self.state.lock().replace(if missed_heartbeats > 0 {
+            state.heartbeat_missed()
+        } else {
+            state.heartbeat_recovered()
+        });
+        cx.notify();
+
+        if missed_heartbeats >= MAX_MISSED_HEARTBEATS {
+            log::error!(
+                "Missed last {} heartbeats. Reconnecting...",
+                missed_heartbeats
+            );
+
+            self.reconnect(cx)
+                .context("failed to start reconnect process after missing heartbeats")
+                .log_err();
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    }
+
     fn multiplex(
         this: WeakModel<Self>,
         mut ssh_proxy_process: Child,
@@ -611,10 +872,11 @@ impl SshRemoteClient {
     }
 
     pub fn ssh_args(&self) -> Option<Vec<String>> {
-        let state = self.inner_state.lock();
-        state
+        self.state
+            .lock()
             .as_ref()
-            .map(|state| state.ssh_connection.socket.ssh_args())
+            .and_then(|state| state.ssh_connection())
+            .map(|ssh_connection| ssh_connection.socket.ssh_args())
     }
 
     pub fn to_proto_client(&self) -> AnyProtoClient {
@@ -625,8 +887,12 @@ impl SshRemoteClient {
         self.connection_options.connection_string()
     }
 
-    pub fn is_reconnect_underway(&self) -> bool {
-        maybe!({ Some(self.inner_state.try_lock()?.is_none()) }).unwrap_or_default()
+    pub fn connection_state(&self) -> ConnectionState {
+        self.state
+            .lock()
+            .as_ref()
+            .map(ConnectionState::from)
+            .unwrap_or(ConnectionState::Disconnected)
     }
 
     #[cfg(any(test, feature = "test-support"))]
@@ -646,7 +912,7 @@ impl SshRemoteClient {
                     client,
                     unique_identifier: "fake".to_string(),
                     connection_options: SshConnectionOptions::default(),
-                    inner_state: Arc::new(Mutex::new(None)),
+                    state: Arc::new(Mutex::new(None)),
                 })
             }),
             server_cx.update(|cx| ChannelClient::new(client_to_server_rx, server_to_client_tx, cx)),
@@ -1046,6 +1312,20 @@ impl ChannelClient {
         }
     }
 
+    pub async fn ping(&self, timeout: Duration) -> Result<()> {
+        smol::future::or(
+            async {
+                self.request(proto::Ping {}).await?;
+                Ok(())
+            },
+            async {
+                smol::Timer::after(timeout).await;
+                Err(anyhow!("Timeout detected"))
+            },
+        )
+        .await
+    }
+
     pub fn send<T: EnvelopedMessage>(&self, payload: T) -> Result<()> {
         log::debug!("ssh send name:{}", T::NAME);
         self.send_dynamic(payload.into_envelope(0, None, None))
diff --git a/crates/title_bar/Cargo.toml b/crates/title_bar/Cargo.toml
index c837b74dcab444..e4d3d7fc5bc659 100644
--- a/crates/title_bar/Cargo.toml
+++ b/crates/title_bar/Cargo.toml
@@ -41,6 +41,7 @@ gpui.workspace = true
 notifications.workspace = true
 project.workspace = true
 recent_projects.workspace = true
+remote.workspace = true
 rpc.workspace = true
 serde.workspace = true
 smallvec.workspace = true
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index 52dab68a2adfba..da0179fd64dcbe 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -265,10 +265,12 @@ impl TitleBar {
     fn render_ssh_project_host(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
         let host = self.project.read(cx).ssh_connection_string(cx)?;
         let meta = SharedString::from(format!("Connected to: {host}"));
-        let indicator_color = if self.project.read(cx).ssh_is_connected(cx)? {
-            Color::Success
-        } else {
-            Color::Warning
+        let indicator_color = match self.project.read(cx).ssh_connection_state(cx)? {
+            remote::ConnectionState::Connecting => Color::Info,
+            remote::ConnectionState::Connected => Color::Success,
+            remote::ConnectionState::HeartbeatMissed => Color::Warning,
+            remote::ConnectionState::Reconnecting => Color::Warning,
+            remote::ConnectionState::Disconnected => Color::Error,
         };
         let indicator = div()
             .absolute()

From be531653a4c84cecdae2be06227b1d907eb08cbb Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 8 Oct 2024 11:54:28 +0200
Subject: [PATCH 521/762] Direnv warn (#18850)

Follow-up fixes to #18567

Release Notes:

- N/A
---
 crates/activity_indicator/src/activity_indicator.rs | 3 ++-
 crates/project/src/environment.rs                   | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs
index 2a4f233db1aea4..687519068d4c35 100644
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -195,7 +195,8 @@ impl ActivityIndicator {
                 on_click: Some(Arc::new(move |this, cx| {
                     this.project.update(cx, |project, cx| {
                         project.remove_environment_error(cx, worktree_id);
-                    })
+                    });
+                    cx.dispatch_action(Box::new(workspace::OpenLog));
                 })),
             });
         }
diff --git a/crates/project/src/environment.rs b/crates/project/src/environment.rs
index 1f6d5ba3d17468..b7aa20a740a67a 100644
--- a/crates/project/src/environment.rs
+++ b/crates/project/src/environment.rs
@@ -134,7 +134,7 @@ impl ProjectEnvironment {
             let load_direnv = ProjectSettings::get_global(cx).load_direnv.clone();
 
             cx.spawn(|this, mut cx| async move {
-                let (mut shell_env, error) = cx
+                let (mut shell_env, error_message) = cx
                     .background_executor()
                     .spawn({
                         let cwd = worktree_abs_path.clone();
@@ -152,7 +152,7 @@ impl ProjectEnvironment {
                     set_origin_marker(shell_env, EnvironmentOrigin::WorktreeShell);
                 }
 
-                if let Some(error) = error {
+                if let Some(error) = error_message {
                     this.update(&mut cx, |this, _| {
                         this.environment_error_messages.insert(worktree_id, error);
                     })

From f0566d54eb058b70de19fc342cf50467c55f5ad0 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Tue, 8 Oct 2024 12:57:47 +0200
Subject: [PATCH 522/762] ssh: Log error when remote server panics (#18853)

Release Notes:

- N/A
---
 Cargo.lock                       |  1 +
 crates/remote_server/Cargo.toml  |  1 +
 crates/remote_server/src/main.rs |  6 ++--
 crates/remote_server/src/unix.rs | 47 +++++++++++++++++++++++++++++++-
 4 files changed, 51 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index dada7d97f80033..dda10e2edc018a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9163,6 +9163,7 @@ name = "remote_server"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "backtrace",
  "cargo_toml",
  "clap",
  "client",
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index 211b76e0917ae7..bd619191514c52 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -22,6 +22,7 @@ test-support = ["fs/test-support"]
 
 [dependencies]
 anyhow.workspace = true
+backtrace = "0.3"
 clap.workspace = true
 client.workspace = true
 env_logger.workspace = true
diff --git a/crates/remote_server/src/main.rs b/crates/remote_server/src/main.rs
index e5582d9b1fc55c..872af42596ffa7 100644
--- a/crates/remote_server/src/main.rs
+++ b/crates/remote_server/src/main.rs
@@ -37,7 +37,7 @@ fn main() {
 
 #[cfg(not(windows))]
 fn main() -> Result<()> {
-    use remote_server::unix::{execute_proxy, execute_run, init_logging};
+    use remote_server::unix::{execute_proxy, execute_run, init};
 
     let cli = Cli::parse();
 
@@ -48,11 +48,11 @@ fn main() -> Result<()> {
             stdin_socket,
             stdout_socket,
         }) => {
-            init_logging(Some(log_file))?;
+            init(Some(log_file))?;
             execute_run(pid_file, stdin_socket, stdout_socket)
         }
         Some(Commands::Proxy { identifier }) => {
-            init_logging(None)?;
+            init(None)?;
             execute_proxy(identifier)
         }
         Some(Commands::Version) => {
diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs
index 74b71a2277bc11..049b0a003e265f 100644
--- a/crates/remote_server/src/unix.rs
+++ b/crates/remote_server/src/unix.rs
@@ -20,7 +20,13 @@ use std::{
     sync::Arc,
 };
 
-pub fn init_logging(log_file: Option<PathBuf>) -> Result<()> {
+pub fn init(log_file: Option<PathBuf>) -> Result<()> {
+    init_logging(log_file)?;
+    init_panic_hook();
+    Ok(())
+}
+
+fn init_logging(log_file: Option<PathBuf>) -> Result<()> {
     if let Some(log_file) = log_file {
         let target = Box::new(if log_file.exists() {
             std::fs::OpenOptions::new()
@@ -46,6 +52,45 @@ pub fn init_logging(log_file: Option<PathBuf>) -> Result<()> {
     Ok(())
 }
 
+fn init_panic_hook() {
+    std::panic::set_hook(Box::new(|info| {
+        let payload = info
+            .payload()
+            .downcast_ref::<&str>()
+            .map(|s| s.to_string())
+            .or_else(|| info.payload().downcast_ref::<String>().cloned())
+            .unwrap_or_else(|| "Box<Any>".to_string());
+
+        let backtrace = backtrace::Backtrace::new();
+        let mut backtrace = backtrace
+            .frames()
+            .iter()
+            .flat_map(|frame| {
+                frame
+                    .symbols()
+                    .iter()
+                    .filter_map(|frame| Some(format!("{:#}", frame.name()?)))
+            })
+            .collect::<Vec<_>>();
+
+        // Strip out leading stack frames for rust panic-handling.
+        if let Some(ix) = backtrace
+            .iter()
+            .position(|name| name == "rust_begin_unwind")
+        {
+            backtrace.drain(0..=ix);
+        }
+
+        log::error!(
+            "server: panic occurred: {}\nBacktrace:\n{}",
+            payload,
+            backtrace.join("\n")
+        );
+
+        std::process::abort();
+    }));
+}
+
 fn start_server(
     stdin_listener: UnixListener,
     stdout_listener: UnixListener,

From b2eb439f32cb0afa34df61e6aa7ef38b00af97bd Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 8 Oct 2024 13:57:26 +0200
Subject: [PATCH 523/762] remote server: Add more debug logging (#18855)

Closes #ISSUE

Release Notes:

- N/A
---
 crates/remote_server/src/unix.rs | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs
index 049b0a003e265f..2e03887ae92d73 100644
--- a/crates/remote_server/src/unix.rs
+++ b/crates/remote_server/src/unix.rs
@@ -106,6 +106,7 @@ fn start_server(
     cx.on_app_quit(move |_| {
         let mut app_quit_tx = app_quit_tx.clone();
         async move {
+            log::info!("app quitting. sending signal to server main loop");
             app_quit_tx.send(()).await.ok();
         }
     })
@@ -195,6 +196,13 @@ fn start_server(
 }
 
 pub fn execute_run(pid_file: PathBuf, stdin_socket: PathBuf, stdout_socket: PathBuf) -> Result<()> {
+    log::info!(
+        "server: starting up. pid_file: {:?}, stdin_socket: {:?}, stdout_socket: {:?}",
+        pid_file,
+        stdin_socket,
+        stdout_socket
+    );
+
     write_pid_file(&pid_file)
         .with_context(|| format!("failed to write pid file: {:?}", &pid_file))?;
 
@@ -202,10 +210,12 @@ pub fn execute_run(pid_file: PathBuf, stdin_socket: PathBuf, stdout_socket: Path
     let stdout_listener =
         UnixListener::bind(stdout_socket).context("failed to bind stdout socket")?;
 
+    log::debug!("server: starting gpui app");
     gpui::App::headless().run(move |cx| {
         settings::init(cx);
         HeadlessProject::init(cx);
 
+        log::info!("server: gpui app started, initializing server");
         let session = start_server(stdin_listener, stdout_listener, cx);
         let project = cx.new_model(|cx| {
             HeadlessProject::new(session, Arc::new(RealFs::new(Default::default(), None)), cx)
@@ -343,8 +353,9 @@ fn write_pid_file(path: &Path) -> Result<()> {
     if path.exists() {
         std::fs::remove_file(path)?;
     }
-
-    std::fs::write(path, std::process::id().to_string()).context("Failed to write PID file")
+    let pid = std::process::id().to_string();
+    log::debug!("server: writing PID {} to file {:?}", pid, path);
+    std::fs::write(path, pid).context("Failed to write PID file")
 }
 
 async fn handle_io<R, W>(mut reader: R, mut writer: W, socket_name: &str) -> Result<()>

From 5bb18adbe86edbe368676f9ed3131a9982522b0c Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 8 Oct 2024 08:13:29 -0400
Subject: [PATCH 524/762] Inform users they can ask us to reopen issues closed
 by the stale issue action (#18857)

Release Notes:

- N/A
---
 .github/workflows/close_stale_issues.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/close_stale_issues.yml
index 03c89b74b72c9c..c38db5bfd764f6 100644
--- a/.github/workflows/close_stale_issues.yml
+++ b/.github/workflows/close_stale_issues.yml
@@ -17,7 +17,7 @@ jobs:
             We're working to clean up our issue tracker by closing older issues that might not be relevant anymore. Are you able to reproduce this issue in the latest version of Zed? If so, please let us know by commenting on this issue and we will keep it open; otherwise, we'll close it in 7 days. Feel free to open a new issue if you're seeing this message after the issue has been closed.
 
             Thanks for your help!
-          close-issue-message: "This issue was closed due to inactivity; feel free to open a new issue if you're still experiencing this problem!"
+          close-issue-message: "This issue was closed due to inactivity. If you're still experiencing this problem, feel free to ping a Zed team member to reopen this issue or open a new one."
           # We will increase `days-before-stale` to 365 on or after Jan 24th,
           # 2024. This date marks one year since migrating issues from
           # 'community' to 'zed' repository. The migration added activity to all

From dd44168cadc8084a963b500617b9a555b87514bb Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 8 Oct 2024 10:20:20 -0400
Subject: [PATCH 525/762] dart: Improve indentation (#18845)

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 assets/settings/default.json               |  3 +++
 extensions/dart/languages/dart/indents.scm | 21 +++------------------
 2 files changed, 6 insertions(+), 18 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 133ff9451d027b..e5cbcd2f9c0c31 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -840,6 +840,9 @@
         "allowed": true
       }
     },
+    "Dart": {
+      "tab_size": 2
+    },
     "Elixir": {
       "language_servers": ["elixir-ls", "!next-ls", "!lexical", "..."]
     },
diff --git a/extensions/dart/languages/dart/indents.scm b/extensions/dart/languages/dart/indents.scm
index 4d6f8c1cb75b69..112b414aa45f27 100644
--- a/extensions/dart/languages/dart/indents.scm
+++ b/extensions/dart/languages/dart/indents.scm
@@ -1,18 +1,3 @@
-(class_definition
-    "class" @context
-    name: (_) @name) @item
-
-(function_signature
-    name: (_) @name) @item
-
-(getter_signature
-    "get" @context
-    name: (_) @name) @item
-
-(setter_signature
-    "set" @context
-    name: (_) @name) @item
-
-(enum_declaration
-    "enum" @context
-    name: (_) @name) @item
+(_ "[" "]" @end) @indent
+(_ "{" "}" @end) @indent
+(_ "(" ")" @end) @indent

From 4c7a6f5e7fdabb2a5daa65fd5f1f5b87b1ab2f65 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 8 Oct 2024 10:30:04 -0400
Subject: [PATCH 526/762] Add is_via_ssh field to editor events (#18837)

Release Notes:

- N/A
---
 crates/client/src/telemetry.rs                  | 2 ++
 crates/collab/src/api/events.rs                 | 2 ++
 crates/editor/src/editor.rs                     | 4 +++-
 crates/telemetry_events/src/telemetry_events.rs | 2 ++
 4 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index a8912c2f205e37..24d448aa0202ff 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -364,6 +364,7 @@ impl Telemetry {
         operation: &'static str,
         copilot_enabled: bool,
         copilot_enabled_for_language: bool,
+        is_via_ssh: bool,
     ) {
         let event = Event::Editor(EditorEvent {
             file_extension,
@@ -371,6 +372,7 @@ impl Telemetry {
             operation: operation.into(),
             copilot_enabled,
             copilot_enabled_for_language,
+            is_via_ssh,
         });
 
         self.report_event(event)
diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index bbfa69c0b8f70b..f5cd1c00eae417 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -679,6 +679,7 @@ pub struct EditorEventRow {
     minor: Option<i32>,
     patch: Option<i32>,
     checksum_matched: bool,
+    is_via_ssh: bool,
 }
 
 impl EditorEventRow {
@@ -720,6 +721,7 @@ impl EditorEventRow {
             region_code: "".to_string(),
             city: "".to_string(),
             historical_event: false,
+            is_via_ssh: event.is_via_ssh,
         }
     }
 }
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 62c2240828ee42..d06f66184b4b4d 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -12481,13 +12481,15 @@ impl Editor {
             .settings_at(0, cx)
             .show_inline_completions;
 
-        let telemetry = project.read(cx).client().telemetry().clone();
+        let project = project.read(cx);
+        let telemetry = project.client().telemetry().clone();
         telemetry.report_editor_event(
             file_extension,
             vim_mode,
             operation,
             copilot_enabled,
             copilot_enabled_for_language,
+            project.is_via_ssh(),
         )
     }
 
diff --git a/crates/telemetry_events/src/telemetry_events.rs b/crates/telemetry_events/src/telemetry_events.rs
index 56e94edb44ac1d..a42b8cc8b5d808 100644
--- a/crates/telemetry_events/src/telemetry_events.rs
+++ b/crates/telemetry_events/src/telemetry_events.rs
@@ -117,6 +117,8 @@ pub struct EditorEvent {
     pub copilot_enabled: bool,
     /// Whether the user has copilot enabled for the language of the file opened or saved
     pub copilot_enabled_for_language: bool,
+    /// Whether the client is editing a local file or a remote file via SSH
+    pub is_via_ssh: bool,
 }
 
 /// Deprecated since Zed v0.137.0 (2024-05-29). Replaced by InlineCompletionEvent.

From d295c46433670118273c6c2b08e2416e13730ec9 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 8 Oct 2024 11:10:20 -0400
Subject: [PATCH 527/762] Remove deprecated copilot event (#18862)

`CopilotEvent` was succeeded by `InlineCompletionEvent` 5 months ago.

Release Notes:

- N/A
---
 crates/collab/src/api/events.rs                 |  2 --
 crates/telemetry_events/src/telemetry_events.rs | 10 ----------
 2 files changed, 12 deletions(-)

diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index f5cd1c00eae417..5d40c59daf548c 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -429,8 +429,6 @@ pub async fn post_events(
                 country_code.clone(),
                 checksum_matched,
             )),
-            // Needed for clients sending old copilot_event types
-            Event::Copilot(_) => {}
             Event::InlineCompletion(event) => {
                 to_upload
                     .inline_completion_events
diff --git a/crates/telemetry_events/src/telemetry_events.rs b/crates/telemetry_events/src/telemetry_events.rs
index a42b8cc8b5d808..32cb377ed616ab 100644
--- a/crates/telemetry_events/src/telemetry_events.rs
+++ b/crates/telemetry_events/src/telemetry_events.rs
@@ -91,7 +91,6 @@ impl Display for AssistantPhase {
 #[serde(tag = "type")]
 pub enum Event {
     Editor(EditorEvent),
-    Copilot(CopilotEvent), // Needed for clients sending old copilot_event types
     InlineCompletion(InlineCompletionEvent),
     Call(CallEvent),
     Assistant(AssistantEvent),
@@ -121,15 +120,6 @@ pub struct EditorEvent {
     pub is_via_ssh: bool,
 }
 
-/// Deprecated since Zed v0.137.0 (2024-05-29). Replaced by InlineCompletionEvent.
-// Needed for clients sending old copilot_event types
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct CopilotEvent {
-    pub suggestion_id: Option<String>,
-    pub suggestion_accepted: bool,
-    pub file_extension: Option<String>,
-}
-
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct InlineCompletionEvent {
     /// Provider of the completion suggestion (e.g. copilot, supermaven)

From ff7aa024eea8f89010c4c8afee943f10168ae05b Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 8 Oct 2024 17:47:24 +0200
Subject: [PATCH 528/762] remote server on macOS: Sign with entitlements
 (#18863)

This does two things:

- Prevent feature unification
- Sign the remote-server binary with the same entitlements we use for
Zed because we saw this in crash report:

Crashed Thread: 4 Dispatch queue: com.apple.root.user-initiated-qos

Exception Type: EXC_BAD_ACCESS (SIGKILL (Code Signature Invalid))
      Exception Codes:       UNKNOWN_0x32 at 0x0000000103636644
      Exception Codes:       0x0000000000000032, 0x0000000103636644

      Termination Reason:    Namespace CODESIGNING, Code 2 Invalid Page

VM Region Info: 0x103636644 is in 0x103634000-0x103638000; bytes after
start: 9796 bytes before end: 6587
REGION TYPE START - END [ VSIZE] PRT/MAX SHRMOD REGION DETAIL
VM_ALLOCATE 103630000-103634000 [ 16K] r--/rwx SM=ZER
---> VM_ALLOCATE 103634000-103638000 [ 16K] r-x/rwx SM=COW
VM_ALLOCATE 103638000-103640000 [ 32K] r--/rwx SM=ZER

  Which sounds a lot like codesigning/jit/entitlements stuff.


Release Notes:

- N/A

Co-authored-by: Piotr <piotr@zed.dev>
Co-authored-by: Bennet <bennet@zed.dev>
---
 script/bundle-mac | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/script/bundle-mac b/script/bundle-mac
index 4c17791812172f..bc95e1dd6a9285 100755
--- a/script/bundle-mac
+++ b/script/bundle-mac
@@ -83,7 +83,10 @@ if [ "$local_arch" = true ]; then
     cargo build ${build_flag} --package zed --package cli --package remote_server
 else
     echo "Compiling zed binaries"
-    cargo build ${build_flag} --package zed --package cli --package remote_server --target aarch64-apple-darwin --target x86_64-apple-darwin
+    cargo build ${build_flag} --package zed --package cli --target aarch64-apple-darwin --target x86_64-apple-darwin
+    # Build remote_server in separate invocation to prevent feature unification from other crates
+    # from influencing dynamic libraries required by it.
+    cargo build ${build_flag} --package remote_server     --target aarch64-apple-darwin --target x86_64-apple-darwin
 fi
 
 echo "Creating application bundle"
@@ -358,7 +361,7 @@ function sign_binary() {
 
     if [[ $can_code_sign = true ]]; then
         echo "Code signing executable $binary_path"
-        /usr/bin/codesign --deep --force --timestamp --options runtime --sign "$IDENTITY" "${binary_path}" -v
+        /usr/bin/codesign --deep --force --timestamp --options runtime --entitlements crates/zed/resources/zed.entitlements --sign "$IDENTITY" "${binary_path}" -v
     fi
 }
 

From 4139e2de235d9cdad9ecc6421e8f2a00ba8ff976 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Tue, 8 Oct 2024 08:58:28 -0700
Subject: [PATCH 529/762] In proposed change editors, apply diff hunks in
 batches (#18841)

Release Notes:

- N/A
---
 crates/editor/src/editor.rs         | 14 +++++++---
 crates/editor/src/hunk_diff.rs      |  4 +--
 crates/language/src/buffer.rs       | 40 +++++++++++++++++++++--------
 crates/language/src/buffer_tests.rs | 14 +++++-----
 4 files changed, 50 insertions(+), 22 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index d06f66184b4b4d..39bc2f45e551ab 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -6213,14 +6213,22 @@ impl Editor {
     fn apply_selected_diff_hunks(&mut self, _: &ApplyDiffHunk, cx: &mut ViewContext<Self>) {
         let snapshot = self.buffer.read(cx).snapshot(cx);
         let hunks = hunks_for_selections(&snapshot, &self.selections.disjoint_anchors());
+        let mut ranges_by_buffer = HashMap::default();
         self.transact(cx, |editor, cx| {
             for hunk in hunks {
                 if let Some(buffer) = editor.buffer.read(cx).buffer(hunk.buffer_id) {
-                    buffer.update(cx, |buffer, cx| {
-                        buffer.merge_into_base(Some(hunk.buffer_range.to_offset(buffer)), cx);
-                    });
+                    ranges_by_buffer
+                        .entry(buffer.clone())
+                        .or_insert_with(Vec::new)
+                        .push(hunk.buffer_range.to_offset(buffer.read(cx)));
                 }
             }
+
+            for (buffer, ranges) in ranges_by_buffer {
+                buffer.update(cx, |buffer, cx| {
+                    buffer.merge_into_base(ranges, cx);
+                });
+            }
         });
     }
 
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index 7fbb07ae35c79e..e495481323a6f4 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -350,7 +350,7 @@ impl Editor {
             .next()?;
 
         buffer.update(cx, |branch_buffer, cx| {
-            branch_buffer.merge_into_base(Some(range), cx);
+            branch_buffer.merge_into_base(vec![range], cx);
         });
 
         None
@@ -360,7 +360,7 @@ impl Editor {
         let buffers = self.buffer.read(cx).all_buffers();
         for branch_buffer in buffers {
             branch_buffer.update(cx, |branch_buffer, cx| {
-                branch_buffer.merge_into_base(None, cx);
+                branch_buffer.merge_into_base(Vec::new(), cx);
             });
         }
     }
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 160e8b3ba9aa96..59740509d3677c 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -827,25 +827,45 @@ impl Buffer {
         })
     }
 
-    /// Applies all of the changes in this buffer that intersect the given `range`
-    /// to its base buffer. This buffer must be a branch buffer to call this method.
-    pub fn merge_into_base(&mut self, range: Option<Range<usize>>, cx: &mut ModelContext<Self>) {
+    /// Applies all of the changes in this buffer that intersect any of the
+    /// given `ranges` to its base buffer.
+    ///
+    /// If `ranges` is empty, then all changes will be applied. This buffer must
+    /// be a branch buffer to call this method.
+    pub fn merge_into_base(&mut self, ranges: Vec<Range<usize>>, cx: &mut ModelContext<Self>) {
         let Some(base_buffer) = self.diff_base_buffer() else {
             debug_panic!("not a branch buffer");
             return;
         };
 
+        let mut ranges = if ranges.is_empty() {
+            &[0..usize::MAX]
+        } else {
+            ranges.as_slice()
+        }
+        .into_iter()
+        .peekable();
+
         let mut edits = Vec::new();
         for edit in self.edits_since::<usize>(&base_buffer.read(cx).version()) {
-            if let Some(range) = &range {
-                if range.start > edit.new.end || edit.new.start > range.end {
-                    continue;
+            let mut is_included = false;
+            while let Some(range) = ranges.peek() {
+                if range.end < edit.new.start {
+                    ranges.next().unwrap();
+                } else {
+                    if range.start <= edit.new.end {
+                        is_included = true;
+                    }
+                    break;
                 }
             }
-            edits.push((
-                edit.old.clone(),
-                self.text_for_range(edit.new.clone()).collect::<String>(),
-            ));
+
+            if is_included {
+                edits.push((
+                    edit.old.clone(),
+                    self.text_for_range(edit.new.clone()).collect::<String>(),
+                ));
+            }
         }
 
         let operation = base_buffer.update(cx, |base_buffer, cx| {
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index fe390d55101b0b..83c35cbeca56bd 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -2472,7 +2472,7 @@ fn test_branch_and_merge(cx: &mut TestAppContext) {
 
     // Merging the branch applies all of its changes to the base.
     branch_buffer.update(cx, |branch_buffer, cx| {
-        branch_buffer.merge_into_base(None, cx);
+        branch_buffer.merge_into_base(Vec::new(), cx);
     });
 
     branch_buffer.update(cx, |branch_buffer, cx| {
@@ -2494,7 +2494,7 @@ fn test_merge_into_base(cx: &mut TestAppContext) {
     // Make 3 edits, merge one into the base.
     branch.update(cx, |branch, cx| {
         branch.edit([(0..3, "ABC"), (7..9, "HI"), (11..11, "LMN")], None, cx);
-        branch.merge_into_base(Some(5..8), cx);
+        branch.merge_into_base(vec![5..8], cx);
     });
 
     branch.read_with(cx, |branch, _| assert_eq!(branch.text(), "ABCdefgHIjkLMN"));
@@ -2503,13 +2503,13 @@ fn test_merge_into_base(cx: &mut TestAppContext) {
     // Undo the one already-merged edit. Merge that into the base.
     branch.update(cx, |branch, cx| {
         branch.edit([(7..9, "hi")], None, cx);
-        branch.merge_into_base(Some(5..8), cx);
+        branch.merge_into_base(vec![5..8], cx);
     });
     base.read_with(cx, |base, _| assert_eq!(base.text(), "abcdefghijk"));
 
     // Merge an insertion into the base.
     branch.update(cx, |branch, cx| {
-        branch.merge_into_base(Some(11..11), cx);
+        branch.merge_into_base(vec![11..11], cx);
     });
 
     branch.read_with(cx, |branch, _| assert_eq!(branch.text(), "ABCdefghijkLMN"));
@@ -2518,7 +2518,7 @@ fn test_merge_into_base(cx: &mut TestAppContext) {
     // Deleted the inserted text and merge that into the base.
     branch.update(cx, |branch, cx| {
         branch.edit([(11..14, "")], None, cx);
-        branch.merge_into_base(Some(10..11), cx);
+        branch.merge_into_base(vec![10..11], cx);
     });
 
     base.read_with(cx, |base, _| assert_eq!(base.text(), "abcdefghijk"));
@@ -2534,7 +2534,7 @@ fn test_undo_after_merge_into_base(cx: &mut TestAppContext) {
     // Make 2 edits, merge one into the base.
     branch.update(cx, |branch, cx| {
         branch.edit([(0..3, "ABC"), (7..9, "HI")], None, cx);
-        branch.merge_into_base(Some(7..7), cx);
+        branch.merge_into_base(vec![7..7], cx);
     });
     base.read_with(cx, |base, _| assert_eq!(base.text(), "abcdefgHIjk"));
     branch.read_with(cx, |branch, _| assert_eq!(branch.text(), "ABCdefgHIjk"));
@@ -2548,7 +2548,7 @@ fn test_undo_after_merge_into_base(cx: &mut TestAppContext) {
 
     // Merge that operation into the base again.
     branch.update(cx, |branch, cx| {
-        branch.merge_into_base(Some(7..7), cx);
+        branch.merge_into_base(vec![7..7], cx);
     });
     base.read_with(cx, |base, _| assert_eq!(base.text(), "abcdefgHIjk"));
     branch.read_with(cx, |branch, _| assert_eq!(branch.text(), "ABCdefgHIjk"));

From 3da1902e24e81d472ed4389ae1f0c25715361a5f Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 8 Oct 2024 13:07:34 -0400
Subject: [PATCH 530/762] worktree: Depend on `rpc` with `test-support` feature
 in tests (#18866)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR updates the `worktree` crate to depend on `rpc` with the
`test-support` feature flag when running tests.

This fixes an issue I was seeing locally when trying to run tests in the
`worktree` crate:

```
λ cargo test -p worktree -- test_repository_subfolder_git_status
   Compiling worktree v0.1.0 (/Users/maxdeviant/projects/zed/crates/worktree)
error[E0432]: unresolved import `rpc::AnyProtoClient`
  --> crates/worktree/src/worktree.rs:39:18
   |
39 | use rpc::{proto, AnyProtoClient};
   |                  ^^^^^^^^^^^^^^ no `AnyProtoClient` in the root

For more information about this error, try `rustc --explain E0432`.
error: could not compile `worktree` (lib test) due to 1 previous error
```

Release Notes:

- N/A
---
 crates/worktree/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/worktree/Cargo.toml b/crates/worktree/Cargo.toml
index 41221d7b6e8186..9437358e1a4def 100644
--- a/crates/worktree/Cargo.toml
+++ b/crates/worktree/Cargo.toml
@@ -56,4 +56,5 @@ gpui = { workspace = true, features = ["test-support"] }
 http_client.workspace = true
 pretty_assertions.workspace = true
 rand.workspace = true
+rpc = { workspace = true, features = ["test-support"] }
 settings = { workspace = true, features = ["test-support"] }

From 77bf2ad0f14b33c2be817b1094321578edbcdccf Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 8 Oct 2024 13:13:40 -0400
Subject: [PATCH 531/762] Add is_via_ssh field to edit events (#18867)

Release Notes:

- N/A
---
 crates/client/src/telemetry.rs                  | 3 ++-
 crates/collab/src/api/events.rs                 | 2 ++
 crates/editor/src/editor.rs                     | 9 +++++++--
 crates/telemetry_events/src/telemetry_events.rs | 4 +++-
 crates/terminal_view/src/terminal_element.rs    | 6 +++---
 5 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index 24d448aa0202ff..5a752bc05f8abc 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -458,7 +458,7 @@ impl Telemetry {
         }))
     }
 
-    pub fn log_edit_event(self: &Arc<Self>, environment: &'static str) {
+    pub fn log_edit_event(self: &Arc<Self>, environment: &'static str, is_via_ssh: bool) {
         let mut state = self.state.lock();
         let period_data = state.event_coalescer.log_event(environment);
         drop(state);
@@ -467,6 +467,7 @@ impl Telemetry {
             let event = Event::Edit(EditEvent {
                 duration: end.timestamp_millis() - start.timestamp_millis(),
                 environment: environment.to_string(),
+                is_via_ssh,
             });
 
             self.report_event(event);
diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index 5d40c59daf548c..715f37449400c4 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -1263,6 +1263,7 @@ pub struct EditEventRow {
     period_start: i64,
     period_end: i64,
     environment: String,
+    is_via_ssh: bool,
 }
 
 impl EditEventRow {
@@ -1296,6 +1297,7 @@ impl EditEventRow {
             period_start: period_start.timestamp_millis(),
             period_end: period_end.timestamp_millis(),
             environment: event.environment,
+            is_via_ssh: event.is_via_ssh,
         }
     }
 }
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 39bc2f45e551ab..2f7c8ce5d7303a 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -12146,9 +12146,14 @@ impl Editor {
                 }
 
                 let Some(project) = &self.project else { return };
-                let telemetry = project.read(cx).client().telemetry().clone();
+                let (telemetry, is_via_ssh) = {
+                    let project = project.read(cx);
+                    let telemetry = project.client().telemetry().clone();
+                    let is_via_ssh = project.is_via_ssh();
+                    (telemetry, is_via_ssh)
+                };
                 refresh_linked_ranges(self, cx);
-                telemetry.log_edit_event("editor");
+                telemetry.log_edit_event("editor", is_via_ssh);
             }
             multi_buffer::Event::ExcerptsAdded {
                 buffer,
diff --git a/crates/telemetry_events/src/telemetry_events.rs b/crates/telemetry_events/src/telemetry_events.rs
index 32cb377ed616ab..32d2bde5c64a62 100644
--- a/crates/telemetry_events/src/telemetry_events.rs
+++ b/crates/telemetry_events/src/telemetry_events.rs
@@ -116,7 +116,7 @@ pub struct EditorEvent {
     pub copilot_enabled: bool,
     /// Whether the user has copilot enabled for the language of the file opened or saved
     pub copilot_enabled_for_language: bool,
-    /// Whether the client is editing a local file or a remote file via SSH
+    /// Whether the client is opening/saving a local file or a remote file via SSH
     pub is_via_ssh: bool,
 }
 
@@ -174,6 +174,8 @@ pub struct ActionEvent {
 pub struct EditEvent {
     pub duration: i64,
     pub environment: String,
+    /// Whether the edits occurred locally or remotely via SSH
+    pub is_via_ssh: bool,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
diff --git a/crates/terminal_view/src/terminal_element.rs b/crates/terminal_view/src/terminal_element.rs
index ce4be0e6797078..db87fd8dc2d597 100644
--- a/crates/terminal_view/src/terminal_element.rs
+++ b/crates/terminal_view/src/terminal_element.rs
@@ -1019,9 +1019,9 @@ impl InputHandler for TerminalInputHandler {
         self.workspace
             .update(cx, |this, cx| {
                 cx.invalidate_character_coordinates();
-
-                let telemetry = this.project().read(cx).client().telemetry().clone();
-                telemetry.log_edit_event("terminal");
+                let project = this.project().read(cx);
+                let telemetry = project.client().telemetry().clone();
+                telemetry.log_edit_event("terminal", project.is_via_ssh());
             })
             .ok();
     }

From 3f2de172aeb378813ddcdf96106bb48386b85ec6 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 8 Oct 2024 13:16:17 -0400
Subject: [PATCH 532/762] collab: Set cached token values when initially
 creating lifetime usage records (#18865)

This PR fixes an issue where we weren't setting the cached token fields
when initially creating a lifetime usage record.

Release Notes:

- N/A
---
 crates/collab/src/llm/db/queries/usages.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/collab/src/llm/db/queries/usages.rs b/crates/collab/src/llm/db/queries/usages.rs
index 128a42bc58791d..d703066913f8f5 100644
--- a/crates/collab/src/llm/db/queries/usages.rs
+++ b/crates/collab/src/llm/db/queries/usages.rs
@@ -382,6 +382,10 @@ impl LlmDatabase {
                         user_id: ActiveValue::set(user_id),
                         model_id: ActiveValue::set(model.id),
                         input_tokens: ActiveValue::set(input_token_count as i64),
+                        cache_creation_input_tokens: ActiveValue::set(
+                            cache_creation_input_tokens as i64,
+                        ),
+                        cache_read_input_tokens: ActiveValue::set(cache_read_input_tokens as i64),
                         output_tokens: ActiveValue::set(output_token_count as i64),
                         ..Default::default()
                     }

From af9a59577032bb24c393928bcde84e5282dd0c74 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Tue, 8 Oct 2024 19:32:52 +0200
Subject: [PATCH 533/762] ssh: Add tweaks to the UI (#18817)

Follow up to https://github.com/zed-industries/zed/pull/18727

---

Release Notes:

- N/A
---
 crates/recent_projects/src/dev_servers.rs     |  39 +++--
 crates/recent_projects/src/recent_projects.rs |   6 +-
 crates/recent_projects/src/ssh_connections.rs | 145 +++++++++++-------
 crates/title_bar/src/title_bar.rs             |  14 +-
 4 files changed, 122 insertions(+), 82 deletions(-)

diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index fa1d511791f87f..6171489872cd41 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -556,23 +556,28 @@ impl DevServerProjects {
                     .w_full()
                     .border_l_1()
                     .border_color(cx.theme().colors().border_variant)
-                    .my_1()
+                    .mb_1()
                     .mx_1p5()
-                    .py_0p5()
-                    .px_3()
+                    .pl_2()
                     .child(
                         List::new()
                             .empty_message("No projects.")
                             .children(ssh_connection.projects.iter().enumerate().map(|(pix, p)| {
-                                self.render_ssh_project(ix, &ssh_connection, pix, p, cx)
+                                v_flex().gap_0p5().child(self.render_ssh_project(
+                                    ix,
+                                    &ssh_connection,
+                                    pix,
+                                    p,
+                                    cx,
+                                ))
                             }))
                             .child(
-                                h_flex().child(
+                                h_flex().mt_1().pl_1().child(
                                     Button::new("new-remote_project", "Open Folder…")
-                                        .icon(IconName::Plus)
                                         .size(ButtonSize::Default)
-                                        .style(ButtonStyle::Filled)
                                         .layer(ElevationIndex::ModalSurface)
+                                        .icon(IconName::Plus)
+                                        .icon_color(Color::Muted)
                                         .icon_position(IconPosition::Start)
                                         .on_click(cx.listener(move |this, _, cx| {
                                             this.create_ssh_project(ix, ssh_connection.clone(), cx);
@@ -593,9 +598,15 @@ impl DevServerProjects {
     ) -> impl IntoElement {
         let project = project.clone();
         let server = server.clone();
+
         ListItem::new(("remote-project", ix))
+            .inset(true)
             .spacing(ui::ListItemSpacing::Sparse)
-            .start_slot(Icon::new(IconName::Folder).color(Color::Muted))
+            .start_slot(
+                Icon::new(IconName::Folder)
+                    .color(Color::Muted)
+                    .size(IconSize::Small),
+            )
             .child(Label::new(project.paths.join(", ")))
             .on_click(cx.listener(move |this, _, cx| {
                 let Some(app_state) = this
@@ -635,7 +646,7 @@ impl DevServerProjects {
                     .on_click(
                         cx.listener(move |this, _, cx| this.delete_ssh_project(server_ix, ix, cx)),
                     )
-                    .tooltip(|cx| Tooltip::text("Delete remote project", cx))
+                    .tooltip(|cx| Tooltip::text("Delete Remote Project", cx))
                     .into_any_element(),
             ))
     }
@@ -709,6 +720,7 @@ impl DevServerProjects {
             })
         });
         let theme = cx.theme();
+
         v_flex()
             .id("create-dev-server")
             .overflow_hidden()
@@ -763,6 +775,7 @@ impl DevServerProjects {
             .child(
                 h_flex()
                     .bg(theme.colors().editor_background)
+                    .rounded_b_md()
                     .w_full()
                     .map(|this| {
                         if let Some(ssh_prompt) = ssh_prompt {
@@ -773,9 +786,8 @@ impl DevServerProjects {
                                 h_flex()
                                     .p_2()
                                     .w_full()
-                                    .content_center()
-                                    .gap_2()
-                                    .child(h_flex().w_full())
+                                    .justify_center()
+                                    .gap_1p5()
                                     .child(
                                         div().p_1().rounded_lg().bg(color).with_animation(
                                             "pulse-ssh-waiting-for-connection",
@@ -788,8 +800,7 @@ impl DevServerProjects {
                                     .child(
                                         Label::new("Waiting for connection…")
                                             .size(LabelSize::Small),
-                                    )
-                                    .child(h_flex().w_full()),
+                                    ),
                             )
                         }
                     }),
diff --git a/crates/recent_projects/src/recent_projects.rs b/crates/recent_projects/src/recent_projects.rs
index f73e7069d48a94..2285ed6287895e 100644
--- a/crates/recent_projects/src/recent_projects.rs
+++ b/crates/recent_projects/src/recent_projects.rs
@@ -566,7 +566,7 @@ impl PickerDelegate for RecentProjectsDelegate {
                 .border_t_1()
                 .py_2()
                 .pr_2()
-                .border_color(cx.theme().colors().border)
+                .border_color(cx.theme().colors().border_variant)
                 .justify_end()
                 .gap_4()
                 .child(
@@ -574,7 +574,7 @@ impl PickerDelegate for RecentProjectsDelegate {
                         .when_some(KeyBinding::for_action(&OpenRemote, cx), |button, key| {
                             button.child(key)
                         })
-                        .child(Label::new("Open remote folder…").color(Color::Muted))
+                        .child(Label::new("Open Remote Folder…").color(Color::Muted))
                         .on_click(|_, cx| cx.dispatch_action(OpenRemote.boxed_clone())),
                 )
                 .child(
@@ -583,7 +583,7 @@ impl PickerDelegate for RecentProjectsDelegate {
                             KeyBinding::for_action(&workspace::Open, cx),
                             |button, key| button.child(key),
                         )
-                        .child(Label::new("Open local folder…").color(Color::Muted))
+                        .child(Label::new("Open Local Folder…").color(Color::Muted))
                         .on_click(|_, cx| cx.dispatch_action(workspace::Open.boxed_clone())),
                 )
                 .into_any(),
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 5862d48e8182b5..2e41d56468682e 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -16,9 +16,9 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 use ui::{
-    div, h_flex, v_flex, ActiveTheme, ButtonCommon, Clickable, Color, FluentBuilder as _, Icon,
-    IconButton, IconName, IconSize, InteractiveElement, IntoElement, Label, LabelCommon, Styled,
-    StyledExt as _, Tooltip, ViewContext, VisualContext, WindowContext,
+    div, h_flex, prelude::*, v_flex, ActiveTheme, ButtonCommon, Clickable, Color, Icon, IconButton,
+    IconName, IconSize, InteractiveElement, IntoElement, Label, LabelCommon, Styled, Tooltip,
+    ViewContext, VisualContext, WindowContext,
 };
 use workspace::{AppState, ModalView, Workspace};
 
@@ -84,6 +84,7 @@ pub struct SshPrompt {
 pub struct SshConnectionModal {
     pub(crate) prompt: View<SshPrompt>,
 }
+
 impl SshPrompt {
     pub fn new(connection_options: &SshConnectionOptions, cx: &mut ViewContext<Self>) -> Self {
         let connection_string = connection_options.connection_string().into();
@@ -136,57 +137,70 @@ impl SshPrompt {
 }
 
 impl Render for SshPrompt {
-    fn render(&mut self, _: &mut ViewContext<Self>) -> impl IntoElement {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let cx = cx.window_context();
+        let theme = cx.theme();
         v_flex()
-            .w_full()
             .key_context("PasswordPrompt")
-            .justify_start()
+            .size_full()
+            .justify_center()
             .child(
-                v_flex()
-                    .p_4()
-                    .size_full()
-                    .child(
-                        h_flex()
-                            .gap_2()
-                            .justify_between()
-                            .child(h_flex().w_full())
-                            .child(if self.error_message.is_some() {
-                                Icon::new(IconName::XCircle)
-                                    .size(IconSize::Medium)
-                                    .color(Color::Error)
-                                    .into_any_element()
-                            } else {
-                                Icon::new(IconName::ArrowCircle)
-                                    .size(IconSize::Medium)
-                                    .with_animation(
-                                        "arrow-circle",
-                                        Animation::new(Duration::from_secs(2)).repeat(),
-                                        |icon, delta| {
-                                            icon.transform(Transformation::rotate(percentage(
-                                                delta,
-                                            )))
-                                        },
-                                    )
-                                    .into_any_element()
-                            })
-                            .child(Label::new(format!(
-                                "Connecting to {}…",
-                                self.connection_string
-                            )))
-                            .child(h_flex().w_full()),
-                    )
-                    .when_some(self.error_message.as_ref(), |el, error| {
-                        el.child(Label::new(error.clone()))
+                h_flex()
+                    .py_2()
+                    .px_4()
+                    .justify_center()
+                    .child(if self.error_message.is_some() {
+                        Icon::new(IconName::XCircle)
+                            .size(IconSize::Medium)
+                            .color(Color::Error)
+                            .into_any_element()
+                    } else {
+                        Icon::new(IconName::ArrowCircle)
+                            .size(IconSize::Medium)
+                            .with_animation(
+                                "arrow-circle",
+                                Animation::new(Duration::from_secs(2)).repeat(),
+                                |icon, delta| {
+                                    icon.transform(Transformation::rotate(percentage(delta)))
+                                },
+                            )
+                            .into_any_element()
                     })
-                    .when(
-                        self.error_message.is_none() && self.status_message.is_some(),
-                        |el| el.child(Label::new(self.status_message.clone().unwrap())),
+                    .child(
+                        div()
+                            .ml_1()
+                            .child(Label::new("SSH Connection").size(LabelSize::Small)),
                     )
-                    .when_some(self.prompt.as_ref(), |el, prompt| {
-                        el.child(Label::new(prompt.0.clone()))
-                            .child(self.editor.clone())
-                    }),
+                    .child(
+                        div()
+                            .when_some(self.error_message.as_ref(), |el, error| {
+                                el.child(Label::new(format!("－{}", error)).size(LabelSize::Small))
+                            })
+                            .when(
+                                self.error_message.is_none() && self.status_message.is_some(),
+                                |el| {
+                                    el.child(
+                                        Label::new(format!(
+                                            "－{}",
+                                            self.status_message.clone().unwrap()
+                                        ))
+                                        .size(LabelSize::Small),
+                                    )
+                                },
+                            ),
+                    ),
             )
+            .child(div().when_some(self.prompt.as_ref(), |el, prompt| {
+                el.child(
+                    h_flex()
+                        .p_4()
+                        .border_t_1()
+                        .border_color(theme.colors().border_variant)
+                        .font_buffer(cx)
+                        .child(Label::new(prompt.0.clone()))
+                        .child(self.editor.clone()),
+                )
+            }))
     }
 }
 
@@ -210,39 +224,54 @@ impl Render for SshConnectionModal {
     fn render(&mut self, cx: &mut ui::ViewContext<Self>) -> impl ui::IntoElement {
         let connection_string = self.prompt.read(cx).connection_string.clone();
         let theme = cx.theme();
-        let header_color = theme.colors().element_background;
-        let body_color = theme.colors().background;
+        let mut header_color = cx.theme().colors().text;
+        header_color.fade_out(0.96);
+        let body_color = theme.colors().editor_background;
+
         v_flex()
             .elevation_3(cx)
             .on_action(cx.listener(Self::dismiss))
             .on_action(cx.listener(Self::confirm))
-            .w(px(400.))
+            .w(px(500.))
+            .border_1()
+            .border_color(theme.colors().border)
             .child(
                 h_flex()
+                    .relative()
                     .p_1()
+                    .rounded_t_md()
                     .border_b_1()
                     .border_color(theme.colors().border)
                     .bg(header_color)
                     .justify_between()
                     .child(
-                        IconButton::new("ssh-connection-cancel", IconName::ArrowLeft)
-                            .icon_size(IconSize::XSmall)
-                            .on_click(|_, cx| cx.dispatch_action(menu::Cancel.boxed_clone()))
-                            .tooltip(|cx| Tooltip::for_action("Back", &menu::Cancel, cx)),
+                        div().absolute().left_0p5().top_0p5().child(
+                            IconButton::new("ssh-connection-cancel", IconName::ArrowLeft)
+                                .icon_size(IconSize::XSmall)
+                                .on_click(|_, cx| cx.dispatch_action(menu::Cancel.boxed_clone()))
+                                .tooltip(|cx| Tooltip::for_action("Back", &menu::Cancel, cx)),
+                        ),
                     )
                     .child(
                         h_flex()
+                            .w_full()
                             .gap_2()
+                            .justify_center()
                             .child(Icon::new(IconName::Server).size(IconSize::XSmall))
                             .child(
                                 Label::new(connection_string)
                                     .size(ui::LabelSize::Small)
                                     .single_line(),
                             ),
-                    )
-                    .child(div()),
+                    ),
+            )
+            .child(
+                h_flex()
+                    .rounded_b_md()
+                    .bg(body_color)
+                    .w_full()
+                    .child(self.prompt.clone()),
             )
-            .child(h_flex().bg(body_color).w_full().child(self.prompt.clone()))
     }
 }
 
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index da0179fd64dcbe..6fda4d594fe50e 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -24,8 +24,8 @@ use smallvec::SmallVec;
 use std::sync::Arc;
 use theme::ActiveTheme;
 use ui::{
-    h_flex, prelude::*, Avatar, Button, ButtonLike, ButtonStyle, ContextMenu, Icon, IconName,
-    Indicator, PopoverMenu, Tooltip,
+    h_flex, prelude::*, Avatar, Button, ButtonLike, ButtonStyle, ContextMenu, Icon,
+    IconButtonShape, IconName, IconSize, Indicator, PopoverMenu, Tooltip,
 };
 use util::ResultExt;
 use vcs_menu::{BranchList, OpenRecent as ToggleVcsMenu};
@@ -274,18 +274,19 @@ impl TitleBar {
         };
         let indicator = div()
             .absolute()
-            .w_1_4()
-            .h_1_4()
+            .size_1p5()
             .right_0p5()
             .bottom_0p5()
-            .p_1()
-            .rounded_2xl()
+            .rounded_full()
             .bg(indicator_color.color(cx));
 
         Some(
             div()
+                .relative()
                 .child(
                     IconButton::new("ssh-server-icon", IconName::Server)
+                        .icon_size(IconSize::Small)
+                        .shape(IconButtonShape::Square)
                         .tooltip(move |cx| {
                             Tooltip::with_meta(
                                 "Remote Project",
@@ -294,7 +295,6 @@ impl TitleBar {
                                 cx,
                             )
                         })
-                        .shape(ui::IconButtonShape::Square)
                         .on_click(|_, cx| {
                             cx.dispatch_action(OpenRemote.boxed_clone());
                         }),

From 5377674fc05ff151750767d19a0026f28c8df67a Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 8 Oct 2024 13:54:11 -0400
Subject: [PATCH 534/762] csharp: Add support for triple-slash doc comments
 (#18869)

This PR adds support for triple-slash (`///`) doc comments in C#.

As requested by https://github.com/zed-industries/zed/issues/18766.

Release Notes:

- N/A
---
 extensions/csharp/languages/csharp/config.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/extensions/csharp/languages/csharp/config.toml b/extensions/csharp/languages/csharp/config.toml
index fd0e13b6c2d652..8f07b45e3bcff2 100644
--- a/extensions/csharp/languages/csharp/config.toml
+++ b/extensions/csharp/languages/csharp/config.toml
@@ -2,7 +2,7 @@ name = "CSharp"
 code_fence_block_name = "csharp"
 grammar = "c_sharp"
 path_suffixes = ["cs"]
-line_comments = ["// "]
+line_comments = ["// ", "/// "]
 autoclose_before = ";:.,=}])>"
 brackets = [
     { start = "{", end = "}", close = true, newline = true },

From 7960468d8a6270f2b5aaca90f739cebf0cba864c Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 8 Oct 2024 14:25:29 -0400
Subject: [PATCH 535/762] dart: Bump to v0.1.1 (#18859)

- Includes https://github.com/zed-industries/zed/pull/18845
---
 Cargo.lock                     | 2 +-
 extensions/dart/Cargo.toml     | 2 +-
 extensions/dart/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index dda10e2edc018a..1bae8d98503186 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14750,7 +14750,7 @@ dependencies = [
 
 [[package]]
 name = "zed_dart"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/dart/Cargo.toml b/extensions/dart/Cargo.toml
index d1b4b290baa51a..3d79e104c105c6 100644
--- a/extensions/dart/Cargo.toml
+++ b/extensions/dart/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_dart"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/dart/extension.toml b/extensions/dart/extension.toml
index 48cd8476181fdf..5ea8c37c2f917f 100644
--- a/extensions/dart/extension.toml
+++ b/extensions/dart/extension.toml
@@ -1,7 +1,7 @@
 id = "dart"
 name = "Dart"
 description = "Dart support."
-version = "0.1.0"
+version = "0.1.1"
 schema_version = 1
 authors = ["Abdullah Alsigar <abdullah.alsigar@gmail.com>", "Flo <flo80@users.noreply.github.com>", "ybbond <hi@ybbond.id>"]
 repository = "https://github.com/zed-industries/zed"

From f33019c885dc8ad1e6cfbcd3f36d5383e14b491f Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 8 Oct 2024 16:13:56 -0400
Subject: [PATCH 536/762] Document extension bump process (#18872)

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 extensions/README.md              | 63 +++++++++++++++++++++++++++++++
 script/language-extension-version | 29 ++++++++++++++
 2 files changed, 92 insertions(+)
 create mode 100644 extensions/README.md
 create mode 100755 script/language-extension-version

diff --git a/extensions/README.md b/extensions/README.md
new file mode 100644
index 00000000000000..c677e0b909c0a3
--- /dev/null
+++ b/extensions/README.md
@@ -0,0 +1,63 @@
+# Zed Extensions
+
+This directory contains extensions for Zed that are largely maintained by the Zed team. They currently live in the Zed repository for ease of maintenance.
+
+If you are looking for the Zed extension registry, see the [`zed-industries/extensions`](https://github.com/zed-industries/extensions) repo.
+
+## Structure
+
+Currently, Zed includes support for a number of languages without requiring installing an extension. Those languages can be found under [`crates/languages/src`](https://github.com/zed-industries/zed/tree/main/crates/languages/src).
+
+Support for all other languages is done via extensions. This directory ([extensions/](https://github.com/zed-industries/zed/tree/main/extensions/)) contains a number of officially maintained extensions. These extensions use the same [zed_extension_api](https://docs.rs/zed_extension_api/latest/zed_extension_api/) available to all [Zed Extensions](https://zed.dev/extensions) for providing [language servers](https://zed.dev/docs/extensions/languages#language-servers), [tree-sitter grammars](https://zed.dev/docs/extensions/languages#grammar) and [tree-sitter queries](https://zed.dev/docs/extensions/languages#tree-sitter-queries).
+
+## Dev Extensions
+
+See the docs for [Developing an Extension Locally](https://zed.dev/docs/extensions/developing-extensions#developing-an-extension-locally) for how to work with one of these extensions.
+
+## Updating
+
+> [!NOTE]
+> This update process is usually handled by Zed staff.
+> Community contributors should just submit a PR (step 1) and we'll take it from there.
+
+The process for updating an extension in this directory has three parts.
+
+1. Create a PR with your changes. (Merge it)
+2. Bump the extension version in:
+
+   - extensions/{language_name}/extension.toml
+   - extensions/{language_name}/Cargo.toml
+   - Cargo.lock
+
+   You can do this manually, or with a script:
+
+   ```sh
+   # Output the current version for a given language
+   ./script/language-extension-version <langname>
+
+   # Update the version in `extension.toml` and `Cargo.toml` and trigger a `cargo check`
+   ./script/language-extension-version <langname> <new_version>
+   ```
+
+   Commit your changes to a branch, push a PR and merge it.
+
+3. Open a PR to [`zed-industries/extensions`](https://github.com/zed-industries/extensions) repo that updates the extension in question
+
+Edit [`extensions.toml`](https://github.com/zed-industries/extensions/blob/main/extensions.toml) in the extensions repo to reflect the new version you set above and update the submodule latest Zed commit.
+
+```sh
+# Go into your clone of the extensions repo
+cd ../extensions
+
+# Update
+git checkout main
+git pull
+just init-submodule extensions/zed
+
+# Update the Zed submodule
+cd extensions/zed
+git checkout main
+git pull
+cd -
+git add extensions.toml extensions/zed
+```
diff --git a/script/language-extension-version b/script/language-extension-version
new file mode 100755
index 00000000000000..fc5c4487368e62
--- /dev/null
+++ b/script/language-extension-version
@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+set -euox pipefail
+
+if [ "$#" -lt 1 ]; then
+  echo "Usage: $0 <language> [version]"
+  exit 1
+fi
+
+LANGUAGE=$1
+VERSION=${2:-}
+
+EXTENSION_DIR="extensions/$LANGUAGE"
+EXTENSION_TOML="$EXTENSION_DIR/extension.toml"
+CARGO_TOML="$EXTENSION_DIR/Cargo.toml"
+
+if [ ! -d "$EXTENSION_DIR" ]; then
+  echo "Directory $EXTENSION_DIR does not exist."
+  exit 1
+fi
+
+if [ -z "$VERSION" ]; then
+  grep -m 1 'version =' "$EXTENSION_TOML" | awk -F\" '{print $2}'
+  exit 0
+fi
+
+sed -i '' -e "s/^version = \".*\"/version = \"$VERSION\"/" "$EXTENSION_TOML"
+sed -i '' -e "s/^version = \".*\"/version = \"$VERSION\"/" "$CARGO_TOML"
+cargo check

From 744891f15f47a69acff0183737b239cc0b10d242 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 8 Oct 2024 16:16:38 -0400
Subject: [PATCH 537/762] Provide a default value for `is_via_ssh` when it
 isn't sent via older clients (#18874)

Release Notes:

- N/A
---
 crates/telemetry_events/src/telemetry_events.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/telemetry_events/src/telemetry_events.rs b/crates/telemetry_events/src/telemetry_events.rs
index 32d2bde5c64a62..14bcf985bf0da6 100644
--- a/crates/telemetry_events/src/telemetry_events.rs
+++ b/crates/telemetry_events/src/telemetry_events.rs
@@ -117,6 +117,7 @@ pub struct EditorEvent {
     /// Whether the user has copilot enabled for the language of the file opened or saved
     pub copilot_enabled_for_language: bool,
     /// Whether the client is opening/saving a local file or a remote file via SSH
+    #[serde(default)]
     pub is_via_ssh: bool,
 }
 
@@ -175,6 +176,7 @@ pub struct EditEvent {
     pub duration: i64,
     pub environment: String,
     /// Whether the edits occurred locally or remotely via SSH
+    #[serde(default)]
     pub is_via_ssh: bool,
 }
 

From a95fb8f1f9cd8c9761fc638c4ff2552e2f3f973a Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Tue, 8 Oct 2024 23:37:04 +0200
Subject: [PATCH 538/762] ssh: Fix text wrapping in loading text (#18876)

This PR adds `flex_wrap` to the loading text container to prevent the
loading modal layout to break.

Release Notes:

- N/A
---
 crates/recent_projects/src/ssh_connections.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 2e41d56468682e..ebac54385d2963 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -146,9 +146,9 @@ impl Render for SshPrompt {
             .justify_center()
             .child(
                 h_flex()
-                    .py_2()
-                    .px_4()
+                    .p_2()
                     .justify_center()
+                    .flex_wrap()
                     .child(if self.error_message.is_some() {
                         Icon::new(IconName::XCircle)
                             .size(IconSize::Medium)
@@ -173,6 +173,8 @@ impl Render for SshPrompt {
                     )
                     .child(
                         div()
+                            .text_ellipsis()
+                            .overflow_x_hidden()
                             .when_some(self.error_message.as_ref(), |el, error| {
                                 el.child(Label::new(format!("－{}", error)).size(LabelSize::Small))
                             })

From f861479890068aa66c73cff4dfe9ed0f4b74b17f Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 8 Oct 2024 18:29:38 -0400
Subject: [PATCH 539/762] collab: Update billing code for LLM usage billing
 (#18879)

This PR reworks our existing billing code in preparation for charging
based on LLM usage.

We aren't yet exercising the new billing-related code outside of
development.

There are some noteworthy changes for our existing LLM usage tracking:

- A new `monthly_usages` table has been added for tracking usage
per-user, per-model, per-month
- The per-month usage measures have been removed, in favor of the
`monthly_usages` table
- All of the per-month metrics in the Clickhouse rows have been changed
from a rolling 30-day window to a calendar month

Release Notes:

- N/A

---------

Co-authored-by: Antonio Scandurra <me@as-cii.com>
Co-authored-by: Richard <richard@zed.dev>
Co-authored-by: Max <max@zed.dev>
---
 .../20241008155620_create_monthly_usages.sql  |  13 +
 crates/collab/src/api/billing.rs              | 103 +++++++-
 .../src/db/queries/billing_subscriptions.rs   |  23 ++
 crates/collab/src/lib.rs                      |   8 +-
 crates/collab/src/llm.rs                      |  16 +-
 crates/collab/src/llm/db.rs                   |   8 +
 crates/collab/src/llm/db/queries/usages.rs    | 230 +++++++++++-------
 crates/collab/src/llm/db/tables.rs            |   1 +
 .../collab/src/llm/db/tables/monthly_usage.rs |  22 ++
 .../collab/src/llm/db/tables/usage_measure.rs |   4 -
 crates/collab/src/llm/db/tests/usage_tests.rs |  32 +--
 crates/collab/src/llm/token.rs                |   8 +
 crates/collab/src/main.rs                     |  25 +-
 crates/collab/src/rpc.rs                      |  27 +-
 crates/collab/src/tests/test_server.rs        |   2 +-
 15 files changed, 390 insertions(+), 132 deletions(-)
 create mode 100644 crates/collab/migrations_llm/20241008155620_create_monthly_usages.sql
 create mode 100644 crates/collab/src/llm/db/tables/monthly_usage.rs

diff --git a/crates/collab/migrations_llm/20241008155620_create_monthly_usages.sql b/crates/collab/migrations_llm/20241008155620_create_monthly_usages.sql
new file mode 100644
index 00000000000000..2733552a3a16f2
--- /dev/null
+++ b/crates/collab/migrations_llm/20241008155620_create_monthly_usages.sql
@@ -0,0 +1,13 @@
+create table monthly_usages (
+    id serial primary key,
+    user_id integer not null,
+    model_id integer not null references models (id) on delete cascade,
+    month integer not null,
+    year integer not null,
+    input_tokens bigint not null default 0,
+    cache_creation_input_tokens bigint not null default 0,
+    cache_read_input_tokens bigint not null default 0,
+    output_tokens bigint not null default 0
+);
+
+create unique index uix_monthly_usages_on_user_id_model_id_month_year on monthly_usages (user_id, model_id, month, year);
diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index 23a16590cac630..b70fc1e3ba32d3 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -22,12 +22,15 @@ use stripe::{
 };
 use util::ResultExt;
 
-use crate::db::billing_subscription::StripeSubscriptionStatus;
+use crate::db::billing_subscription::{self, StripeSubscriptionStatus};
 use crate::db::{
     billing_customer, BillingSubscriptionId, CreateBillingCustomerParams,
     CreateBillingSubscriptionParams, CreateProcessedStripeEventParams, UpdateBillingCustomerParams,
     UpdateBillingSubscriptionParams,
 };
+use crate::llm::db::LlmDatabase;
+use crate::llm::MONTHLY_SPENDING_LIMIT_IN_CENTS;
+use crate::rpc::ResultExt as _;
 use crate::{AppState, Error, Result};
 
 pub fn router() -> Router {
@@ -79,7 +82,7 @@ async fn list_billing_subscriptions(
             .into_iter()
             .map(|subscription| BillingSubscriptionJson {
                 id: subscription.id,
-                name: "Zed Pro".to_string(),
+                name: "Zed LLM Usage".to_string(),
                 status: subscription.stripe_subscription_status,
                 cancel_at: subscription.stripe_cancel_at.map(|cancel_at| {
                     cancel_at
@@ -117,7 +120,7 @@ async fn create_billing_subscription(
     let Some((stripe_client, stripe_price_id)) = app
         .stripe_client
         .clone()
-        .zip(app.config.stripe_price_id.clone())
+        .zip(app.config.stripe_llm_usage_price_id.clone())
     else {
         log::error!("failed to retrieve Stripe client or price ID");
         Err(Error::http(
@@ -150,7 +153,7 @@ async fn create_billing_subscription(
         params.client_reference_id = Some(user.github_login.as_str());
         params.line_items = Some(vec![CreateCheckoutSessionLineItems {
             price: Some(stripe_price_id.to_string()),
-            quantity: Some(1),
+            quantity: Some(0),
             ..Default::default()
         }]);
         let success_url = format!("{}/account", app.config.zed_dot_dev_url());
@@ -631,3 +634,95 @@ async fn find_or_create_billing_customer(
 
     Ok(Some(billing_customer))
 }
+
+const SYNC_LLM_USAGE_WITH_STRIPE_INTERVAL: Duration = Duration::from_secs(24 * 60 * 60);
+
+pub fn sync_llm_usage_with_stripe_periodically(app: Arc<AppState>, llm_db: LlmDatabase) {
+    let Some(stripe_client) = app.stripe_client.clone() else {
+        log::warn!("failed to retrieve Stripe client");
+        return;
+    };
+    let Some(stripe_llm_usage_price_id) = app.config.stripe_llm_usage_price_id.clone() else {
+        log::warn!("failed to retrieve Stripe LLM usage price ID");
+        return;
+    };
+
+    let executor = app.executor.clone();
+    executor.spawn_detached({
+        let executor = executor.clone();
+        async move {
+            loop {
+                sync_with_stripe(
+                    &app,
+                    &llm_db,
+                    &stripe_client,
+                    stripe_llm_usage_price_id.clone(),
+                )
+                .await
+                .trace_err();
+
+                executor.sleep(SYNC_LLM_USAGE_WITH_STRIPE_INTERVAL).await;
+            }
+        }
+    });
+}
+
+async fn sync_with_stripe(
+    app: &Arc<AppState>,
+    llm_db: &LlmDatabase,
+    stripe_client: &stripe::Client,
+    stripe_llm_usage_price_id: Arc<str>,
+) -> anyhow::Result<()> {
+    let subscriptions = app.db.get_active_billing_subscriptions().await?;
+
+    for (customer, subscription) in subscriptions {
+        update_stripe_subscription(
+            llm_db,
+            stripe_client,
+            &stripe_llm_usage_price_id,
+            customer,
+            subscription,
+        )
+        .await
+        .log_err();
+    }
+
+    Ok(())
+}
+
+async fn update_stripe_subscription(
+    llm_db: &LlmDatabase,
+    stripe_client: &stripe::Client,
+    stripe_llm_usage_price_id: &Arc<str>,
+    customer: billing_customer::Model,
+    subscription: billing_subscription::Model,
+) -> Result<(), anyhow::Error> {
+    let monthly_spending = llm_db
+        .get_user_spending_for_month(customer.user_id, Utc::now())
+        .await?;
+    let subscription_id = SubscriptionId::from_str(&subscription.stripe_subscription_id)
+        .context("failed to parse subscription ID")?;
+
+    let monthly_spending_over_free_tier =
+        monthly_spending.saturating_sub(MONTHLY_SPENDING_LIMIT_IN_CENTS);
+
+    let new_quantity = (monthly_spending_over_free_tier as f32 / 100.).ceil();
+    Subscription::update(
+        stripe_client,
+        &subscription_id,
+        stripe::UpdateSubscription {
+            items: Some(vec![stripe::UpdateSubscriptionItems {
+                // TODO: Do we need to send up the `id` if a subscription item
+                // with this price already exists, or will Stripe take care of
+                // it?
+                id: None,
+                price: Some(stripe_llm_usage_price_id.to_string()),
+                quantity: Some(new_quantity as u64),
+                ..Default::default()
+            }]),
+            ..Default::default()
+        },
+    )
+    .await?;
+    Ok(())
+}
diff --git a/crates/collab/src/db/queries/billing_subscriptions.rs b/crates/collab/src/db/queries/billing_subscriptions.rs
index 7a7ba31f166988..bcf093bebd4240 100644
--- a/crates/collab/src/db/queries/billing_subscriptions.rs
+++ b/crates/collab/src/db/queries/billing_subscriptions.rs
@@ -112,6 +112,29 @@ impl Database {
         .await
     }
 
+    pub async fn get_active_billing_subscriptions(
+        &self,
+    ) -> Result<Vec<(billing_customer::Model, billing_subscription::Model)>> {
+        self.transaction(|tx| async move {
+            let mut result = Vec::new();
+            let mut rows = billing_subscription::Entity::find()
+                .inner_join(billing_customer::Entity)
+                .select_also(billing_customer::Entity)
+                .order_by_asc(billing_subscription::Column::Id)
+                .stream(&*tx)
+                .await?;
+
+            while let Some(row) = rows.next().await {
+                if let (subscription, Some(customer)) = row? {
+                    result.push((customer, subscription));
+                }
+            }
+
+            Ok(result)
+        })
+        .await
+    }
+
     /// Returns whether the user has an active billing subscription.
     pub async fn has_active_billing_subscription(&self, user_id: UserId) -> Result<bool> {
         Ok(self.count_active_billing_subscriptions(user_id).await? > 0)
diff --git a/crates/collab/src/lib.rs b/crates/collab/src/lib.rs
index 6c32023a97a287..ccecf80087aacb 100644
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -174,7 +174,7 @@ pub struct Config {
     pub slack_panics_webhook: Option<String>,
     pub auto_join_channel_id: Option<ChannelId>,
     pub stripe_api_key: Option<String>,
-    pub stripe_price_id: Option<Arc<str>>,
+    pub stripe_llm_usage_price_id: Option<Arc<str>>,
     pub supermaven_admin_api_key: Option<Arc<str>>,
     pub user_backfiller_github_access_token: Option<Arc<str>>,
 }
@@ -193,6 +193,10 @@ impl Config {
         }
     }
 
+    pub fn is_llm_billing_enabled(&self) -> bool {
+        self.stripe_llm_usage_price_id.is_some()
+    }
+
     #[cfg(test)]
     pub fn test() -> Self {
         Self {
@@ -231,7 +235,7 @@ impl Config {
             migrations_path: None,
             seed_path: None,
             stripe_api_key: None,
-            stripe_price_id: None,
+            stripe_llm_usage_price_id: None,
             supermaven_admin_api_key: None,
             user_backfiller_github_access_token: None,
         }
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index 9809985ac72b23..96413cf7c56710 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -436,6 +436,9 @@ fn normalize_model_name(known_models: Vec<String>, name: String) -> String {
     }
 }
 
+/// The maximum monthly spending an individual user can reach before they have to pay.
+pub const MONTHLY_SPENDING_LIMIT_IN_CENTS: usize = 5 * 100;
+
 /// The maximum lifetime spending an individual user can reach before being cut off.
 ///
 /// Represented in cents.
@@ -458,6 +461,18 @@ async fn check_usage_limit(
         )
         .await?;
 
+    if state.config.is_llm_billing_enabled() {
+        if usage.spending_this_month >= MONTHLY_SPENDING_LIMIT_IN_CENTS {
+            if !claims.has_llm_subscription.unwrap_or(false) {
+                return Err(Error::http(
+                    StatusCode::PAYMENT_REQUIRED,
+                    "Maximum spending limit reached for this month.".to_string(),
+                ));
+            }
+        }
+    }
+
+    // TODO: Remove this once we've rolled out monthly spending limits.
     if usage.lifetime_spending >= LIFETIME_SPENDING_LIMIT_IN_CENTS {
         return Err(Error::http(
             StatusCode::FORBIDDEN,
@@ -505,7 +520,6 @@ async fn check_usage_limit(
                 UsageMeasure::RequestsPerMinute => "requests_per_minute",
                 UsageMeasure::TokensPerMinute => "tokens_per_minute",
                 UsageMeasure::TokensPerDay => "tokens_per_day",
-                _ => "",
             };
 
             if let Some(client) = state.clickhouse_client.as_ref() {
diff --git a/crates/collab/src/llm/db.rs b/crates/collab/src/llm/db.rs
index d46f51bb0df594..996837116b190d 100644
--- a/crates/collab/src/llm/db.rs
+++ b/crates/collab/src/llm/db.rs
@@ -97,6 +97,14 @@ impl LlmDatabase {
             .ok_or_else(|| anyhow!("unknown model {provider:?}:{name}"))?)
     }
 
+    pub fn model_by_id(&self, id: ModelId) -> Result<&model::Model> {
+        Ok(self
+            .models
+            .values()
+            .find(|model| model.id == id)
+            .ok_or_else(|| anyhow!("no model for ID {id:?}"))?)
+    }
+
     pub fn options(&self) -> &ConnectOptions {
         &self.options
     }
diff --git a/crates/collab/src/llm/db/queries/usages.rs b/crates/collab/src/llm/db/queries/usages.rs
index d703066913f8f5..1a98685bcddb4e 100644
--- a/crates/collab/src/llm/db/queries/usages.rs
+++ b/crates/collab/src/llm/db/queries/usages.rs
@@ -1,5 +1,5 @@
 use crate::db::UserId;
-use chrono::Duration;
+use chrono::{Datelike, Duration};
 use futures::StreamExt as _;
 use rpc::LanguageModelProvider;
 use sea_orm::QuerySelect;
@@ -140,6 +140,46 @@ impl LlmDatabase {
         .await
     }
 
+    pub async fn get_user_spending_for_month(
+        &self,
+        user_id: UserId,
+        now: DateTimeUtc,
+    ) -> Result<usize> {
+        self.transaction(|tx| async move {
+            let month = now.date_naive().month() as i32;
+            let year = now.date_naive().year();
+
+            let mut monthly_usages = monthly_usage::Entity::find()
+                .filter(
+                    monthly_usage::Column::UserId
+                        .eq(user_id)
+                        .and(monthly_usage::Column::Month.eq(month))
+                        .and(monthly_usage::Column::Year.eq(year)),
+                )
+                .stream(&*tx)
+                .await?;
+            let mut monthly_spending_in_cents = 0;
+
+            while let Some(usage) = monthly_usages.next().await {
+                let usage = usage?;
+                let Ok(model) = self.model_by_id(usage.model_id) else {
+                    continue;
+                };
+
+                monthly_spending_in_cents += calculate_spending(
+                    model,
+                    usage.input_tokens as usize,
+                    usage.cache_creation_input_tokens as usize,
+                    usage.cache_read_input_tokens as usize,
+                    usage.output_tokens as usize,
+                );
+            }
+
+            Ok(monthly_spending_in_cents)
+        })
+        .await
+    }
+
     pub async fn get_usage(
         &self,
         user_id: UserId,
@@ -162,6 +202,18 @@ impl LlmDatabase {
                 .all(&*tx)
                 .await?;
 
+            let month = now.date_naive().month() as i32;
+            let year = now.date_naive().year();
+            let monthly_usage = monthly_usage::Entity::find()
+                .filter(
+                    monthly_usage::Column::UserId
+                        .eq(user_id)
+                        .and(monthly_usage::Column::ModelId.eq(model.id))
+                        .and(monthly_usage::Column::Month.eq(month))
+                        .and(monthly_usage::Column::Year.eq(year)),
+                )
+                .one(&*tx)
+                .await?;
             let lifetime_usage = lifetime_usage::Entity::find()
                 .filter(
                     lifetime_usage::Column::UserId
@@ -177,28 +229,18 @@ impl LlmDatabase {
                 self.get_usage_for_measure(&usages, now, UsageMeasure::TokensPerMinute)?;
             let tokens_this_day =
                 self.get_usage_for_measure(&usages, now, UsageMeasure::TokensPerDay)?;
-            let input_tokens_this_month =
-                self.get_usage_for_measure(&usages, now, UsageMeasure::InputTokensPerMonth)?;
-            let cache_creation_input_tokens_this_month = self.get_usage_for_measure(
-                &usages,
-                now,
-                UsageMeasure::CacheCreationInputTokensPerMonth,
-            )?;
-            let cache_read_input_tokens_this_month = self.get_usage_for_measure(
-                &usages,
-                now,
-                UsageMeasure::CacheReadInputTokensPerMonth,
-            )?;
-            let output_tokens_this_month =
-                self.get_usage_for_measure(&usages, now, UsageMeasure::OutputTokensPerMonth)?;
-            let spending_this_month = calculate_spending(
-                model,
-                input_tokens_this_month,
-                cache_creation_input_tokens_this_month,
-                cache_read_input_tokens_this_month,
-                output_tokens_this_month,
-            );
-            let lifetime_spending = if let Some(lifetime_usage) = lifetime_usage {
+            let spending_this_month = if let Some(monthly_usage) = &monthly_usage {
+                calculate_spending(
+                    model,
+                    monthly_usage.input_tokens as usize,
+                    monthly_usage.cache_creation_input_tokens as usize,
+                    monthly_usage.cache_read_input_tokens as usize,
+                    monthly_usage.output_tokens as usize,
+                )
+            } else {
+                0
+            };
+            let lifetime_spending = if let Some(lifetime_usage) = &lifetime_usage {
                 calculate_spending(
                     model,
                     lifetime_usage.input_tokens as usize,
@@ -214,10 +256,18 @@ impl LlmDatabase {
                 requests_this_minute,
                 tokens_this_minute,
                 tokens_this_day,
-                input_tokens_this_month,
-                cache_creation_input_tokens_this_month,
-                cache_read_input_tokens_this_month,
-                output_tokens_this_month,
+                input_tokens_this_month: monthly_usage
+                    .as_ref()
+                    .map_or(0, |usage| usage.input_tokens as usize),
+                cache_creation_input_tokens_this_month: monthly_usage
+                    .as_ref()
+                    .map_or(0, |usage| usage.cache_creation_input_tokens as usize),
+                cache_read_input_tokens_this_month: monthly_usage
+                    .as_ref()
+                    .map_or(0, |usage| usage.cache_read_input_tokens as usize),
+                output_tokens_this_month: monthly_usage
+                    .as_ref()
+                    .map_or(0, |usage| usage.output_tokens as usize),
                 spending_this_month,
                 lifetime_spending,
             })
@@ -290,60 +340,68 @@ impl LlmDatabase {
                     &tx,
                 )
                 .await?;
-            let input_tokens_this_month = self
-                .update_usage_for_measure(
-                    user_id,
-                    is_staff,
-                    model.id,
-                    &usages,
-                    UsageMeasure::InputTokensPerMonth,
-                    now,
-                    input_token_count,
-                    &tx,
-                )
-                .await?;
-            let cache_creation_input_tokens_this_month = self
-                .update_usage_for_measure(
-                    user_id,
-                    is_staff,
-                    model.id,
-                    &usages,
-                    UsageMeasure::CacheCreationInputTokensPerMonth,
-                    now,
-                    cache_creation_input_tokens,
-                    &tx,
-                )
-                .await?;
-            let cache_read_input_tokens_this_month = self
-                .update_usage_for_measure(
-                    user_id,
-                    is_staff,
-                    model.id,
-                    &usages,
-                    UsageMeasure::CacheReadInputTokensPerMonth,
-                    now,
-                    cache_read_input_tokens,
-                    &tx,
-                )
-                .await?;
-            let output_tokens_this_month = self
-                .update_usage_for_measure(
-                    user_id,
-                    is_staff,
-                    model.id,
-                    &usages,
-                    UsageMeasure::OutputTokensPerMonth,
-                    now,
-                    output_token_count,
-                    &tx,
+
+            let month = now.date_naive().month() as i32;
+            let year = now.date_naive().year();
+
+            // Update monthly usage
+            let monthly_usage = monthly_usage::Entity::find()
+                .filter(
+                    monthly_usage::Column::UserId
+                        .eq(user_id)
+                        .and(monthly_usage::Column::ModelId.eq(model.id))
+                        .and(monthly_usage::Column::Month.eq(month))
+                        .and(monthly_usage::Column::Year.eq(year)),
                 )
+                .one(&*tx)
                 .await?;
+
+            let monthly_usage = match monthly_usage {
+                Some(usage) => {
+                    monthly_usage::Entity::update(monthly_usage::ActiveModel {
+                        id: ActiveValue::unchanged(usage.id),
+                        input_tokens: ActiveValue::set(
+                            usage.input_tokens + input_token_count as i64,
+                        ),
+                        cache_creation_input_tokens: ActiveValue::set(
+                            usage.cache_creation_input_tokens + cache_creation_input_tokens as i64,
+                        ),
+                        cache_read_input_tokens: ActiveValue::set(
+                            usage.cache_read_input_tokens + cache_read_input_tokens as i64,
+                        ),
+                        output_tokens: ActiveValue::set(
+                            usage.output_tokens + output_token_count as i64,
+                        ),
+                        ..Default::default()
+                    })
+                    .exec(&*tx)
+                    .await?
+                }
+                None => {
+                    monthly_usage::ActiveModel {
+                        user_id: ActiveValue::set(user_id),
+                        model_id: ActiveValue::set(model.id),
+                        month: ActiveValue::set(month),
+                        year: ActiveValue::set(year),
+                        input_tokens: ActiveValue::set(input_token_count as i64),
+                        cache_creation_input_tokens: ActiveValue::set(
+                            cache_creation_input_tokens as i64,
+                        ),
+                        cache_read_input_tokens: ActiveValue::set(cache_read_input_tokens as i64),
+                        output_tokens: ActiveValue::set(output_token_count as i64),
+                        ..Default::default()
+                    }
+                    .insert(&*tx)
+                    .await?
+                }
+            };
+
             let spending_this_month = calculate_spending(
                 model,
-                input_tokens_this_month,
-                cache_creation_input_tokens_this_month,
-                cache_read_input_tokens_this_month,
-                output_tokens_this_month,
+                monthly_usage.input_tokens as usize,
+                monthly_usage.cache_creation_input_tokens as usize,
+                monthly_usage.cache_read_input_tokens as usize,
+                monthly_usage.output_tokens as usize,
             );
 
             // Update lifetime usage
@@ -406,10 +464,11 @@ impl LlmDatabase {
                 requests_this_minute,
                 tokens_this_minute,
                 tokens_this_day,
-                input_tokens_this_month,
-                cache_creation_input_tokens_this_month,
-                cache_read_input_tokens_this_month,
-                output_tokens_this_month,
+                input_tokens_this_month: monthly_usage.input_tokens as usize,
+                cache_creation_input_tokens_this_month: monthly_usage.cache_creation_input_tokens
+                    as usize,
+                cache_read_input_tokens_this_month: monthly_usage.cache_read_input_tokens as usize,
+                output_tokens_this_month: monthly_usage.output_tokens as usize,
                 spending_this_month,
                 lifetime_spending,
             })
@@ -597,7 +656,6 @@ fn calculate_spending(
 
 const MINUTE_BUCKET_COUNT: usize = 12;
 const DAY_BUCKET_COUNT: usize = 48;
-const MONTH_BUCKET_COUNT: usize = 30;
 
 impl UsageMeasure {
     fn bucket_count(&self) -> usize {
@@ -605,10 +663,6 @@ impl UsageMeasure {
             UsageMeasure::RequestsPerMinute => MINUTE_BUCKET_COUNT,
             UsageMeasure::TokensPerMinute => MINUTE_BUCKET_COUNT,
             UsageMeasure::TokensPerDay => DAY_BUCKET_COUNT,
-            UsageMeasure::InputTokensPerMonth => MONTH_BUCKET_COUNT,
-            UsageMeasure::CacheCreationInputTokensPerMonth => MONTH_BUCKET_COUNT,
-            UsageMeasure::CacheReadInputTokensPerMonth => MONTH_BUCKET_COUNT,
-            UsageMeasure::OutputTokensPerMonth => MONTH_BUCKET_COUNT,
         }
     }
 
@@ -617,10 +671,6 @@ impl UsageMeasure {
             UsageMeasure::RequestsPerMinute => Duration::minutes(1),
             UsageMeasure::TokensPerMinute => Duration::minutes(1),
             UsageMeasure::TokensPerDay => Duration::hours(24),
-            UsageMeasure::InputTokensPerMonth => Duration::days(30),
-            UsageMeasure::CacheCreationInputTokensPerMonth => Duration::days(30),
-            UsageMeasure::CacheReadInputTokensPerMonth => Duration::days(30),
-            UsageMeasure::OutputTokensPerMonth => Duration::days(30),
         }
     }
 
diff --git a/crates/collab/src/llm/db/tables.rs b/crates/collab/src/llm/db/tables.rs
index 4beefe2b5d45d7..57aded70e91d29 100644
--- a/crates/collab/src/llm/db/tables.rs
+++ b/crates/collab/src/llm/db/tables.rs
@@ -1,5 +1,6 @@
 pub mod lifetime_usage;
 pub mod model;
+pub mod monthly_usage;
 pub mod provider;
 pub mod revoked_access_token;
 pub mod usage;
diff --git a/crates/collab/src/llm/db/tables/monthly_usage.rs b/crates/collab/src/llm/db/tables/monthly_usage.rs
new file mode 100644
index 00000000000000..1e849f6aefc585
--- /dev/null
+++ b/crates/collab/src/llm/db/tables/monthly_usage.rs
@@ -0,0 +1,22 @@
+use crate::{db::UserId, llm::db::ModelId};
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "monthly_usages")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub user_id: UserId,
+    pub model_id: ModelId,
+    pub month: i32,
+    pub year: i32,
+    pub input_tokens: i64,
+    pub cache_creation_input_tokens: i64,
+    pub cache_read_input_tokens: i64,
+    pub output_tokens: i64,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}
diff --git a/crates/collab/src/llm/db/tables/usage_measure.rs b/crates/collab/src/llm/db/tables/usage_measure.rs
index 50c9501e54f1d6..b0e5b866447ed0 100644
--- a/crates/collab/src/llm/db/tables/usage_measure.rs
+++ b/crates/collab/src/llm/db/tables/usage_measure.rs
@@ -9,10 +9,6 @@ pub enum UsageMeasure {
     RequestsPerMinute,
     TokensPerMinute,
     TokensPerDay,
-    InputTokensPerMonth,
-    CacheCreationInputTokensPerMonth,
-    CacheReadInputTokensPerMonth,
-    OutputTokensPerMonth,
 }
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
diff --git a/crates/collab/src/llm/db/tests/usage_tests.rs b/crates/collab/src/llm/db/tests/usage_tests.rs
index 97bcc20e44d1f3..8e8dc0ff6b240b 100644
--- a/crates/collab/src/llm/db/tests/usage_tests.rs
+++ b/crates/collab/src/llm/db/tests/usage_tests.rs
@@ -6,7 +6,7 @@ use crate::{
     },
     test_llm_db,
 };
-use chrono::{Duration, Utc};
+use chrono::{DateTime, Duration, Utc};
 use pretty_assertions::assert_eq;
 use rpc::LanguageModelProvider;
 
@@ -29,7 +29,10 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
     .await
     .unwrap();
 
-    let t0 = Utc::now();
+    // We're using a fixed datetime to prevent flakiness based on the clock.
+    let t0 = DateTime::parse_from_rfc3339("2024-08-08T22:46:33Z")
+        .unwrap()
+        .with_timezone(&Utc);
     let user_id = UserId::from_proto(123);
 
     let now = t0;
@@ -134,23 +137,10 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
         }
     );
 
-    let t2 = t0 + Duration::days(30);
-    let now = t2;
-    let usage = db.get_usage(user_id, provider, model, now).await.unwrap();
-    assert_eq!(
-        usage,
-        Usage {
-            requests_this_minute: 0,
-            tokens_this_minute: 0,
-            tokens_this_day: 0,
-            input_tokens_this_month: 9000,
-            cache_creation_input_tokens_this_month: 0,
-            cache_read_input_tokens_this_month: 0,
-            output_tokens_this_month: 0,
-            spending_this_month: 0,
-            lifetime_spending: 0,
-        }
-    );
+    // We're using a fixed datetime to prevent flakiness based on the clock.
+    let now = DateTime::parse_from_rfc3339("2024-10-08T22:15:58Z")
+        .unwrap()
+        .with_timezone(&Utc);
 
     // Test cache creation input tokens
     db.record_usage(user_id, false, provider, model, 1000, 500, 0, 0, now)
@@ -164,7 +154,7 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             requests_this_minute: 1,
             tokens_this_minute: 1500,
             tokens_this_day: 1500,
-            input_tokens_this_month: 10000,
+            input_tokens_this_month: 1000,
             cache_creation_input_tokens_this_month: 500,
             cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
@@ -185,7 +175,7 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             requests_this_minute: 2,
             tokens_this_minute: 2800,
             tokens_this_day: 2800,
-            input_tokens_this_month: 11000,
+            input_tokens_this_month: 2000,
             cache_creation_input_tokens_this_month: 500,
             cache_read_input_tokens_this_month: 300,
             output_tokens_this_month: 0,
diff --git a/crates/collab/src/llm/token.rs b/crates/collab/src/llm/token.rs
index e1e6c7332627dc..2f6ce6ee286ccc 100644
--- a/crates/collab/src/llm/token.rs
+++ b/crates/collab/src/llm/token.rs
@@ -22,6 +22,12 @@ pub struct LlmTokenClaims {
     pub is_staff: bool,
     #[serde(default)]
     pub has_llm_closed_beta_feature_flag: bool,
+    // This field is temporarily optional so it can be added
+    // in a backwards-compatible way. We can make it required
+    // once all of the LLM tokens have cycled (~1 hour after
+    // this change has been deployed).
+    #[serde(default)]
+    pub has_llm_subscription: Option<bool>,
     pub plan: rpc::proto::Plan,
 }
 
@@ -33,6 +39,7 @@ impl LlmTokenClaims {
         github_user_login: String,
         is_staff: bool,
         has_llm_closed_beta_feature_flag: bool,
+        has_llm_subscription: bool,
         plan: rpc::proto::Plan,
         config: &Config,
     ) -> Result<String> {
@@ -50,6 +57,7 @@ impl LlmTokenClaims {
             github_user_login: Some(github_user_login),
             is_staff,
             has_llm_closed_beta_feature_flag,
+            has_llm_subscription: Some(has_llm_subscription),
             plan,
         };
 
diff --git a/crates/collab/src/main.rs b/crates/collab/src/main.rs
index 0e6bb67d13db37..bbbd4e562cb901 100644
--- a/crates/collab/src/main.rs
+++ b/crates/collab/src/main.rs
@@ -6,6 +6,7 @@ use axum::{
     routing::get,
     Extension, Router,
 };
+use collab::api::billing::sync_llm_usage_with_stripe_periodically;
 use collab::api::CloudflareIpCountryHeader;
 use collab::llm::{db::LlmDatabase, log_usage_periodically};
 use collab::migrations::run_database_migrations;
@@ -29,7 +30,7 @@ use tower_http::trace::TraceLayer;
 use tracing_subscriber::{
     filter::EnvFilter, fmt::format::JsonFields, util::SubscriberInitExt, Layer,
 };
-use util::ResultExt as _;
+use util::{maybe, ResultExt as _};
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 const REVISION: Option<&'static str> = option_env!("GITHUB_SHA");
@@ -136,6 +137,28 @@ async fn main() -> Result<()> {
                     fetch_extensions_from_blob_store_periodically(state.clone());
                     spawn_user_backfiller(state.clone());
 
+                    let llm_db = maybe!(async {
+                        let database_url = state
+                            .config
+                            .llm_database_url
+                            .as_ref()
+                            .ok_or_else(|| anyhow!("missing LLM_DATABASE_URL"))?;
+                        let max_connections = state
+                            .config
+                            .llm_database_max_connections
+                            .ok_or_else(|| anyhow!("missing LLM_DATABASE_MAX_CONNECTIONS"))?;
+
+                        let mut db_options = db::ConnectOptions::new(database_url);
+                        db_options.max_connections(max_connections);
+                        LlmDatabase::new(db_options, state.executor.clone()).await
+                    })
+                    .await
+                    .trace_err();
+
+                    if let Some(llm_db) = llm_db {
+                        sync_llm_usage_with_stripe_periodically(state.clone(), llm_db);
+                    }
+
                     app = app
                         .merge(collab::api::events::router())
                         .merge(collab::api::extensions::router())
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index 27c95a5b44e1a8..e66c306c506ddb 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -191,16 +191,26 @@ impl Session {
         }
     }
 
-    pub async fn current_plan(&self, db: MutexGuard<'_, DbHandle>) -> anyhow::Result<proto::Plan> {
+    pub async fn has_llm_subscription(
+        &self,
+        db: &MutexGuard<'_, DbHandle>,
+    ) -> anyhow::Result<bool> {
         if self.is_staff() {
-            return Ok(proto::Plan::ZedPro);
+            return Ok(true);
         }
 
         let Some(user_id) = self.user_id() else {
-            return Ok(proto::Plan::Free);
+            return Ok(false);
         };
 
-        if db.has_active_billing_subscription(user_id).await? {
+        Ok(db.has_active_billing_subscription(user_id).await?)
+    }
+
+    pub async fn current_plan(
+        &self,
+        _db: &MutexGuard<'_, DbHandle>,
+    ) -> anyhow::Result<proto::Plan> {
+        if self.is_staff() {
             Ok(proto::Plan::ZedPro)
         } else {
             Ok(proto::Plan::Free)
@@ -3471,7 +3481,7 @@ fn should_auto_subscribe_to_channels(version: ZedVersion) -> bool {
 }
 
 async fn update_user_plan(_user_id: UserId, session: &Session) -> Result<()> {
-    let plan = session.current_plan(session.db().await).await?;
+    let plan = session.current_plan(&session.db().await).await?;
 
     session
         .peer
@@ -4471,7 +4481,7 @@ async fn count_language_model_tokens(
     };
     authorize_access_to_legacy_llm_endpoints(&session).await?;
 
-    let rate_limit: Box<dyn RateLimit> = match session.current_plan(session.db().await).await? {
+    let rate_limit: Box<dyn RateLimit> = match session.current_plan(&session.db().await).await? {
         proto::Plan::ZedPro => Box::new(ZedProCountLanguageModelTokensRateLimit),
         proto::Plan::Free => Box::new(FreeCountLanguageModelTokensRateLimit),
     };
@@ -4592,7 +4602,7 @@ async fn compute_embeddings(
     let api_key = api_key.context("no OpenAI API key configured on the server")?;
     authorize_access_to_legacy_llm_endpoints(&session).await?;
 
-    let rate_limit: Box<dyn RateLimit> = match session.current_plan(session.db().await).await? {
+    let rate_limit: Box<dyn RateLimit> = match session.current_plan(&session.db().await).await? {
         proto::Plan::ZedPro => Box::new(ZedProComputeEmbeddingsRateLimit),
         proto::Plan::Free => Box::new(FreeComputeEmbeddingsRateLimit),
     };
@@ -4915,7 +4925,8 @@ async fn get_llm_api_token(
         user.github_login.clone(),
         session.is_staff(),
         has_llm_closed_beta_feature_flag,
-        session.current_plan(db).await?,
+        session.has_llm_subscription(&db).await?,
+        session.current_plan(&db).await?,
         &session.app_state.config,
     )?;
     response.send(proto::GetLlmTokenResponse { token })?;
diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs
index 8d2396eef08181..55bc279c8eaf6e 100644
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -677,7 +677,7 @@ impl TestServer {
                 migrations_path: None,
                 seed_path: None,
                 stripe_api_key: None,
-                stripe_price_id: None,
+                stripe_llm_usage_price_id: None,
                 supermaven_admin_api_key: None,
                 user_backfiller_github_access_token: None,
             },

From 801210cd50d4cdbae81e56ba333e39d559197209 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 8 Oct 2024 20:03:33 -0400
Subject: [PATCH 540/762] collab: Make `github_user_login` required in
 `LlmTokenClaims` (#18882)

This PR makes the `github_user_login` field required in the
`LlmTokenClaims`.

We previously added this in
https://github.com/zed-industries/zed/pull/16316 and made it optional
for backwards-compatibility.

It's been more than long enough for all of the previous LLM tokens to
have expired, so we can now make the field required.

Release Notes:

- N/A
---
 crates/collab/src/llm/token.rs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/crates/collab/src/llm/token.rs b/crates/collab/src/llm/token.rs
index 2f6ce6ee286ccc..6098a1cd138069 100644
--- a/crates/collab/src/llm/token.rs
+++ b/crates/collab/src/llm/token.rs
@@ -13,14 +13,8 @@ pub struct LlmTokenClaims {
     pub exp: u64,
     pub jti: String,
     pub user_id: u64,
-    // This field is temporarily optional so it can be added
-    // in a backwards-compatible way. We can make it required
-    // once all of the LLM tokens have cycled (~1 hour after
-    // this change has been deployed).
-    #[serde(default)]
-    pub github_user_login: Option<String>,
+    pub github_user_login: String,
     pub is_staff: bool,
-    #[serde(default)]
     pub has_llm_closed_beta_feature_flag: bool,
     // This field is temporarily optional so it can be added
     // in a backwards-compatible way. We can make it required
@@ -54,7 +48,7 @@ impl LlmTokenClaims {
             exp: (now + LLM_TOKEN_LIFETIME).timestamp() as u64,
             jti: uuid::Uuid::new_v4().to_string(),
             user_id: user_id.to_proto(),
-            github_user_login: Some(github_user_login),
+            github_user_login,
             is_staff,
             has_llm_closed_beta_feature_flag,
             has_llm_subscription: Some(has_llm_subscription),

From b0a9005163e16f1ed8f7a4204e6d8ab6ac908a02 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 8 Oct 2024 20:25:07 -0400
Subject: [PATCH 541/762] client: Send telemetry events with `Content-Type:
 application/json` (#18886)

This PR updates the telemetry events sent to collab to use
`Content-Type: application/json` instead of `Content-Type: text/plain`.

The POST bodies are JSON, so `application/json` is the correct MIME
type.

I suspect the `text/plain` is a remnant from when the events were still
going through Vercel.

Release Notes:

- N/A
---
 crates/client/src/telemetry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index 5a752bc05f8abc..1dc3cedee28d7b 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -653,7 +653,7 @@ impl Telemetry {
                                 .build_zed_api_url("/telemetry/events", &[])?
                                 .as_ref(),
                         )
-                        .header("Content-Type", "text/plain")
+                        .header("Content-Type", "application/json")
                         .header("x-zed-checksum", checksum)
                         .body(json_bytes.into());
 

From e35114815257f800acf9020aeb82470b8cec53b3 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Tue, 8 Oct 2024 17:30:42 -0700
Subject: [PATCH 542/762] Fix bugs in expanding diff hunk (#18885)

Release Notes:

- Fixed an issue where diff hunks at the boundaries of multi buffer
excerpts could not be expanded
---
 crates/editor/src/editor_tests.rs | 54 ++++++++++++++++++++
 crates/editor/src/hunk_diff.rs    | 84 ++++++++++++-------------------
 crates/language/src/buffer.rs     |  1 -
 3 files changed, 85 insertions(+), 54 deletions(-)

diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 249d0a474641d0..092afb394e42fb 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -11715,6 +11715,60 @@ async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut gpui::TestAppContext)
     );
 }
 
+#[gpui::test]
+async fn test_expand_diff_hunk_at_excerpt_boundary(cx: &mut gpui::TestAppContext) {
+    init_test(cx, |_| {});
+
+    let base = "aaa\nbbb\nccc\nddd\neee\nfff\nggg\n";
+    let text = "aaa\nBBB\nBB2\nccc\nDDD\nEEE\nfff\nggg\n";
+
+    let buffer = cx.new_model(|cx| {
+        let mut buffer = Buffer::local(text.to_string(), cx);
+        buffer.set_diff_base(Some(base.into()), cx);
+        buffer
+    });
+
+    let multi_buffer = cx.new_model(|cx| {
+        let mut multibuffer = MultiBuffer::new(ReadWrite);
+        multibuffer.push_excerpts(
+            buffer.clone(),
+            [
+                ExcerptRange {
+                    context: Point::new(0, 0)..Point::new(2, 0),
+                    primary: None,
+                },
+                ExcerptRange {
+                    context: Point::new(5, 0)..Point::new(7, 0),
+                    primary: None,
+                },
+            ],
+            cx,
+        );
+        multibuffer
+    });
+
+    let editor = cx.add_window(|cx| Editor::new(EditorMode::Full, multi_buffer, None, true, cx));
+    let mut cx = EditorTestContext::for_editor(editor, cx).await;
+    cx.run_until_parked();
+
+    cx.update_editor(|editor, cx| editor.expand_all_hunk_diffs(&Default::default(), cx));
+    cx.executor().run_until_parked();
+
+    cx.assert_diff_hunks(
+        "
+            aaa
+          - bbb
+          + BBB
+
+          - ddd
+          - eee
+          + EEE
+            fff
+        "
+        .unindent(),
+    );
+}
+
 #[gpui::test]
 async fn test_edits_around_expanded_insertion_hunks(
     executor: BackgroundExecutor,
diff --git a/crates/editor/src/hunk_diff.rs b/crates/editor/src/hunk_diff.rs
index e495481323a6f4..c3a539b3d4c48c 100644
--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -209,19 +209,20 @@ impl Editor {
 
                         retain
                     });
-                    for remaining_hunk in hunks_to_toggle {
-                        let remaining_hunk_point_range =
-                            Point::new(remaining_hunk.row_range.start.0, 0)
-                                ..Point::new(remaining_hunk.row_range.end.0, 0);
+                    for hunk in hunks_to_toggle {
+                        let remaining_hunk_point_range = Point::new(hunk.row_range.start.0, 0)
+                            ..Point::new(hunk.row_range.end.0, 0);
+                        let hunk_start = snapshot
+                            .buffer_snapshot
+                            .anchor_before(remaining_hunk_point_range.start);
+                        let hunk_end = snapshot
+                            .buffer_snapshot
+                            .anchor_in_excerpt(hunk_start.excerpt_id, hunk.buffer_range.end)
+                            .unwrap();
                         hunks_to_expand.push(HoveredHunk {
-                            status: hunk_status(&remaining_hunk),
-                            multi_buffer_range: snapshot
-                                .buffer_snapshot
-                                .anchor_before(remaining_hunk_point_range.start)
-                                ..snapshot
-                                    .buffer_snapshot
-                                    .anchor_after(remaining_hunk_point_range.end),
-                            diff_base_byte_range: remaining_hunk.diff_base_byte_range.clone(),
+                            status: hunk_status(&hunk),
+                            multi_buffer_range: hunk_start..hunk_end,
+                            diff_base_byte_range: hunk.diff_base_byte_range.clone(),
                         });
                     }
 
@@ -246,33 +247,22 @@ impl Editor {
         hunk: &HoveredHunk,
         cx: &mut ViewContext<'_, Editor>,
     ) -> Option<()> {
-        let multi_buffer_snapshot = self.buffer().read(cx).snapshot(cx);
+        let buffer = self.buffer.clone();
+        let multi_buffer_snapshot = buffer.read(cx).snapshot(cx);
         let hunk_range = hunk.multi_buffer_range.clone();
-        let hunk_point_range = hunk_range.to_point(&multi_buffer_snapshot);
-
-        let buffer = self.buffer().clone();
-        let snapshot = self.snapshot(cx);
         let (diff_base_buffer, deleted_text_lines) = buffer.update(cx, |buffer, cx| {
-            let hunk = buffer_diff_hunk(&snapshot.buffer_snapshot, hunk_point_range.clone())?;
-            let mut buffer_ranges = buffer.range_to_buffer_ranges(hunk_point_range, cx);
-            if buffer_ranges.len() == 1 {
-                let (buffer, _, _) = buffer_ranges.pop()?;
-                let diff_base_buffer = diff_base_buffer
-                    .or_else(|| self.current_diff_base_buffer(&buffer, cx))
-                    .or_else(|| create_diff_base_buffer(&buffer, cx))?;
-                let buffer = buffer.read(cx);
-                let deleted_text_lines = buffer.diff_base().map(|diff_base| {
-                    let diff_start_row = diff_base
-                        .offset_to_point(hunk.diff_base_byte_range.start)
-                        .row;
-                    let diff_end_row = diff_base.offset_to_point(hunk.diff_base_byte_range.end).row;
-
-                    diff_end_row - diff_start_row
-                })?;
-                Some((diff_base_buffer, deleted_text_lines))
-            } else {
-                None
-            }
+            let buffer = buffer.buffer(hunk_range.start.buffer_id?)?;
+            let diff_base_buffer = diff_base_buffer
+                .or_else(|| self.current_diff_base_buffer(&buffer, cx))
+                .or_else(|| create_diff_base_buffer(&buffer, cx))?;
+            let deleted_text_lines = buffer.read(cx).diff_base().map(|diff_base| {
+                let diff_start_row = diff_base
+                    .offset_to_point(hunk.diff_base_byte_range.start)
+                    .row;
+                let diff_end_row = diff_base.offset_to_point(hunk.diff_base_byte_range.end).row;
+                diff_end_row - diff_start_row
+            })?;
+            Some((diff_base_buffer, deleted_text_lines))
         })?;
 
         let block_insert_index = match self.expanded_hunks.hunks.binary_search_by(|probe| {
@@ -1128,21 +1118,6 @@ fn editor_with_deleted_text(
     (editor_height, editor)
 }
 
-fn buffer_diff_hunk(
-    buffer_snapshot: &MultiBufferSnapshot,
-    row_range: Range<Point>,
-) -> Option<MultiBufferDiffHunk> {
-    let mut hunks = buffer_snapshot.git_diff_hunks_in_range(
-        MultiBufferRow(row_range.start.row)..MultiBufferRow(row_range.end.row),
-    );
-    let hunk = hunks.next()?;
-    let second_hunk = hunks.next();
-    if second_hunk.is_none() {
-        return Some(hunk);
-    }
-    None
-}
-
 impl DisplayDiffHunk {
     pub fn start_display_row(&self) -> DisplayRow {
         match self {
@@ -1209,7 +1184,10 @@ pub fn diff_hunk_to_display(
         let hunk_end_point = Point::new(hunk_end_row.0, 0);
 
         let multi_buffer_start = snapshot.buffer_snapshot.anchor_before(hunk_start_point);
-        let multi_buffer_end = snapshot.buffer_snapshot.anchor_after(hunk_end_point);
+        let multi_buffer_end = snapshot
+            .buffer_snapshot
+            .anchor_in_excerpt(multi_buffer_start.excerpt_id, hunk.buffer_range.end)
+            .unwrap();
         let end = hunk_end_point.to_display_point(snapshot).row();
 
         DisplayDiffHunk::Unfolded {
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 59740509d3677c..13d07caa88a71d 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -1156,7 +1156,6 @@ impl Buffer {
                 this.non_text_state_update_count += 1;
                 if let Some(BufferDiffBase::PastBufferVersion { rope, .. }) = &mut this.diff_base {
                     *rope = diff_base_rope;
-                    cx.emit(BufferEvent::DiffBaseChanged);
                 }
                 cx.emit(BufferEvent::DiffUpdated);
             })

From 5d5c4b667741246c521c161cda792b9ad29fc102 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Wed, 9 Oct 2024 01:07:18 -0700
Subject: [PATCH 543/762] Revert http client changes (#18892)

These proved to be too unstable. Will restore these changes once the issues have been fixed.

Release Notes:

- N/A
---
 Cargo.lock                                    | 603 ++++++------------
 Cargo.toml                                    |  15 +-
 crates/client/Cargo.toml                      |   3 +-
 crates/client/src/client.rs                   |  27 +-
 crates/collab/Cargo.toml                      |   2 +-
 crates/collab/src/llm.rs                      |  12 +-
 crates/collab/src/rpc.rs                      |   6 +-
 crates/evals/Cargo.toml                       |   2 +-
 crates/evals/src/eval.rs                      |   7 +-
 crates/extension/Cargo.toml                   |   3 +-
 crates/extension/src/extension_builder.rs     |   2 +-
 crates/extension/src/extension_store_test.rs  |  52 +-
 crates/extension_cli/Cargo.toml               |   2 +-
 crates/extension_cli/src/main.rs              |   9 +-
 crates/gpui/src/app.rs                        |   4 -
 crates/http_client/Cargo.toml                 |   4 +-
 crates/http_client/src/http_client.rs         |  56 +-
 .../Cargo.toml                                |  15 +-
 crates/isahc_http_client/LICENSE-APACHE       |   1 +
 .../src/isahc_http_client.rs                  | 105 +++
 crates/live_kit_server/Cargo.toml             |   2 +-
 crates/reqwest_client/Cargo.toml              |  31 -
 crates/reqwest_client/LICENSE-GPL             |   1 -
 crates/reqwest_client/examples/client.rs      |  16 -
 crates/reqwest_client/src/reqwest_client.rs   | 259 --------
 crates/semantic_index/Cargo.toml              |   2 +-
 crates/semantic_index/examples/index.rs       |   7 +-
 crates/storybook/Cargo.toml                   |   2 +-
 crates/storybook/src/storybook.rs             |  12 +-
 crates/ureq_client/LICENSE-GPL                |   1 -
 crates/ureq_client/examples/client.rs         |  24 -
 crates/ureq_client/src/ureq_client.rs         | 200 ------
 crates/vim/Cargo.toml                         |   2 +-
 crates/zed/Cargo.toml                         |   2 +-
 crates/zed/src/main.rs                        |  10 +-
 35 files changed, 381 insertions(+), 1120 deletions(-)
 rename crates/{ureq_client => isahc_http_client}/Cargo.toml (53%)
 create mode 120000 crates/isahc_http_client/LICENSE-APACHE
 create mode 100644 crates/isahc_http_client/src/isahc_http_client.rs
 delete mode 100644 crates/reqwest_client/Cargo.toml
 delete mode 120000 crates/reqwest_client/LICENSE-GPL
 delete mode 100644 crates/reqwest_client/examples/client.rs
 delete mode 100644 crates/reqwest_client/src/reqwest_client.rs
 delete mode 120000 crates/ureq_client/LICENSE-GPL
 delete mode 100644 crates/ureq_client/examples/client.rs
 delete mode 100644 crates/ureq_client/src/ureq_client.rs

diff --git a/Cargo.lock b/Cargo.lock
index 1bae8d98503186..cc588fcb22cb35 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -846,8 +846,8 @@ dependencies = [
  "chrono",
  "futures-util",
  "http-types",
- "hyper 0.14.30",
- "hyper-rustls 0.24.2",
+ "hyper",
+ "hyper-rustls",
  "serde",
  "serde_json",
  "serde_path_to_error",
@@ -880,14 +880,15 @@ checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
 
 [[package]]
 name = "async-tls"
-version = "0.13.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ae3c9eba89d472a0e4fe1dea433df78fbbe63d2b764addaf2ba3a6bde89a5e"
+checksum = "cfeefd0ca297cbbb3bd34fd6b228401c2a5177038257afd751bc29f0a2da4795"
 dependencies = [
  "futures-core",
  "futures-io",
- "rustls 0.21.12",
+ "rustls 0.20.9",
  "rustls-pemfile 1.0.4",
+ "webpki",
  "webpki-roots 0.22.6",
 ]
 
@@ -904,9 +905,9 @@ dependencies = [
 
 [[package]]
 name = "async-tungstenite"
-version = "0.28.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90e661b6cb0a6eb34d02c520b052daa3aa9ac0cc02495c9d066bbce13ead132b"
+checksum = "a1e9efbe14612da0a19fb983059a0b621e9cf6225d7018ecab4f9988215540dc"
 dependencies = [
  "async-std",
  "async-tls",
@@ -914,7 +915,7 @@ dependencies = [
  "futures-util",
  "log",
  "pin-project-lite",
- "tungstenite 0.24.0",
+ "tungstenite 0.20.1",
 ]
 
 [[package]]
@@ -1063,7 +1064,7 @@ dependencies = [
  "fastrand 2.1.1",
  "hex",
  "http 0.2.12",
- "ring",
+ "ring 0.17.8",
  "time",
  "tokio",
  "tracing",
@@ -1232,7 +1233,7 @@ dependencies = [
  "once_cell",
  "p256",
  "percent-encoding",
- "ring",
+ "ring 0.17.8",
  "sha2",
  "subtle",
  "time",
@@ -1335,13 +1336,13 @@ dependencies = [
  "aws-smithy-types",
  "bytes 1.7.1",
  "fastrand 2.1.1",
- "h2 0.3.26",
+ "h2",
  "http 0.2.12",
  "http-body 0.4.6",
  "http-body 1.0.1",
  "httparse",
- "hyper 0.14.30",
- "hyper-rustls 0.24.2",
+ "hyper",
+ "hyper-rustls",
  "once_cell",
  "pin-project-lite",
  "pin-utils",
@@ -1431,7 +1432,7 @@ dependencies = [
  "headers",
  "http 0.2.12",
  "http-body 0.4.6",
- "hyper 0.14.30",
+ "hyper",
  "itoa",
  "matchit",
  "memchr",
@@ -1444,7 +1445,7 @@ dependencies = [
  "serde_path_to_error",
  "serde_urlencoded",
  "sha1",
- "sync_wrapper 0.1.2",
+ "sync_wrapper",
  "tokio",
  "tokio-tungstenite 0.20.1",
  "tower",
@@ -1583,7 +1584,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash 1.1.0",
+ "rustc-hash",
  "shlex",
  "syn 2.0.76",
 ]
@@ -1603,7 +1604,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash 1.1.0",
+ "rustc-hash",
  "shlex",
  "syn 2.0.76",
 ]
@@ -2099,6 +2100,12 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
+[[package]]
+name = "castaway"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2698f953def977c68f935bb0dfa959375ad4638570e969e2f1e9f433cbf1af6"
+
 [[package]]
 name = "cbc"
 version = "0.1.2"
@@ -2356,8 +2363,8 @@ dependencies = [
  "clickhouse-derive",
  "clickhouse-rs-cityhash-sys",
  "futures 0.3.30",
- "hyper 0.14.30",
- "hyper-tls 0.5.0",
+ "hyper",
+ "hyper-tls",
  "lz4",
  "sealed",
  "serde",
@@ -2395,7 +2402,6 @@ dependencies = [
  "anyhow",
  "async-native-tls",
  "async-recursion 0.3.2",
- "async-tls",
  "async-tungstenite",
  "chrono",
  "clock",
@@ -2413,6 +2419,8 @@ dependencies = [
  "rand 0.8.5",
  "release_channel",
  "rpc",
+ "rustls 0.20.9",
+ "rustls-native-certs 0.8.0",
  "schemars",
  "serde",
  "serde_json",
@@ -2559,8 +2567,9 @@ dependencies = [
  "headless",
  "hex",
  "http_client",
- "hyper 0.14.30",
+ "hyper",
  "indoc",
+ "isahc_http_client",
  "jsonwebtoken",
  "language",
  "language_model",
@@ -2584,8 +2593,7 @@ dependencies = [
  "release_channel",
  "remote",
  "remote_server",
- "reqwest 0.11.27",
- "reqwest_client",
+ "reqwest",
  "rpc",
  "rustc-demangle",
  "scrypt",
@@ -2669,7 +2677,7 @@ dependencies = [
 name = "collections"
 version = "0.1.0"
 dependencies = [
- "rustc-hash 1.1.0",
+ "rustc-hash",
 ]
 
 [[package]]
@@ -2987,7 +2995,7 @@ dependencies = [
  "log",
  "rangemap",
  "rayon",
- "rustc-hash 1.1.0",
+ "rustc-hash",
  "rustybuzz",
  "self_cell",
  "swash",
@@ -3077,7 +3085,7 @@ dependencies = [
  "hashbrown 0.14.5",
  "log",
  "regalloc2",
- "rustc-hash 1.1.0",
+ "rustc-hash",
  "smallvec",
  "target-lexicon",
 ]
@@ -3333,6 +3341,36 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "curl"
+version = "0.4.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e2161dd6eba090ff1594084e95fd67aeccf04382ffea77999ea94ed42ec67b6"
+dependencies = [
+ "curl-sys",
+ "libc",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "socket2 0.5.7",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "curl-sys"
+version = "0.4.74+curl-8.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8af10b986114528fcdc4b63b6f5f021b7057618411046a4de2ba0f0149a097bf"
+dependencies = [
+ "cc",
+ "libc",
+ "libz-sys",
+ "openssl-sys",
+ "pkg-config",
+ "vcpkg",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "cursor-icon"
 version = "1.1.0"
@@ -3994,6 +4032,7 @@ dependencies = [
  "git",
  "gpui",
  "http_client",
+ "isahc_http_client",
  "language",
  "languages",
  "node_runtime",
@@ -4004,7 +4043,6 @@ dependencies = [
  "serde_json",
  "settings",
  "smol",
- "ureq_client",
 ]
 
 [[package]]
@@ -4089,6 +4127,7 @@ dependencies = [
  "gpui",
  "http_client",
  "indexed_docs",
+ "isahc_http_client",
  "language",
  "log",
  "lsp",
@@ -4097,7 +4136,6 @@ dependencies = [
  "paths",
  "project",
  "release_channel",
- "reqwest_client",
  "schemars",
  "semantic_version",
  "serde",
@@ -4110,7 +4148,6 @@ dependencies = [
  "tokio",
  "toml 0.8.19",
  "ui",
- "ureq_client",
  "url",
  "util",
  "wasm-encoder 0.215.0",
@@ -4130,9 +4167,9 @@ dependencies = [
  "env_logger",
  "extension",
  "fs",
+ "isahc_http_client",
  "language",
  "log",
- "reqwest_client",
  "rpc",
  "serde",
  "serde_json",
@@ -4379,7 +4416,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "nanorand",
- "spin",
+ "spin 0.9.8",
 ]
 
 [[package]]
@@ -5145,25 +5182,6 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "h2"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524e8ac6999421f49a846c2d4411f337e53497d8ec55d67753beffa43c5d9205"
-dependencies = [
- "atomic-waker",
- "bytes 1.7.1",
- "fnv",
- "futures-core",
- "futures-sink",
- "http 1.1.0",
- "indexmap 2.4.0",
- "slab",
- "tokio",
- "tokio-util",
- "tracing",
-]
-
 [[package]]
 name = "half"
 version = "2.4.1"
@@ -5544,10 +5562,8 @@ dependencies = [
  "anyhow",
  "derive_more",
  "futures 0.3.30",
- "http 1.1.0",
+ "http 0.2.12",
  "log",
- "rustls 0.21.12",
- "rustls-native-certs 0.8.0",
  "serde",
  "serde_json",
  "smol",
@@ -5588,7 +5604,7 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2 0.3.26",
+ "h2",
  "http 0.2.12",
  "http-body 0.4.6",
  "httparse",
@@ -5602,26 +5618,6 @@ dependencies = [
  "want",
 ]
 
-[[package]]
-name = "hyper"
-version = "1.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50dfd22e0e76d0f662d429a5f80fcaf3855009297eab6a0a9f8543834744ba05"
-dependencies = [
- "bytes 1.7.1",
- "futures-channel",
- "futures-util",
- "h2 0.4.6",
- "http 1.1.0",
- "http-body 1.0.1",
- "httparse",
- "itoa",
- "pin-project-lite",
- "smallvec",
- "tokio",
- "want",
-]
-
 [[package]]
 name = "hyper-rustls"
 version = "0.24.2"
@@ -5630,29 +5626,12 @@ checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
  "futures-util",
  "http 0.2.12",
- "hyper 0.14.30",
+ "hyper",
  "log",
  "rustls 0.21.12",
  "rustls-native-certs 0.6.3",
  "tokio",
- "tokio-rustls 0.24.1",
-]
-
-[[package]]
-name = "hyper-rustls"
-version = "0.27.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08afdbb5c31130e3034af566421053ab03787c640246a446327f550d11bcb333"
-dependencies = [
- "futures-util",
- "http 1.1.0",
- "hyper 1.4.1",
- "hyper-util",
- "rustls 0.23.13",
- "rustls-pki-types",
- "tokio",
- "tokio-rustls 0.26.0",
- "tower-service",
+ "tokio-rustls",
 ]
 
 [[package]]
@@ -5662,47 +5641,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
 dependencies = [
  "bytes 1.7.1",
- "hyper 0.14.30",
+ "hyper",
  "native-tls",
  "tokio",
  "tokio-native-tls",
 ]
 
-[[package]]
-name = "hyper-tls"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
-dependencies = [
- "bytes 1.7.1",
- "http-body-util",
- "hyper 1.4.1",
- "hyper-util",
- "native-tls",
- "tokio",
- "tokio-native-tls",
- "tower-service",
-]
-
-[[package]]
-name = "hyper-util"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41296eb09f183ac68eec06e03cdbea2e759633d4067b2f6552fc2e009bcad08b"
-dependencies = [
- "bytes 1.7.1",
- "futures-channel",
- "futures-util",
- "http 1.1.0",
- "http-body 1.0.1",
- "hyper 1.4.1",
- "pin-project-lite",
- "socket2 0.5.7",
- "tokio",
- "tower-service",
- "tracing",
-]
-
 [[package]]
 name = "iana-time-zone"
 version = "0.1.60"
@@ -6070,6 +6014,44 @@ version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 
+[[package]]
+name = "isahc"
+version = "1.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "334e04b4d781f436dc315cb1e7515bd96826426345d498149e4bde36b67f8ee9"
+dependencies = [
+ "async-channel 1.9.0",
+ "castaway",
+ "crossbeam-utils",
+ "curl",
+ "curl-sys",
+ "encoding_rs",
+ "event-listener 2.5.3",
+ "futures-lite 1.13.0",
+ "http 0.2.12",
+ "log",
+ "mime",
+ "once_cell",
+ "polling 2.8.0",
+ "slab",
+ "sluice",
+ "tracing",
+ "tracing-futures",
+ "url",
+ "waker-fn",
+]
+
+[[package]]
+name = "isahc_http_client"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "futures 0.3.30",
+ "http_client",
+ "isahc",
+ "util",
+]
+
 [[package]]
 name = "itertools"
 version = "0.10.5"
@@ -6174,7 +6156,7 @@ dependencies = [
  "base64 0.21.7",
  "js-sys",
  "pem",
- "ring",
+ "ring 0.17.8",
  "serde",
  "serde_json",
  "simple_asn1",
@@ -6424,7 +6406,7 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 dependencies = [
- "spin",
+ "spin 0.9.8",
 ]
 
 [[package]]
@@ -6619,7 +6601,7 @@ dependencies = [
  "prost",
  "prost-build",
  "prost-types",
- "reqwest 0.12.8",
+ "reqwest",
  "serde",
 ]
 
@@ -7103,7 +7085,7 @@ dependencies = [
  "hexf-parse",
  "indexmap 2.4.0",
  "log",
- "rustc-hash 1.1.0",
+ "rustc-hash",
  "spirv",
  "termcolor",
  "thiserror",
@@ -8751,54 +8733,6 @@ dependencies = [
  "zed_actions",
 ]
 
-[[package]]
-name = "quinn"
-version = "0.11.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c7c5fdde3cdae7203427dc4f0a68fe0ed09833edc525a03456b153b79828684"
-dependencies = [
- "bytes 1.7.1",
- "pin-project-lite",
- "quinn-proto",
- "quinn-udp",
- "rustc-hash 2.0.0",
- "rustls 0.23.13",
- "socket2 0.5.7",
- "thiserror",
- "tokio",
- "tracing",
-]
-
-[[package]]
-name = "quinn-proto"
-version = "0.11.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fadfaed2cd7f389d0161bb73eeb07b7b78f8691047a6f3e73caaeae55310a4a6"
-dependencies = [
- "bytes 1.7.1",
- "rand 0.8.5",
- "ring",
- "rustc-hash 2.0.0",
- "rustls 0.23.13",
- "slab",
- "thiserror",
- "tinyvec",
- "tracing",
-]
-
-[[package]]
-name = "quinn-udp"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fe68c2e9e1a1234e218683dbdf9f9dfcb094113c5ac2b938dfcb9bab4c4140b"
-dependencies = [
- "libc",
- "once_cell",
- "socket2 0.5.7",
- "tracing",
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "quote"
 version = "1.0.37"
@@ -9075,7 +9009,7 @@ checksum = "ad156d539c879b7a24a363a2016d77961786e71f48f2e2fc8302a92abd2429a6"
 dependencies = [
  "hashbrown 0.13.2",
  "log",
- "rustc-hash 1.1.0",
+ "rustc-hash",
  "slice-group-by",
  "smallvec",
 ]
@@ -9254,11 +9188,11 @@ dependencies = [
  "encoding_rs",
  "futures-core",
  "futures-util",
- "h2 0.3.26",
+ "h2",
  "http 0.2.12",
  "http-body 0.4.6",
- "hyper 0.14.30",
- "hyper-tls 0.5.0",
+ "hyper",
+ "hyper-tls",
  "ipnet",
  "js-sys",
  "log",
@@ -9271,8 +9205,8 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_urlencoded",
- "sync_wrapper 0.1.2",
- "system-configuration 0.5.1",
+ "sync_wrapper",
+ "system-configuration",
  "tokio",
  "tokio-native-tls",
  "tower-service",
@@ -9283,68 +9217,6 @@ dependencies = [
  "winreg 0.50.0",
 ]
 
-[[package]]
-name = "reqwest"
-version = "0.12.8"
-source = "git+https://github.com/zed-industries/reqwest.git?rev=fd110f6998da16bbca97b6dddda9be7827c50e29#fd110f6998da16bbca97b6dddda9be7827c50e29"
-dependencies = [
- "base64 0.22.1",
- "bytes 1.7.1",
- "encoding_rs",
- "futures-core",
- "futures-util",
- "h2 0.4.6",
- "http 1.1.0",
- "http-body 1.0.1",
- "http-body-util",
- "hyper 1.4.1",
- "hyper-rustls 0.27.3",
- "hyper-tls 0.6.0",
- "hyper-util",
- "ipnet",
- "js-sys",
- "log",
- "mime",
- "native-tls",
- "once_cell",
- "percent-encoding",
- "pin-project-lite",
- "quinn",
- "rustls 0.23.13",
- "rustls-pemfile 2.1.3",
- "rustls-pki-types",
- "serde",
- "serde_json",
- "serde_urlencoded",
- "sync_wrapper 1.0.1",
- "system-configuration 0.6.1",
- "tokio",
- "tokio-native-tls",
- "tokio-rustls 0.26.0",
- "tokio-util",
- "tower-service",
- "url",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-streams",
- "web-sys",
- "windows-registry",
-]
-
-[[package]]
-name = "reqwest_client"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "bytes 1.7.1",
- "futures 0.3.30",
- "http_client",
- "reqwest 0.12.8",
- "serde",
- "smol",
- "tokio",
-]
-
 [[package]]
 name = "resvg"
 version = "0.41.0"
@@ -9393,6 +9265,21 @@ dependencies = [
  "util",
 ]
 
+[[package]]
+name = "ring"
+version = "0.16.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+dependencies = [
+ "cc",
+ "libc",
+ "once_cell",
+ "spin 0.5.2",
+ "untrusted 0.7.1",
+ "web-sys",
+ "winapi",
+]
+
 [[package]]
 name = "ring"
 version = "0.17.8"
@@ -9403,8 +9290,8 @@ dependencies = [
  "cfg-if",
  "getrandom 0.2.15",
  "libc",
- "spin",
- "untrusted",
+ "spin 0.9.8",
+ "untrusted 0.9.0",
  "windows-sys 0.52.0",
 ]
 
@@ -9560,7 +9447,7 @@ dependencies = [
  "futures 0.3.30",
  "glob",
  "rand 0.8.5",
- "ring",
+ "ring 0.17.8",
  "serde",
  "serde_json",
  "shellexpand 3.1.0",
@@ -9632,12 +9519,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
-[[package]]
-name = "rustc-hash"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152"
-
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -9689,28 +9570,26 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.21.12"
+version = "0.20.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
+checksum = "1b80e3dec595989ea8510028f30c408a4630db12c9cbb8de34203b89d6577e99"
 dependencies = [
  "log",
- "ring",
- "rustls-webpki 0.101.7",
+ "ring 0.16.20",
  "sct",
+ "webpki",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.23.13"
+version = "0.21.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2dabaac7466917e566adb06783a81ca48944c6898a1b08b9374106dd671f4c8"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 dependencies = [
- "once_cell",
- "ring",
- "rustls-pki-types",
- "rustls-webpki 0.102.8",
- "subtle",
- "zeroize",
+ "log",
+ "ring 0.17.8",
+ "rustls-webpki",
+ "sct",
 ]
 
 [[package]]
@@ -9769,19 +9648,8 @@ version = "0.101.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 dependencies = [
- "ring",
- "untrusted",
-]
-
-[[package]]
-name = "rustls-webpki"
-version = "0.102.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
-dependencies = [
- "ring",
- "rustls-pki-types",
- "untrusted",
+ "ring 0.17.8",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -9895,8 +9763,8 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.8",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -10092,6 +9960,7 @@ dependencies = [
  "gpui",
  "heed",
  "http_client",
+ "isahc_http_client",
  "language",
  "language_model",
  "languages",
@@ -10109,7 +9978,6 @@ dependencies = [
  "tree-sitter",
  "ui",
  "unindent",
- "ureq_client",
  "util",
  "workspace",
  "worktree",
@@ -10542,6 +10410,17 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "sluice"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d7400c0eff44aa2fcb5e31a5f24ba9716ed90138769e4977a2ba6014ae63eb5"
+dependencies = [
+ "async-channel 1.9.0",
+ "futures-core",
+ "futures-io",
+]
+
 [[package]]
 name = "smallvec"
 version = "1.13.2"
@@ -10656,6 +10535,12 @@ dependencies = [
  "smallvec",
 ]
 
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -10986,6 +10871,7 @@ dependencies = [
  "fuzzy",
  "gpui",
  "indoc",
+ "isahc_http_client",
  "language",
  "log",
  "menu",
@@ -10999,7 +10885,6 @@ dependencies = [
  "theme",
  "title_bar",
  "ui",
- "ureq_client",
 ]
 
 [[package]]
@@ -11287,15 +11172,6 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
 
-[[package]]
-name = "sync_wrapper"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394"
-dependencies = [
- "futures-core",
-]
-
 [[package]]
 name = "synchronoise"
 version = "1.0.1"
@@ -11336,18 +11212,7 @@ checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
 dependencies = [
  "bitflags 1.3.2",
  "core-foundation 0.9.4",
- "system-configuration-sys 0.5.0",
-]
-
-[[package]]
-name = "system-configuration"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
-dependencies = [
- "bitflags 2.6.0",
- "core-foundation 0.9.4",
- "system-configuration-sys 0.6.0",
+ "system-configuration-sys",
 ]
 
 [[package]]
@@ -11360,16 +11225,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "system-configuration-sys"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
 [[package]]
 name = "system-deps"
 version = "6.2.2"
@@ -11747,7 +11602,7 @@ dependencies = [
  "fancy-regex",
  "lazy_static",
  "parking_lot",
- "rustc-hash 1.1.0",
+ "rustc-hash",
 ]
 
 [[package]]
@@ -11963,17 +11818,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "tokio-rustls"
-version = "0.26.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4"
-dependencies = [
- "rustls 0.23.13",
- "rustls-pki-types",
- "tokio",
-]
-
 [[package]]
 name = "tokio-socks"
 version = "0.5.2"
@@ -12023,9 +11867,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.12"
+version = "0.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a"
+checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1"
 dependencies = [
  "bytes 1.7.1",
  "futures-core",
@@ -12207,6 +12051,16 @@ dependencies = [
  "valuable",
 ]
 
+[[package]]
+name = "tracing-futures"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
+dependencies = [
+ "pin-project",
+ "tracing",
+]
+
 [[package]]
 name = "tracing-log"
 version = "0.2.0"
@@ -12513,24 +12367,6 @@ dependencies = [
  "utf-8",
 ]
 
-[[package]]
-name = "tungstenite"
-version = "0.24.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
-dependencies = [
- "byteorder",
- "bytes 1.7.1",
- "data-encoding",
- "http 1.1.0",
- "httparse",
- "log",
- "rand 0.8.5",
- "sha1",
- "thiserror",
- "utf-8",
-]
-
 [[package]]
 name = "typeid"
 version = "1.0.2"
@@ -12691,40 +12527,15 @@ checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
 
 [[package]]
 name = "untrusted"
-version = "0.9.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
 
 [[package]]
-name = "ureq"
-version = "2.9.1"
+name = "untrusted"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8cdd25c339e200129fe4de81451814e5228c9b771d57378817d6117cc2b3f97"
-dependencies = [
- "base64 0.21.7",
- "flate2",
- "log",
- "once_cell",
- "rustls 0.21.12",
- "rustls-webpki 0.101.7",
- "url",
- "webpki-roots 0.25.4",
-]
-
-[[package]]
-name = "ureq_client"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "futures 0.3.30",
- "gpui",
- "http_client",
- "parking_lot",
- "serde",
- "smol",
- "ureq",
- "util",
-]
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "url"
@@ -13029,7 +12840,7 @@ dependencies = [
  "futures-util",
  "headers",
  "http 0.2.12",
- "hyper 0.14.30",
+ "hyper",
  "log",
  "mime",
  "mime_guess",
@@ -13165,19 +12976,6 @@ dependencies = [
  "wasmparser 0.201.0",
 ]
 
-[[package]]
-name = "wasm-streams"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b65dc4c90b63b118468cf747d8bf3566c1913ef60be765b5730ead9e0a3ba129"
-dependencies = [
- "futures-util",
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
-]
-
 [[package]]
 name = "wasmparser"
 version = "0.201.0"
@@ -13593,8 +13391,8 @@ version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.8",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -13851,17 +13649,6 @@ dependencies = [
  "syn 2.0.76",
 ]
 
-[[package]]
-name = "windows-registry"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e400001bb720a623c1c69032f8e3e4cf09984deec740f007dd2b03ec864804b0"
-dependencies = [
- "windows-result 0.2.0",
- "windows-strings",
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows-result"
 version = "0.1.2"
@@ -14653,6 +14440,7 @@ dependencies = [
  "image_viewer",
  "inline_completion_button",
  "install_cli",
+ "isahc_http_client",
  "journal",
  "language",
  "language_model",
@@ -14705,7 +14493,6 @@ dependencies = [
  "tree-sitter-md",
  "tree-sitter-rust",
  "ui",
- "ureq_client",
  "url",
  "urlencoding",
  "util",
diff --git a/Cargo.toml b/Cargo.toml
index 6fc22029e7a4f4..887d9fb55a4e7f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,6 +52,7 @@ members = [
     "crates/indexed_docs",
     "crates/inline_completion_button",
     "crates/install_cli",
+    "crates/isahc_http_client",
     "crates/journal",
     "crates/language",
     "crates/language_model",
@@ -87,7 +88,6 @@ members = [
     "crates/remote",
     "crates/remote_server",
     "crates/repl",
-    "crates/reqwest_client",
     "crates/rich_text",
     "crates/rope",
     "crates/rpc",
@@ -122,7 +122,6 @@ members = [
     "crates/ui",
     "crates/ui_input",
     "crates/ui_macros",
-    "crates/ureq_client",
     "crates/util",
     "crates/vcs_menu",
     "crates/vim",
@@ -230,6 +229,7 @@ image_viewer = { path = "crates/image_viewer" }
 indexed_docs = { path = "crates/indexed_docs" }
 inline_completion_button = { path = "crates/inline_completion_button" }
 install_cli = { path = "crates/install_cli" }
+isahc_http_client = { path = "crates/isahc_http_client" }
 journal = { path = "crates/journal" }
 language = { path = "crates/language" }
 language_model = { path = "crates/language_model" }
@@ -266,7 +266,6 @@ release_channel = { path = "crates/release_channel" }
 remote = { path = "crates/remote" }
 remote_server = { path = "crates/remote_server" }
 repl = { path = "crates/repl" }
-reqwest_client = { path = "crates/reqwest_client" }
 rich_text = { path = "crates/rich_text" }
 rope = { path = "crates/rope" }
 rpc = { path = "crates/rpc" }
@@ -301,7 +300,6 @@ title_bar = { path = "crates/title_bar" }
 ui = { path = "crates/ui" }
 ui_input = { path = "crates/ui_input" }
 ui_macros = { path = "crates/ui_macros" }
-ureq_client = { path = "crates/ureq_client" }
 util = { path = "crates/util" }
 vcs_menu = { path = "crates/vcs_menu" }
 vim = { path = "crates/vim" }
@@ -329,7 +327,7 @@ async-pipe = { git = "https://github.com/zed-industries/async-pipe-rs", rev = "8
 async-recursion = "1.0.0"
 async-tar = "0.5.0"
 async-trait = "0.1"
-async-tungstenite = "0.28"
+async-tungstenite = "0.23"
 async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
 base64 = "0.22"
@@ -369,6 +367,10 @@ ignore = "0.4.22"
 image = "0.25.1"
 indexmap = { version = "1.6.2", features = ["serde"] }
 indoc = "2"
+# We explicitly disable http2 support in isahc.
+isahc = { version = "1.7.2", default-features = false, features = [
+    "text-decoding",
+] }
 itertools = "0.13.0"
 jsonwebtoken = "9.3"
 libc = "0.2"
@@ -393,14 +395,13 @@ pulldown-cmark = { version = "0.12.0", default-features = false }
 rand = "0.8.5"
 regex = "1.5"
 repair_json = "0.1.0"
-reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29" }
 rsa = "0.9.6"
 runtimelib = { version = "0.15", default-features = false, features = [
     "async-dispatcher-runtime",
 ] }
 rustc-demangle = "0.1.23"
 rust-embed = { version = "8.4", features = ["include-exclude"] }
-rustls = "0.21.12"
+rustls = "0.20.3"
 rustls-native-certs = "0.8.0"
 schemars = { version = "0.8", features = ["impl_json_schema"] }
 semver = "1.0"
diff --git a/crates/client/Cargo.toml b/crates/client/Cargo.toml
index c3fbea1f98a882..dd420bbbe63184 100644
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -18,7 +18,6 @@ test-support = ["clock/test-support", "collections/test-support", "gpui/test-sup
 [dependencies]
 anyhow.workspace = true
 async-recursion = "0.3"
-async-tls = "0.13"
 async-tungstenite = { workspace = true, features = ["async-std", "async-tls"] }
 chrono = { workspace = true, features = ["serde"] }
 clock.workspace = true
@@ -35,6 +34,8 @@ postage.workspace = true
 rand.workspace = true
 release_channel.workspace = true
 rpc = { workspace = true, features = ["gpui"] }
+rustls.workspace = true
+rustls-native-certs.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 03d81b117f37e6..7a37b1b40556b8 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -1023,7 +1023,7 @@ impl Client {
         &self,
         http: Arc<HttpClientWithUrl>,
         release_channel: Option<ReleaseChannel>,
-    ) -> impl Future<Output = Result<url::Url>> {
+    ) -> impl Future<Output = Result<Url>> {
         #[cfg(any(test, feature = "test-support"))]
         let url_override = self.rpc_url.read().clone();
 
@@ -1117,7 +1117,7 @@ impl Client {
             // for us from the RPC URL.
             //
             // Among other things, it will generate and set a `Sec-WebSocket-Key` header for us.
-            let mut request = IntoClientRequest::into_client_request(rpc_url.as_str())?;
+            let mut request = rpc_url.into_client_request()?;
 
             // We then modify the request to add our desired headers.
             let request_headers = request.headers_mut();
@@ -1137,13 +1137,30 @@ impl Client {
 
             match url_scheme {
                 Https => {
+                    let client_config = {
+                        let mut root_store = rustls::RootCertStore::empty();
+
+                        let root_certs = rustls_native_certs::load_native_certs();
+                        for error in root_certs.errors {
+                            log::warn!("error loading native certs: {:?}", error);
+                        }
+                        root_store.add_parsable_certificates(
+                            &root_certs
+                                .certs
+                                .into_iter()
+                                .map(|cert| cert.as_ref().to_owned())
+                                .collect::<Vec<_>>(),
+                        );
+                        rustls::ClientConfig::builder()
+                            .with_safe_defaults()
+                            .with_root_certificates(root_store)
+                            .with_no_client_auth()
+                    };
                     let (stream, _) =
                         async_tungstenite::async_tls::client_async_tls_with_connector(
                             request,
                             stream,
-                            Some(async_tls::TlsConnector::from(
-                                http_client::TLS_CONFIG.clone(),
-                            )),
+                            Some(client_config.into()),
                         )
                         .await?;
                     Ok(Connection::new(
diff --git a/crates/collab/Cargo.toml b/crates/collab/Cargo.toml
index de7a3c621465e0..48482bd4356226 100644
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -37,6 +37,7 @@ futures.workspace = true
 google_ai.workspace = true
 hex.workspace = true
 http_client.workspace = true
+isahc_http_client.workspace = true
 jsonwebtoken.workspace = true
 live_kit_server.workspace = true
 log.workspace = true
@@ -47,7 +48,6 @@ prometheus = "0.13"
 prost.workspace = true
 rand.workspace = true
 reqwest = { version = "0.11", features = ["json"] }
-reqwest_client.workspace = true
 rpc.workspace = true
 rustc-demangle.workspace = true
 scrypt = "0.11"
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index 96413cf7c56710..86563a766cdea6 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -22,8 +22,7 @@ use chrono::{DateTime, Duration, Utc};
 use collections::HashMap;
 use db::{usage_measure::UsageMeasure, ActiveUserCount, LlmDatabase};
 use futures::{Stream, StreamExt as _};
-
-use reqwest_client::ReqwestClient;
+use isahc_http_client::IsahcHttpClient;
 use rpc::ListModelsResponse;
 use rpc::{
     proto::Plan, LanguageModelProvider, PerformCompletionParams, EXPIRED_LLM_TOKEN_HEADER_NAME,
@@ -44,7 +43,7 @@ pub struct LlmState {
     pub config: Config,
     pub executor: Executor,
     pub db: Arc<LlmDatabase>,
-    pub http_client: ReqwestClient,
+    pub http_client: IsahcHttpClient,
     pub clickhouse_client: Option<clickhouse::Client>,
     active_user_count_by_model:
         RwLock<HashMap<(LanguageModelProvider, String), (DateTime<Utc>, ActiveUserCount)>>,
@@ -70,8 +69,11 @@ impl LlmState {
         let db = Arc::new(db);
 
         let user_agent = format!("Zed Server/{}", env!("CARGO_PKG_VERSION"));
-        let http_client =
-            ReqwestClient::user_agent(&user_agent).context("failed to construct http client")?;
+        let http_client = IsahcHttpClient::builder()
+            .default_header("User-Agent", user_agent)
+            .build()
+            .map(IsahcHttpClient::from)
+            .context("failed to construct http client")?;
 
         let this = Self {
             executor,
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index e66c306c506ddb..95e2e620419bd2 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -36,8 +36,8 @@ use collections::{HashMap, HashSet};
 pub use connection_pool::{ConnectionPool, ZedVersion};
 use core::fmt::{self, Debug, Formatter};
 use http_client::HttpClient;
+use isahc_http_client::IsahcHttpClient;
 use open_ai::{OpenAiEmbeddingModel, OPEN_AI_API_URL};
-use reqwest_client::ReqwestClient;
 use sha2::Digest;
 use supermaven_api::{CreateExternalUserRequest, SupermavenAdminApi};
 
@@ -964,8 +964,8 @@ impl Server {
             tracing::info!("connection opened");
 
             let user_agent = format!("Zed Server/{}", env!("CARGO_PKG_VERSION"));
-            let http_client = match ReqwestClient::user_agent(&user_agent) {
-                Ok(http_client) => Arc::new(http_client),
+            let http_client = match IsahcHttpClient::builder().default_header("User-Agent", user_agent).build() {
+                Ok(http_client) => Arc::new(IsahcHttpClient::from(http_client)),
                 Err(error) => {
                     tracing::error!(?error, "failed to create HTTP client");
                     return;
diff --git a/crates/evals/Cargo.toml b/crates/evals/Cargo.toml
index 2697b768453f16..b3b3a2f2a80109 100644
--- a/crates/evals/Cargo.toml
+++ b/crates/evals/Cargo.toml
@@ -25,6 +25,7 @@ fs.workspace = true
 git.workspace = true
 gpui.workspace = true
 http_client.workspace = true
+isahc_http_client.workspace = true
 language.workspace = true
 languages.workspace = true
 node_runtime.workspace = true
@@ -35,4 +36,3 @@ serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
 smol.workspace = true
-ureq_client.workspace = true
diff --git a/crates/evals/src/eval.rs b/crates/evals/src/eval.rs
index e2dc5c8e03a2fa..899d8210537111 100644
--- a/crates/evals/src/eval.rs
+++ b/crates/evals/src/eval.rs
@@ -32,7 +32,6 @@ use std::{
         Arc,
     },
 };
-use ureq_client::UreqClient;
 
 const CODESEARCH_NET_DIR: &'static str = "target/datasets/code-search-net";
 const EVAL_REPOS_DIR: &'static str = "target/datasets/eval-repos";
@@ -101,11 +100,7 @@ fn main() -> Result<()> {
 
     gpui::App::headless().run(move |cx| {
         let executor = cx.background_executor().clone();
-        let client = Arc::new(UreqClient::new(
-            None,
-            "Zed LLM evals".to_string(),
-            executor.clone(),
-        ));
+        let client = isahc_http_client::IsahcHttpClient::new(None, None);
         cx.set_http_client(client.clone());
         match cli.command {
             Commands::Fetch {} => {
diff --git a/crates/extension/Cargo.toml b/crates/extension/Cargo.toml
index 2b1d6193f86699..f495ef7cdc9920 100644
--- a/crates/extension/Cargo.toml
+++ b/crates/extension/Cargo.toml
@@ -56,6 +56,7 @@ wit-component.workspace = true
 workspace.workspace = true
 
 [dev-dependencies]
+isahc_http_client.workspace = true
 ctor.workspace = true
 env_logger.workspace = true
 fs = { workspace = true, features = ["test-support"] }
@@ -63,7 +64,5 @@ gpui = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }
 parking_lot.workspace = true
 project = { workspace = true, features = ["test-support"] }
-reqwest_client.workspace = true
 tokio.workspace = true
-ureq_client.workspace = true
 workspace = { workspace = true, features = ["test-support"] }
diff --git a/crates/extension/src/extension_builder.rs b/crates/extension/src/extension_builder.rs
index 876d0336dc7077..7380e699f9e715 100644
--- a/crates/extension/src/extension_builder.rs
+++ b/crates/extension/src/extension_builder.rs
@@ -25,7 +25,7 @@ use wit_component::ComponentEncoder;
 /// Once Rust 1.78 is released, there will be a `wasm32-wasip2` target available, so we will
 /// not need the adapter anymore.
 const RUST_TARGET: &str = "wasm32-wasip1";
-pub const WASI_ADAPTER_URL: &str =
+const WASI_ADAPTER_URL: &str =
     "https://github.com/bytecodealliance/wasmtime/releases/download/v18.0.2/wasi_snapshot_preview1.reactor.wasm";
 
 /// Compiling Tree-sitter parsers from C to WASM requires Clang 17, and a WASM build of libc
diff --git a/crates/extension/src/extension_store_test.rs b/crates/extension/src/extension_store_test.rs
index 7a3c645e041a14..126e6b2cfbdad0 100644
--- a/crates/extension/src/extension_store_test.rs
+++ b/crates/extension/src/extension_store_test.rs
@@ -1,4 +1,3 @@
-use crate::extension_builder::WASI_ADAPTER_URL;
 use crate::extension_manifest::SchemaVersion;
 use crate::extension_settings::ExtensionSettings;
 use crate::{
@@ -12,14 +11,14 @@ use collections::BTreeMap;
 use fs::{FakeFs, Fs, RealFs};
 use futures::{io::BufReader, AsyncReadExt, StreamExt};
 use gpui::{Context, SemanticVersion, TestAppContext};
-use http_client::{AsyncBody, FakeHttpClient, HttpClient, Response};
+use http_client::{FakeHttpClient, Response};
 use indexed_docs::IndexedDocsRegistry;
+use isahc_http_client::IsahcHttpClient;
 use language::{LanguageMatcher, LanguageRegistry, LanguageServerBinaryStatus, LanguageServerName};
 use node_runtime::NodeRuntime;
 use parking_lot::Mutex;
 use project::{Project, DEFAULT_COMPLETION_CONTEXT};
 use release_channel::AppVersion;
-use reqwest_client::ReqwestClient;
 use serde_json::json;
 use settings::{Settings as _, SettingsStore};
 use snippet_provider::SnippetRegistry;
@@ -29,7 +28,6 @@ use std::{
     sync::Arc,
 };
 use theme::ThemeRegistry;
-use ureq_client::UreqClient;
 use util::test::temp_tree;
 
 #[cfg(test)]
@@ -578,7 +576,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
             std::env::consts::ARCH
         )
     });
-    let builder_client = Arc::new(UreqClient::new(None, user_agent, cx.executor().clone()));
+    let builder_client = IsahcHttpClient::new(None, Some(user_agent));
 
     let extension_store = cx.new_model(|cx| {
         ExtensionStore::new(
@@ -771,50 +769,6 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
     assert!(fs.metadata(&expected_server_path).await.unwrap().is_none());
 }
 
-#[gpui::test]
-async fn test_wasi_adapter_download(cx: &mut TestAppContext) {
-    let client = Arc::new(UreqClient::new(
-        None,
-        "zed-test-wasi-adapter-download".to_string(),
-        cx.executor().clone(),
-    ));
-
-    let mut response = client
-        .get(WASI_ADAPTER_URL, AsyncBody::default(), true)
-        .await
-        .unwrap();
-
-    let mut content = Vec::new();
-    let mut body = BufReader::new(response.body_mut());
-    body.read_to_end(&mut content).await.unwrap();
-
-    assert!(wasmparser::Parser::is_core_wasm(&content));
-    assert_eq!(content.len(), 96801); // Determined by downloading this to my computer
-    wit_component::ComponentEncoder::default()
-        .adapter("wasi_snapshot_preview1", &content)
-        .unwrap();
-}
-
-#[tokio::test]
-async fn test_wasi_adapter_download_tokio() {
-    let client = Arc::new(ReqwestClient::new());
-
-    let mut response = client
-        .get(WASI_ADAPTER_URL, AsyncBody::default(), true)
-        .await
-        .unwrap();
-
-    let mut content = Vec::new();
-    let mut body = BufReader::new(response.body_mut());
-    body.read_to_end(&mut content).await.unwrap();
-
-    assert!(wasmparser::Parser::is_core_wasm(&content));
-    assert_eq!(content.len(), 96801); // Determined by downloading this to my computer
-    wit_component::ComponentEncoder::default()
-        .adapter("wasi_snapshot_preview1", &content)
-        .unwrap();
-}
-
 fn init_test(cx: &mut TestAppContext) {
     cx.update(|cx| {
         let store = SettingsStore::test(cx);
diff --git a/crates/extension_cli/Cargo.toml b/crates/extension_cli/Cargo.toml
index 6de3e858d4fff5..bc649d8e04989f 100644
--- a/crates/extension_cli/Cargo.toml
+++ b/crates/extension_cli/Cargo.toml
@@ -18,9 +18,9 @@ clap = { workspace = true, features = ["derive"] }
 env_logger.workspace = true
 extension = { workspace = true, features = ["no-webrtc"] }
 fs.workspace = true
+isahc_http_client.workspace = true
 language.workspace = true
 log.workspace = true
-reqwest_client.workspace = true
 rpc.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/extension_cli/src/main.rs b/crates/extension_cli/src/main.rs
index dd6f2213781197..6eaebca2f0e9bf 100644
--- a/crates/extension_cli/src/main.rs
+++ b/crates/extension_cli/src/main.rs
@@ -13,8 +13,8 @@ use extension::{
     extension_builder::{CompileExtensionOptions, ExtensionBuilder},
     ExtensionManifest,
 };
+use isahc_http_client::IsahcHttpClient;
 use language::LanguageConfig;
-use reqwest_client::ReqwestClient;
 use theme::ThemeRegistry;
 use tree_sitter::{Language, Query, WasmStore};
 
@@ -66,7 +66,12 @@ async fn main() -> Result<()> {
         std::env::consts::OS,
         std::env::consts::ARCH
     );
-    let http_client = Arc::new(ReqwestClient::user_agent(&user_agent)?);
+    let http_client = Arc::new(
+        IsahcHttpClient::builder()
+            .default_header("User-Agent", user_agent)
+            .build()
+            .map(IsahcHttpClient::from)?,
+    );
 
     let builder = ExtensionBuilder::new(http_client, scratch_dir);
     builder
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index f81a2092d56af6..bba5f857b4f52c 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -1533,8 +1533,4 @@ impl HttpClient for NullHttpClient {
     fn proxy(&self) -> Option<&http_client::Uri> {
         None
     }
-
-    fn type_name(&self) -> &'static str {
-        type_name::<Self>()
-    }
 }
diff --git a/crates/http_client/Cargo.toml b/crates/http_client/Cargo.toml
index e8585cff9820fd..0244ac41042b6f 100644
--- a/crates/http_client/Cargo.toml
+++ b/crates/http_client/Cargo.toml
@@ -16,13 +16,11 @@ path = "src/http_client.rs"
 doctest = true
 
 [dependencies]
+http = "0.2"
 anyhow.workspace = true
 derive_more.workspace = true
 futures.workspace = true
-http = "1.1"
 log.workspace = true
-rustls-native-certs.workspace = true
-rustls.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 smol.workspace = true
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index bf1046d88ee820..2f029a1d236bba 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -11,22 +11,13 @@ use http::request::Builder;
 #[cfg(feature = "test-support")]
 use std::fmt;
 use std::{
-    any::type_name,
-    sync::{Arc, LazyLock, Mutex},
+    sync::{Arc, Mutex},
     time::Duration,
 };
 pub use url::Url;
 
-#[derive(Clone)]
 pub struct ReadTimeout(pub Duration);
-impl Default for ReadTimeout {
-    fn default() -> Self {
-        Self(Duration::from_secs(5))
-    }
-}
-
-#[derive(Default, Debug, Clone, PartialEq, Eq, Hash)]
-
+#[derive(Default, Debug, Clone)]
 pub enum RedirectPolicy {
     #[default]
     NoFollow,
@@ -35,23 +26,6 @@ pub enum RedirectPolicy {
 }
 pub struct FollowRedirects(pub bool);
 
-pub static TLS_CONFIG: LazyLock<Arc<rustls::ClientConfig>> = LazyLock::new(|| {
-    let mut root_store = rustls::RootCertStore::empty();
-
-    let root_certs = rustls_native_certs::load_native_certs();
-    for error in root_certs.errors {
-        log::warn!("error loading native certs: {:?}", error);
-    }
-    root_store.add_parsable_certificates(&root_certs.certs);
-
-    Arc::new(
-        rustls::ClientConfig::builder()
-            .with_safe_defaults()
-            .with_root_certificates(root_store)
-            .with_no_client_auth(),
-    )
-});
-
 pub trait HttpRequestExt {
     /// Set a read timeout on the request.
     /// For isahc, this is the low_speed_timeout.
@@ -73,8 +47,6 @@ impl HttpRequestExt for http::request::Builder {
 }
 
 pub trait HttpClient: 'static + Send + Sync {
-    fn type_name(&self) -> &'static str;
-
     fn send(
         &self,
         req: http::Request<AsyncBody>,
@@ -157,10 +129,6 @@ impl HttpClient for HttpClientWithProxy {
     fn proxy(&self) -> Option<&Uri> {
         self.proxy.as_ref()
     }
-
-    fn type_name(&self) -> &'static str {
-        self.client.type_name()
-    }
 }
 
 impl HttpClient for Arc<HttpClientWithProxy> {
@@ -174,10 +142,6 @@ impl HttpClient for Arc<HttpClientWithProxy> {
     fn proxy(&self) -> Option<&Uri> {
         self.proxy.as_ref()
     }
-
-    fn type_name(&self) -> &'static str {
-        self.client.type_name()
-    }
 }
 
 /// An [`HttpClient`] that has a base URL.
@@ -289,10 +253,6 @@ impl HttpClient for Arc<HttpClientWithUrl> {
     fn proxy(&self) -> Option<&Uri> {
         self.client.proxy.as_ref()
     }
-
-    fn type_name(&self) -> &'static str {
-        self.client.type_name()
-    }
 }
 
 impl HttpClient for HttpClientWithUrl {
@@ -306,10 +266,6 @@ impl HttpClient for HttpClientWithUrl {
     fn proxy(&self) -> Option<&Uri> {
         self.client.proxy.as_ref()
     }
-
-    fn type_name(&self) -> &'static str {
-        self.client.type_name()
-    }
 }
 
 pub fn read_proxy_from_env() -> Option<Uri> {
@@ -350,10 +306,6 @@ impl HttpClient for BlockedHttpClient {
     fn proxy(&self) -> Option<&Uri> {
         None
     }
-
-    fn type_name(&self) -> &'static str {
-        type_name::<Self>()
-    }
 }
 
 #[cfg(feature = "test-support")]
@@ -426,8 +378,4 @@ impl HttpClient for FakeHttpClient {
     fn proxy(&self) -> Option<&Uri> {
         None
     }
-
-    fn type_name(&self) -> &'static str {
-        type_name::<Self>()
-    }
 }
diff --git a/crates/ureq_client/Cargo.toml b/crates/isahc_http_client/Cargo.toml
similarity index 53%
rename from crates/ureq_client/Cargo.toml
rename to crates/isahc_http_client/Cargo.toml
index 757ba010946c70..82f7621bf8cace 100644
--- a/crates/ureq_client/Cargo.toml
+++ b/crates/isahc_http_client/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "ureq_client"
+name = "isahc_http_client"
 version = "0.1.0"
 edition = "2021"
 publish = false
@@ -12,20 +12,11 @@ workspace = true
 test-support = []
 
 [lib]
-path = "src/ureq_client.rs"
-doctest = true
-
-[[example]]
-name = "client"
-path = "examples/client.rs"
+path = "src/isahc_http_client.rs"
 
 [dependencies]
 anyhow.workspace = true
 futures.workspace = true
-gpui.workspace = true
 http_client.workspace = true
-parking_lot.workspace = true
-serde.workspace = true
-smol.workspace = true
-ureq = "=2.9.1"
+isahc.workspace = true
 util.workspace = true
diff --git a/crates/isahc_http_client/LICENSE-APACHE b/crates/isahc_http_client/LICENSE-APACHE
new file mode 120000
index 00000000000000..1cd601d0a3affa
--- /dev/null
+++ b/crates/isahc_http_client/LICENSE-APACHE
@@ -0,0 +1 @@
+../../LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/isahc_http_client/src/isahc_http_client.rs b/crates/isahc_http_client/src/isahc_http_client.rs
new file mode 100644
index 00000000000000..778f6a04598909
--- /dev/null
+++ b/crates/isahc_http_client/src/isahc_http_client.rs
@@ -0,0 +1,105 @@
+use std::{mem, sync::Arc, time::Duration};
+
+use futures::future::BoxFuture;
+use util::maybe;
+
+pub use isahc::config::Configurable;
+pub struct IsahcHttpClient(isahc::HttpClient);
+
+pub use http_client::*;
+
+impl IsahcHttpClient {
+    pub fn new(proxy: Option<Uri>, user_agent: Option<String>) -> Arc<IsahcHttpClient> {
+        let mut builder = isahc::HttpClient::builder()
+            .connect_timeout(Duration::from_secs(5))
+            .low_speed_timeout(100, Duration::from_secs(5))
+            .proxy(proxy.clone());
+        if let Some(agent) = user_agent {
+            builder = builder.default_header("User-Agent", agent);
+        }
+        Arc::new(IsahcHttpClient(builder.build().unwrap()))
+    }
+    pub fn builder() -> isahc::HttpClientBuilder {
+        isahc::HttpClientBuilder::new()
+    }
+}
+
+impl From<isahc::HttpClient> for IsahcHttpClient {
+    fn from(client: isahc::HttpClient) -> Self {
+        Self(client)
+    }
+}
+
+impl HttpClient for IsahcHttpClient {
+    fn proxy(&self) -> Option<&Uri> {
+        None
+    }
+
+    fn send(
+        &self,
+        req: http_client::http::Request<http_client::AsyncBody>,
+    ) -> BoxFuture<'static, Result<http_client::Response<http_client::AsyncBody>, anyhow::Error>>
+    {
+        let redirect_policy = req
+            .extensions()
+            .get::<http_client::RedirectPolicy>()
+            .cloned()
+            .unwrap_or_default();
+        let read_timeout = req
+            .extensions()
+            .get::<http_client::ReadTimeout>()
+            .map(|t| t.0);
+        let req = maybe!({
+            let (mut parts, body) = req.into_parts();
+            let mut builder = isahc::Request::builder()
+                .method(parts.method)
+                .uri(parts.uri)
+                .version(parts.version);
+            if let Some(read_timeout) = read_timeout {
+                builder = builder.low_speed_timeout(100, read_timeout);
+            }
+
+            let headers = builder.headers_mut()?;
+            mem::swap(headers, &mut parts.headers);
+
+            let extensions = builder.extensions_mut()?;
+            mem::swap(extensions, &mut parts.extensions);
+
+            let isahc_body = match body.0 {
+                http_client::Inner::Empty => isahc::AsyncBody::empty(),
+                http_client::Inner::AsyncReader(reader) => isahc::AsyncBody::from_reader(reader),
+                http_client::Inner::SyncReader(reader) => {
+                    isahc::AsyncBody::from_bytes_static(reader.into_inner())
+                }
+            };
+
+            builder
+                .redirect_policy(match redirect_policy {
+                    http_client::RedirectPolicy::FollowAll => isahc::config::RedirectPolicy::Follow,
+                    http_client::RedirectPolicy::FollowLimit(limit) => {
+                        isahc::config::RedirectPolicy::Limit(limit)
+                    }
+                    http_client::RedirectPolicy::NoFollow => isahc::config::RedirectPolicy::None,
+                })
+                .body(isahc_body)
+                .ok()
+        });
+
+        let client = self.0.clone();
+
+        Box::pin(async move {
+            match req {
+                Some(req) => client
+                    .send_async(req)
+                    .await
+                    .map_err(Into::into)
+                    .map(|response| {
+                        let (parts, body) = response.into_parts();
+                        let body = http_client::AsyncBody::from_reader(body);
+                        http_client::Response::from_parts(parts, body)
+                    }),
+                None => Err(anyhow::anyhow!("Request was malformed")),
+            }
+        })
+    }
+}
diff --git a/crates/live_kit_server/Cargo.toml b/crates/live_kit_server/Cargo.toml
index 4b4b5e13dad43b..bad4c5a05f4754 100644
--- a/crates/live_kit_server/Cargo.toml
+++ b/crates/live_kit_server/Cargo.toml
@@ -20,7 +20,7 @@ jsonwebtoken.workspace = true
 log.workspace = true
 prost.workspace = true
 prost-types.workspace = true
-reqwest.workspace = true
+reqwest = "0.11"
 serde.workspace = true
 
 [build-dependencies]
diff --git a/crates/reqwest_client/Cargo.toml b/crates/reqwest_client/Cargo.toml
deleted file mode 100644
index 060a382d72ee43..00000000000000
--- a/crates/reqwest_client/Cargo.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-[package]
-name = "reqwest_client"
-version = "0.1.0"
-edition = "2021"
-publish = false
-license = "Apache-2.0"
-
-[lints]
-workspace = true
-
-[features]
-test-support = []
-
-[lib]
-path = "src/reqwest_client.rs"
-doctest = true
-
-[[example]]
-name = "client"
-path = "examples/client.rs"
-
-[dependencies]
-anyhow.workspace = true
-bytes = "1.0"
-futures.workspace = true
-http_client.workspace = true
-serde.workspace = true
-smol.workspace = true
-tokio.workspace = true
-
-reqwest = { workspace = true, features = ["rustls-tls-manual-roots", "stream"] }
diff --git a/crates/reqwest_client/LICENSE-GPL b/crates/reqwest_client/LICENSE-GPL
deleted file mode 120000
index 89e542f750cd38..00000000000000
--- a/crates/reqwest_client/LICENSE-GPL
+++ /dev/null
@@ -1 +0,0 @@
-../../LICENSE-GPL
\ No newline at end of file
diff --git a/crates/reqwest_client/examples/client.rs b/crates/reqwest_client/examples/client.rs
deleted file mode 100644
index 1f50d21e4edc2b..00000000000000
--- a/crates/reqwest_client/examples/client.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-use futures::AsyncReadExt as _;
-use http_client::AsyncBody;
-use http_client::HttpClient;
-use reqwest_client::ReqwestClient;
-
-#[tokio::main]
-async fn main() {
-    let resp = ReqwestClient::new()
-        .get("http://zed.dev", AsyncBody::empty(), true)
-        .await
-        .unwrap();
-
-    let mut body = String::new();
-    resp.into_body().read_to_string(&mut body).await.unwrap();
-    println!("{}", &body);
-}
diff --git a/crates/reqwest_client/src/reqwest_client.rs b/crates/reqwest_client/src/reqwest_client.rs
deleted file mode 100644
index f8698b908096b8..00000000000000
--- a/crates/reqwest_client/src/reqwest_client.rs
+++ /dev/null
@@ -1,259 +0,0 @@
-use std::{any::type_name, borrow::Cow, io::Read, pin::Pin, task::Poll};
-
-use anyhow::anyhow;
-use bytes::{BufMut, Bytes, BytesMut};
-use futures::{AsyncRead, TryStreamExt};
-use http_client::{http, AsyncBody, ReadTimeout};
-use reqwest::header::{HeaderMap, HeaderValue};
-use smol::future::FutureExt;
-
-const DEFAULT_CAPACITY: usize = 4096;
-
-pub struct ReqwestClient {
-    client: reqwest::Client,
-}
-
-impl ReqwestClient {
-    pub fn new() -> Self {
-        Self {
-            client: reqwest::Client::new(),
-        }
-    }
-
-    pub fn user_agent(agent: &str) -> anyhow::Result<Self> {
-        let mut map = HeaderMap::new();
-        map.insert(http::header::USER_AGENT, HeaderValue::from_str(agent)?);
-        Ok(Self {
-            client: reqwest::Client::builder().default_headers(map).build()?,
-        })
-    }
-}
-
-impl From<reqwest::Client> for ReqwestClient {
-    fn from(client: reqwest::Client) -> Self {
-        Self { client }
-    }
-}
-
-// This struct is essentially a re-implementation of
-// https://docs.rs/tokio-util/0.7.12/tokio_util/io/struct.ReaderStream.html
-// except outside of Tokio's aegis
-struct ReaderStream {
-    reader: Option<Pin<Box<dyn futures::AsyncRead + Send + Sync>>>,
-    buf: BytesMut,
-    capacity: usize,
-}
-
-impl ReaderStream {
-    fn new(reader: Pin<Box<dyn futures::AsyncRead + Send + Sync>>) -> Self {
-        Self {
-            reader: Some(reader),
-            buf: BytesMut::new(),
-            capacity: DEFAULT_CAPACITY,
-        }
-    }
-}
-
-impl futures::Stream for ReaderStream {
-    type Item = std::io::Result<Bytes>;
-
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        let mut this = self.as_mut();
-
-        let mut reader = match this.reader.take() {
-            Some(r) => r,
-            None => return Poll::Ready(None),
-        };
-
-        if this.buf.capacity() == 0 {
-            let capacity = this.capacity;
-            this.buf.reserve(capacity);
-        }
-
-        match poll_read_buf(&mut reader, cx, &mut this.buf) {
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(Err(err)) => {
-                self.reader = None;
-
-                Poll::Ready(Some(Err(err)))
-            }
-            Poll::Ready(Ok(0)) => {
-                self.reader = None;
-                Poll::Ready(None)
-            }
-            Poll::Ready(Ok(_)) => {
-                let chunk = this.buf.split();
-                self.reader = Some(reader);
-                Poll::Ready(Some(Ok(chunk.freeze())))
-            }
-        }
-    }
-}
-
-/// Implementation from https://docs.rs/tokio-util/0.7.12/src/tokio_util/util/poll_buf.rs.html
-/// Specialized for this use case
-pub fn poll_read_buf(
-    io: &mut Pin<Box<dyn futures::AsyncRead + Send + Sync>>,
-    cx: &mut std::task::Context<'_>,
-    buf: &mut BytesMut,
-) -> Poll<std::io::Result<usize>> {
-    if !buf.has_remaining_mut() {
-        return Poll::Ready(Ok(0));
-    }
-
-    let n = {
-        let dst = buf.chunk_mut();
-
-        // Safety: `chunk_mut()` returns a `&mut UninitSlice`, and `UninitSlice` is a
-        // transparent wrapper around `[MaybeUninit<u8>]`.
-        let dst = unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit<u8>]) };
-        let mut buf = tokio::io::ReadBuf::uninit(dst);
-        let ptr = buf.filled().as_ptr();
-        let unfilled_portion = buf.initialize_unfilled();
-        // SAFETY: Pin projection
-        let io_pin = unsafe { Pin::new_unchecked(io) };
-        std::task::ready!(io_pin.poll_read(cx, unfilled_portion)?);
-
-        // Ensure the pointer does not change from under us
-        assert_eq!(ptr, buf.filled().as_ptr());
-        buf.filled().len()
-    };
-
-    // Safety: This is guaranteed to be the number of initialized (and read)
-    // bytes due to the invariants provided by `ReadBuf::filled`.
-    unsafe {
-        buf.advance_mut(n);
-    }
-
-    Poll::Ready(Ok(n))
-}
-
-enum WrappedBodyInner {
-    None,
-    SyncReader(std::io::Cursor<Cow<'static, [u8]>>),
-    Stream(ReaderStream),
-}
-
-struct WrappedBody(WrappedBodyInner);
-
-impl WrappedBody {
-    fn new(body: AsyncBody) -> Self {
-        match body.0 {
-            http_client::Inner::Empty => Self(WrappedBodyInner::None),
-            http_client::Inner::SyncReader(cursor) => Self(WrappedBodyInner::SyncReader(cursor)),
-            http_client::Inner::AsyncReader(pin) => {
-                Self(WrappedBodyInner::Stream(ReaderStream::new(pin)))
-            }
-        }
-    }
-}
-
-impl futures::stream::Stream for WrappedBody {
-    type Item = Result<Bytes, std::io::Error>;
-
-    fn poll_next(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Option<Self::Item>> {
-        match &mut self.0 {
-            WrappedBodyInner::None => Poll::Ready(None),
-            WrappedBodyInner::SyncReader(cursor) => {
-                let mut buf = Vec::new();
-                match cursor.read_to_end(&mut buf) {
-                    Ok(bytes) => {
-                        if bytes == 0 {
-                            return Poll::Ready(None);
-                        } else {
-                            return Poll::Ready(Some(Ok(Bytes::from(buf))));
-                        }
-                    }
-                    Err(e) => return Poll::Ready(Some(Err(e))),
-                }
-            }
-            WrappedBodyInner::Stream(stream) => {
-                // SAFETY: Pin projection
-                let stream = unsafe { Pin::new_unchecked(stream) };
-                futures::Stream::poll_next(stream, cx)
-            }
-        }
-    }
-}
-
-impl http_client::HttpClient for ReqwestClient {
-    fn proxy(&self) -> Option<&http::Uri> {
-        None
-    }
-
-    fn type_name(&self) -> &'static str {
-        type_name::<Self>()
-    }
-
-    fn send(
-        &self,
-        req: http::Request<http_client::AsyncBody>,
-    ) -> futures::future::BoxFuture<
-        'static,
-        Result<http_client::Response<http_client::AsyncBody>, anyhow::Error>,
-    > {
-        let (parts, body) = req.into_parts();
-
-        let mut request = self.client.request(parts.method, parts.uri.to_string());
-
-        request = request.headers(parts.headers);
-
-        if let Some(redirect_policy) = parts.extensions.get::<http_client::RedirectPolicy>() {
-            request = request.redirect_policy(match redirect_policy {
-                http_client::RedirectPolicy::NoFollow => reqwest::redirect::Policy::none(),
-                http_client::RedirectPolicy::FollowLimit(limit) => {
-                    reqwest::redirect::Policy::limited(*limit as usize)
-                }
-                http_client::RedirectPolicy::FollowAll => reqwest::redirect::Policy::limited(100),
-            });
-        }
-
-        if let Some(ReadTimeout(timeout)) = parts.extensions.get::<ReadTimeout>() {
-            request = request.timeout(*timeout);
-        }
-
-        let body = WrappedBody::new(body);
-        let request = request.body(reqwest::Body::wrap_stream(body));
-
-        async move {
-            let response = request.send().await.map_err(|e| anyhow!(e))?;
-            let status = response.status();
-            let mut builder = http::Response::builder().status(status.as_u16());
-            for (name, value) in response.headers() {
-                builder = builder.header(name, value);
-            }
-            let bytes = response.bytes_stream();
-            let bytes = bytes
-                .map_err(|e| futures::io::Error::new(futures::io::ErrorKind::Other, e))
-                .into_async_read();
-            let body = http_client::AsyncBody::from_reader(bytes);
-            builder.body(body).map_err(|e| anyhow!(e))
-        }
-        .boxed()
-    }
-}
-
-#[cfg(test)]
-mod test {
-
-    use core::str;
-
-    use http_client::AsyncBody;
-    use smol::stream::StreamExt;
-
-    use crate::WrappedBody;
-
-    #[tokio::test]
-    async fn test_sync_streaming_upload() {
-        let mut body = WrappedBody::new(AsyncBody::from("hello there".to_string())).fuse();
-        let result = body.next().await.unwrap().unwrap();
-        assert!(body.next().await.is_none());
-        assert_eq!(str::from_utf8(&result).unwrap(), "hello there");
-    }
-}
diff --git a/crates/semantic_index/Cargo.toml b/crates/semantic_index/Cargo.toml
index 508e64ffea3626..f157cc9b3fc8ef 100644
--- a/crates/semantic_index/Cargo.toml
+++ b/crates/semantic_index/Cargo.toml
@@ -51,6 +51,7 @@ workspace.workspace = true
 worktree.workspace = true
 
 [dev-dependencies]
+isahc_http_client.workspace = true
 client = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
 fs = { workspace = true, features = ["test-support"] }
@@ -61,7 +62,6 @@ language = { workspace = true, features = ["test-support"] }
 languages.workspace = true
 project = { workspace = true, features = ["test-support"] }
 tempfile.workspace = true
-ureq_client.workspace = true
 util = { workspace = true, features = ["test-support"] }
 workspace = { workspace = true, features = ["test-support"] }
 worktree = { workspace = true, features = ["test-support"] }
diff --git a/crates/semantic_index/examples/index.rs b/crates/semantic_index/examples/index.rs
index 1ebed4c17f3bda..c5c2c633a10603 100644
--- a/crates/semantic_index/examples/index.rs
+++ b/crates/semantic_index/examples/index.rs
@@ -2,6 +2,7 @@ use client::Client;
 use futures::channel::oneshot;
 use gpui::App;
 use http_client::HttpClientWithUrl;
+use isahc_http_client::IsahcHttpClient;
 use language::language_settings::AllLanguageSettings;
 use project::Project;
 use semantic_index::{OpenAiEmbeddingModel, OpenAiEmbeddingProvider, SemanticDb};
@@ -28,11 +29,7 @@ fn main() {
         let clock = Arc::new(FakeSystemClock::default());
 
         let http = Arc::new(HttpClientWithUrl::new(
-            Arc::new(ureq_client::UreqClient::new(
-                None,
-                "Zed semantic index example".to_string(),
-                cx.background_executor().clone(),
-            )),
+            IsahcHttpClient::new(None, None),
             "http://localhost:11434",
             None,
         ));
diff --git a/crates/storybook/Cargo.toml b/crates/storybook/Cargo.toml
index b05c7692f9529b..f8e78acad336b0 100644
--- a/crates/storybook/Cargo.toml
+++ b/crates/storybook/Cargo.toml
@@ -22,6 +22,7 @@ editor.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
 indoc.workspace = true
+isahc_http_client.workspace = true
 language.workspace = true
 log.workspace = true
 menu.workspace = true
@@ -35,7 +36,6 @@ strum = { workspace = true, features = ["derive"] }
 theme.workspace = true
 title_bar = { workspace = true, features = ["stories"] }
 ui = { workspace = true, features = ["stories"] }
-ureq_client.workspace = true
 
 [dev-dependencies]
 gpui = { workspace = true, features = ["test-support"] }
diff --git a/crates/storybook/src/storybook.rs b/crates/storybook/src/storybook.rs
index a77602efcca8b5..73b1396da51662 100644
--- a/crates/storybook/src/storybook.rs
+++ b/crates/storybook/src/storybook.rs
@@ -4,14 +4,13 @@ mod assets;
 mod stories;
 mod story_selector;
 
-use std::sync::Arc;
-
 use clap::Parser;
 use dialoguer::FuzzySelect;
 use gpui::{
     div, px, size, AnyView, AppContext, Bounds, Render, ViewContext, VisualContext, WindowBounds,
     WindowOptions,
 };
+use isahc_http_client::IsahcHttpClient;
 use log::LevelFilter;
 use project::Project;
 use settings::{KeymapFile, Settings};
@@ -19,7 +18,6 @@ use simplelog::SimpleLogger;
 use strum::IntoEnumIterator;
 use theme::{ThemeRegistry, ThemeSettings};
 use ui::prelude::*;
-use ureq_client::UreqClient;
 
 use crate::app_menus::app_menus;
 use crate::assets::Assets;
@@ -68,12 +66,8 @@ fn main() {
     gpui::App::new().with_assets(Assets).run(move |cx| {
         load_embedded_fonts(cx).unwrap();
 
-        let http_client = UreqClient::new(
-            None,
-            "zed_storybook".to_string(),
-            cx.background_executor().clone(),
-        );
-        cx.set_http_client(Arc::new(http_client));
+        let http_client = IsahcHttpClient::new(None, Some("zed_storybook".to_string()));
+        cx.set_http_client(http_client);
 
         settings::init(cx);
         theme::init(theme::LoadThemes::All(Box::new(Assets)), cx);
diff --git a/crates/ureq_client/LICENSE-GPL b/crates/ureq_client/LICENSE-GPL
deleted file mode 120000
index 89e542f750cd38..00000000000000
--- a/crates/ureq_client/LICENSE-GPL
+++ /dev/null
@@ -1 +0,0 @@
-../../LICENSE-GPL
\ No newline at end of file
diff --git a/crates/ureq_client/examples/client.rs b/crates/ureq_client/examples/client.rs
deleted file mode 100644
index c5caae40dac9ec..00000000000000
--- a/crates/ureq_client/examples/client.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use futures::AsyncReadExt;
-use http_client::{AsyncBody, HttpClient};
-use ureq_client::UreqClient;
-
-fn main() {
-    gpui::App::headless().run(|cx| {
-        println!("{:?}", std::thread::current().id());
-        cx.spawn(|cx| async move {
-            let resp = UreqClient::new(
-                None,
-                "Conrad's bot".to_string(),
-                cx.background_executor().clone(),
-            )
-            .get("http://zed.dev", AsyncBody::empty(), true)
-            .await
-            .unwrap();
-
-            let mut body = String::new();
-            resp.into_body().read_to_string(&mut body).await.unwrap();
-            println!("{}", body);
-        })
-        .detach();
-    })
-}
diff --git a/crates/ureq_client/src/ureq_client.rs b/crates/ureq_client/src/ureq_client.rs
deleted file mode 100644
index d3d8d3aedc502f..00000000000000
--- a/crates/ureq_client/src/ureq_client.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-use std::any::type_name;
-use std::collections::HashMap;
-use std::io::Read;
-use std::sync::Arc;
-use std::time::Duration;
-use std::{pin::Pin, task::Poll};
-
-use anyhow::Error;
-use futures::channel::mpsc;
-use futures::future::BoxFuture;
-use futures::{AsyncRead, SinkExt, StreamExt};
-use http_client::{http, AsyncBody, HttpClient, RedirectPolicy, Uri};
-use smol::future::FutureExt;
-use util::ResultExt;
-
-pub struct UreqClient {
-    // Note in ureq 2.x the options are stored on the Agent.
-    // In ureq 3.x we'll be able to set these on the request.
-    // In practice it's probably "fine" to have many clients, the number of distinct options
-    // is low; and most requests to the same connection will have the same options so the
-    // connection pool will work.
-    clients: Arc<parking_lot::Mutex<HashMap<(Duration, RedirectPolicy), ureq::Agent>>>,
-    proxy_url: Option<Uri>,
-    proxy: Option<ureq::Proxy>,
-    user_agent: String,
-    background_executor: gpui::BackgroundExecutor,
-}
-
-impl UreqClient {
-    pub fn new(
-        proxy_url: Option<Uri>,
-        user_agent: String,
-        background_executor: gpui::BackgroundExecutor,
-    ) -> Self {
-        Self {
-            clients: Arc::default(),
-            proxy_url: proxy_url.clone(),
-            proxy: proxy_url.and_then(|url| ureq::Proxy::new(url.to_string()).log_err()),
-            user_agent,
-            background_executor,
-        }
-    }
-
-    fn agent_for(&self, redirect_policy: RedirectPolicy, timeout: Duration) -> ureq::Agent {
-        let mut clients = self.clients.lock();
-        // in case our assumption of distinct options is wrong, we'll sporadically clean it out.
-        if clients.len() > 50 {
-            clients.clear()
-        }
-
-        clients
-            .entry((timeout, redirect_policy.clone()))
-            .or_insert_with(|| {
-                let mut builder = ureq::AgentBuilder::new()
-                    .timeout_connect(Duration::from_secs(5))
-                    .timeout_read(timeout)
-                    .timeout_write(timeout)
-                    .user_agent(&self.user_agent)
-                    .tls_config(http_client::TLS_CONFIG.clone())
-                    .redirects(match redirect_policy {
-                        RedirectPolicy::NoFollow => 0,
-                        RedirectPolicy::FollowLimit(limit) => limit,
-                        RedirectPolicy::FollowAll => 100,
-                    });
-                if let Some(proxy) = &self.proxy {
-                    builder = builder.proxy(proxy.clone());
-                }
-                builder.build()
-            })
-            .clone()
-    }
-}
-impl HttpClient for UreqClient {
-    fn proxy(&self) -> Option<&Uri> {
-        self.proxy_url.as_ref()
-    }
-
-    fn type_name(&self) -> &'static str {
-        type_name::<Self>()
-    }
-
-    fn send(
-        &self,
-        request: http::Request<AsyncBody>,
-    ) -> BoxFuture<'static, Result<http::Response<AsyncBody>, Error>> {
-        let agent = self.agent_for(
-            request
-                .extensions()
-                .get::<RedirectPolicy>()
-                .cloned()
-                .unwrap_or_default(),
-            request
-                .extensions()
-                .get::<http_client::ReadTimeout>()
-                .cloned()
-                .unwrap_or_default()
-                .0,
-        );
-        let mut req = agent.request(&request.method().as_ref(), &request.uri().to_string());
-        for (name, value) in request.headers().into_iter() {
-            req = req.set(name.as_str(), value.to_str().unwrap());
-        }
-        let body = request.into_body();
-        let executor = self.background_executor.clone();
-
-        self.background_executor
-            .spawn(async move {
-                let response = match req.send(body) {
-                    Ok(response) => response,
-                    Err(e) => match e {
-                        ureq::Error::Status(_, response) => response,
-                        ureq::Error::Transport(transport) => {
-                            anyhow::bail!(transport)
-                        }
-                    },
-                };
-
-                let mut builder = http::Response::builder()
-                    .status(response.status())
-                    .version(http::Version::HTTP_11);
-                for name in response.headers_names() {
-                    if let Some(value) = response.header(&name) {
-                        builder = builder.header(name, value);
-                    }
-                }
-
-                let body = AsyncBody::from_reader(UreqResponseReader::new(executor, response));
-                let http_response = builder.body(body)?;
-
-                Ok(http_response)
-            })
-            .boxed()
-    }
-}
-
-struct UreqResponseReader {
-    receiver: mpsc::Receiver<std::io::Result<Vec<u8>>>,
-    buffer: Vec<u8>,
-    idx: usize,
-    _task: gpui::Task<()>,
-}
-
-impl UreqResponseReader {
-    fn new(background_executor: gpui::BackgroundExecutor, response: ureq::Response) -> Self {
-        let (mut sender, receiver) = mpsc::channel(1);
-        let mut reader = response.into_reader();
-        let task = background_executor.spawn(async move {
-            let mut buffer = vec![0; 8192];
-            loop {
-                let n = match reader.read(&mut buffer) {
-                    Ok(0) => break,
-                    Ok(n) => n,
-                    Err(e) => {
-                        let _ = sender.send(Err(e)).await;
-                        break;
-                    }
-                };
-                let _ = sender.send(Ok(buffer[..n].to_vec())).await;
-            }
-        });
-
-        UreqResponseReader {
-            _task: task,
-            receiver,
-            buffer: Vec::new(),
-            idx: 0,
-        }
-    }
-}
-
-impl AsyncRead for UreqResponseReader {
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        buf: &mut [u8],
-    ) -> Poll<std::io::Result<usize>> {
-        if self.buffer.is_empty() {
-            match self.receiver.poll_next_unpin(cx) {
-                Poll::Ready(Some(Ok(data))) => self.buffer = data,
-                Poll::Ready(Some(Err(e))) => {
-                    return Poll::Ready(Err(e));
-                }
-                Poll::Ready(None) => {
-                    return Poll::Ready(Ok(0));
-                }
-                Poll::Pending => {
-                    return Poll::Pending;
-                }
-            }
-        }
-        let n = std::cmp::min(buf.len(), self.buffer.len() - self.idx);
-        buf[..n].copy_from_slice(&self.buffer[self.idx..self.idx + n]);
-        self.idx += n;
-        if self.idx == self.buffer.len() {
-            self.buffer.clear();
-            self.idx = 0;
-        }
-        Poll::Ready(Ok(n))
-    }
-}
diff --git a/crates/vim/Cargo.toml b/crates/vim/Cargo.toml
index bb347f49b79d84..410371cb0c554b 100644
--- a/crates/vim/Cargo.toml
+++ b/crates/vim/Cargo.toml
@@ -17,7 +17,7 @@ neovim = ["nvim-rs", "async-compat", "async-trait", "tokio"]
 
 [dependencies]
 anyhow.workspace = true
-async-compat = { workspace = true, "optional" = true }
+async-compat = { version = "0.2.1", "optional" = true }
 async-trait = { workspace = true, "optional" = true }
 collections.workspace = true
 command_palette.workspace = true
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index e340e176a74146..e22f75f5bb3e54 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -57,6 +57,7 @@ http_client.workspace = true
 image_viewer.workspace = true
 inline_completion_button.workspace = true
 install_cli.workspace = true
+isahc_http_client.workspace = true
 journal.workspace = true
 language.workspace = true
 language_model.workspace = true
@@ -107,7 +108,6 @@ theme.workspace = true
 theme_selector.workspace = true
 time.workspace = true
 ui.workspace = true
-ureq_client.workspace = true
 url.workspace = true
 urlencoding = "2.1.2"
 util.workspace = true
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 535cafbccba662..9857c60491b1cc 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -24,9 +24,9 @@ use gpui::{
     UpdateGlobal as _, VisualContext,
 };
 use http_client::{read_proxy_from_env, Uri};
+use isahc_http_client::IsahcHttpClient;
 use language::LanguageRegistry;
 use log::LevelFilter;
-use ureq_client::UreqClient;
 
 use assets::Assets;
 use node_runtime::{NodeBinaryOptions, NodeRuntime};
@@ -334,7 +334,9 @@ fn main() {
 
     log::info!("========== starting zed ==========");
 
-    let app = App::new().with_assets(Assets);
+    let app = App::new()
+        .with_assets(Assets)
+        .with_http_client(IsahcHttpClient::new(None, None));
 
     let system_id = app.background_executor().block(system_id()).ok();
     let installation_id = app.background_executor().block(installation_id()).ok();
@@ -468,8 +470,8 @@ fn main() {
                     .ok()
             })
             .or_else(read_proxy_from_env);
-        let http = UreqClient::new(proxy_url, user_agent, cx.background_executor().clone());
-        cx.set_http_client(Arc::new(http));
+        let http = IsahcHttpClient::new(proxy_url, Some(user_agent));
+        cx.set_http_client(http);
 
         <dyn Fs>::set_global(fs.clone(), cx);
 

From 9c54bd1bd4afe7f19113e896b041dd79d14fd8d6 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 9 Oct 2024 10:45:35 +0200
Subject: [PATCH 544/762] macOS: Drop input handler to avoid editor/project not
 being dropped (#18898)

This fixes the problem of a `Project` sometimes not being dropped when
closing the single, last window of Zed.

Turns out, it wasn't get dropped for the following reason:

1. `editor::Editor` held a reference to project
2. The macOS `input_handler` on the `Window` held a reference to that
`Editor`
3. The AppKit window (and its input handler) get dropped asynchronously
(in the code in this diff), after the window is closed.
4. After the window is closed and no `cx.update()` calls are made
anymore, `flush_effects` is not called anymore.
5. But `flush_effects` is where we dropped entities that don't have any
more references.

In short: we dropped `Editor`, which held a reference to `Project`, out
of band, `flush_effects` wasn't called anymore, and thus the `Project`
wasn't dropped.

cc @ConradIrwin @bennetbo since we talked about this.

Release Notes:

- N/A

Co-authored-by: Antonio <antonio@zed.dev>
---
 crates/gpui/src/platform/mac/window.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/gpui/src/platform/mac/window.rs b/crates/gpui/src/platform/mac/window.rs
index 5f9ee43dec48f7..6d887f2b1384f0 100644
--- a/crates/gpui/src/platform/mac/window.rs
+++ b/crates/gpui/src/platform/mac/window.rs
@@ -768,6 +768,7 @@ impl Drop for MacWindow {
         unsafe {
             this.native_window.setDelegate_(nil);
         }
+        this.input_handler.take();
         this.executor
             .spawn(async move {
                 unsafe {

From f50bca76303f958870f4a3e8864647a63194ebce Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Wed, 9 Oct 2024 12:22:53 +0200
Subject: [PATCH 545/762] ssh: Improve dismissal behaviour (#18900)

Do not always close current window in SshConnectionModal; only do so
when the window was spawned from ssh modal. Assign unique IDs to "Open
folder" buttons

Closes #ISSUE

Release Notes:

- N/A
---
 crates/recent_projects/src/dev_servers.rs     |  6 ++-
 crates/recent_projects/src/recent_projects.rs |  1 -
 crates/recent_projects/src/ssh_connections.rs | 42 +++++++++++++------
 crates/recent_projects/src/ssh_remotes.rs     |  1 -
 4 files changed, 33 insertions(+), 17 deletions(-)
 delete mode 100644 crates/recent_projects/src/ssh_remotes.rs

diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 6171489872cd41..b80a011ca35e24 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -319,7 +319,9 @@ impl DevServerProjects {
         let connection_options = ssh_connection.into();
         workspace.update(cx, |_, cx| {
             cx.defer(move |workspace, cx| {
-                workspace.toggle_modal(cx, |cx| SshConnectionModal::new(&connection_options, cx));
+                workspace.toggle_modal(cx, |cx| {
+                    SshConnectionModal::new(&connection_options, false, cx)
+                });
                 let prompt = workspace
                     .active_modal::<SshConnectionModal>(cx)
                     .unwrap()
@@ -573,7 +575,7 @@ impl DevServerProjects {
                             }))
                             .child(
                                 h_flex().mt_1().pl_1().child(
-                                    Button::new("new-remote_project", "Open Folder…")
+                                    Button::new(("new-remote_project", ix), "Open Folder…")
                                         .size(ButtonSize::Default)
                                         .layer(ElevationIndex::ModalSurface)
                                         .icon(IconName::Plus)
diff --git a/crates/recent_projects/src/recent_projects.rs b/crates/recent_projects/src/recent_projects.rs
index 2285ed6287895e..d763d24234342e 100644
--- a/crates/recent_projects/src/recent_projects.rs
+++ b/crates/recent_projects/src/recent_projects.rs
@@ -1,7 +1,6 @@
 mod dev_servers;
 pub mod disconnected_overlay;
 mod ssh_connections;
-mod ssh_remotes;
 use remote::SshConnectionOptions;
 pub use ssh_connections::open_ssh_project;
 
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index ebac54385d2963..af651333398099 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -5,9 +5,9 @@ use auto_update::AutoUpdater;
 use editor::Editor;
 use futures::channel::oneshot;
 use gpui::{
-    percentage, px, Action, Animation, AnimationExt, AnyWindowHandle, AsyncAppContext,
-    DismissEvent, EventEmitter, FocusableView, ParentElement as _, Render, SemanticVersion,
-    SharedString, Task, Transformation, View,
+    percentage, px, Animation, AnimationExt, AnyWindowHandle, AsyncAppContext, DismissEvent,
+    EventEmitter, FocusableView, ParentElement as _, Render, SemanticVersion, SharedString, Task,
+    Transformation, View,
 };
 use gpui::{AppContext, Model};
 use release_channel::{AppVersion, ReleaseChannel};
@@ -83,6 +83,7 @@ pub struct SshPrompt {
 
 pub struct SshConnectionModal {
     pub(crate) prompt: View<SshPrompt>,
+    is_separate_window: bool,
 }
 
 impl SshPrompt {
@@ -207,9 +208,14 @@ impl Render for SshPrompt {
 }
 
 impl SshConnectionModal {
-    pub fn new(connection_options: &SshConnectionOptions, cx: &mut ViewContext<Self>) -> Self {
+    pub fn new(
+        connection_options: &SshConnectionOptions,
+        is_separate_window: bool,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
         Self {
             prompt: cx.new_view(|cx| SshPrompt::new(connection_options, cx)),
+            is_separate_window,
         }
     }
 
@@ -218,7 +224,10 @@ impl SshConnectionModal {
     }
 
     fn dismiss(&mut self, _: &menu::Cancel, cx: &mut ViewContext<Self>) {
-        cx.remove_window();
+        cx.emit(DismissEvent);
+        if self.is_separate_window {
+            cx.remove_window();
+        }
     }
 }
 
@@ -232,6 +241,7 @@ impl Render for SshConnectionModal {
 
         v_flex()
             .elevation_3(cx)
+            .track_focus(&self.focus_handle(cx))
             .on_action(cx.listener(Self::dismiss))
             .on_action(cx.listener(Self::confirm))
             .w(px(500.))
@@ -250,7 +260,9 @@ impl Render for SshConnectionModal {
                         div().absolute().left_0p5().top_0p5().child(
                             IconButton::new("ssh-connection-cancel", IconName::ArrowLeft)
                                 .icon_size(IconSize::XSmall)
-                                .on_click(|_, cx| cx.dispatch_action(menu::Cancel.boxed_clone()))
+                                .on_click(cx.listener(move |this, _, cx| {
+                                    this.dismiss(&Default::default(), cx);
+                                }))
                                 .tooltip(|cx| Tooltip::for_action("Back", &menu::Cancel, cx)),
                         ),
                     )
@@ -464,11 +476,10 @@ pub async fn open_ssh_project(
     open_options: workspace::OpenOptions,
     cx: &mut AsyncAppContext,
 ) -> Result<()> {
-    let options = cx.update(|cx| (app_state.build_window_options)(None, cx))?;
-
     let window = if let Some(window) = open_options.replace_window {
         window
     } else {
+        let options = cx.update(|cx| (app_state.build_window_options)(None, cx))?;
         cx.open_window(options, |cx| {
             let project = project::Project::local(
                 app_state.client.clone(),
@@ -485,7 +496,9 @@ pub async fn open_ssh_project(
 
     let delegate = window.update(cx, |workspace, cx| {
         cx.activate_window();
-        workspace.toggle_modal(cx, |cx| SshConnectionModal::new(&connection_options, cx));
+        workspace.toggle_modal(cx, |cx| {
+            SshConnectionModal::new(&connection_options, true, cx)
+        });
         let ui = workspace
             .active_modal::<SshConnectionModal>(cx)
             .unwrap()
@@ -500,8 +513,11 @@ pub async fn open_ssh_project(
         })
     })?;
 
-    cx.update(|cx| {
-        workspace::open_ssh_project(window, connection_options, delegate, app_state, paths, cx)
-    })?
-    .await
+    let did_open_ssh_project = cx
+        .update(|cx| {
+            workspace::open_ssh_project(window, connection_options, delegate, app_state, paths, cx)
+        })?
+        .await;
+
+    did_open_ssh_project
 }
diff --git a/crates/recent_projects/src/ssh_remotes.rs b/crates/recent_projects/src/ssh_remotes.rs
deleted file mode 100644
index 8b137891791fe9..00000000000000
--- a/crates/recent_projects/src/ssh_remotes.rs
+++ /dev/null
@@ -1 +0,0 @@
-

From a62a2fa8f7372799a3f66955e39c7da8ed97cf76 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 9 Oct 2024 17:18:20 +0300
Subject: [PATCH 546/762] Always wait for completion resolve before applying
 the completion edits (#18907)

After https://github.com/rust-lang/rust-analyzer/pull/18167 and certain
people who type and complete rapidly, it turned out that we have not
waited for `completionItem/resolve` to finish before applying the
completion results.

Release Notes:

- Fixed completion items applied improperly on fast typing
---
 crates/collab/src/tests/editor_tests.rs       | 84 +++++++++++++------
 .../src/copilot_completion_provider.rs        | 10 ++-
 crates/editor/src/debounced_delay.rs          | 22 +++--
 crates/editor/src/editor.rs                   | 47 +++++++++--
 crates/editor/src/editor_tests.rs             | 18 ++--
 crates/editor/src/hover_popover.rs            | 17 ++--
 crates/editor/src/test/editor_test_context.rs |  1 +
 crates/vim/src/normal/repeat.rs               |  6 +-
 8 files changed, 143 insertions(+), 62 deletions(-)

diff --git a/crates/collab/src/tests/editor_tests.rs b/crates/collab/src/tests/editor_tests.rs
index f9bc21efb1abdf..e35cf873801af2 100644
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -379,51 +379,75 @@ async fn test_collaborating_with_completion(cx_a: &mut TestAppContext, cx_b: &mu
         .next()
         .await
         .unwrap();
-    cx_a.executor().finish_waiting();
-
     // Open the buffer on the host.
     let buffer_a = project_a
         .update(cx_a, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx))
         .await
         .unwrap();
-    cx_a.executor().run_until_parked();
 
     buffer_a.read_with(cx_a, |buffer, _| {
         assert_eq!(buffer.text(), "fn main() { a. }")
     });
 
-    // Confirm a completion on the guest.
-    editor_b.update(cx_b, |editor, cx| {
-        assert!(editor.context_menu_visible());
-        editor.confirm_completion(&ConfirmCompletion { item_ix: Some(0) }, cx);
-        assert_eq!(editor.text(cx), "fn main() { a.first_method() }");
-    });
-
     // Return a resolved completion from the host's language server.
     // The resolved completion has an additional text edit.
     fake_language_server.handle_request::<lsp::request::ResolveCompletionItem, _, _>(
         |params, _| async move {
-            assert_eq!(params.label, "first_method(…)");
-            Ok(lsp::CompletionItem {
-                label: "first_method(…)".into(),
-                detail: Some("fn(&mut self, B) -> C".into()),
-                text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
-                    new_text: "first_method($1)".to_string(),
-                    range: lsp::Range::new(lsp::Position::new(0, 14), lsp::Position::new(0, 14)),
-                })),
-                additional_text_edits: Some(vec![lsp::TextEdit {
-                    new_text: "use d::SomeTrait;\n".to_string(),
-                    range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 0)),
-                }]),
-                insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
-                ..Default::default()
+            Ok(match params.label.as_str() {
+                "first_method(…)" => lsp::CompletionItem {
+                    label: "first_method(…)".into(),
+                    detail: Some("fn(&mut self, B) -> C".into()),
+                    text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
+                        new_text: "first_method($1)".to_string(),
+                        range: lsp::Range::new(
+                            lsp::Position::new(0, 14),
+                            lsp::Position::new(0, 14),
+                        ),
+                    })),
+                    additional_text_edits: Some(vec![lsp::TextEdit {
+                        new_text: "use d::SomeTrait;\n".to_string(),
+                        range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 0)),
+                    }]),
+                    insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
+                    ..Default::default()
+                },
+                "second_method(…)" => lsp::CompletionItem {
+                    label: "second_method(…)".into(),
+                    detail: Some("fn(&mut self, C) -> D<E>".into()),
+                    text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
+                        new_text: "second_method()".to_string(),
+                        range: lsp::Range::new(
+                            lsp::Position::new(0, 14),
+                            lsp::Position::new(0, 14),
+                        ),
+                    })),
+                    insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
+                    additional_text_edits: Some(vec![lsp::TextEdit {
+                        new_text: "use d::SomeTrait;\n".to_string(),
+                        range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 0)),
+                    }]),
+                    ..Default::default()
+                },
+                _ => panic!("unexpected completion label: {:?}", params.label),
             })
         },
     );
+    cx_a.executor().finish_waiting();
+    cx_a.executor().run_until_parked();
 
-    // The additional edit is applied.
+    // Confirm a completion on the guest.
+    editor_b
+        .update(cx_b, |editor, cx| {
+            assert!(editor.context_menu_visible());
+            editor.confirm_completion(&ConfirmCompletion { item_ix: Some(0) }, cx)
+        })
+        .unwrap()
+        .await
+        .unwrap();
     cx_a.executor().run_until_parked();
+    cx_b.executor().run_until_parked();
 
+    // The additional edit is applied.
     buffer_a.read_with(cx_a, |buffer, _| {
         assert_eq!(
             buffer.text(),
@@ -516,9 +540,15 @@ async fn test_collaborating_with_completion(cx_a: &mut TestAppContext, cx_b: &mu
     cx_b.executor().run_until_parked();
 
     // When accepting the completion, the snippet is insert.
+    editor_b
+        .update(cx_b, |editor, cx| {
+            assert!(editor.context_menu_visible());
+            editor.confirm_completion(&ConfirmCompletion { item_ix: Some(0) }, cx)
+        })
+        .unwrap()
+        .await
+        .unwrap();
     editor_b.update(cx_b, |editor, cx| {
-        assert!(editor.context_menu_visible());
-        editor.confirm_completion(&ConfirmCompletion { item_ix: Some(0) }, cx);
         assert_eq!(
             editor.text(cx),
             "use d::SomeTrait;\nfn main() { a.first_method(); a.third_method(, , ) }"
diff --git a/crates/copilot/src/copilot_completion_provider.rs b/crates/copilot/src/copilot_completion_provider.rs
index 3a3361cda1996d..f03d6137faedfb 100644
--- a/crates/copilot/src/copilot_completion_provider.rs
+++ b/crates/copilot/src/copilot_completion_provider.rs
@@ -363,10 +363,12 @@ mod tests {
 
             // Confirming a completion inserts it and hides the context menu, without showing
             // the copilot suggestion afterwards.
-            editor
-                .confirm_completion(&Default::default(), cx)
-                .unwrap()
-                .detach();
+            editor.confirm_completion(&Default::default(), cx).unwrap()
+        })
+        .await
+        .unwrap();
+
+        cx.update_editor(|editor, cx| {
             assert!(!editor.context_menu_visible());
             assert!(!editor.has_active_inline_completion(cx));
             assert_eq!(editor.text(cx), "one.completion_a\ntwo\nthree\n");
diff --git a/crates/editor/src/debounced_delay.rs b/crates/editor/src/debounced_delay.rs
index 0dbf36d49e38aa..1f009c7d7939fa 100644
--- a/crates/editor/src/debounced_delay.rs
+++ b/crates/editor/src/debounced_delay.rs
@@ -1,4 +1,4 @@
-use std::time::Duration;
+use std::{ops::ControlFlow, time::Duration};
 
 use futures::{channel::oneshot, FutureExt};
 use gpui::{Task, ViewContext};
@@ -7,7 +7,7 @@ use crate::Editor;
 
 pub struct DebouncedDelay {
     task: Option<Task<()>>,
-    cancel_channel: Option<oneshot::Sender<()>>,
+    cancel_channel: Option<oneshot::Sender<ControlFlow<()>>>,
 }
 
 impl DebouncedDelay {
@@ -23,17 +23,22 @@ impl DebouncedDelay {
         F: 'static + Send + FnOnce(&mut Editor, &mut ViewContext<Editor>) -> Task<()>,
     {
         if let Some(channel) = self.cancel_channel.take() {
-            _ = channel.send(());
+            channel.send(ControlFlow::Break(())).ok();
         }
 
-        let (sender, mut receiver) = oneshot::channel::<()>();
+        let (sender, mut receiver) = oneshot::channel::<ControlFlow<()>>();
         self.cancel_channel = Some(sender);
 
         drop(self.task.take());
         self.task = Some(cx.spawn(move |model, mut cx| async move {
             let mut timer = cx.background_executor().timer(delay).fuse();
             futures::select_biased! {
-                _ = receiver => return,
+                interrupt = receiver => {
+                    match interrupt {
+                        Ok(ControlFlow::Break(())) | Err(_) => return,
+                        Ok(ControlFlow::Continue(())) => {},
+                    }
+                }
                 _ = timer => {}
             }
 
@@ -42,4 +47,11 @@ impl DebouncedDelay {
             }
         }));
     }
+
+    pub fn start_now(&mut self) -> Option<Task<()>> {
+        if let Some(channel) = self.cancel_channel.take() {
+            channel.send(ControlFlow::Continue(())).ok();
+        }
+        self.task.take()
+    }
 }
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 2f7c8ce5d7303a..412c7d3051ab72 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -4427,16 +4427,49 @@ impl Editor {
         &mut self,
         item_ix: Option<usize>,
         intent: CompletionIntent,
-        cx: &mut ViewContext<Editor>,
-    ) -> Option<Task<std::result::Result<(), anyhow::Error>>> {
-        use language::ToOffset as _;
-
+        cx: &mut ViewContext<Self>,
+    ) -> Option<Task<anyhow::Result<()>>> {
         let completions_menu = if let ContextMenu::Completions(menu) = self.hide_context_menu(cx)? {
             menu
         } else {
             return None;
         };
 
+        let mut resolve_task_store = completions_menu
+            .selected_completion_documentation_resolve_debounce
+            .lock();
+        let selected_completion_resolve = resolve_task_store.start_now();
+        let menu_pre_resolve = self
+            .completion_documentation_pre_resolve_debounce
+            .start_now();
+        drop(resolve_task_store);
+
+        Some(cx.spawn(|editor, mut cx| async move {
+            match (selected_completion_resolve, menu_pre_resolve) {
+                (None, None) => {}
+                (Some(resolve), None) | (None, Some(resolve)) => resolve.await,
+                (Some(resolve_1), Some(resolve_2)) => {
+                    futures::join!(resolve_1, resolve_2);
+                }
+            }
+            if let Some(apply_edits_task) = editor.update(&mut cx, |editor, cx| {
+                editor.apply_resolved_completion(completions_menu, item_ix, intent, cx)
+            })? {
+                apply_edits_task.await?;
+            }
+            Ok(())
+        }))
+    }
+
+    fn apply_resolved_completion(
+        &mut self,
+        completions_menu: CompletionsMenu,
+        item_ix: Option<usize>,
+        intent: CompletionIntent,
+        cx: &mut ViewContext<'_, Editor>,
+    ) -> Option<Task<anyhow::Result<Option<language::Transaction>>>> {
+        use language::ToOffset as _;
+
         let mat = completions_menu
             .matches
             .get(item_ix.unwrap_or(completions_menu.selected_item))?;
@@ -4595,11 +4628,7 @@ impl Editor {
             // so we should automatically call signature_help
             self.show_signature_help(&ShowSignatureHelp, cx);
         }
-
-        Some(cx.foreground_executor().spawn(async move {
-            apply_edits.await?;
-            Ok(())
-        }))
+        Some(apply_edits)
     }
 
     pub fn toggle_code_actions(&mut self, action: &ToggleCodeActions, cx: &mut ViewContext<Self>) {
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 092afb394e42fb..5ab2c9e3a854cf 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -7996,7 +7996,7 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
             .unwrap()
     });
     cx.assert_editor_state(indoc! {"
-        one.second_completionˇ
+        one.ˇ
         two
         three
     "});
@@ -8029,9 +8029,9 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
     cx.assert_editor_state(indoc! {"
         one.second_completionˇ
         two
-        three
-        additional edit
-    "});
+        thoverlapping additional editree
+
+        additional edit"});
 
     cx.set_state(indoc! {"
         one.second_completion
@@ -8091,8 +8091,8 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
     });
     cx.assert_editor_state(indoc! {"
         one.second_completion
-        two sixth_completionˇ
-        three sixth_completionˇ
+        two siˇ
+        three siˇ
         additional edit
     "});
 
@@ -8133,9 +8133,11 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
             .confirm_completion(&ConfirmCompletion::default(), cx)
             .unwrap()
     });
-    cx.assert_editor_state("editor.closeˇ");
+    cx.assert_editor_state("editor.cloˇ");
     handle_resolve_completion_request(&mut cx, None).await;
     apply_additional_edits.await.unwrap();
+    cx.assert_editor_state(indoc! {"
+    editor.closeˇ"});
 }
 
 #[gpui::test]
@@ -10140,7 +10142,7 @@ async fn test_completions_with_additional_edits(cx: &mut gpui::TestAppContext) {
             .confirm_completion(&ConfirmCompletion::default(), cx)
             .unwrap()
     });
-    cx.assert_editor_state(indoc! {"fn main() { let a = 2.Some(2)ˇ; }"});
+    cx.assert_editor_state(indoc! {"fn main() { let a = 2.ˇ; }"});
 
     cx.handle_request::<lsp::request::ResolveCompletionItem, _, _>(move |_, _, _| {
         let task_completion_item = completion_item.clone();
diff --git a/crates/editor/src/hover_popover.rs b/crates/editor/src/hover_popover.rs
index f6eb837ae8ceef..e20b6a3dc85d73 100644
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -821,7 +821,7 @@ mod tests {
                 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
                 completion_provider: Some(lsp::CompletionOptions {
                     trigger_characters: Some(vec![".".to_string(), ":".to_string()]),
-                    resolve_provider: Some(true),
+                    resolve_provider: Some(false),
                     ..Default::default()
                 }),
                 ..Default::default()
@@ -913,12 +913,15 @@ mod tests {
         assert_eq!(counter.load(atomic::Ordering::Acquire), 1);
 
         //apply a completion and check it was successfully applied
-        let _apply_additional_edits = cx.update_editor(|editor, cx| {
-            editor.context_menu_next(&Default::default(), cx);
-            editor
-                .confirm_completion(&ConfirmCompletion::default(), cx)
-                .unwrap()
-        });
+        let () = cx
+            .update_editor(|editor, cx| {
+                editor.context_menu_next(&Default::default(), cx);
+                editor
+                    .confirm_completion(&ConfirmCompletion::default(), cx)
+                    .unwrap()
+            })
+            .await
+            .unwrap();
         cx.assert_editor_state(indoc! {"
             one.second_completionˇ
             two
diff --git a/crates/editor/src/test/editor_test_context.rs b/crates/editor/src/test/editor_test_context.rs
index 7234d97c5b77e4..9406a487969fed 100644
--- a/crates/editor/src/test/editor_test_context.rs
+++ b/crates/editor/src/test/editor_test_context.rs
@@ -13,6 +13,7 @@ use itertools::Itertools;
 use language::{Buffer, BufferSnapshot, LanguageRegistry};
 use multi_buffer::{ExcerptRange, ToPoint};
 use parking_lot::RwLock;
+use pretty_assertions::assert_eq;
 use project::{FakeFs, Project};
 use std::{
     any::TypeId,
diff --git a/crates/vim/src/normal/repeat.rs b/crates/vim/src/normal/repeat.rs
index e0e34ceda79d22..7f06c424f32c0d 100644
--- a/crates/vim/src/normal/repeat.rs
+++ b/crates/vim/src/normal/repeat.rs
@@ -387,7 +387,7 @@ mod test {
             lsp::ServerCapabilities {
                 completion_provider: Some(lsp::CompletionOptions {
                     trigger_characters: Some(vec![".".to_string(), ":".to_string()]),
-                    resolve_provider: Some(true),
+                    resolve_provider: Some(false),
                     ..Default::default()
                 }),
                 ..Default::default()
@@ -432,7 +432,9 @@ mod test {
         request.next().await;
         cx.condition(|editor, _| editor.context_menu_visible())
             .await;
-        cx.simulate_keystrokes("down enter ! escape");
+        cx.simulate_keystrokes("down enter");
+        cx.run_until_parked();
+        cx.simulate_keystrokes("! escape");
 
         cx.assert_state(
             indoc! {"

From dbf986d37a6fb768fc502b0d191d979f0c5b3f0c Mon Sep 17 00:00:00 2001
From: Adam Wolff <wolffiex@anthropic.com>
Date: Wed, 9 Oct 2024 07:47:59 -0700
Subject: [PATCH 547/762] telemetry: Refactor telemetry request  into separate
 method (#18890)

Refactor telemetry request into separate method to make it easier to
override in a fork.

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 crates/client/src/telemetry.rs | 52 ++++++++++++++++++++--------------
 1 file changed, 31 insertions(+), 21 deletions(-)

diff --git a/crates/client/src/telemetry.rs b/crates/client/src/telemetry.rs
index 1dc3cedee28d7b..ba03255d54680b 100644
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -1,12 +1,13 @@
 mod event_coalescer;
 
 use crate::{ChannelId, TelemetrySettings};
+use anyhow::Result;
 use chrono::{DateTime, Utc};
 use clock::SystemClock;
 use collections::{HashMap, HashSet};
 use futures::Future;
 use gpui::{AppContext, BackgroundExecutor, Task};
-use http_client::{self, HttpClient, HttpClientWithUrl, Method};
+use http_client::{self, AsyncBody, HttpClient, HttpClientWithUrl, Method, Request};
 use once_cell::sync::Lazy;
 use parking_lot::Mutex;
 use release_channel::ReleaseChannel;
@@ -597,6 +598,29 @@ impl Telemetry {
         self.state.lock().is_staff
     }
 
+    fn build_request(
+        self: &Arc<Self>,
+        // We take in the JSON bytes buffer so we can reuse the existing allocation.
+        mut json_bytes: Vec<u8>,
+        event_request: EventRequestBody,
+    ) -> Result<Request<AsyncBody>> {
+        json_bytes.clear();
+        serde_json::to_writer(&mut json_bytes, &event_request)?;
+
+        let checksum = calculate_json_checksum(&json_bytes).unwrap_or("".to_string());
+
+        Ok(Request::builder()
+            .method(Method::POST)
+            .uri(
+                self.http_client
+                    .build_zed_api_url("/telemetry/events", &[])?
+                    .as_ref(),
+            )
+            .header("Content-Type", "application/json")
+            .header("x-zed-checksum", checksum)
+            .body(json_bytes.into())?)
+    }
+
     pub fn flush_events(self: &Arc<Self>) {
         let mut state = self.state.lock();
         state.first_event_date_time = None;
@@ -623,10 +647,10 @@ impl Telemetry {
                         }
                     }
 
-                    {
+                    let request_body = {
                         let state = this.state.lock();
 
-                        let request_body = EventRequestBody {
+                        EventRequestBody {
                             system_id: state.system_id.as_deref().map(Into::into),
                             installation_id: state.installation_id.as_deref().map(Into::into),
                             session_id: state.session_id.clone(),
@@ -639,25 +663,11 @@ impl Telemetry {
 
                             release_channel: state.release_channel.map(Into::into),
                             events,
-                        };
-                        json_bytes.clear();
-                        serde_json::to_writer(&mut json_bytes, &request_body)?;
-                    }
-
-                    let checksum = calculate_json_checksum(&json_bytes).unwrap_or("".to_string());
-
-                    let request = http_client::Request::builder()
-                        .method(Method::POST)
-                        .uri(
-                            this.http_client
-                                .build_zed_api_url("/telemetry/events", &[])?
-                                .as_ref(),
-                        )
-                        .header("Content-Type", "application/json")
-                        .header("x-zed-checksum", checksum)
-                        .body(json_bytes.into());
+                        }
+                    };
 
-                    let response = this.http_client.send(request?).await?;
+                    let request = this.build_request(json_bytes, request_body)?;
+                    let response = this.http_client.send(request).await?;
                     if response.status() != 200 {
                         log::error!("Failed to send events: HTTP {:?}", response.status());
                     }

From c674d737347ab713d6f4540e26c103f1bbc7d09a Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 9 Oct 2024 16:51:12 +0200
Subject: [PATCH 548/762] remote server: Do not spawn server when proxy
 reconnects (#18864)

This ensures that we only ever reconnect to a running server and not
spawn a new server with no state.

This avoids the problem of the server process crashing, `proxy`
reconnecting, starting a new server, and the user getting errors like
"unknown buffer id: ...".

Release Notes:

- N/A

---------

Co-authored-by: Bennet Bo Fenner <bennet@zed.dev>
---
 Cargo.lock                       |   1 +
 crates/remote/Cargo.toml         |   1 +
 crates/remote/src/proxy.rs       |  25 +++++
 crates/remote/src/remote.rs      |   1 +
 crates/remote/src/ssh_session.rs | 176 +++++++++++++++++++++----------
 crates/remote_server/src/main.rs |  18 +++-
 crates/remote_server/src/unix.rs | 117 +++++++++++++-------
 7 files changed, 248 insertions(+), 91 deletions(-)
 create mode 100644 crates/remote/src/proxy.rs

diff --git a/Cargo.lock b/Cargo.lock
index cc588fcb22cb35..426d52b8d068fd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9089,6 +9089,7 @@ dependencies = [
  "serde_json",
  "smol",
  "tempfile",
+ "thiserror",
  "util",
 ]
 
diff --git a/crates/remote/Cargo.toml b/crates/remote/Cargo.toml
index 5c291b59d344e7..63c12cf11704b3 100644
--- a/crates/remote/Cargo.toml
+++ b/crates/remote/Cargo.toml
@@ -31,6 +31,7 @@ serde.workspace = true
 serde_json.workspace = true
 smol.workspace = true
 tempfile.workspace = true
+thiserror.workspace = true
 util.workspace = true
 
 [dev-dependencies]
diff --git a/crates/remote/src/proxy.rs b/crates/remote/src/proxy.rs
new file mode 100644
index 00000000000000..d715d5ecf62867
--- /dev/null
+++ b/crates/remote/src/proxy.rs
@@ -0,0 +1,25 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ProxyLaunchError {
+    #[error("Attempted reconnect, but server not running.")]
+    ServerNotRunning,
+}
+
+impl ProxyLaunchError {
+    pub fn to_exit_code(&self) -> i32 {
+        match self {
+            // We're using 90 as the exit code, because 0-78 are often taken
+            // by shells and other conventions and >128 also has certain meanings
+            // in certain contexts.
+            Self::ServerNotRunning => 90,
+        }
+    }
+
+    pub fn from_exit_code(exit_code: i32) -> Option<Self> {
+        match exit_code {
+            90 => Some(Self::ServerNotRunning),
+            _ => None,
+        }
+    }
+}
diff --git a/crates/remote/src/remote.rs b/crates/remote/src/remote.rs
index 3cfaf48a88c4a9..382adf0dacd50f 100644
--- a/crates/remote/src/remote.rs
+++ b/crates/remote/src/remote.rs
@@ -1,5 +1,6 @@
 pub mod json_log;
 pub mod protocol;
+pub mod proxy;
 pub mod ssh_session;
 
 pub use ssh_session::{
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index cf2a70223134d1..5aeda7ade36ce4 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -3,6 +3,7 @@ use crate::{
     protocol::{
         message_len_from_buffer, read_message_with_len, write_message, MessageId, MESSAGE_LEN_SIZE,
     },
+    proxy::ProxyLaunchError,
 };
 use anyhow::{anyhow, Context as _, Result};
 use collections::HashMap;
@@ -271,6 +272,7 @@ enum State {
         attempts: usize,
     },
     ReconnectExhausted,
+    ServerNotRunning,
 }
 
 impl fmt::Display for State {
@@ -282,6 +284,7 @@ impl fmt::Display for State {
             Self::ReconnectFailed { .. } => write!(f, "reconnect failed"),
             Self::ReconnectExhausted => write!(f, "reconnect exhausted"),
             Self::HeartbeatMissed { .. } => write!(f, "heartbeat missed"),
+            Self::ServerNotRunning { .. } => write!(f, "server not running"),
         }
     }
 }
@@ -297,10 +300,23 @@ impl State {
     }
 
     fn can_reconnect(&self) -> bool {
-        matches!(
-            self,
-            Self::Connected { .. } | Self::HeartbeatMissed { .. } | Self::ReconnectFailed { .. }
-        )
+        match self {
+            Self::Connected { .. }
+            | Self::HeartbeatMissed { .. }
+            | Self::ReconnectFailed { .. } => true,
+            State::Connecting
+            | State::Reconnecting
+            | State::ReconnectExhausted
+            | State::ServerNotRunning => false,
+        }
+    }
+
+    fn is_reconnect_failed(&self) -> bool {
+        matches!(self, Self::ReconnectFailed { .. })
+    }
+
+    fn is_reconnecting(&self) -> bool {
+        matches!(self, Self::Reconnecting { .. })
     }
 
     fn heartbeat_recovered(self) -> Self {
@@ -377,6 +393,7 @@ impl From<&State> for ConnectionState {
             State::Reconnecting | State::ReconnectFailed { .. } => Self::Reconnecting,
             State::HeartbeatMissed { .. } => Self::HeartbeatMissed,
             State::ReconnectExhausted => Self::Disconnected,
+            State::ServerNotRunning => Self::Disconnected,
         }
     }
 }
@@ -426,6 +443,7 @@ impl SshRemoteClient {
 
             let (ssh_connection, ssh_proxy_process) = Self::establish_connection(
                 unique_identifier,
+                false,
                 connection_options,
                 delegate.clone(),
                 &mut cx,
@@ -496,6 +514,7 @@ impl SshRemoteClient {
             } else {
                 "no state set".to_string()
             };
+            log::info!("aborting reconnect, because not in state that allows reconnecting");
             return Err(anyhow!(error));
         }
 
@@ -527,7 +546,10 @@ impl SshRemoteClient {
                 forwarder,
                 ..
             } => (attempts, ssh_connection, delegate, forwarder),
-            State::Connecting | State::Reconnecting | State::ReconnectExhausted => unreachable!(),
+            State::Connecting
+            | State::Reconnecting
+            | State::ReconnectExhausted
+            | State::ServerNotRunning => unreachable!(),
         };
 
         let attempts = attempts + 1;
@@ -536,11 +558,12 @@ impl SshRemoteClient {
                 "Failed to reconnect to after {} attempts, giving up",
                 MAX_RECONNECT_ATTEMPTS
             );
-            *lock = Some(State::ReconnectExhausted);
+            drop(lock);
+            self.set_state(State::ReconnectExhausted, cx);
             return Ok(());
         }
-        *lock = Some(State::Reconnecting);
         drop(lock);
+        self.set_state(State::Reconnecting, cx);
 
         log::info!("Trying to reconnect to ssh server... Attempt {}", attempts);
 
@@ -580,6 +603,7 @@ impl SshRemoteClient {
 
             let (ssh_connection, ssh_process) = match Self::establish_connection(
                 identifier,
+                true,
                 connection_options,
                 delegate.clone(),
                 &mut cx,
@@ -616,33 +640,39 @@ impl SshRemoteClient {
         cx.spawn(|this, mut cx| async move {
             let new_state = reconnect_task.await;
             this.update(&mut cx, |this, cx| {
-                match &new_state {
-                    State::Connecting
-                    | State::Reconnecting { .. }
-                    | State::HeartbeatMissed { .. } => {}
-                    State::Connected { .. } => {
-                        log::info!("Successfully reconnected");
-                    }
-                    State::ReconnectFailed {
-                        error, attempts, ..
-                    } => {
-                        log::error!(
-                            "Reconnect attempt {} failed: {:?}. Starting new attempt...",
-                            attempts,
-                            error
-                        );
-                    }
-                    State::ReconnectExhausted => {
-                        log::error!("Reconnect attempt failed and all attempts exhausted");
+                this.try_set_state(cx, |old_state| {
+                    if old_state.is_reconnecting() {
+                        match &new_state {
+                            State::Connecting
+                            | State::Reconnecting { .. }
+                            | State::HeartbeatMissed { .. }
+                            | State::ServerNotRunning => {}
+                            State::Connected { .. } => {
+                                log::info!("Successfully reconnected");
+                            }
+                            State::ReconnectFailed {
+                                error, attempts, ..
+                            } => {
+                                log::error!(
+                                    "Reconnect attempt {} failed: {:?}. Starting new attempt...",
+                                    attempts,
+                                    error
+                                );
+                            }
+                            State::ReconnectExhausted => {
+                                log::error!("Reconnect attempt failed and all attempts exhausted");
+                            }
+                        }
+                        Some(new_state)
+                    } else {
+                        None
                     }
-                }
+                });
 
-                let reconnect_failed = matches!(new_state, State::ReconnectFailed { .. });
-                *this.state.lock() = Some(new_state);
-                cx.notify();
-                if reconnect_failed {
+                if this.state_is(State::is_reconnect_failed) {
                     this.reconnect(cx)
                 } else {
+                    log::debug!("State has transition from Reconnecting into new state while attempting reconnect. Ignoring new state.");
                     Ok(())
                 }
             })
@@ -676,8 +706,10 @@ impl SshRemoteClient {
                             missed_heartbeats,
                             MAX_MISSED_HEARTBEATS
                         );
-                    } else {
+                    } else if missed_heartbeats != 0 {
                         missed_heartbeats = 0;
+                    } else {
+                        continue;
                     }
 
                     let result = this.update(&mut cx, |this, mut cx| {
@@ -697,12 +729,12 @@ impl SshRemoteClient {
         cx: &mut ModelContext<Self>,
     ) -> ControlFlow<()> {
         let state = self.state.lock().take().unwrap();
-        self.state.lock().replace(if missed_heartbeats > 0 {
+        let next_state = if missed_heartbeats > 0 {
             state.heartbeat_missed()
         } else {
             state.heartbeat_recovered()
-        });
-        cx.notify();
+        };
+        self.set_state(next_state, cx);
 
         if missed_heartbeats >= MAX_MISSED_HEARTBEATS {
             log::error!(
@@ -743,7 +775,7 @@ impl SshRemoteClient {
                 select_biased! {
                     outgoing = outgoing_rx.next().fuse() => {
                         let Some(outgoing) = outgoing else {
-                            return anyhow::Ok(());
+                            return anyhow::Ok(None);
                         };
 
                         write_message(&mut child_stdin, &mut stdin_buffer, outgoing).await?;
@@ -755,11 +787,7 @@ impl SshRemoteClient {
                                 child_stdin.close().await?;
                                 outgoing_rx.close();
                                 let status = ssh_proxy_process.status().await?;
-                                if !status.success() {
-                                    log::error!("ssh process exited with status: {status:?}");
-                                    return Err(anyhow!("ssh process exited with non-zero status code: {:?}", status.code()));
-                                }
-                                return Ok(());
+                                return Ok(status.code());
                             }
                             Ok(len) => {
                                 if len < stdout_buffer.len() {
@@ -813,19 +841,56 @@ impl SshRemoteClient {
         cx.spawn(|mut cx| async move {
             let result = io_task.await;
 
-            if let Err(error) = result {
-                log::warn!("ssh io task died with error: {:?}. reconnecting...", error);
-                this.update(&mut cx, |this, cx| {
-                    this.reconnect(cx).ok();
-                })?;
+            match result {
+                Ok(Some(exit_code)) => {
+                    if let Some(error) = ProxyLaunchError::from_exit_code(exit_code) {
+                        match error {
+                            ProxyLaunchError::ServerNotRunning => {
+                                log::error!("failed to reconnect because server is not running");
+                                this.update(&mut cx, |this, cx| {
+                                    this.set_state(State::ServerNotRunning, cx);
+                                })?;
+                            }
+                        }
+                    } else if exit_code > 0 {
+                        log::error!("proxy process terminated unexpectedly");
+                    }
+                }
+                Ok(None) => {}
+                Err(error) => {
+                    log::warn!("ssh io task died with error: {:?}. reconnecting...", error);
+                    this.update(&mut cx, |this, cx| {
+                        this.reconnect(cx).ok();
+                    })?;
+                }
             }
-
             Ok(())
         })
     }
 
+    fn state_is(&self, check: impl FnOnce(&State) -> bool) -> bool {
+        self.state.lock().as_ref().map_or(false, check)
+    }
+
+    fn try_set_state(
+        &self,
+        cx: &mut ModelContext<Self>,
+        map: impl FnOnce(&State) -> Option<State>,
+    ) {
+        if let Some(new_state) = self.state.lock().as_ref().and_then(map) {
+            self.set_state(new_state, cx);
+        }
+    }
+
+    fn set_state(&self, state: State, cx: &mut ModelContext<Self>) {
+        log::info!("setting state to '{}'", &state);
+        self.state.lock().replace(state);
+        cx.notify();
+    }
+
     async fn establish_connection(
         unique_identifier: String,
+        reconnect: bool,
         connection_options: SshConnectionOptions,
         delegate: Arc<dyn SshClientDelegate>,
         cx: &mut AsyncAppContext,
@@ -851,14 +916,19 @@ impl SshRemoteClient {
 
         delegate.set_status(Some("Starting proxy"), cx);
 
+        let mut start_proxy_command = format!(
+            "RUST_LOG={} RUST_BACKTRACE={} {:?} proxy --identifier {}",
+            std::env::var("RUST_LOG").unwrap_or_default(),
+            std::env::var("RUST_BACKTRACE").unwrap_or_default(),
+            remote_binary_path,
+            unique_identifier,
+        );
+        if reconnect {
+            start_proxy_command.push_str(" --reconnect");
+        }
+
         let ssh_proxy_process = socket
-            .ssh_command(format!(
-                "RUST_LOG={} RUST_BACKTRACE={} {:?} proxy --identifier {}",
-                std::env::var("RUST_LOG").unwrap_or_default(),
-                std::env::var("RUST_BACKTRACE").unwrap_or_default(),
-                remote_binary_path,
-                unique_identifier,
-            ))
+            .ssh_command(start_proxy_command)
             // IMPORTANT: we kill this process when we drop the task that uses it.
             .kill_on_drop(true)
             .spawn()
diff --git a/crates/remote_server/src/main.rs b/crates/remote_server/src/main.rs
index 872af42596ffa7..50f34fbd39f581 100644
--- a/crates/remote_server/src/main.rs
+++ b/crates/remote_server/src/main.rs
@@ -24,6 +24,8 @@ enum Commands {
         stdout_socket: PathBuf,
     },
     Proxy {
+        #[arg(long)]
+        reconnect: bool,
         #[arg(long)]
         identifier: String,
     },
@@ -37,6 +39,7 @@ fn main() {
 
 #[cfg(not(windows))]
 fn main() -> Result<()> {
+    use remote::proxy::ProxyLaunchError;
     use remote_server::unix::{execute_proxy, execute_run, init};
 
     let cli = Cli::parse();
@@ -51,9 +54,20 @@ fn main() -> Result<()> {
             init(Some(log_file))?;
             execute_run(pid_file, stdin_socket, stdout_socket)
         }
-        Some(Commands::Proxy { identifier }) => {
+        Some(Commands::Proxy {
+            identifier,
+            reconnect,
+        }) => {
             init(None)?;
-            execute_proxy(identifier)
+            match execute_proxy(identifier, reconnect) {
+                Ok(_) => Ok(()),
+                Err(err) => {
+                    if let Some(err) = err.downcast_ref::<ProxyLaunchError>() {
+                        std::process::exit(err.to_exit_code());
+                    }
+                    Err(err)
+                }
+            }
         }
         Some(Commands::Version) => {
             eprintln!("{}", env!("ZED_PKG_VERSION"));
diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs
index 2e03887ae92d73..7a05268cc8efc1 100644
--- a/crates/remote_server/src/unix.rs
+++ b/crates/remote_server/src/unix.rs
@@ -4,6 +4,7 @@ use fs::RealFs;
 use futures::channel::mpsc;
 use futures::{select, select_biased, AsyncRead, AsyncWrite, FutureExt, SinkExt};
 use gpui::{AppContext, Context as _};
+use remote::proxy::ProxyLaunchError;
 use remote::ssh_session::ChannelClient;
 use remote::{
     json_log::LogRecord,
@@ -227,30 +228,62 @@ pub fn execute_run(pid_file: PathBuf, stdin_socket: PathBuf, stdout_socket: Path
     Ok(())
 }
 
-pub fn execute_proxy(identifier: String) -> Result<()> {
+#[derive(Clone)]
+struct ServerPaths {
+    log_file: PathBuf,
+    pid_file: PathBuf,
+    stdin_socket: PathBuf,
+    stdout_socket: PathBuf,
+}
+
+impl ServerPaths {
+    fn new(identifier: &str) -> Result<Self> {
+        let project_dir = create_state_directory(identifier)?;
+
+        let pid_file = project_dir.join("server.pid");
+        let stdin_socket = project_dir.join("stdin.sock");
+        let stdout_socket = project_dir.join("stdout.sock");
+        let log_file = project_dir.join("server.log");
+
+        Ok(Self {
+            pid_file,
+            stdin_socket,
+            stdout_socket,
+            log_file,
+        })
+    }
+}
+
+pub fn execute_proxy(identifier: String, is_reconnecting: bool) -> Result<()> {
     log::debug!("proxy: starting up. PID: {}", std::process::id());
 
-    let project_dir = ensure_project_dir(&identifier)?;
+    let server_paths = ServerPaths::new(&identifier)?;
 
-    let pid_file = project_dir.join("server.pid");
-    let stdin_socket = project_dir.join("stdin.sock");
-    let stdout_socket = project_dir.join("stdout.sock");
-    let log_file = project_dir.join("server.log");
+    let server_pid = check_pid_file(&server_paths.pid_file)?;
+    let server_running = server_pid.is_some();
+    if is_reconnecting {
+        if !server_running {
+            log::error!("proxy: attempted to reconnect, but no server running");
+            return Err(anyhow!(ProxyLaunchError::ServerNotRunning));
+        }
+    } else {
+        if let Some(pid) = server_pid {
+            log::debug!("proxy: found server already running with PID {}. Killing process and cleaning up files...", pid);
+            kill_running_server(pid, &server_paths)?;
+        }
 
-    let server_running = check_pid_file(&pid_file)?;
-    if !server_running {
-        spawn_server(&log_file, &pid_file, &stdin_socket, &stdout_socket)?;
-    };
+        spawn_server(&server_paths)?;
+    }
 
     let stdin_task = smol::spawn(async move {
         let stdin = Async::new(std::io::stdin())?;
-        let stream = smol::net::unix::UnixStream::connect(stdin_socket).await?;
+        let stream = smol::net::unix::UnixStream::connect(&server_paths.stdin_socket).await?;
         handle_io(stdin, stream, "stdin").await
     });
 
     let stdout_task: smol::Task<Result<()>> = smol::spawn(async move {
         let stdout = Async::new(std::io::stdout())?;
-        let stream = smol::net::unix::UnixStream::connect(stdout_socket).await?;
+        let stream = smol::net::unix::UnixStream::connect(&server_paths.stdout_socket).await?;
         handle_io(stream, stdout, "stdout").await
     });
 
@@ -267,50 +300,62 @@ pub fn execute_proxy(identifier: String) -> Result<()> {
     Ok(())
 }
 
-fn ensure_project_dir(identifier: &str) -> Result<PathBuf> {
-    let project_dir = env::var("HOME").unwrap_or_else(|_| ".".to_string());
-    let project_dir = PathBuf::from(project_dir)
+fn create_state_directory(identifier: &str) -> Result<PathBuf> {
+    let home_dir = env::var("HOME").unwrap_or_else(|_| ".".to_string());
+    let server_dir = PathBuf::from(home_dir)
         .join(".local")
         .join("state")
         .join("zed-remote-server")
         .join(identifier);
 
-    std::fs::create_dir_all(&project_dir)?;
+    std::fs::create_dir_all(&server_dir)?;
 
-    Ok(project_dir)
+    Ok(server_dir)
 }
 
-fn spawn_server(
-    log_file: &Path,
-    pid_file: &Path,
-    stdin_socket: &Path,
-    stdout_socket: &Path,
-) -> Result<()> {
-    if stdin_socket.exists() {
-        std::fs::remove_file(&stdin_socket)?;
+fn kill_running_server(pid: u32, paths: &ServerPaths) -> Result<()> {
+    log::info!("proxy: killing existing server with PID {}", pid);
+    std::process::Command::new("kill")
+        .arg(pid.to_string())
+        .output()
+        .context("proxy: failed to kill existing server")?;
+
+    for file in [&paths.pid_file, &paths.stdin_socket, &paths.stdout_socket] {
+        log::debug!(
+            "proxy: cleaning up file {:?} before starting new server",
+            file
+        );
+        std::fs::remove_file(file).ok();
+    }
+    Ok(())
+}
+
+fn spawn_server(paths: &ServerPaths) -> Result<()> {
+    if paths.stdin_socket.exists() {
+        std::fs::remove_file(&paths.stdin_socket)?;
     }
-    if stdout_socket.exists() {
-        std::fs::remove_file(&stdout_socket)?;
+    if paths.stdout_socket.exists() {
+        std::fs::remove_file(&paths.stdout_socket)?;
     }
 
     let binary_name = std::env::current_exe()?;
     let server_process = std::process::Command::new(binary_name)
         .arg("run")
         .arg("--log-file")
-        .arg(log_file)
+        .arg(&paths.log_file)
         .arg("--pid-file")
-        .arg(pid_file)
+        .arg(&paths.pid_file)
         .arg("--stdin-socket")
-        .arg(stdin_socket)
+        .arg(&paths.stdin_socket)
         .arg("--stdout-socket")
-        .arg(stdout_socket)
+        .arg(&paths.stdout_socket)
         .spawn()?;
 
     log::debug!("proxy: server started. PID: {:?}", server_process.id());
 
     let mut total_time_waited = std::time::Duration::from_secs(0);
     let wait_duration = std::time::Duration::from_millis(20);
-    while !stdout_socket.exists() || !stdin_socket.exists() {
+    while !paths.stdout_socket.exists() || !paths.stdin_socket.exists() {
         log::debug!("proxy: waiting for server to be ready to accept connections...");
         std::thread::sleep(wait_duration);
         total_time_waited += wait_duration;
@@ -323,12 +368,12 @@ fn spawn_server(
     Ok(())
 }
 
-fn check_pid_file(path: &Path) -> Result<bool> {
+fn check_pid_file(path: &Path) -> Result<Option<u32>> {
     let Some(pid) = std::fs::read_to_string(&path)
         .ok()
         .and_then(|contents| contents.parse::<u32>().ok())
     else {
-        return Ok(false);
+        return Ok(None);
     };
 
     log::debug!("proxy: Checking if process with PID {} exists...", pid);
@@ -339,12 +384,12 @@ fn check_pid_file(path: &Path) -> Result<bool> {
     {
         Ok(output) if output.status.success() => {
             log::debug!("proxy: Process with PID {} exists. NOT spawning new server, but attaching to existing one.", pid);
-            Ok(true)
+            Ok(Some(pid))
         }
         _ => {
             log::debug!("proxy: Found PID file, but process with that PID does not exist. Removing PID file.");
             std::fs::remove_file(&path).context("proxy: Failed to remove PID file")?;
-            Ok(false)
+            Ok(None)
         }
     }
 }

From b703514d0e5037419cc3f00a09e51455b2ec55e5 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 9 Oct 2024 17:13:43 +0200
Subject: [PATCH 549/762] project: Observe SshRemoteClient to get notified
 about state changes (#18918)

Release Notes:

- N/A
---
 crates/project/src/project.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 8c2b4bd2a067df..de8601044aab20 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -732,6 +732,7 @@ impl Project {
                 }
             })
             .detach();
+            cx.observe(&ssh, |_, _, cx| cx.notify()).detach();
 
             let this = Self {
                 buffer_ordered_messages_tx: tx,

From b6ba4fcc51bea9a0e9e010cd6579b0456dbc2484 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 9 Oct 2024 18:16:22 +0300
Subject: [PATCH 550/762] Silence the logs

---
 crates/remote/src/ssh_session.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 5aeda7ade36ce4..d79c3eb8d03efd 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -695,7 +695,7 @@ impl SshRemoteClient {
                 loop {
                     timer.next().await;
 
-                    log::info!("Sending heartbeat to server...");
+                    log::debug!("Sending heartbeat to server...");
 
                     let result = client.ping(HEARTBEAT_TIMEOUT).await;
                     if result.is_err() {

From 926e54bd4a15c0b4da7ef7a75d268ed9a78fd6ae Mon Sep 17 00:00:00 2001
From: Joseph T Lyons <JosephTLyons@gmail.com>
Date: Wed, 9 Oct 2024 11:32:34 -0400
Subject: [PATCH 551/762] v0.158.x dev

---
 Cargo.lock            | 2 +-
 crates/zed/Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 426d52b8d068fd..2be2380956af38 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14396,7 +14396,7 @@ dependencies = [
 
 [[package]]
 name = "zed"
-version = "0.157.0"
+version = "0.158.0"
 dependencies = [
  "activity_indicator",
  "anyhow",
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index e22f75f5bb3e54..0ec26ea7cd9fe2 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -2,7 +2,7 @@
 description = "The fast, collaborative code editor."
 edition = "2021"
 name = "zed"
-version = "0.157.0"
+version = "0.158.0"
 publish = false
 license = "GPL-3.0-or-later"
 authors = ["Zed Team <hi@zed.dev>"]

From 8911fd46e12695f4bfb87e49e3261d8100dc8c97 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 9 Oct 2024 18:45:22 +0300
Subject: [PATCH 552/762] Do not log errors when no worktree is found for
 certain assistant panel editors (#18923)

Nothing in the assistant panel needs LSP so far, so the errors are not
useful.

Release Notes:

- N/A
---
 crates/assistant/src/assistant_panel.rs | 32 +++++++++++++++----------
 1 file changed, 19 insertions(+), 13 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 20e6347d01c3d9..c3b4fcc4dc9218 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -18,7 +18,7 @@ use crate::{
     PendingSlashCommand, PendingSlashCommandStatus, QuoteSelection, RemoteContextMetadata,
     SavedContextMetadata, Split, ToggleFocus, ToggleModelSelector, WorkflowStepResolution,
 };
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 use assistant_slash_command::{SlashCommand, SlashCommandOutputSection};
 use assistant_tool::ToolRegistry;
 use client::{proto, Client, Status};
@@ -697,7 +697,9 @@ impl AssistantPanel {
             log::error!("no context found with ID: {}", context_id.to_proto());
             return;
         };
-        let lsp_adapter_delegate = make_lsp_adapter_delegate(&self.project, cx).log_err();
+        let lsp_adapter_delegate = make_lsp_adapter_delegate(&self.project, cx)
+            .log_err()
+            .flatten();
 
         let assistant_panel = cx.view().downgrade();
         let editor = cx.new_view(|cx| {
@@ -971,7 +973,8 @@ impl AssistantPanel {
                 this.update(&mut cx, |this, cx| {
                     let workspace = this.workspace.clone();
                     let project = this.project.clone();
-                    let lsp_adapter_delegate = make_lsp_adapter_delegate(&project, cx).log_err();
+                    let lsp_adapter_delegate =
+                        make_lsp_adapter_delegate(&project, cx).log_err().flatten();
 
                     let fs = this.fs.clone();
                     let project = this.project.clone();
@@ -1001,7 +1004,9 @@ impl AssistantPanel {
             None
         } else {
             let context = self.context_store.update(cx, |store, cx| store.create(cx));
-            let lsp_adapter_delegate = make_lsp_adapter_delegate(&self.project, cx).log_err();
+            let lsp_adapter_delegate = make_lsp_adapter_delegate(&self.project, cx)
+                .log_err()
+                .flatten();
 
             let assistant_panel = cx.view().downgrade();
             let editor = cx.new_view(|cx| {
@@ -1207,7 +1212,7 @@ impl AssistantPanel {
         let project = self.project.clone();
         let workspace = self.workspace.clone();
 
-        let lsp_adapter_delegate = make_lsp_adapter_delegate(&project, cx).log_err();
+        let lsp_adapter_delegate = make_lsp_adapter_delegate(&project, cx).log_err().flatten();
 
         cx.spawn(|this, mut cx| async move {
             let context = context.await?;
@@ -1254,7 +1259,9 @@ impl AssistantPanel {
             .update(cx, |store, cx| store.open_remote_context(id, cx));
         let fs = self.fs.clone();
         let workspace = self.workspace.clone();
-        let lsp_adapter_delegate = make_lsp_adapter_delegate(&self.project, cx).log_err();
+        let lsp_adapter_delegate = make_lsp_adapter_delegate(&self.project, cx)
+            .log_err()
+            .flatten();
 
         cx.spawn(|this, mut cx| async move {
             let context = context.await?;
@@ -5505,22 +5512,21 @@ fn render_docs_slash_command_trailer(
 fn make_lsp_adapter_delegate(
     project: &Model<Project>,
     cx: &mut AppContext,
-) -> Result<Arc<dyn LspAdapterDelegate>> {
+) -> Result<Option<Arc<dyn LspAdapterDelegate>>> {
     project.update(cx, |project, cx| {
         // TODO: Find the right worktree.
-        let worktree = project
-            .worktrees(cx)
-            .next()
-            .ok_or_else(|| anyhow!("no worktrees when constructing LocalLspAdapterDelegate"))?;
+        let Some(worktree) = project.worktrees(cx).next() else {
+            return Ok(None::<Arc<dyn LspAdapterDelegate>>);
+        };
         let http_client = project.client().http_client().clone();
         project.lsp_store().update(cx, |lsp_store, cx| {
-            Ok(LocalLspAdapterDelegate::new(
+            Ok(Some(LocalLspAdapterDelegate::new(
                 lsp_store,
                 &worktree,
                 http_client,
                 project.fs().clone(),
                 cx,
-            ) as Arc<dyn LspAdapterDelegate>)
+            ) as Arc<dyn LspAdapterDelegate>))
         })
     })
 }

From 1cbaca667f71363b85d7e329dfde2541757bddc2 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Wed, 9 Oct 2024 13:19:13 -0400
Subject: [PATCH 553/762] Remove `historical_event` column in editor events
 (#18932)

We have a lot of data in Clickhouse. This column was used when migrating
the events dataset between analytics databases and has no purpose today.

Naive maths: 257,170,993 editor event rows * 1 byte per boolean =
257,170,993 bytes, or ~0.24 GB

I'll drop the column after deploying a new collab.

Going forward, I'd like to remove more data that we never touch, to try
to keep things more focused. We should discuss some TTL at some point.

Release Notes:

- N/A
---
 crates/collab/src/api/events.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/crates/collab/src/api/events.rs b/crates/collab/src/api/events.rs
index 715f37449400c4..c1ab3d7939a075 100644
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -670,7 +670,6 @@ pub struct EditorEventRow {
     time: i64,
     copilot_enabled: bool,
     copilot_enabled_for_language: bool,
-    historical_event: bool,
     architecture: String,
     is_staff: Option<bool>,
     major: Option<i32>,
@@ -718,7 +717,6 @@ impl EditorEventRow {
             country_code: country_code.unwrap_or("XX".to_string()),
             region_code: "".to_string(),
             city: "".to_string(),
-            historical_event: false,
             is_via_ssh: event.is_via_ssh,
         }
     }

From f05b440572860b94053ed24c7d84d9faa2500074 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8B=90=E7=8B=B8?=
 <134658521+Huliiiiii@users.noreply.github.com>
Date: Thu, 10 Oct 2024 01:25:46 +0800
Subject: [PATCH 554/762] Improve syntax highlights (#18728)

Closes #18722

- Replace the `@escape` capture name with `@string.escape` for escape
sequences in Go, Python, Regex, Racket, Ruby, and Scheme.
- Rust
  - Add syntax highlighting for escape sequences. Close #18722
- Fix the issue where `@punctuation.delimiter` is being overwritten by
`@operator`.
  - Add the period (".") to `@punctuation.delimiter`.

Release Notes:

- N/A
---
 crates/languages/src/go/highlights.scm            | 2 +-
 crates/languages/src/python/highlights.scm        | 2 +-
 crates/languages/src/regex/highlights.scm         | 2 +-
 crates/languages/src/rust/highlights.scm          | 7 +++----
 extensions/racket/languages/racket/highlights.scm | 2 +-
 extensions/ruby/languages/ruby/highlights.scm     | 2 +-
 extensions/scheme/languages/scheme/highlights.scm | 2 +-
 7 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/crates/languages/src/go/highlights.scm b/crates/languages/src/go/highlights.scm
index 17b009da35cee4..b9ce232112fb52 100644
--- a/crates/languages/src/go/highlights.scm
+++ b/crates/languages/src/go/highlights.scm
@@ -102,7 +102,7 @@
   (rune_literal)
 ] @string
 
-(escape_sequence) @escape
+(escape_sequence) @string.escape
 
 [
   (int_literal)
diff --git a/crates/languages/src/python/highlights.scm b/crates/languages/src/python/highlights.scm
index 5edbefa7be747d..5b646427712f98 100644
--- a/crates/languages/src/python/highlights.scm
+++ b/crates/languages/src/python/highlights.scm
@@ -54,7 +54,7 @@
 
 (comment) @comment
 (string) @string
-(escape_sequence) @escape
+(escape_sequence) @string.escape
 
 [
   "("
diff --git a/crates/languages/src/regex/highlights.scm b/crates/languages/src/regex/highlights.scm
index 8b653465b4406a..d1ebcda0d3a8c9 100644
--- a/crates/languages/src/regex/highlights.scm
+++ b/crates/languages/src/regex/highlights.scm
@@ -22,7 +22,7 @@
   (end_assertion)
   (boundary_assertion)
   (non_boundary_assertion)
-] @escape
+] @string.escape
 
 [
   "*"
diff --git a/crates/languages/src/rust/highlights.scm b/crates/languages/src/rust/highlights.scm
index 8d4bad06e06ea9..d25b8a734719ba 100644
--- a/crates/languages/src/rust/highlights.scm
+++ b/crates/languages/src/rust/highlights.scm
@@ -65,6 +65,7 @@
   ">" @punctuation.bracket)
 
 [
+  "."
   ";"
   ","
   "::"
@@ -121,6 +122,8 @@
   (char_literal)
 ] @string
 
+(escape_sequence) @string.escape
+
 [
   (integer_literal)
   (float_literal)
@@ -147,20 +150,16 @@
   "&&"
   "*"
   "*="
-  "*"
   "+"
   "+="
-  ","
   "-"
   "-="
   "->"
-  "."
   ".."
   "..="
   "..."
   "/="
   ":"
-  ";"
   "<<"
   "<<="
   "<"
diff --git a/extensions/racket/languages/racket/highlights.scm b/extensions/racket/languages/racket/highlights.scm
index 3caf1d88e97dd0..0b462a9c261f46 100644
--- a/extensions/racket/languages/racket/highlights.scm
+++ b/extensions/racket/languages/racket/highlights.scm
@@ -4,7 +4,7 @@
  (here_string)
  (byte_string)] @string
 (regex) @string.regex
-(escape_sequence) @escape
+(escape_sequence) @string.escape
 
 [(comment)
  (block_comment)
diff --git a/extensions/ruby/languages/ruby/highlights.scm b/extensions/ruby/languages/ruby/highlights.scm
index 17dbb4b07d5b92..7b4d2ff616b7cd 100644
--- a/extensions/ruby/languages/ruby/highlights.scm
+++ b/extensions/ruby/languages/ruby/highlights.scm
@@ -116,7 +116,7 @@
 ] @string.special.symbol
 
 (regex) @string.regex
-(escape_sequence) @escape
+(escape_sequence) @string.escape
 
 [
   (integer)
diff --git a/extensions/scheme/languages/scheme/highlights.scm b/extensions/scheme/languages/scheme/highlights.scm
index 40ba61cd055948..76a4ba7a52a5c4 100644
--- a/extensions/scheme/languages/scheme/highlights.scm
+++ b/extensions/scheme/languages/scheme/highlights.scm
@@ -7,7 +7,7 @@
 (symbol) @variable
 (string) @string
 
-(escape_sequence) @escape
+(escape_sequence) @string.escape
 
 [(comment)
  (block_comment)

From 71f4ca67c23653d1919b0b2a151be9b6dc325ee8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=96mer=20Sinan=20A=C4=9Facan?= <omeragacan@gmail.com>
Date: Wed, 9 Oct 2024 19:26:28 +0200
Subject: [PATCH 555/762] Use WHOLE_WORD search option in vim mode's whole-word
 search (#18725)

Instead of wrapping the search term with `\<...\>`, enable the
`WHOLE_WORD` search option.

The advantage of the search option is that it can be toggled with one
click/key press (alt+w by default), and it doesn't require regex mode.

Release Notes:

- Vim mode's whole word search now uses the search bar's "Match whole
words" option, instead of wrapping the search term with `\<...\>`. This
allows easier toggling of whole-word search, and it also works without
enabling the regex mode.
---
 crates/vim/src/normal/search.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/vim/src/normal/search.rs b/crates/vim/src/normal/search.rs
index 519606b0e5d649..6769238407e8ec 100644
--- a/crates/vim/src/normal/search.rs
+++ b/crates/vim/src/normal/search.rs
@@ -269,6 +269,9 @@ impl Vim {
                 if regex {
                     options |= SearchOptions::REGEX;
                 }
+                if whole_word {
+                    options |= SearchOptions::WHOLE_WORD;
+                }
                 if !search_bar.show(cx) {
                     return None;
                 }
@@ -276,10 +279,7 @@ impl Vim {
                     drop(search_bar.search("", None, cx));
                     return None;
                 };
-                let mut query = regex::escape(&query);
-                if whole_word {
-                    query = format!(r"\<{}\>", query);
-                }
+                let query = regex::escape(&query);
                 Some(search_bar.search(&query, Some(options), cx))
             });
 

From bc4abd2b29d1424d157fc267ea99f2f5a754fcf2 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 9 Oct 2024 19:40:09 +0200
Subject: [PATCH 556/762] ssh session: Fix hang when doing state update in
 reconnect (#18934)

This snuck in last-minute.

Release Notes:

- Fixed a potential hang and panic when an SSH project goes through a
slow reconnect.
---
 crates/remote/src/ssh_session.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index d79c3eb8d03efd..e709fd726e9a7f 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -563,6 +563,7 @@ impl SshRemoteClient {
             return Ok(());
         }
         drop(lock);
+
         self.set_state(State::Reconnecting, cx);
 
         log::info!("Trying to reconnect to ssh server... Attempt {}", attempts);
@@ -734,6 +735,7 @@ impl SshRemoteClient {
         } else {
             state.heartbeat_recovered()
         };
+
         self.set_state(next_state, cx);
 
         if missed_heartbeats >= MAX_MISSED_HEARTBEATS {
@@ -877,8 +879,12 @@ impl SshRemoteClient {
         cx: &mut ModelContext<Self>,
         map: impl FnOnce(&State) -> Option<State>,
     ) {
-        if let Some(new_state) = self.state.lock().as_ref().and_then(map) {
-            self.set_state(new_state, cx);
+        let mut lock = self.state.lock();
+        let new_state = lock.as_ref().and_then(map);
+
+        if let Some(new_state) = new_state {
+            lock.replace(new_state);
+            cx.notify();
         }
     }
 

From bc23d1e6661875f62431744613567b1becce68a6 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 9 Oct 2024 14:05:35 -0400
Subject: [PATCH 557/762] docs: Add gopls install instructions (#18919)

---
 docs/src/languages/go.md | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/docs/src/languages/go.md b/docs/src/languages/go.md
index abbaaa258482ba..dfd047df68188c 100644
--- a/docs/src/languages/go.md
+++ b/docs/src/languages/go.md
@@ -5,6 +5,37 @@ Go support is available natively in Zed.
 - Tree Sitter: [tree-sitter/tree-sitter-go](https://github.com/tree-sitter/tree-sitter-go)
 - Language Server: [golang/tools/tree/master/gopls](https://github.com/golang/tools/tree/master/gopls)
 
+## Setup
+
+We recommend installing gopls via go's package manager and not via Homebrew or your Linux distribution's package manager.
+
+1. Make sure you have uninstalled any version of gopls you have installed via your package manager:
+
+```sh
+# MacOS homebrew
+brew remove gopls
+# Ubuntu
+sudo apt-get remove gopls
+sudo snap remove gopls
+# Arch
+sudo pacman -R gopls
+```
+
+2. Install/Update `gopls` to the latest version using the go module tool:
+
+```sh
+go install golang.org/x/tools/gopls@latest
+```
+
+3. Ensure that `gopls` is in your path:
+
+```sh
+which gopls
+gopls version
+```
+
+If `gopls` is not found you will likely need to add `export PATH="$PATH:$HOME/go/bin"` to your `.zshrc` / `.bash_profile`
+
 ## Inlay Hints
 
 Zed sets the following initialization options for inlay hints:

From 817a41c4dc711debcb935524850fe61ea3ee5daf Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 9 Oct 2024 14:22:32 -0400
Subject: [PATCH 558/762] collab: Add a `Cents` type (#18935)

This PR adds a new `Cents` type that can be used to represent a monetary
value in cents.

This cuts down on the primitive obsession we were using when dealing
with money in the billing code.

Release Notes:

- N/A
---
 Cargo.lock                                    |  1 +
 crates/collab/Cargo.toml                      |  1 +
 crates/collab/src/api/billing.rs              |  7 +-
 crates/collab/src/cents.rs                    | 78 +++++++++++++++++++
 crates/collab/src/lib.rs                      |  2 +
 crates/collab/src/llm.rs                      | 16 ++--
 crates/collab/src/llm/db/queries/usages.rs    | 24 +++---
 crates/collab/src/llm/db/tests/usage_tests.rs | 30 +++----
 8 files changed, 120 insertions(+), 39 deletions(-)
 create mode 100644 crates/collab/src/cents.rs

diff --git a/Cargo.lock b/Cargo.lock
index 2be2380956af38..65deb35f66c450 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2553,6 +2553,7 @@ dependencies = [
  "collections",
  "ctor",
  "dashmap 6.0.1",
+ "derive_more",
  "dev_server_projects",
  "editor",
  "env_logger",
diff --git a/crates/collab/Cargo.toml b/crates/collab/Cargo.toml
index 48482bd4356226..4513e02af30e18 100644
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -32,6 +32,7 @@ clickhouse.workspace = true
 clock.workspace = true
 collections.workspace = true
 dashmap.workspace = true
+derive_more.workspace = true
 envy = "0.4.2"
 futures.workspace = true
 google_ai.workspace = true
diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index b70fc1e3ba32d3..0a0bebbc56317e 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -29,7 +29,7 @@ use crate::db::{
     UpdateBillingSubscriptionParams,
 };
 use crate::llm::db::LlmDatabase;
-use crate::llm::MONTHLY_SPENDING_LIMIT_IN_CENTS;
+use crate::llm::MONTHLY_SPENDING_LIMIT;
 use crate::rpc::ResultExt as _;
 use crate::{AppState, Error, Result};
 
@@ -703,10 +703,9 @@ async fn update_stripe_subscription(
     let subscription_id = SubscriptionId::from_str(&subscription.stripe_subscription_id)
         .context("failed to parse subscription ID")?;
 
-    let monthly_spending_over_free_tier =
-        monthly_spending.saturating_sub(MONTHLY_SPENDING_LIMIT_IN_CENTS);
+    let monthly_spending_over_free_tier = monthly_spending.saturating_sub(MONTHLY_SPENDING_LIMIT);
 
-    let new_quantity = (monthly_spending_over_free_tier as f32 / 100.).ceil();
+    let new_quantity = (monthly_spending_over_free_tier.0 as f32 / 100.).ceil();
     Subscription::update(
         stripe_client,
         &subscription_id,
diff --git a/crates/collab/src/cents.rs b/crates/collab/src/cents.rs
new file mode 100644
index 00000000000000..917177bc51219a
--- /dev/null
+++ b/crates/collab/src/cents.rs
@@ -0,0 +1,78 @@
+/// A number of cents.
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    Clone,
+    Copy,
+    derive_more::Add,
+    derive_more::AddAssign,
+)]
+pub struct Cents(pub u32);
+
+impl Cents {
+    pub const ZERO: Self = Self(0);
+
+    pub const fn new(cents: u32) -> Self {
+        Self(cents)
+    }
+
+    pub const fn from_dollars(dollars: u32) -> Self {
+        Self(dollars * 100)
+    }
+
+    pub fn saturating_sub(self, other: Cents) -> Self {
+        Self(self.0.saturating_sub(other.0))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn test_cents_new() {
+        assert_eq!(Cents::new(50), Cents(50));
+    }
+
+    #[test]
+    fn test_cents_from_dollars() {
+        assert_eq!(Cents::from_dollars(1), Cents(100));
+        assert_eq!(Cents::from_dollars(5), Cents(500));
+    }
+
+    #[test]
+    fn test_cents_zero() {
+        assert_eq!(Cents::ZERO, Cents(0));
+    }
+
+    #[test]
+    fn test_cents_add() {
+        assert_eq!(Cents(50) + Cents(30), Cents(80));
+    }
+
+    #[test]
+    fn test_cents_add_assign() {
+        let mut cents = Cents(50);
+        cents += Cents(30);
+        assert_eq!(cents, Cents(80));
+    }
+
+    #[test]
+    fn test_cents_saturating_sub() {
+        assert_eq!(Cents(50).saturating_sub(Cents(30)), Cents(20));
+        assert_eq!(Cents(30).saturating_sub(Cents(50)), Cents(0));
+    }
+
+    #[test]
+    fn test_cents_ordering() {
+        assert!(Cents(50) > Cents(30));
+        assert!(Cents(30) < Cents(50));
+        assert_eq!(Cents(50), Cents(50));
+    }
+}
diff --git a/crates/collab/src/lib.rs b/crates/collab/src/lib.rs
index ccecf80087aacb..a6141abb888730 100644
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -1,5 +1,6 @@
 pub mod api;
 pub mod auth;
+mod cents;
 pub mod clickhouse;
 pub mod db;
 pub mod env;
@@ -20,6 +21,7 @@ use axum::{
     http::{HeaderMap, StatusCode},
     response::IntoResponse,
 };
+pub use cents::*;
 use db::{ChannelId, Database};
 use executor::Executor;
 pub use rate_limiter::*;
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index 86563a766cdea6..c475de35874c8d 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -4,7 +4,7 @@ mod telemetry;
 mod token;
 
 use crate::{
-    api::CloudflareIpCountryHeader, build_clickhouse_client, db::UserId, executor::Executor,
+    api::CloudflareIpCountryHeader, build_clickhouse_client, db::UserId, executor::Executor, Cents,
     Config, Error, Result,
 };
 use anyhow::{anyhow, Context as _};
@@ -439,12 +439,10 @@ fn normalize_model_name(known_models: Vec<String>, name: String) -> String {
 }
 
 /// The maximum monthly spending an individual user can reach before they have to pay.
-pub const MONTHLY_SPENDING_LIMIT_IN_CENTS: usize = 5 * 100;
+pub const MONTHLY_SPENDING_LIMIT: Cents = Cents::from_dollars(5);
 
 /// The maximum lifetime spending an individual user can reach before being cut off.
-///
-/// Represented in cents.
-const LIFETIME_SPENDING_LIMIT_IN_CENTS: usize = 1_000 * 100;
+const LIFETIME_SPENDING_LIMIT: Cents = Cents::from_dollars(1_000);
 
 async fn check_usage_limit(
     state: &Arc<LlmState>,
@@ -464,7 +462,7 @@ async fn check_usage_limit(
         .await?;
 
     if state.config.is_llm_billing_enabled() {
-        if usage.spending_this_month >= MONTHLY_SPENDING_LIMIT_IN_CENTS {
+        if usage.spending_this_month >= MONTHLY_SPENDING_LIMIT {
             if !claims.has_llm_subscription.unwrap_or(false) {
                 return Err(Error::http(
                     StatusCode::PAYMENT_REQUIRED,
@@ -475,7 +473,7 @@ async fn check_usage_limit(
     }
 
     // TODO: Remove this once we've rolled out monthly spending limits.
-    if usage.lifetime_spending >= LIFETIME_SPENDING_LIMIT_IN_CENTS {
+    if usage.lifetime_spending >= LIFETIME_SPENDING_LIMIT {
         return Err(Error::http(
             StatusCode::FORBIDDEN,
             "Maximum spending limit reached.".to_string(),
@@ -690,8 +688,8 @@ impl<S> Drop for TokenCountingStream<S> {
                                 .cache_read_input_tokens_this_month
                                 as u64,
                             output_tokens_this_month: usage.output_tokens_this_month as u64,
-                            spending_this_month: usage.spending_this_month as u64,
-                            lifetime_spending: usage.lifetime_spending as u64,
+                            spending_this_month: usage.spending_this_month.0 as u64,
+                            lifetime_spending: usage.lifetime_spending.0 as u64,
                         },
                     )
                     .await
diff --git a/crates/collab/src/llm/db/queries/usages.rs b/crates/collab/src/llm/db/queries/usages.rs
index 1a98685bcddb4e..3d6ab184153c4b 100644
--- a/crates/collab/src/llm/db/queries/usages.rs
+++ b/crates/collab/src/llm/db/queries/usages.rs
@@ -1,4 +1,5 @@
 use crate::db::UserId;
+use crate::llm::Cents;
 use chrono::{Datelike, Duration};
 use futures::StreamExt as _;
 use rpc::LanguageModelProvider;
@@ -17,8 +18,8 @@ pub struct Usage {
     pub cache_creation_input_tokens_this_month: usize,
     pub cache_read_input_tokens_this_month: usize,
     pub output_tokens_this_month: usize,
-    pub spending_this_month: usize,
-    pub lifetime_spending: usize,
+    pub spending_this_month: Cents,
+    pub lifetime_spending: Cents,
 }
 
 #[derive(Debug, PartialEq, Clone)]
@@ -144,7 +145,7 @@ impl LlmDatabase {
         &self,
         user_id: UserId,
         now: DateTimeUtc,
-    ) -> Result<usize> {
+    ) -> Result<Cents> {
         self.transaction(|tx| async move {
             let month = now.date_naive().month() as i32;
             let year = now.date_naive().year();
@@ -158,7 +159,7 @@ impl LlmDatabase {
                 )
                 .stream(&*tx)
                 .await?;
-            let mut monthly_spending_in_cents = 0;
+            let mut monthly_spending = Cents::ZERO;
 
             while let Some(usage) = monthly_usages.next().await {
                 let usage = usage?;
@@ -166,7 +167,7 @@ impl LlmDatabase {
                     continue;
                 };
 
-                monthly_spending_in_cents += calculate_spending(
+                monthly_spending += calculate_spending(
                     model,
                     usage.input_tokens as usize,
                     usage.cache_creation_input_tokens as usize,
@@ -175,7 +176,7 @@ impl LlmDatabase {
                 );
             }
 
-            Ok(monthly_spending_in_cents)
+            Ok(monthly_spending)
         })
         .await
     }
@@ -238,7 +239,7 @@ impl LlmDatabase {
                     monthly_usage.output_tokens as usize,
                 )
             } else {
-                0
+                Cents::ZERO
             };
             let lifetime_spending = if let Some(lifetime_usage) = &lifetime_usage {
                 calculate_spending(
@@ -249,7 +250,7 @@ impl LlmDatabase {
                     lifetime_usage.output_tokens as usize,
                 )
             } else {
-                0
+                Cents::ZERO
             };
 
             Ok(Usage {
@@ -637,7 +638,7 @@ fn calculate_spending(
     cache_creation_input_tokens_this_month: usize,
     cache_read_input_tokens_this_month: usize,
     output_tokens_this_month: usize,
-) -> usize {
+) -> Cents {
     let input_token_cost =
         input_tokens_this_month * model.price_per_million_input_tokens as usize / 1_000_000;
     let cache_creation_input_token_cost = cache_creation_input_tokens_this_month
@@ -648,10 +649,11 @@ fn calculate_spending(
         / 1_000_000;
     let output_token_cost =
         output_tokens_this_month * model.price_per_million_output_tokens as usize / 1_000_000;
-    input_token_cost
+    let spending = input_token_cost
         + cache_creation_input_token_cost
         + cache_read_input_token_cost
-        + output_token_cost
+        + output_token_cost;
+    Cents::new(spending as u32)
 }
 
 const MINUTE_BUCKET_COUNT: usize = 12;
diff --git a/crates/collab/src/llm/db/tests/usage_tests.rs b/crates/collab/src/llm/db/tests/usage_tests.rs
index 8e8dc0ff6b240b..2730a030466cad 100644
--- a/crates/collab/src/llm/db/tests/usage_tests.rs
+++ b/crates/collab/src/llm/db/tests/usage_tests.rs
@@ -4,7 +4,7 @@ use crate::{
         queries::{providers::ModelParams, usages::Usage},
         LlmDatabase,
     },
-    test_llm_db,
+    test_llm_db, Cents,
 };
 use chrono::{DateTime, Duration, Utc};
 use pretty_assertions::assert_eq;
@@ -56,8 +56,8 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             cache_creation_input_tokens_this_month: 0,
             cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
-            spending_this_month: 0,
-            lifetime_spending: 0,
+            spending_this_month: Cents::ZERO,
+            lifetime_spending: Cents::ZERO,
         }
     );
 
@@ -73,8 +73,8 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             cache_creation_input_tokens_this_month: 0,
             cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
-            spending_this_month: 0,
-            lifetime_spending: 0,
+            spending_this_month: Cents::ZERO,
+            lifetime_spending: Cents::ZERO,
         }
     );
 
@@ -94,8 +94,8 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             cache_creation_input_tokens_this_month: 0,
             cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
-            spending_this_month: 0,
-            lifetime_spending: 0,
+            spending_this_month: Cents::ZERO,
+            lifetime_spending: Cents::ZERO,
         }
     );
 
@@ -112,8 +112,8 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             cache_creation_input_tokens_this_month: 0,
             cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
-            spending_this_month: 0,
-            lifetime_spending: 0,
+            spending_this_month: Cents::ZERO,
+            lifetime_spending: Cents::ZERO,
         }
     );
 
@@ -132,8 +132,8 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             cache_creation_input_tokens_this_month: 0,
             cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
-            spending_this_month: 0,
-            lifetime_spending: 0,
+            spending_this_month: Cents::ZERO,
+            lifetime_spending: Cents::ZERO,
         }
     );
 
@@ -158,8 +158,8 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             cache_creation_input_tokens_this_month: 500,
             cache_read_input_tokens_this_month: 0,
             output_tokens_this_month: 0,
-            spending_this_month: 0,
-            lifetime_spending: 0,
+            spending_this_month: Cents::ZERO,
+            lifetime_spending: Cents::ZERO,
         }
     );
 
@@ -179,8 +179,8 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             cache_creation_input_tokens_this_month: 500,
             cache_read_input_tokens_this_month: 300,
             output_tokens_this_month: 0,
-            spending_this_month: 0,
-            lifetime_spending: 0,
+            spending_this_month: Cents::ZERO,
+            lifetime_spending: Cents::ZERO,
         }
     );
 }

From f1053ff525f6846025382dfd1aadf6719cefb984 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 9 Oct 2024 15:05:53 -0400
Subject: [PATCH 559/762] collab: Clarify naming around free tier spending
 limits (#18936)

This PR renames the `MONTHLY_SPENDING_LIMIT` constant to
`FREE_TIER_MONTHLY_SPENDING_LIMIT` to clarify it.

This will help distinguish it from the user's specified limit on their
paid monthly spending.

Release Notes:

- N/A
---
 crates/collab/src/api/billing.rs | 5 +++--
 crates/collab/src/llm.rs         | 7 ++++---
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index 0a0bebbc56317e..d2e43714a811e7 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -29,7 +29,7 @@ use crate::db::{
     UpdateBillingSubscriptionParams,
 };
 use crate::llm::db::LlmDatabase;
-use crate::llm::MONTHLY_SPENDING_LIMIT;
+use crate::llm::FREE_TIER_MONTHLY_SPENDING_LIMIT;
 use crate::rpc::ResultExt as _;
 use crate::{AppState, Error, Result};
 
@@ -703,7 +703,8 @@ async fn update_stripe_subscription(
     let subscription_id = SubscriptionId::from_str(&subscription.stripe_subscription_id)
         .context("failed to parse subscription ID")?;
 
-    let monthly_spending_over_free_tier = monthly_spending.saturating_sub(MONTHLY_SPENDING_LIMIT);
+    let monthly_spending_over_free_tier =
+        monthly_spending.saturating_sub(FREE_TIER_MONTHLY_SPENDING_LIMIT);
 
     let new_quantity = (monthly_spending_over_free_tier.0 as f32 / 100.).ceil();
     Subscription::update(
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index c475de35874c8d..c733beb596d912 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -438,8 +438,9 @@ fn normalize_model_name(known_models: Vec<String>, name: String) -> String {
     }
 }
 
-/// The maximum monthly spending an individual user can reach before they have to pay.
-pub const MONTHLY_SPENDING_LIMIT: Cents = Cents::from_dollars(5);
+/// The maximum monthly spending an individual user can reach on the free tier
+/// before they have to pay.
+pub const FREE_TIER_MONTHLY_SPENDING_LIMIT: Cents = Cents::from_dollars(5);
 
 /// The maximum lifetime spending an individual user can reach before being cut off.
 const LIFETIME_SPENDING_LIMIT: Cents = Cents::from_dollars(1_000);
@@ -462,7 +463,7 @@ async fn check_usage_limit(
         .await?;
 
     if state.config.is_llm_billing_enabled() {
-        if usage.spending_this_month >= MONTHLY_SPENDING_LIMIT {
+        if usage.spending_this_month >= FREE_TIER_MONTHLY_SPENDING_LIMIT {
             if !claims.has_llm_subscription.unwrap_or(false) {
                 return Err(Error::http(
                     StatusCode::PAYMENT_REQUIRED,

From 49c75eb062d7af9a7ca7d9d781001960a66061d0 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 9 Oct 2024 22:28:42 +0300
Subject: [PATCH 560/762] Rework remote task synchronization (#18746)

Reworks the way tasks are stored, accessed and synchronized in the
`project`.
Now both collab and ssh remote projects use the same TaskStorage kind to
get the task context from the remote host, and worktree task templates
are synchronized along with other worktree settings.

Release Notes:

- Adds ssh support to tasks, improves collab-remote projects' tasks sync
---
 crates/collab/src/rpc.rs                     |   3 -
 crates/editor/src/editor.rs                  |  49 +-
 crates/editor/src/tasks.rs                   |   9 +-
 crates/project/src/project.rs                | 654 +++--------------
 crates/project/src/project_settings.rs       | 240 +++++--
 crates/project/src/project_tests.rs          | 142 ++--
 crates/project/src/task_inventory.rs         | 705 +++++++------------
 crates/project/src/task_store.rs             | 432 ++++++++++++
 crates/proto/proto/zed.proto                 |  59 +-
 crates/proto/src/proto.rs                    |   4 -
 crates/remote_server/src/headless_project.rs |  25 +-
 crates/settings/src/settings.rs              |   4 +-
 crates/settings/src/settings_store.rs        |  33 +-
 crates/task/src/lib.rs                       |   5 +
 crates/tasks_ui/src/lib.rs                   |  86 ++-
 crates/tasks_ui/src/modal.rs                 | 141 ++--
 crates/workspace/src/tasks.rs                |  10 +-
 crates/zed/src/zed.rs                        |  27 +-
 18 files changed, 1262 insertions(+), 1366 deletions(-)
 create mode 100644 crates/project/src/task_store.rs

diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index 95e2e620419bd2..e5e401e493e9ac 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -469,9 +469,6 @@ impl Server {
             .add_request_handler(user_handler(
                 forward_project_request_for_owner::<proto::TaskContextForLocation>,
             ))
-            .add_request_handler(user_handler(
-                forward_project_request_for_owner::<proto::TaskTemplates>,
-            ))
             .add_request_handler(user_handler(
                 forward_read_only_project_request::<proto::GetHover>,
             ))
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 412c7d3051ab72..15b833c1dcbba5 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -1879,10 +1879,17 @@ impl Editor {
                         }
                     }
                 }));
-                let task_inventory = project.read(cx).task_inventory().clone();
-                project_subscriptions.push(cx.observe(&task_inventory, |editor, _, cx| {
-                    editor.tasks_update_task = Some(editor.refresh_runnables(cx));
-                }));
+                if let Some(task_inventory) = project
+                    .read(cx)
+                    .task_store()
+                    .read(cx)
+                    .task_inventory()
+                    .cloned()
+                {
+                    project_subscriptions.push(cx.observe(&task_inventory, |editor, _, cx| {
+                        editor.tasks_update_task = Some(editor.refresh_runnables(cx));
+                    }));
+                }
             }
         }
 
@@ -4717,11 +4724,13 @@ impl Editor {
                                     );
                                 }
                                 project.update(cx, |project, cx| {
-                                    project.task_context_for_location(
-                                        captured_task_variables,
-                                        location,
-                                        cx,
-                                    )
+                                    project.task_store().update(cx, |task_store, cx| {
+                                        task_store.task_context_for_location(
+                                            captured_task_variables,
+                                            location,
+                                            cx,
+                                        )
+                                    })
                                 })
                             });
 
@@ -9134,23 +9143,29 @@ impl Editor {
                 .map(|file| (file.worktree_id(cx), file.clone()))
                 .unzip();
 
-            (project.task_inventory().clone(), worktree_id, file)
+            (
+                project.task_store().read(cx).task_inventory().cloned(),
+                worktree_id,
+                file,
+            )
         });
 
-        let inventory = inventory.read(cx);
         let tags = mem::take(&mut runnable.tags);
         let mut tags: Vec<_> = tags
             .into_iter()
             .flat_map(|tag| {
                 let tag = tag.0.clone();
                 inventory
-                    .list_tasks(
-                        file.clone(),
-                        Some(runnable.language.clone()),
-                        worktree_id,
-                        cx,
-                    )
+                    .as_ref()
                     .into_iter()
+                    .flat_map(|inventory| {
+                        inventory.read(cx).list_tasks(
+                            file.clone(),
+                            Some(runnable.language.clone()),
+                            worktree_id,
+                            cx,
+                        )
+                    })
                     .filter(move |(_, template)| {
                         template.tags.iter().any(|source_tag| source_tag == &tag)
                     })
diff --git a/crates/editor/src/tasks.rs b/crates/editor/src/tasks.rs
index eb5131e252834b..51945a17803354 100644
--- a/crates/editor/src/tasks.rs
+++ b/crates/editor/src/tasks.rs
@@ -67,10 +67,11 @@ fn task_context_with_editor(
         variables
     };
 
-    let context_task = project.update(cx, |project, cx| {
-        project.task_context_for_location(captured_variables, location.clone(), cx)
-    });
-    cx.spawn(|_| context_task)
+    project.update(cx, |project, cx| {
+        project.task_store().update(cx, |task_store, cx| {
+            task_store.task_context_for_location(captured_variables, location, cx)
+        })
+    })
 }
 
 pub fn task_context(workspace: &Workspace, cx: &mut WindowContext<'_>) -> AsyncTask<TaskContext> {
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index de8601044aab20..214436231dd82a 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -9,6 +9,7 @@ pub mod prettier_store;
 pub mod project_settings;
 pub mod search;
 mod task_inventory;
+pub mod task_store;
 pub mod terminals;
 pub mod worktree_store;
 
@@ -21,7 +22,7 @@ pub use environment::EnvironmentErrorMessage;
 pub mod search_history;
 mod yarn;
 
-use anyhow::{anyhow, Context as _, Result};
+use anyhow::{anyhow, Result};
 use buffer_store::{BufferStore, BufferStoreEvent};
 use client::{
     proto, Client, Collaborator, DevServerProjectId, PendingEntitySubscription, ProjectId,
@@ -44,11 +45,10 @@ use gpui::{
 };
 use itertools::Itertools;
 use language::{
-    language_settings::InlayHintKind,
-    proto::{deserialize_anchor, serialize_anchor, split_operations},
-    Buffer, BufferEvent, CachedLspAdapter, Capability, CodeLabel, ContextProvider, DiagnosticEntry,
-    Documentation, File as _, Language, LanguageRegistry, LanguageServerName, PointUtf16, ToOffset,
-    ToPointUtf16, Transaction, Unclipped,
+    language_settings::InlayHintKind, proto::split_operations, Buffer, BufferEvent,
+    CachedLspAdapter, Capability, CodeLabel, DiagnosticEntry, Documentation, File as _, Language,
+    LanguageRegistry, LanguageServerName, PointUtf16, ToOffset, ToPointUtf16, Transaction,
+    Unclipped,
 };
 use lsp::{
     CompletionContext, CompletionItemKind, DocumentHighlightKind, LanguageServer, LanguageServerId,
@@ -56,16 +56,13 @@ use lsp::{
 use lsp_command::*;
 use node_runtime::NodeRuntime;
 use parking_lot::{Mutex, RwLock};
-use paths::{local_tasks_file_relative_path, local_vscode_tasks_file_relative_path};
 pub use prettier_store::PrettierStore;
 use project_settings::{ProjectSettings, SettingsObserver, SettingsObserverEvent};
 use remote::SshRemoteClient;
 use rpc::{proto::SSH_PROJECT_ID, AnyProtoClient, ErrorCode};
 use search::{SearchInputKind, SearchQuery, SearchResult};
 use search_history::SearchHistory;
-use settings::{
-    watch_config_file, InvalidSettingsError, Settings, SettingsLocation, SettingsStore,
-};
+use settings::{InvalidSettingsError, Settings, SettingsLocation, SettingsStore};
 use smol::channel::Receiver;
 use snippet::Snippet;
 use snippet_provider::SnippetProvider;
@@ -77,10 +74,7 @@ use std::{
     sync::Arc,
     time::Duration,
 };
-use task::{
-    static_source::{StaticSource, TrackedFile},
-    HideStrategy, RevealStrategy, Shell, TaskContext, TaskTemplate, TaskVariables, VariableName,
-};
+use task_store::TaskStore;
 use terminals::Terminals;
 use text::{Anchor, BufferId};
 use util::{paths::compare_paths, ResultExt as _};
@@ -141,6 +135,7 @@ pub struct Project {
     languages: Arc<LanguageRegistry>,
     client: Arc<client::Client>,
     join_project_response_message_id: u32,
+    task_store: Model<TaskStore>,
     user_store: Model<UserStore>,
     fs: Arc<dyn Fs>,
     ssh_client: Option<Model<SshRemoteClient>>,
@@ -156,7 +151,6 @@ pub struct Project {
     remotely_created_models: Arc<Mutex<RemotelyCreatedModels>>,
     terminals: Terminals,
     node: Option<NodeRuntime>,
-    tasks: Model<Inventory>,
     hosted_project_id: Option<ProjectId>,
     dev_server_project_id: Option<client::DevServerProjectId>,
     search_history: SearchHistory,
@@ -567,14 +561,13 @@ impl Project {
         client.add_model_request_handler(Self::handle_open_buffer_by_id);
         client.add_model_request_handler(Self::handle_open_buffer_by_path);
         client.add_model_request_handler(Self::handle_open_new_buffer);
-        client.add_model_request_handler(Self::handle_task_context_for_location);
-        client.add_model_request_handler(Self::handle_task_templates);
         client.add_model_message_handler(Self::handle_create_buffer_for_peer);
 
         WorktreeStore::init(&client);
         BufferStore::init(&client);
         LspStore::init(&client);
         SettingsObserver::init(&client);
+        TaskStore::init(Some(&client));
     }
 
     pub fn local(
@@ -590,7 +583,6 @@ impl Project {
             let (tx, rx) = mpsc::unbounded();
             cx.spawn(move |this, cx| Self::send_buffer_ordered_messages(this, rx, cx))
                 .detach();
-            let tasks = Inventory::new(cx);
             let snippets = SnippetProvider::new(fs.clone(), BTreeSet::from_iter([]), cx);
             let worktree_store = cx.new_model(|_| WorktreeStore::local(false, fs.clone()));
             cx.subscribe(&worktree_store, Self::on_worktree_store_event)
@@ -610,13 +602,29 @@ impl Project {
                 )
             });
 
+            let environment = ProjectEnvironment::new(&worktree_store, env, cx);
+
+            let task_store = cx.new_model(|cx| {
+                TaskStore::local(
+                    fs.clone(),
+                    buffer_store.downgrade(),
+                    worktree_store.clone(),
+                    environment.clone(),
+                    cx,
+                )
+            });
+
             let settings_observer = cx.new_model(|cx| {
-                SettingsObserver::new_local(fs.clone(), worktree_store.clone(), cx)
+                SettingsObserver::new_local(
+                    fs.clone(),
+                    worktree_store.clone(),
+                    task_store.clone(),
+                    cx,
+                )
             });
             cx.subscribe(&settings_observer, Self::on_settings_observer_event)
                 .detach();
 
-            let environment = ProjectEnvironment::new(&worktree_store, env, cx);
             let lsp_store = cx.new_model(|cx| {
                 LspStore::new_local(
                     buffer_store.clone(),
@@ -645,6 +653,7 @@ impl Project {
                 snippets,
                 languages,
                 client,
+                task_store,
                 user_store,
                 settings_observer,
                 fs,
@@ -655,7 +664,6 @@ impl Project {
                     local_handles: Vec::new(),
                 },
                 node: Some(node),
-                tasks,
                 hosted_project_id: None,
                 dev_server_project_id: None,
                 search_history: Self::new_search_history(),
@@ -681,7 +689,6 @@ impl Project {
             let (tx, rx) = mpsc::unbounded();
             cx.spawn(move |this, cx| Self::send_buffer_ordered_messages(this, rx, cx))
                 .detach();
-            let tasks = Inventory::new(cx);
             let global_snippets_dir = paths::config_dir().join("snippets");
             let snippets =
                 SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
@@ -703,8 +710,24 @@ impl Project {
             cx.subscribe(&buffer_store, Self::on_buffer_store_event)
                 .detach();
 
+            let task_store = cx.new_model(|cx| {
+                TaskStore::remote(
+                    fs.clone(),
+                    buffer_store.downgrade(),
+                    worktree_store.clone(),
+                    ssh.read(cx).to_proto_client(),
+                    SSH_PROJECT_ID,
+                    cx,
+                )
+            });
+
             let settings_observer = cx.new_model(|cx| {
-                SettingsObserver::new_ssh(ssh_proto.clone(), worktree_store.clone(), cx)
+                SettingsObserver::new_ssh(
+                    ssh_proto.clone(),
+                    worktree_store.clone(),
+                    task_store.clone(),
+                    cx,
+                )
             });
             cx.subscribe(&settings_observer, Self::on_settings_observer_event)
                 .detach();
@@ -748,6 +771,7 @@ impl Project {
                 snippets,
                 languages,
                 client,
+                task_store,
                 user_store,
                 settings_observer,
                 fs,
@@ -758,7 +782,6 @@ impl Project {
                     local_handles: Vec::new(),
                 },
                 node: Some(node),
-                tasks,
                 hosted_project_id: None,
                 dev_server_project_id: None,
                 search_history: Self::new_search_history(),
@@ -783,6 +806,7 @@ impl Project {
             BufferStore::init(&ssh_proto);
             LspStore::init(&ssh_proto);
             SettingsObserver::init(&ssh_proto);
+            TaskStore::init(Some(&ssh_proto));
 
             this
         })
@@ -836,6 +860,7 @@ impl Project {
             response,
             subscriptions,
             client,
+            false,
             user_store,
             languages,
             fs,
@@ -844,10 +869,12 @@ impl Project {
         .await
     }
 
+    #[allow(clippy::too_many_arguments)]
     async fn from_join_project_response(
         response: TypedEnvelope<proto::JoinProjectResponse>,
         subscriptions: [EntitySubscription; 5],
         client: Arc<Client>,
+        run_tasks: bool,
         user_store: Model<UserStore>,
         languages: Arc<LanguageRegistry>,
         fs: Arc<dyn Fs>,
@@ -884,12 +911,27 @@ impl Project {
             lsp_store
         })?;
 
-        let settings_observer =
-            cx.new_model(|cx| SettingsObserver::new_remote(worktree_store.clone(), cx))?;
+        let task_store = cx.new_model(|cx| {
+            if run_tasks {
+                TaskStore::remote(
+                    fs.clone(),
+                    buffer_store.downgrade(),
+                    worktree_store.clone(),
+                    client.clone().into(),
+                    remote_id,
+                    cx,
+                )
+            } else {
+                TaskStore::Noop
+            }
+        })?;
+
+        let settings_observer = cx.new_model(|cx| {
+            SettingsObserver::new_remote(worktree_store.clone(), task_store.clone(), cx)
+        })?;
 
         let this = cx.new_model(|cx| {
             let replica_id = response.payload.replica_id as ReplicaId;
-            let tasks = Inventory::new(cx);
 
             let snippets = SnippetProvider::new(fs.clone(), BTreeSet::from_iter([]), cx);
 
@@ -923,6 +965,7 @@ impl Project {
                 join_project_response_message_id: response.message_id,
                 languages,
                 user_store: user_store.clone(),
+                task_store,
                 snippets,
                 fs,
                 ssh_client: None,
@@ -943,7 +986,6 @@ impl Project {
                     local_handles: Vec::new(),
                 },
                 node: None,
-                tasks,
                 hosted_project_id: None,
                 dev_server_project_id: response
                     .payload
@@ -1032,6 +1074,7 @@ impl Project {
             response,
             subscriptions,
             client,
+            true,
             user_store,
             languages,
             fs,
@@ -1283,8 +1326,8 @@ impl Project {
         }
     }
 
-    pub fn task_inventory(&self) -> &Model<Inventory> {
-        &self.tasks
+    pub fn task_store(&self) -> &Model<TaskStore> {
+        &self.task_store
     }
 
     pub fn snippets(&self) -> &Model<SnippetProvider> {
@@ -1505,6 +1548,9 @@ impl Project {
         self.lsp_store.update(cx, |lsp_store, cx| {
             lsp_store.shared(project_id, self.client.clone().into(), cx)
         });
+        self.task_store.update(cx, |task_store, cx| {
+            task_store.shared(project_id, self.client.clone().into(), cx);
+        });
         self.settings_observer.update(cx, |settings_observer, cx| {
             settings_observer.shared(project_id, self.client.clone().into(), cx)
         });
@@ -1593,9 +1639,13 @@ impl Project {
                 buffer_store.forget_shared_buffers();
                 buffer_store.unshared(cx)
             });
+            self.task_store.update(cx, |task_store, cx| {
+                task_store.unshared(cx);
+            });
             self.settings_observer.update(cx, |settings_observer, cx| {
                 settings_observer.unshared(cx);
             });
+
             self.client
                 .send(proto::UnshareProject {
                     project_id: remote_id,
@@ -2105,29 +2155,23 @@ impl Project {
             }
         }
         cx.observe(worktree, |_, _, cx| cx.notify()).detach();
-        cx.subscribe(worktree, |this, worktree, event, cx| {
-            let is_local = worktree.read(cx).is_local();
-            match event {
-                worktree::Event::UpdatedEntries(changes) => {
-                    if is_local {
-                        this.update_local_worktree_settings(&worktree, changes, cx);
-                    }
-
-                    cx.emit(Event::WorktreeUpdatedEntries(
-                        worktree.read(cx).id(),
-                        changes.clone(),
-                    ));
-
-                    let worktree_id = worktree.update(cx, |worktree, _| worktree.id());
-                    this.client()
-                        .telemetry()
-                        .report_discovered_project_events(worktree_id, changes);
-                }
-                worktree::Event::UpdatedGitRepositories(_) => {
-                    cx.emit(Event::WorktreeUpdatedGitRepositories);
-                }
-                worktree::Event::DeletedEntry(id) => cx.emit(Event::DeletedEntry(*id)),
+        cx.subscribe(worktree, |project, worktree, event, cx| match event {
+            worktree::Event::UpdatedEntries(changes) => {
+                cx.emit(Event::WorktreeUpdatedEntries(
+                    worktree.read(cx).id(),
+                    changes.clone(),
+                ));
+
+                let worktree_id = worktree.update(cx, |worktree, _| worktree.id());
+                project
+                    .client()
+                    .telemetry()
+                    .report_discovered_project_events(worktree_id, changes);
             }
+            worktree::Event::UpdatedGitRepositories(_) => {
+                cx.emit(Event::WorktreeUpdatedGitRepositories);
+            }
+            worktree::Event::DeletedEntry(id) => cx.emit(Event::DeletedEntry(*id)),
         })
         .detach();
         cx.notify();
@@ -2157,10 +2201,6 @@ impl Project {
             return;
         }
 
-        self.task_inventory().update(cx, |inventory, _| {
-            inventory.remove_worktree_sources(id_to_remove);
-        });
-
         cx.notify();
     }
 
@@ -3139,77 +3179,6 @@ impl Project {
         });
     }
 
-    fn update_local_worktree_settings(
-        &mut self,
-        worktree: &Model<Worktree>,
-        changes: &UpdatedEntriesSet,
-        cx: &mut ModelContext<Self>,
-    ) {
-        if worktree.read(cx).is_remote() {
-            return;
-        }
-        let remote_worktree_id = worktree.read(cx).id();
-
-        for (path, _, change) in changes.iter() {
-            let removed = change == &PathChange::Removed;
-            let abs_path = match worktree.read(cx).absolutize(path) {
-                Ok(abs_path) => abs_path,
-                Err(e) => {
-                    log::warn!("Cannot absolutize {path:?} received as {change:?} FS change: {e}");
-                    continue;
-                }
-            };
-
-            if path.ends_with(local_tasks_file_relative_path()) {
-                self.task_inventory().update(cx, |task_inventory, cx| {
-                    if removed {
-                        task_inventory.remove_local_static_source(&abs_path);
-                    } else {
-                        let fs = self.fs.clone();
-                        let task_abs_path = abs_path.clone();
-                        let tasks_file_rx =
-                            watch_config_file(cx.background_executor(), fs, task_abs_path);
-                        task_inventory.add_source(
-                            TaskSourceKind::Worktree {
-                                id: remote_worktree_id,
-                                abs_path,
-                                id_base: "local_tasks_for_worktree".into(),
-                            },
-                            |tx, cx| StaticSource::new(TrackedFile::new(tasks_file_rx, tx, cx)),
-                            cx,
-                        );
-                    }
-                })
-            } else if path.ends_with(local_vscode_tasks_file_relative_path()) {
-                self.task_inventory().update(cx, |task_inventory, cx| {
-                    if removed {
-                        task_inventory.remove_local_static_source(&abs_path);
-                    } else {
-                        let fs = self.fs.clone();
-                        let task_abs_path = abs_path.clone();
-                        let tasks_file_rx =
-                            watch_config_file(cx.background_executor(), fs, task_abs_path);
-                        task_inventory.add_source(
-                            TaskSourceKind::Worktree {
-                                id: remote_worktree_id,
-                                abs_path,
-                                id_base: "local_vscode_tasks_for_worktree".into(),
-                            },
-                            |tx, cx| {
-                                StaticSource::new(TrackedFile::new_convertible::<
-                                    task::VsCodeTaskFile,
-                                >(
-                                    tasks_file_rx, tx, cx
-                                ))
-                            },
-                            cx,
-                        );
-                    }
-                })
-            }
-        }
-    }
-
     pub fn set_active_path(&mut self, entry: Option<ProjectPath>, cx: &mut ModelContext<Self>) {
         let new_active_entry = entry.and_then(|project_path| {
             let worktree = self.worktree_for_id(project_path.worktree_id, cx)?;
@@ -3518,7 +3487,7 @@ impl Project {
         let buffer_store = this.read_with(&cx, |this, cx| {
             if let Some(ssh) = &this.ssh_client {
                 let mut payload = envelope.payload.clone();
-                payload.project_id = 0;
+                payload.project_id = SSH_PROJECT_ID;
                 cx.background_executor()
                     .spawn(ssh.read(cx).to_proto_client().request(payload))
                     .detach_and_log_err(cx);
@@ -3578,137 +3547,6 @@ impl Project {
         Ok(response)
     }
 
-    async fn handle_task_context_for_location(
-        project: Model<Self>,
-        envelope: TypedEnvelope<proto::TaskContextForLocation>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::TaskContext> {
-        let location = envelope
-            .payload
-            .location
-            .context("no location given for task context handling")?;
-        let location = cx
-            .update(|cx| deserialize_location(&project, location, cx))?
-            .await?;
-        let context_task = project.update(&mut cx, |project, cx| {
-            let captured_variables = {
-                let mut variables = TaskVariables::default();
-                for range in location
-                    .buffer
-                    .read(cx)
-                    .snapshot()
-                    .runnable_ranges(location.range.clone())
-                {
-                    for (capture_name, value) in range.extra_captures {
-                        variables.insert(VariableName::Custom(capture_name.into()), value);
-                    }
-                }
-                variables
-            };
-            project.task_context_for_location(captured_variables, location, cx)
-        })?;
-        let task_context = context_task.await.unwrap_or_default();
-        Ok(proto::TaskContext {
-            project_env: task_context.project_env.into_iter().collect(),
-            cwd: task_context
-                .cwd
-                .map(|cwd| cwd.to_string_lossy().to_string()),
-            task_variables: task_context
-                .task_variables
-                .into_iter()
-                .map(|(variable_name, variable_value)| (variable_name.to_string(), variable_value))
-                .collect(),
-        })
-    }
-
-    async fn handle_task_templates(
-        project: Model<Self>,
-        envelope: TypedEnvelope<proto::TaskTemplates>,
-        mut cx: AsyncAppContext,
-    ) -> Result<proto::TaskTemplatesResponse> {
-        let worktree = envelope.payload.worktree_id.map(WorktreeId::from_proto);
-        let location = match envelope.payload.location {
-            Some(location) => Some(
-                cx.update(|cx| deserialize_location(&project, location, cx))?
-                    .await
-                    .context("task templates request location deserializing")?,
-            ),
-            None => None,
-        };
-
-        let templates = project
-            .update(&mut cx, |project, cx| {
-                project.task_templates(worktree, location, cx)
-            })?
-            .await
-            .context("receiving task templates")?
-            .into_iter()
-            .map(|(kind, template)| {
-                let kind = Some(match kind {
-                    TaskSourceKind::UserInput => proto::task_source_kind::Kind::UserInput(
-                        proto::task_source_kind::UserInput {},
-                    ),
-                    TaskSourceKind::Worktree {
-                        id,
-                        abs_path,
-                        id_base,
-                    } => {
-                        proto::task_source_kind::Kind::Worktree(proto::task_source_kind::Worktree {
-                            id: id.to_proto(),
-                            abs_path: abs_path.to_string_lossy().to_string(),
-                            id_base: id_base.to_string(),
-                        })
-                    }
-                    TaskSourceKind::AbsPath { id_base, abs_path } => {
-                        proto::task_source_kind::Kind::AbsPath(proto::task_source_kind::AbsPath {
-                            abs_path: abs_path.to_string_lossy().to_string(),
-                            id_base: id_base.to_string(),
-                        })
-                    }
-                    TaskSourceKind::Language { name } => {
-                        proto::task_source_kind::Kind::Language(proto::task_source_kind::Language {
-                            name: name.to_string(),
-                        })
-                    }
-                });
-                let kind = Some(proto::TaskSourceKind { kind });
-                let template = Some(proto::TaskTemplate {
-                    label: template.label,
-                    command: template.command,
-                    args: template.args,
-                    env: template.env.into_iter().collect(),
-                    cwd: template.cwd,
-                    use_new_terminal: template.use_new_terminal,
-                    allow_concurrent_runs: template.allow_concurrent_runs,
-                    reveal: match template.reveal {
-                        RevealStrategy::Always => proto::RevealStrategy::RevealAlways as i32,
-                        RevealStrategy::Never => proto::RevealStrategy::RevealNever as i32,
-                    },
-                    hide: match template.hide {
-                        HideStrategy::Always => proto::HideStrategy::HideAlways as i32,
-                        HideStrategy::Never => proto::HideStrategy::HideNever as i32,
-                        HideStrategy::OnSuccess => proto::HideStrategy::HideOnSuccess as i32,
-                    },
-                    shell: Some(proto::Shell {
-                        shell_type: Some(match template.shell {
-                            Shell::System => proto::shell::ShellType::System(proto::System {}),
-                            Shell::Program(program) => proto::shell::ShellType::Program(program),
-                            Shell::WithArguments { program, args } => {
-                                proto::shell::ShellType::WithArguments(
-                                    proto::shell::WithArguments { program, args },
-                                )
-                            }
-                        }),
-                    }),
-                    tags: template.tags,
-                });
-                proto::TemplatePair { kind, template }
-            })
-            .collect();
-
-        Ok(proto::TaskTemplatesResponse { templates })
-    }
-
     async fn handle_search_candidate_buffers(
         this: Model<Self>,
         envelope: TypedEnvelope<proto::FindSearchCandidates>,
@@ -3996,267 +3834,6 @@ impl Project {
             .read(cx)
             .language_server_for_buffer(buffer, server_id, cx)
     }
-
-    pub fn task_context_for_location(
-        &self,
-        captured_variables: TaskVariables,
-        location: Location,
-        cx: &mut ModelContext<'_, Project>,
-    ) -> Task<Option<TaskContext>> {
-        if self.is_local() {
-            let (worktree_id, worktree_abs_path) = if let Some(worktree) = self.task_worktree(cx) {
-                (
-                    Some(worktree.read(cx).id()),
-                    Some(worktree.read(cx).abs_path()),
-                )
-            } else {
-                (None, None)
-            };
-
-            cx.spawn(|project, mut cx| async move {
-                let project_env = project
-                    .update(&mut cx, |project, cx| {
-                        let worktree_abs_path = worktree_abs_path.clone();
-                        project.environment.update(cx, |environment, cx| {
-                            environment.get_environment(worktree_id, worktree_abs_path, cx)
-                        })
-                    })
-                    .ok()?
-                    .await;
-
-                let mut task_variables = cx
-                    .update(|cx| {
-                        combine_task_variables(
-                            captured_variables,
-                            location,
-                            project_env.as_ref(),
-                            BasicContextProvider::new(project.upgrade()?),
-                            cx,
-                        )
-                        .log_err()
-                    })
-                    .ok()
-                    .flatten()?;
-                // Remove all custom entries starting with _, as they're not intended for use by the end user.
-                task_variables.sweep();
-
-                Some(TaskContext {
-                    project_env: project_env.unwrap_or_default(),
-                    cwd: worktree_abs_path.map(|p| p.to_path_buf()),
-                    task_variables,
-                })
-            })
-        } else if let Some(project_id) = self
-            .remote_id()
-            .filter(|_| self.ssh_connection_string(cx).is_some())
-        {
-            let task_context = self.client().request(proto::TaskContextForLocation {
-                project_id,
-                location: Some(proto::Location {
-                    buffer_id: location.buffer.read(cx).remote_id().into(),
-                    start: Some(serialize_anchor(&location.range.start)),
-                    end: Some(serialize_anchor(&location.range.end)),
-                }),
-            });
-            cx.background_executor().spawn(async move {
-                let task_context = task_context.await.log_err()?;
-                Some(TaskContext {
-                    project_env: task_context.project_env.into_iter().collect(),
-                    cwd: task_context.cwd.map(PathBuf::from),
-                    task_variables: task_context
-                        .task_variables
-                        .into_iter()
-                        .filter_map(
-                            |(variable_name, variable_value)| match variable_name.parse() {
-                                Ok(variable_name) => Some((variable_name, variable_value)),
-                                Err(()) => {
-                                    log::error!("Unknown variable name: {variable_name}");
-                                    None
-                                }
-                            },
-                        )
-                        .collect(),
-                })
-            })
-        } else {
-            Task::ready(None)
-        }
-    }
-
-    pub fn task_templates(
-        &self,
-        worktree: Option<WorktreeId>,
-        location: Option<Location>,
-        cx: &mut ModelContext<Self>,
-    ) -> Task<Result<Vec<(TaskSourceKind, TaskTemplate)>>> {
-        if self.is_local() {
-            let (file, language) = location
-                .map(|location| {
-                    let buffer = location.buffer.read(cx);
-                    (
-                        buffer.file().cloned(),
-                        buffer.language_at(location.range.start),
-                    )
-                })
-                .unwrap_or_default();
-            Task::ready(Ok(self
-                .task_inventory()
-                .read(cx)
-                .list_tasks(file, language, worktree, cx)))
-        } else if let Some(project_id) = self
-            .remote_id()
-            .filter(|_| self.ssh_connection_string(cx).is_some())
-        {
-            let remote_templates =
-                self.query_remote_task_templates(project_id, worktree, location.as_ref(), cx);
-            cx.background_executor().spawn(remote_templates)
-        } else {
-            Task::ready(Ok(Vec::new()))
-        }
-    }
-
-    pub fn query_remote_task_templates(
-        &self,
-        project_id: u64,
-        worktree: Option<WorktreeId>,
-        location: Option<&Location>,
-        cx: &AppContext,
-    ) -> Task<Result<Vec<(TaskSourceKind, TaskTemplate)>>> {
-        let client = self.client();
-        let location = location.map(|location| serialize_location(location, cx));
-        cx.spawn(|_| async move {
-            let response = client
-                .request(proto::TaskTemplates {
-                    project_id,
-                    worktree_id: worktree.map(|id| id.to_proto()),
-                    location,
-                })
-                .await?;
-
-            Ok(response
-                .templates
-                .into_iter()
-                .filter_map(|template_pair| {
-                    let task_source_kind = match template_pair.kind?.kind? {
-                        proto::task_source_kind::Kind::UserInput(_) => TaskSourceKind::UserInput,
-                        proto::task_source_kind::Kind::Worktree(worktree) => {
-                            TaskSourceKind::Worktree {
-                                id: WorktreeId::from_proto(worktree.id),
-                                abs_path: PathBuf::from(worktree.abs_path),
-                                id_base: Cow::Owned(worktree.id_base),
-                            }
-                        }
-                        proto::task_source_kind::Kind::AbsPath(abs_path) => {
-                            TaskSourceKind::AbsPath {
-                                id_base: Cow::Owned(abs_path.id_base),
-                                abs_path: PathBuf::from(abs_path.abs_path),
-                            }
-                        }
-                        proto::task_source_kind::Kind::Language(language) => {
-                            TaskSourceKind::Language {
-                                name: language.name.into(),
-                            }
-                        }
-                    };
-
-                    let proto_template = template_pair.template?;
-                    let reveal = match proto::RevealStrategy::from_i32(proto_template.reveal)
-                        .unwrap_or(proto::RevealStrategy::RevealAlways)
-                    {
-                        proto::RevealStrategy::RevealAlways => RevealStrategy::Always,
-                        proto::RevealStrategy::RevealNever => RevealStrategy::Never,
-                    };
-                    let hide = match proto::HideStrategy::from_i32(proto_template.hide)
-                        .unwrap_or(proto::HideStrategy::HideNever)
-                    {
-                        proto::HideStrategy::HideAlways => HideStrategy::Always,
-                        proto::HideStrategy::HideNever => HideStrategy::Never,
-                        proto::HideStrategy::HideOnSuccess => HideStrategy::OnSuccess,
-                    };
-                    let shell = match proto_template
-                        .shell
-                        .and_then(|shell| shell.shell_type)
-                        .unwrap_or(proto::shell::ShellType::System(proto::System {}))
-                    {
-                        proto::shell::ShellType::System(_) => Shell::System,
-                        proto::shell::ShellType::Program(program) => Shell::Program(program),
-                        proto::shell::ShellType::WithArguments(with_arguments) => {
-                            Shell::WithArguments {
-                                program: with_arguments.program,
-                                args: with_arguments.args,
-                            }
-                        }
-                    };
-                    let task_template = TaskTemplate {
-                        label: proto_template.label,
-                        command: proto_template.command,
-                        args: proto_template.args,
-                        env: proto_template.env.into_iter().collect(),
-                        cwd: proto_template.cwd,
-                        use_new_terminal: proto_template.use_new_terminal,
-                        allow_concurrent_runs: proto_template.allow_concurrent_runs,
-                        reveal,
-                        hide,
-                        shell,
-                        tags: proto_template.tags,
-                    };
-                    Some((task_source_kind, task_template))
-                })
-                .collect())
-        })
-    }
-
-    fn task_worktree(&self, cx: &AppContext) -> Option<Model<Worktree>> {
-        let available_worktrees = self
-            .worktrees(cx)
-            .filter(|worktree| {
-                let worktree = worktree.read(cx);
-                worktree.is_visible()
-                    && worktree.is_local()
-                    && worktree.root_entry().map_or(false, |e| e.is_dir())
-            })
-            .collect::<Vec<_>>();
-
-        match available_worktrees.len() {
-            0 => None,
-            1 => Some(available_worktrees[0].clone()),
-            _ => self.active_entry().and_then(|entry_id| {
-                available_worktrees.into_iter().find_map(|worktree| {
-                    if worktree.read(cx).contains_entry(entry_id) {
-                        Some(worktree)
-                    } else {
-                        None
-                    }
-                })
-            }),
-        }
-    }
-}
-
-fn combine_task_variables(
-    mut captured_variables: TaskVariables,
-    location: Location,
-    project_env: Option<&HashMap<String, String>>,
-    baseline: BasicContextProvider,
-    cx: &mut AppContext,
-) -> anyhow::Result<TaskVariables> {
-    let language_context_provider = location
-        .buffer
-        .read(cx)
-        .language()
-        .and_then(|language| language.context_provider());
-    let baseline = baseline
-        .build_context(&captured_variables, &location, project_env, cx)
-        .context("building basic default context")?;
-    captured_variables.extend(baseline);
-    if let Some(provider) = language_context_provider {
-        captured_variables.extend(
-            provider
-                .build_context(&captured_variables, &location, project_env, cx)
-                .context("building provider context")?,
-        );
-    }
-    Ok(captured_variables)
 }
 
 fn deserialize_code_actions(code_actions: &HashMap<String, bool>) -> Vec<lsp::CodeActionKind> {
@@ -4509,43 +4086,6 @@ impl std::fmt::Display for NoRepositoryError {
 
 impl std::error::Error for NoRepositoryError {}
 
-fn serialize_location(location: &Location, cx: &AppContext) -> proto::Location {
-    proto::Location {
-        buffer_id: location.buffer.read(cx).remote_id().into(),
-        start: Some(serialize_anchor(&location.range.start)),
-        end: Some(serialize_anchor(&location.range.end)),
-    }
-}
-
-fn deserialize_location(
-    project: &Model<Project>,
-    location: proto::Location,
-    cx: &mut AppContext,
-) -> Task<Result<Location>> {
-    let buffer_id = match BufferId::new(location.buffer_id) {
-        Ok(id) => id,
-        Err(e) => return Task::ready(Err(e)),
-    };
-    let buffer_task = project.update(cx, |project, cx| {
-        project.wait_for_remote_buffer(buffer_id, cx)
-    });
-    cx.spawn(|_| async move {
-        let buffer = buffer_task.await?;
-        let start = location
-            .start
-            .and_then(deserialize_anchor)
-            .context("missing task context location start")?;
-        let end = location
-            .end
-            .and_then(deserialize_anchor)
-            .context("missing task context location end")?;
-        Ok(Location {
-            buffer,
-            range: start..end,
-        })
-    })
-}
-
 pub fn sort_worktree_entries(entries: &mut [Entry]) {
     entries.sort_by(|entry_a, entry_b| {
         compare_paths(
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index e956f672607298..49378fbc1dc7e4 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -3,20 +3,30 @@ use collections::HashMap;
 use fs::Fs;
 use gpui::{AppContext, AsyncAppContext, BorrowAppContext, EventEmitter, Model, ModelContext};
 use language::LanguageServerName;
-use paths::local_settings_file_relative_path;
+use paths::{
+    local_settings_file_relative_path, local_tasks_file_relative_path,
+    local_vscode_tasks_file_relative_path,
+};
 use rpc::{proto, AnyProtoClient, TypedEnvelope};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{InvalidSettingsError, LocalSettingsKind, Settings, SettingsSources, SettingsStore};
+use settings::{
+    parse_json_with_comments, InvalidSettingsError, LocalSettingsKind, Settings, SettingsLocation,
+    SettingsSources, SettingsStore,
+};
 use std::{
     path::{Path, PathBuf},
     sync::Arc,
     time::Duration,
 };
+use task::{TaskTemplates, VsCodeTaskFile};
 use util::ResultExt;
 use worktree::{PathChange, UpdatedEntriesSet, Worktree, WorktreeId};
 
-use crate::worktree_store::{WorktreeStore, WorktreeStoreEvent};
+use crate::{
+    task_store::TaskStore,
+    worktree_store::{WorktreeStore, WorktreeStoreEvent},
+};
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
 pub struct ProjectSettings {
@@ -202,12 +212,13 @@ pub struct SettingsObserver {
     downstream_client: Option<AnyProtoClient>,
     worktree_store: Model<WorktreeStore>,
     project_id: u64,
+    task_store: Model<TaskStore>,
 }
 
-/// SettingsObserver observers changes to .zed/settings.json files in local worktrees
+/// SettingsObserver observers changes to .zed/{settings, task}.json files in local worktrees
 /// (or the equivalent protobuf messages from upstream) and updates local settings
 /// and sends notifications downstream.
-/// In ssh mode it also monitors ~/.config/zed/settings.json and sends the content
+/// In ssh mode it also monitors ~/.config/zed/{settings, task}.json and sends the content
 /// upstream.
 impl SettingsObserver {
     pub fn init(client: &AnyProtoClient) {
@@ -218,6 +229,7 @@ impl SettingsObserver {
     pub fn new_local(
         fs: Arc<dyn Fs>,
         worktree_store: Model<WorktreeStore>,
+        task_store: Model<TaskStore>,
         cx: &mut ModelContext<Self>,
     ) -> Self {
         cx.subscribe(&worktree_store, Self::on_worktree_store_event)
@@ -225,6 +237,7 @@ impl SettingsObserver {
 
         Self {
             worktree_store,
+            task_store,
             mode: SettingsObserverMode::Local(fs),
             downstream_client: None,
             project_id: 0,
@@ -234,10 +247,12 @@ impl SettingsObserver {
     pub fn new_ssh(
         client: AnyProtoClient,
         worktree_store: Model<WorktreeStore>,
+        task_store: Model<TaskStore>,
         cx: &mut ModelContext<Self>,
     ) -> Self {
         let this = Self {
             worktree_store,
+            task_store,
             mode: SettingsObserverMode::Ssh(client.clone()),
             downstream_client: None,
             project_id: 0,
@@ -246,9 +261,14 @@ impl SettingsObserver {
         this
     }
 
-    pub fn new_remote(worktree_store: Model<WorktreeStore>, _: &mut ModelContext<Self>) -> Self {
+    pub fn new_remote(
+        worktree_store: Model<WorktreeStore>,
+        task_store: Model<TaskStore>,
+        _: &mut ModelContext<Self>,
+    ) -> Self {
         Self {
             worktree_store,
+            task_store,
             mode: SettingsObserverMode::Remote,
             downstream_client: None,
             project_id: 0,
@@ -319,19 +339,32 @@ impl SettingsObserver {
     }
 
     pub async fn handle_update_user_settings(
-        _: Model<Self>,
+        settings_observer: Model<Self>,
         envelope: TypedEnvelope<proto::UpdateUserSettings>,
-        cx: AsyncAppContext,
+        mut cx: AsyncAppContext,
     ) -> anyhow::Result<()> {
-        cx.update_global(move |settings_store: &mut SettingsStore, cx| {
-            settings_store.set_user_settings(&envelope.payload.content, cx)
-        })??;
+        match envelope.payload.kind() {
+            proto::update_user_settings::Kind::Settings => {
+                cx.update_global(move |settings_store: &mut SettingsStore, cx| {
+                    settings_store.set_user_settings(&envelope.payload.content, cx)
+                })
+            }
+            proto::update_user_settings::Kind::Tasks => {
+                settings_observer.update(&mut cx, |settings_observer, cx| {
+                    settings_observer.task_store.update(cx, |task_store, cx| {
+                        task_store.update_user_tasks(None, Some(&envelope.payload.content), cx)
+                    })
+                })
+            }
+        }??;
 
         Ok(())
     }
 
     pub fn maintain_ssh_settings(&self, ssh: AnyProtoClient, cx: &mut ModelContext<Self>) {
-        let mut settings = cx.global::<SettingsStore>().raw_user_settings().clone();
+        let settings_store = cx.global::<SettingsStore>();
+
+        let mut settings = settings_store.raw_user_settings().clone();
         if let Some(content) = serde_json::to_string(&settings).log_err() {
             ssh.send(proto::UpdateUserSettings {
                 project_id: 0,
@@ -389,7 +422,43 @@ impl SettingsObserver {
 
         let mut settings_contents = Vec::new();
         for (path, _, change) in changes.iter() {
+            let (settings_dir, kind) = if path.ends_with(local_settings_file_relative_path()) {
+                let settings_dir = Arc::<Path>::from(
+                    path.ancestors()
+                        .nth(local_settings_file_relative_path().components().count())
+                        .unwrap(),
+                );
+                (settings_dir, LocalSettingsKind::Settings)
+            } else if path.ends_with(local_tasks_file_relative_path()) {
+                let settings_dir = Arc::<Path>::from(
+                    path.ancestors()
+                        .nth(
+                            local_tasks_file_relative_path()
+                                .components()
+                                .count()
+                                .saturating_sub(1),
+                        )
+                        .unwrap(),
+                );
+                (settings_dir, LocalSettingsKind::Tasks)
+            } else if path.ends_with(local_vscode_tasks_file_relative_path()) {
+                let settings_dir = Arc::<Path>::from(
+                    path.ancestors()
+                        .nth(
+                            local_vscode_tasks_file_relative_path()
+                                .components()
+                                .count()
+                                .saturating_sub(1),
+                        )
+                        .unwrap(),
+                );
+                (settings_dir, LocalSettingsKind::Tasks)
+            } else {
+                continue;
+            };
+
             let removed = change == &PathChange::Removed;
+            let fs = fs.clone();
             let abs_path = match worktree.read(cx).absolutize(path) {
                 Ok(abs_path) => abs_path,
                 Err(e) => {
@@ -397,26 +466,42 @@ impl SettingsObserver {
                     continue;
                 }
             };
-
-            if path.ends_with(local_settings_file_relative_path()) {
-                let settings_dir = Arc::from(
-                    path.ancestors()
-                        .nth(local_settings_file_relative_path().components().count())
-                        .unwrap(),
-                );
-                let fs = fs.clone();
-                settings_contents.push(async move {
-                    (
-                        settings_dir,
-                        LocalSettingsKind::Settings,
-                        if removed {
-                            None
-                        } else {
-                            Some(async move { fs.load(&abs_path).await }.await)
-                        },
-                    )
-                });
-            }
+            settings_contents.push(async move {
+                (
+                    settings_dir,
+                    kind,
+                    if removed {
+                        None
+                    } else {
+                        Some(
+                            async move {
+                                let content = fs.load(&abs_path).await?;
+                                if abs_path.ends_with(local_vscode_tasks_file_relative_path()) {
+                                    let vscode_tasks =
+                                        parse_json_with_comments::<VsCodeTaskFile>(&content)
+                                            .with_context(|| {
+                                                format!("parsing VSCode tasks, file {abs_path:?}")
+                                            })?;
+                                    let zed_tasks = TaskTemplates::try_from(vscode_tasks)
+                                        .with_context(|| {
+                                            format!(
+                                        "converting VSCode tasks into Zed ones, file {abs_path:?}"
+                                    )
+                                        })?;
+                                    serde_json::to_string(&zed_tasks).with_context(|| {
+                                        format!(
+                                            "serializing Zed tasks into JSON, file {abs_path:?}"
+                                        )
+                                    })
+                                } else {
+                                    Ok(content)
+                                }
+                            }
+                            .await,
+                        )
+                    },
+                )
+            });
         }
 
         if settings_contents.is_empty() {
@@ -450,47 +535,64 @@ impl SettingsObserver {
     ) {
         let worktree_id = worktree.read(cx).id();
         let remote_worktree_id = worktree.read(cx).id();
+        let task_store = self.task_store.clone();
+
+        for (directory, kind, file_content) in settings_contents {
+            let result = match kind {
+                LocalSettingsKind::Settings | LocalSettingsKind::Editorconfig => cx
+                    .update_global::<SettingsStore, anyhow::Result<()>>(|store, cx| {
+                        store.set_local_settings(
+                            worktree_id,
+                            directory.clone(),
+                            kind,
+                            file_content.as_deref(),
+                            cx,
+                        )
+                    }),
+                LocalSettingsKind::Tasks => task_store.update(cx, |task_store, cx| {
+                    task_store.update_user_tasks(
+                        Some(SettingsLocation {
+                            worktree_id,
+                            path: directory.as_ref(),
+                        }),
+                        file_content.as_deref(),
+                        cx,
+                    )
+                }),
+            };
 
-        let result = cx.update_global::<SettingsStore, anyhow::Result<()>>(|store, cx| {
-            for (directory, kind, file_content) in settings_contents {
-                store.set_local_settings(
-                    worktree_id,
-                    directory.clone(),
-                    kind,
-                    file_content.as_deref(),
-                    cx,
-                )?;
-
-                if let Some(downstream_client) = &self.downstream_client {
-                    downstream_client
-                        .send(proto::UpdateWorktreeSettings {
-                            project_id: self.project_id,
-                            worktree_id: remote_worktree_id.to_proto(),
-                            path: directory.to_string_lossy().into_owned(),
-                            content: file_content,
-                            kind: Some(local_settings_kind_to_proto(kind).into()),
-                        })
-                        .log_err();
-                }
+            if let Some(downstream_client) = &self.downstream_client {
+                downstream_client
+                    .send(proto::UpdateWorktreeSettings {
+                        project_id: self.project_id,
+                        worktree_id: remote_worktree_id.to_proto(),
+                        path: directory.to_string_lossy().into_owned(),
+                        content: file_content,
+                        kind: Some(local_settings_kind_to_proto(kind).into()),
+                    })
+                    .log_err();
             }
-            anyhow::Ok(())
-        });
-
-        match result {
-            Err(error) => {
-                if let Ok(error) = error.downcast::<InvalidSettingsError>() {
-                    if let InvalidSettingsError::LocalSettings {
-                        ref path,
-                        ref message,
-                    } = error
-                    {
-                        log::error!("Failed to set local settings in {:?}: {:?}", path, message);
-                        cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Err(error)));
+
+            match result {
+                Err(error) => {
+                    if let Ok(error) = error.downcast::<InvalidSettingsError>() {
+                        if let InvalidSettingsError::LocalSettings {
+                            ref path,
+                            ref message,
+                        } = error
+                        {
+                            log::error!(
+                                "Failed to set local settings in {:?}: {:?}",
+                                path,
+                                message
+                            );
+                            cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Err(error)));
+                        }
                     }
                 }
-            }
-            Ok(()) => {
-                cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Ok(())));
+                Ok(()) => {
+                    cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Ok(())));
+                }
             }
         }
     }
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index dd14ccd60f4e98..ee448543be9701 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -16,7 +16,7 @@ use serde_json::json;
 use std::os;
 
 use std::{mem, ops::Range, task::Poll};
-use task::{ResolvedTask, TaskContext, TaskTemplate, TaskTemplates};
+use task::{ResolvedTask, TaskContext};
 use unindent::Unindent as _;
 use util::{assert_set_eq, paths::PathMatcher, test::temp_tree, TryFutureExt as _};
 
@@ -94,6 +94,7 @@ async fn test_symlinks(cx: &mut gpui::TestAppContext) {
 #[gpui::test]
 async fn test_managing_project_specific_settings(cx: &mut gpui::TestAppContext) {
     init_test(cx);
+    TaskStore::init(None);
 
     let fs = FakeFs::new(cx.executor());
     fs.insert_tree(
@@ -102,7 +103,7 @@ async fn test_managing_project_specific_settings(cx: &mut gpui::TestAppContext)
             ".zed": {
                 "settings.json": r#"{ "tab_size": 8 }"#,
                 "tasks.json": r#"[{
-                    "label": "cargo check",
+                    "label": "cargo check all",
                     "command": "cargo",
                     "args": ["check", "--all"]
                 },]"#,
@@ -135,10 +136,10 @@ async fn test_managing_project_specific_settings(cx: &mut gpui::TestAppContext)
             project.worktrees(cx).next().unwrap().read(cx).id()
         })
     });
-    let global_task_source_kind = TaskSourceKind::Worktree {
+    let topmost_local_task_source_kind = TaskSourceKind::Worktree {
         id: worktree_id,
-        abs_path: PathBuf::from("/the-root/.zed/tasks.json"),
-        id_base: "local_tasks_for_worktree".into(),
+        directory_in_worktree: PathBuf::from(".zed"),
+        id_base: "local worktree tasks from directory \".zed\"".into(),
     };
 
     let all_tasks = cx
@@ -171,7 +172,6 @@ async fn test_managing_project_specific_settings(cx: &mut gpui::TestAppContext)
 
             get_all_tasks(&project, Some(worktree_id), &task_context, cx)
         })
-        .await
         .into_iter()
         .map(|(source_kind, task)| {
             let resolved = task.resolved.unwrap();
@@ -186,71 +186,65 @@ async fn test_managing_project_specific_settings(cx: &mut gpui::TestAppContext)
     assert_eq!(
         all_tasks,
         vec![
-            (
-                global_task_source_kind.clone(),
-                "cargo check".to_string(),
-                vec!["check".to_string(), "--all".to_string()],
-                HashMap::default(),
-            ),
             (
                 TaskSourceKind::Worktree {
                     id: worktree_id,
-                    abs_path: PathBuf::from("/the-root/b/.zed/tasks.json"),
-                    id_base: "local_tasks_for_worktree".into(),
+                    directory_in_worktree: PathBuf::from("b/.zed"),
+                    id_base: "local worktree tasks from directory \"b/.zed\"".into(),
                 },
                 "cargo check".to_string(),
                 vec!["check".to_string()],
                 HashMap::default(),
             ),
+            (
+                topmost_local_task_source_kind.clone(),
+                "cargo check all".to_string(),
+                vec!["check".to_string(), "--all".to_string()],
+                HashMap::default(),
+            ),
         ]
     );
 
     let (_, resolved_task) = cx
         .update(|cx| get_all_tasks(&project, Some(worktree_id), &task_context, cx))
-        .await
         .into_iter()
-        .find(|(source_kind, _)| source_kind == &global_task_source_kind)
+        .find(|(source_kind, _)| source_kind == &topmost_local_task_source_kind)
         .expect("should have one global task");
     project.update(cx, |project, cx| {
-        project.task_inventory().update(cx, |inventory, _| {
-            inventory.task_scheduled(global_task_source_kind.clone(), resolved_task);
+        let task_inventory = project
+            .task_store
+            .read(cx)
+            .task_inventory()
+            .cloned()
+            .unwrap();
+        task_inventory.update(cx, |inventory, _| {
+            inventory.task_scheduled(topmost_local_task_source_kind.clone(), resolved_task);
+            inventory
+                .update_file_based_tasks(
+                    None,
+                    Some(
+                        &json!([{
+                            "label": "cargo check unstable",
+                            "command": "cargo",
+                            "args": [
+                                "check",
+                                "--all",
+                                "--all-targets"
+                            ],
+                            "env": {
+                                "RUSTFLAGS": "-Zunstable-options"
+                            }
+                        }])
+                        .to_string(),
+                    ),
+                )
+                .unwrap();
         });
     });
-
-    let tasks = serde_json::to_string(&TaskTemplates(vec![TaskTemplate {
-        label: "cargo check".to_string(),
-        command: "cargo".to_string(),
-        args: vec![
-            "check".to_string(),
-            "--all".to_string(),
-            "--all-targets".to_string(),
-        ],
-        env: HashMap::from_iter(Some((
-            "RUSTFLAGS".to_string(),
-            "-Zunstable-options".to_string(),
-        ))),
-        ..TaskTemplate::default()
-    }]))
-    .unwrap();
-    let (tx, rx) = futures::channel::mpsc::unbounded();
-    cx.update(|cx| {
-        project.update(cx, |project, cx| {
-            project.task_inventory().update(cx, |inventory, cx| {
-                inventory.remove_local_static_source(Path::new("/the-root/.zed/tasks.json"));
-                inventory.add_source(
-                    global_task_source_kind.clone(),
-                    |tx, cx| StaticSource::new(TrackedFile::new(rx, tx, cx)),
-                    cx,
-                );
-            });
-        })
-    });
-    tx.unbounded_send(tasks).unwrap();
-
     cx.run_until_parked();
+
     let all_tasks = cx
         .update(|cx| get_all_tasks(&project, Some(worktree_id), &task_context, cx))
-        .await
         .into_iter()
         .map(|(source_kind, task)| {
             let resolved = task.resolved.unwrap();
@@ -265,33 +259,38 @@ async fn test_managing_project_specific_settings(cx: &mut gpui::TestAppContext)
     assert_eq!(
         all_tasks,
         vec![
+            (
+                topmost_local_task_source_kind.clone(),
+                "cargo check all".to_string(),
+                vec!["check".to_string(), "--all".to_string()],
+                HashMap::default(),
+            ),
             (
                 TaskSourceKind::Worktree {
                     id: worktree_id,
-                    abs_path: PathBuf::from("/the-root/.zed/tasks.json"),
-                    id_base: "local_tasks_for_worktree".into(),
+                    directory_in_worktree: PathBuf::from("b/.zed"),
+                    id_base: "local worktree tasks from directory \"b/.zed\"".into(),
                 },
                 "cargo check".to_string(),
+                vec!["check".to_string()],
+                HashMap::default(),
+            ),
+            (
+                TaskSourceKind::AbsPath {
+                    abs_path: paths::tasks_file().clone(),
+                    id_base: "global tasks.json".into(),
+                },
+                "cargo check unstable".to_string(),
                 vec![
                     "check".to_string(),
                     "--all".to_string(),
-                    "--all-targets".to_string()
+                    "--all-targets".to_string(),
                 ],
                 HashMap::from_iter(Some((
                     "RUSTFLAGS".to_string(),
                     "-Zunstable-options".to_string()
                 ))),
             ),
-            (
-                TaskSourceKind::Worktree {
-                    id: worktree_id,
-                    abs_path: PathBuf::from("/the-root/b/.zed/tasks.json"),
-                    id_base: "local_tasks_for_worktree".into(),
-                },
-                "cargo check".to_string(),
-                vec!["check".to_string()],
-                HashMap::default(),
-            ),
         ]
     );
 }
@@ -5416,17 +5415,16 @@ fn get_all_tasks(
     worktree_id: Option<WorktreeId>,
     task_context: &TaskContext,
     cx: &mut AppContext,
-) -> Task<Vec<(TaskSourceKind, ResolvedTask)>> {
-    let resolved_tasks = project.update(cx, |project, cx| {
+) -> Vec<(TaskSourceKind, ResolvedTask)> {
+    let (mut old, new) = project.update(cx, |project, cx| {
         project
+            .task_store
+            .read(cx)
             .task_inventory()
+            .unwrap()
             .read(cx)
-            .used_and_current_resolved_tasks(None, worktree_id, None, task_context, cx)
+            .used_and_current_resolved_tasks(worktree_id, None, task_context, cx)
     });
-
-    cx.spawn(|_| async move {
-        let (mut old, new) = resolved_tasks.await;
-        old.extend(new);
-        old
-    })
+    old.extend(new);
+    old
 }
diff --git a/crates/project/src/task_inventory.rs b/crates/project/src/task_inventory.rs
index 83c9c1f8e58be9..eb982fdcd7d581 100644
--- a/crates/project/src/task_inventory.rs
+++ b/crates/project/src/task_inventory.rs
@@ -3,40 +3,37 @@
 use std::{
     borrow::Cow,
     cmp::{self, Reverse},
+    collections::hash_map,
     path::{Path, PathBuf},
     sync::Arc,
 };
 
-use anyhow::Result;
-use collections::{btree_map, BTreeMap, HashMap, VecDeque};
-use futures::{
-    channel::mpsc::{unbounded, UnboundedSender},
-    StreamExt,
-};
-use gpui::{AppContext, Context, Model, ModelContext, Task};
+use anyhow::{Context, Result};
+use collections::{HashMap, HashSet, VecDeque};
+use gpui::{AppContext, Context as _, Model};
 use itertools::Itertools;
 use language::{ContextProvider, File, Language, Location};
+use settings::{parse_json_with_comments, SettingsLocation};
 use task::{
-    static_source::StaticSource, ResolvedTask, TaskContext, TaskId, TaskTemplate, TaskTemplates,
-    TaskVariables, VariableName,
+    ResolvedTask, TaskContext, TaskId, TaskTemplate, TaskTemplates, TaskVariables, VariableName,
 };
 use text::{Point, ToPoint};
-use util::{post_inc, NumericPrefixWithSuffix, ResultExt};
+use util::{post_inc, NumericPrefixWithSuffix, ResultExt as _};
 use worktree::WorktreeId;
 
-use crate::Project;
+use crate::worktree_store::WorktreeStore;
 
 /// Inventory tracks available tasks for a given project.
+#[derive(Debug, Default)]
 pub struct Inventory {
-    sources: Vec<SourceInInventory>,
     last_scheduled_tasks: VecDeque<(TaskSourceKind, ResolvedTask)>,
-    update_sender: UnboundedSender<()>,
-    _update_pooler: Task<anyhow::Result<()>>,
+    templates_from_settings: ParsedTemplates,
 }
 
-struct SourceInInventory {
-    source: StaticSource,
-    kind: TaskSourceKind,
+#[derive(Debug, Default)]
+struct ParsedTemplates {
+    global: Vec<TaskTemplate>,
+    worktree: HashMap<WorktreeId, HashMap<Arc<Path>, Vec<TaskTemplate>>>,
 }
 
 /// Kind of a source the tasks are fetched from, used to display more source information in the UI.
@@ -47,7 +44,7 @@ pub enum TaskSourceKind {
     /// Tasks from the worktree's .zed/task.json
     Worktree {
         id: WorktreeId,
-        abs_path: PathBuf,
+        directory_in_worktree: PathBuf,
         id_base: Cow<'static, str>,
     },
     /// ~/.config/zed/task.json - like global files with task definitions, applicable to any path
@@ -60,20 +57,6 @@ pub enum TaskSourceKind {
 }
 
 impl TaskSourceKind {
-    pub fn abs_path(&self) -> Option<&Path> {
-        match self {
-            Self::AbsPath { abs_path, .. } | Self::Worktree { abs_path, .. } => Some(abs_path),
-            Self::UserInput | Self::Language { .. } => None,
-        }
-    }
-
-    pub fn worktree(&self) -> Option<WorktreeId> {
-        match self {
-            Self::Worktree { id, .. } => Some(*id),
-            _ => None,
-        }
-    }
-
     pub fn to_id_base(&self) -> String {
         match self {
             TaskSourceKind::UserInput => "oneshot".to_string(),
@@ -83,9 +66,9 @@ impl TaskSourceKind {
             TaskSourceKind::Worktree {
                 id,
                 id_base,
-                abs_path,
+                directory_in_worktree,
             } => {
-                format!("{id_base}_{id}_{}", abs_path.display())
+                format!("{id_base}_{id}_{}", directory_in_worktree.display())
             }
             TaskSourceKind::Language { name } => format!("language_{name}"),
         }
@@ -94,61 +77,7 @@ impl TaskSourceKind {
 
 impl Inventory {
     pub fn new(cx: &mut AppContext) -> Model<Self> {
-        cx.new_model(|cx| {
-            let (update_sender, mut rx) = unbounded();
-            let _update_pooler = cx.spawn(|this, mut cx| async move {
-                while let Some(()) = rx.next().await {
-                    this.update(&mut cx, |_, cx| {
-                        cx.notify();
-                    })?;
-                }
-                Ok(())
-            });
-            Self {
-                sources: Vec::new(),
-                last_scheduled_tasks: VecDeque::new(),
-                update_sender,
-                _update_pooler,
-            }
-        })
-    }
-
-    /// If the task with the same path was not added yet,
-    /// registers a new tasks source to fetch for available tasks later.
-    /// Unless a source is removed, ignores future additions for the same path.
-    pub fn add_source(
-        &mut self,
-        kind: TaskSourceKind,
-        create_source: impl FnOnce(UnboundedSender<()>, &mut AppContext) -> StaticSource,
-        cx: &mut ModelContext<Self>,
-    ) {
-        let abs_path = kind.abs_path();
-        if abs_path.is_some() {
-            if let Some(a) = self.sources.iter().find(|s| s.kind.abs_path() == abs_path) {
-                log::debug!("Source for path {abs_path:?} already exists, not adding. Old kind: {OLD_KIND:?}, new kind: {kind:?}", OLD_KIND = a.kind);
-                return;
-            }
-        }
-        let source = create_source(self.update_sender.clone(), cx);
-        let source = SourceInInventory { source, kind };
-        self.sources.push(source);
-        cx.notify();
-    }
-
-    /// If present, removes the local static source entry that has the given path,
-    /// making corresponding task definitions unavailable in the fetch results.
-    ///
-    /// Now, entry for this path can be re-added again.
-    pub fn remove_local_static_source(&mut self, abs_path: &Path) {
-        self.sources.retain(|s| s.kind.abs_path() != Some(abs_path));
-    }
-
-    /// If present, removes the worktree source entry that has the given worktree id,
-    /// making corresponding task definitions unavailable in the fetch results.
-    ///
-    /// Now, entry for this path can be re-added again.
-    pub fn remove_worktree_sources(&mut self, worktree: WorktreeId) {
-        self.sources.retain(|s| s.kind.worktree() != Some(worktree));
+        cx.new_model(|_| Self::default())
     }
 
     /// Pulls its task sources relevant to the worktree and the language given,
@@ -167,42 +96,27 @@ impl Inventory {
             .and_then(|language| language.context_provider()?.associated_tasks(file, cx))
             .into_iter()
             .flat_map(|tasks| tasks.0.into_iter())
-            .flat_map(|task| Some((task_source_kind.as_ref()?, task)));
+            .flat_map(|task| Some((task_source_kind.clone()?, task)));
 
-        self.sources
-            .iter()
-            .filter(|source| {
-                let source_worktree = source.kind.worktree();
-                worktree.is_none() || source_worktree.is_none() || source_worktree == worktree
-            })
-            .flat_map(|source| {
-                source
-                    .source
-                    .tasks_to_schedule()
-                    .0
-                    .into_iter()
-                    .map(|task| (&source.kind, task))
-            })
+        self.templates_from_settings(worktree)
             .chain(language_tasks)
-            .map(|(task_source_kind, task)| (task_source_kind.clone(), task))
             .collect()
     }
 
     /// Pulls its task sources relevant to the worktree and the language given and resolves them with the [`TaskContext`] given.
     /// Joins the new resolutions with the resolved tasks that were used (spawned) before,
     /// orders them so that the most recently used come first, all equally used ones are ordered so that the most specific tasks come first.
-    /// Deduplicates the tasks by their labels and splits the ordered list into two: used tasks and the rest, newly resolved tasks.
+    /// Deduplicates the tasks by their labels and contenxt and splits the ordered list into two: used tasks and the rest, newly resolved tasks.
     pub fn used_and_current_resolved_tasks(
         &self,
-        remote_templates_task: Option<Task<Result<Vec<(TaskSourceKind, TaskTemplate)>>>>,
         worktree: Option<WorktreeId>,
         location: Option<Location>,
         task_context: &TaskContext,
         cx: &AppContext,
-    ) -> Task<(
+    ) -> (
         Vec<(TaskSourceKind, ResolvedTask)>,
         Vec<(TaskSourceKind, ResolvedTask)>,
-    )> {
+    ) {
         let language = location
             .as_ref()
             .and_then(|location| location.buffer.read(cx).language_at(location.range.start));
@@ -212,14 +126,10 @@ impl Inventory {
         let file = location
             .as_ref()
             .and_then(|location| location.buffer.read(cx).file().cloned());
-        let language_tasks = language
-            .and_then(|language| language.context_provider()?.associated_tasks(file, cx))
-            .into_iter()
-            .flat_map(|tasks| tasks.0.into_iter())
-            .flat_map(|task| Some((task_source_kind.as_ref()?, task)));
 
+        let mut task_labels_to_ids = HashMap::<String, HashSet<TaskId>>::default();
         let mut lru_score = 0_u32;
-        let mut task_usage = self
+        let previously_spawned_tasks = self
             .last_scheduled_tasks
             .iter()
             .rev()
@@ -230,127 +140,64 @@ impl Inventory {
                     true
                 }
             })
-            .fold(
-                BTreeMap::default(),
-                |mut tasks, (task_source_kind, resolved_task)| {
-                    tasks.entry(&resolved_task.id).or_insert_with(|| {
-                        (task_source_kind, resolved_task, post_inc(&mut lru_score))
-                    });
-                    tasks
-                },
-            );
-        let not_used_score = post_inc(&mut lru_score);
-        let mut currently_resolved_tasks = self
-            .sources
-            .iter()
-            .filter(|source| {
-                let source_worktree = source.kind.worktree();
-                worktree.is_none() || source_worktree.is_none() || source_worktree == worktree
-            })
-            .flat_map(|source| {
-                source
-                    .source
-                    .tasks_to_schedule()
-                    .0
-                    .into_iter()
-                    .map(|task| (&source.kind, task))
-            })
-            .chain(language_tasks.filter(|_| remote_templates_task.is_none()))
-            .filter_map(|(kind, task)| {
-                let id_base = kind.to_id_base();
-                Some((kind, task.resolve_task(&id_base, task_context)?))
+            .filter(|(_, resolved_task)| {
+                match task_labels_to_ids.entry(resolved_task.resolved_label.clone()) {
+                    hash_map::Entry::Occupied(mut o) => {
+                        o.get_mut().insert(resolved_task.id.clone());
+                        // Neber allow duplicate reused tasks with the same labels
+                        false
+                    }
+                    hash_map::Entry::Vacant(v) => {
+                        v.insert(HashSet::from_iter(Some(resolved_task.id.clone())));
+                        true
+                    }
+                }
             })
-            .map(|(kind, task)| {
-                let lru_score = task_usage
-                    .remove(&task.id)
-                    .map(|(_, _, lru_score)| lru_score)
-                    .unwrap_or(not_used_score);
-                (kind.clone(), task, lru_score)
+            .map(|(task_source_kind, resolved_task)| {
+                (
+                    task_source_kind.clone(),
+                    resolved_task.clone(),
+                    post_inc(&mut lru_score),
+                )
             })
-            .collect::<Vec<_>>();
-        let previously_spawned_tasks = task_usage
-            .into_iter()
-            .map(|(_, (kind, task, lru_score))| (kind.clone(), task.clone(), lru_score))
+            .sorted_unstable_by(task_lru_comparator)
+            .map(|(kind, task, _)| (kind, task))
             .collect::<Vec<_>>();
 
-        let task_context = task_context.clone();
-        cx.spawn(move |_| async move {
-            let remote_templates = match remote_templates_task {
-                Some(task) => match task.await.log_err() {
-                    Some(remote_templates) => remote_templates,
-                    None => return (Vec::new(), Vec::new()),
-                },
-                None => Vec::new(),
-            };
-            let remote_tasks = remote_templates.into_iter().filter_map(|(kind, task)| {
+        let not_used_score = post_inc(&mut lru_score);
+        let language_tasks = language
+            .and_then(|language| language.context_provider()?.associated_tasks(file, cx))
+            .into_iter()
+            .flat_map(|tasks| tasks.0.into_iter())
+            .flat_map(|task| Some((task_source_kind.clone()?, task)));
+        let new_resolved_tasks = self
+            .templates_from_settings(worktree)
+            .chain(language_tasks)
+            .filter_map(|(kind, task)| {
                 let id_base = kind.to_id_base();
                 Some((
                     kind,
-                    task.resolve_task(&id_base, &task_context)?,
+                    task.resolve_task(&id_base, task_context)?,
                     not_used_score,
                 ))
-            });
-            currently_resolved_tasks.extend(remote_tasks);
-
-            let mut tasks_by_label = BTreeMap::default();
-            tasks_by_label = previously_spawned_tasks.into_iter().fold(
-                tasks_by_label,
-                |mut tasks_by_label, (source, task, lru_score)| {
-                    match tasks_by_label.entry((source, task.resolved_label.clone())) {
-                        btree_map::Entry::Occupied(mut o) => {
-                            let (_, previous_lru_score) = o.get();
-                            if previous_lru_score >= &lru_score {
-                                o.insert((task, lru_score));
-                            }
-                        }
-                        btree_map::Entry::Vacant(v) => {
-                            v.insert((task, lru_score));
-                        }
-                    }
-                    tasks_by_label
-                },
-            );
-            tasks_by_label = currently_resolved_tasks.iter().fold(
-                tasks_by_label,
-                |mut tasks_by_label, (source, task, lru_score)| {
-                    match tasks_by_label.entry((source.clone(), task.resolved_label.clone())) {
-                        btree_map::Entry::Occupied(mut o) => {
-                            let (previous_task, _) = o.get();
-                            let new_template = task.original_task();
-                            if new_template != previous_task.original_task() {
-                                o.insert((task.clone(), *lru_score));
-                            }
-                        }
-                        btree_map::Entry::Vacant(v) => {
-                            v.insert((task.clone(), *lru_score));
-                        }
+            })
+            .filter(|(_, resolved_task, _)| {
+                match task_labels_to_ids.entry(resolved_task.resolved_label.clone()) {
+                    hash_map::Entry::Occupied(mut o) => {
+                        // Allow new tasks with the same label, if their context is different
+                        o.get_mut().insert(resolved_task.id.clone())
                     }
-                    tasks_by_label
-                },
-            );
-
-            let resolved = tasks_by_label
-                .into_iter()
-                .map(|((kind, _), (task, lru_score))| (kind, task, lru_score))
-                .sorted_by(task_lru_comparator)
-                .filter_map(|(kind, task, lru_score)| {
-                    if lru_score < not_used_score {
-                        Some((kind, task))
-                    } else {
-                        None
+                    hash_map::Entry::Vacant(v) => {
+                        v.insert(HashSet::from_iter(Some(resolved_task.id.clone())));
+                        true
                     }
-                })
-                .collect::<Vec<_>>();
+                }
+            })
+            .sorted_unstable_by(task_lru_comparator)
+            .map(|(kind, task, _)| (kind, task))
+            .collect::<Vec<_>>();
 
-            (
-                resolved,
-                currently_resolved_tasks
-                    .into_iter()
-                    .sorted_unstable_by(task_lru_comparator)
-                    .map(|(kind, task, _)| (kind, task))
-                    .collect(),
-            )
-        })
+        (previously_spawned_tasks, new_resolved_tasks)
     }
 
     /// Returns the last scheduled task by task_id if provided.
@@ -387,6 +234,86 @@ impl Inventory {
     pub fn delete_previously_used(&mut self, id: &TaskId) {
         self.last_scheduled_tasks.retain(|(_, task)| &task.id != id);
     }
+
+    fn templates_from_settings(
+        &self,
+        worktree: Option<WorktreeId>,
+    ) -> impl '_ + Iterator<Item = (TaskSourceKind, TaskTemplate)> {
+        self.templates_from_settings
+            .global
+            .clone()
+            .into_iter()
+            .map(|template| {
+                (
+                    TaskSourceKind::AbsPath {
+                        id_base: Cow::Borrowed("global tasks.json"),
+                        abs_path: paths::tasks_file().clone(),
+                    },
+                    template,
+                )
+            })
+            .chain(worktree.into_iter().flat_map(|worktree| {
+                self.templates_from_settings
+                    .worktree
+                    .get(&worktree)
+                    .into_iter()
+                    .flatten()
+                    .flat_map(|(directory, templates)| {
+                        templates.iter().map(move |template| (directory, template))
+                    })
+                    .map(move |(directory, template)| {
+                        (
+                            TaskSourceKind::Worktree {
+                                id: worktree,
+                                directory_in_worktree: directory.to_path_buf(),
+                                id_base: Cow::Owned(format!(
+                                    "local worktree tasks from directory {directory:?}"
+                                )),
+                            },
+                            template.clone(),
+                        )
+                    })
+            }))
+    }
+
+    /// Updates in-memory task metadata from the JSON string given.
+    /// Will fail if the JSON is not a valid array of objects, but will continue if any object will not parse into a [`TaskTemplate`].
+    ///
+    /// Global tasks are updated for no worktree provided, otherwise the worktree metadata for a given path will be updated.
+    pub(crate) fn update_file_based_tasks(
+        &mut self,
+        location: Option<SettingsLocation<'_>>,
+        raw_tasks_json: Option<&str>,
+    ) -> anyhow::Result<()> {
+        let raw_tasks =
+            parse_json_with_comments::<Vec<serde_json::Value>>(raw_tasks_json.unwrap_or("[]"))
+                .context("parsing tasks file content as a JSON array")?;
+        let new_templates = raw_tasks.into_iter().filter_map(|raw_template| {
+            serde_json::from_value::<TaskTemplate>(raw_template).log_err()
+        });
+
+        let parsed_templates = &mut self.templates_from_settings;
+        match location {
+            Some(location) => {
+                let new_templates = new_templates.collect::<Vec<_>>();
+                if new_templates.is_empty() {
+                    if let Some(worktree_tasks) =
+                        parsed_templates.worktree.get_mut(&location.worktree_id)
+                    {
+                        worktree_tasks.remove(location.path);
+                    }
+                } else {
+                    parsed_templates
+                        .worktree
+                        .entry(location.worktree_id)
+                        .or_default()
+                        .insert(Arc::from(location.path), new_templates);
+                }
+            }
+            None => parsed_templates.global = new_templates.collect(),
+        }
+        Ok(())
+    }
 }
 
 fn task_lru_comparator(
@@ -432,39 +359,14 @@ fn task_variables_preference(task: &ResolvedTask) -> Reverse<usize> {
 
 #[cfg(test)]
 mod test_inventory {
-    use gpui::{AppContext, Model, TestAppContext};
+    use gpui::{Model, TestAppContext};
     use itertools::Itertools;
-    use task::{
-        static_source::{StaticSource, TrackedFile},
-        TaskContext, TaskTemplate, TaskTemplates,
-    };
+    use task::TaskContext;
     use worktree::WorktreeId;
 
     use crate::Inventory;
 
-    use super::{task_source_kind_preference, TaskSourceKind, UnboundedSender};
-
-    pub(super) fn static_test_source(
-        task_names: impl IntoIterator<Item = String>,
-        updates: UnboundedSender<()>,
-        cx: &mut AppContext,
-    ) -> StaticSource {
-        let tasks = TaskTemplates(
-            task_names
-                .into_iter()
-                .map(|name| TaskTemplate {
-                    label: name,
-                    command: "test command".to_owned(),
-                    ..TaskTemplate::default()
-                })
-                .collect(),
-        );
-        let (tx, rx) = futures::channel::mpsc::unbounded();
-        let file = TrackedFile::new(rx, updates, cx);
-        tx.unbounded_send(serde_json::to_string(&tasks).unwrap())
-            .unwrap();
-        StaticSource::new(file)
-    }
+    use super::{task_source_kind_preference, TaskSourceKind};
 
     pub(super) fn task_template_names(
         inventory: &Model<Inventory>,
@@ -506,17 +408,9 @@ mod test_inventory {
         worktree: Option<WorktreeId>,
         cx: &mut TestAppContext,
     ) -> Vec<(TaskSourceKind, String)> {
-        let (used, current) = inventory
-            .update(cx, |inventory, cx| {
-                inventory.used_and_current_resolved_tasks(
-                    None,
-                    worktree,
-                    None,
-                    &TaskContext::default(),
-                    cx,
-                )
-            })
-            .await;
+        let (used, current) = inventory.update(cx, |inventory, cx| {
+            inventory.used_and_current_resolved_tasks(worktree, None, &TaskContext::default(), cx)
+        });
         let mut all = used;
         all.extend(current);
         all.into_iter()
@@ -529,12 +423,12 @@ mod test_inventory {
 /// A context provided that tries to provide values for all non-custom [`VariableName`] variants for a currently opened file.
 /// Applied as a base for every custom [`ContextProvider`] unless explicitly oped out.
 pub struct BasicContextProvider {
-    project: Model<Project>,
+    worktree_store: Model<WorktreeStore>,
 }
 
 impl BasicContextProvider {
-    pub fn new(project: Model<Project>) -> Self {
-        Self { project }
+    pub fn new(worktree_store: Model<WorktreeStore>) -> Self {
+        Self { worktree_store }
     }
 }
 
@@ -585,7 +479,7 @@ impl ContextProvider for BasicContextProvider {
                 .file()
                 .map(|file| file.worktree_id(cx))
                 .and_then(|worktree_id| {
-                    self.project
+                    self.worktree_store
                         .read(cx)
                         .worktree_for_id(worktree_id, cx)
                         .map(|worktree| worktree.read(cx).abs_path())
@@ -653,12 +547,17 @@ impl ContextProvider for ContextProviderWithTasks {
 #[cfg(test)]
 mod tests {
     use gpui::TestAppContext;
+    use pretty_assertions::assert_eq;
+    use serde_json::json;
+
+    use crate::task_store::TaskStore;
 
     use super::test_inventory::*;
     use super::*;
 
     #[gpui::test]
     async fn test_task_list_sorting(cx: &mut TestAppContext) {
+        init_test(cx);
         let inventory = cx.update(Inventory::new);
         let initial_tasks = resolved_task_names(&inventory, None, cx).await;
         assert!(
@@ -670,31 +569,6 @@ mod tests {
             initial_tasks.is_empty(),
             "No tasks expected for empty inventory, but got {initial_tasks:?}"
         );
-
-        inventory.update(cx, |inventory, cx| {
-            inventory.add_source(
-                TaskSourceKind::UserInput,
-                |tx, cx| static_test_source(vec!["3_task".to_string()], tx, cx),
-                cx,
-            );
-        });
-        inventory.update(cx, |inventory, cx| {
-            inventory.add_source(
-                TaskSourceKind::UserInput,
-                |tx, cx| {
-                    static_test_source(
-                        vec![
-                            "1_task".to_string(),
-                            "2_task".to_string(),
-                            "1_a_task".to_string(),
-                        ],
-                        tx,
-                        cx,
-                    )
-                },
-                cx,
-            );
-        });
         cx.run_until_parked();
         let expected_initial_state = [
             "1_a_task".to_string(),
@@ -702,6 +576,17 @@ mod tests {
             "2_task".to_string(),
             "3_task".to_string(),
         ];
+
+        inventory.update(cx, |inventory, _| {
+            inventory
+                .update_file_based_tasks(
+                    None,
+                    Some(&mock_tasks_from_names(
+                        expected_initial_state.iter().map(|name| name.as_str()),
+                    )),
+                )
+                .unwrap();
+        });
         assert_eq!(
             task_template_names(&inventory, None, cx),
             &expected_initial_state,
@@ -720,7 +605,6 @@ mod tests {
         assert_eq!(
             resolved_task_names(&inventory, None, cx).await,
             vec![
-                "2_task".to_string(),
                 "2_task".to_string(),
                 "1_a_task".to_string(),
                 "1_task".to_string(),
@@ -739,9 +623,6 @@ mod tests {
         assert_eq!(
             resolved_task_names(&inventory, None, cx).await,
             vec![
-                "3_task".to_string(),
-                "1_task".to_string(),
-                "2_task".to_string(),
                 "3_task".to_string(),
                 "1_task".to_string(),
                 "2_task".to_string(),
@@ -749,14 +630,17 @@ mod tests {
             ],
         );
 
-        inventory.update(cx, |inventory, cx| {
-            inventory.add_source(
-                TaskSourceKind::UserInput,
-                |tx, cx| {
-                    static_test_source(vec!["10_hello".to_string(), "11_hello".to_string()], tx, cx)
-                },
-                cx,
-            );
+        inventory.update(cx, |inventory, _| {
+            inventory
+                .update_file_based_tasks(
+                    None,
+                    Some(&mock_tasks_from_names(
+                        ["10_hello", "11_hello"]
+                            .into_iter()
+                            .chain(expected_initial_state.iter().map(|name| name.as_str())),
+                    )),
+                )
+                .unwrap();
         });
         cx.run_until_parked();
         let expected_updated_state = [
@@ -774,9 +658,6 @@ mod tests {
         assert_eq!(
             resolved_task_names(&inventory, None, cx).await,
             vec![
-                "3_task".to_string(),
-                "1_task".to_string(),
-                "2_task".to_string(),
                 "3_task".to_string(),
                 "1_task".to_string(),
                 "2_task".to_string(),
@@ -794,10 +675,6 @@ mod tests {
         assert_eq!(
             resolved_task_names(&inventory, None, cx).await,
             vec![
-                "11_hello".to_string(),
-                "3_task".to_string(),
-                "1_task".to_string(),
-                "2_task".to_string(),
                 "11_hello".to_string(),
                 "3_task".to_string(),
                 "1_task".to_string(),
@@ -810,133 +687,50 @@ mod tests {
 
     #[gpui::test]
     async fn test_inventory_static_task_filters(cx: &mut TestAppContext) {
-        let inventory_with_statics = cx.update(Inventory::new);
+        init_test(cx);
+        let inventory = cx.update(Inventory::new);
         let common_name = "common_task_name";
-        let path_1 = Path::new("path_1");
-        let path_2 = Path::new("path_2");
         let worktree_1 = WorktreeId::from_usize(1);
-        let worktree_path_1 = Path::new("worktree_path_1");
         let worktree_2 = WorktreeId::from_usize(2);
-        let worktree_path_2 = Path::new("worktree_path_2");
-
-        inventory_with_statics.update(cx, |inventory, cx| {
-            inventory.add_source(
-                TaskSourceKind::UserInput,
-                |tx, cx| {
-                    static_test_source(
-                        vec!["user_input".to_string(), common_name.to_string()],
-                        tx,
-                        cx,
-                    )
-                },
-                cx,
-            );
-            inventory.add_source(
-                TaskSourceKind::AbsPath {
-                    id_base: "test source".into(),
-                    abs_path: path_1.to_path_buf(),
-                },
-                |tx, cx| {
-                    static_test_source(
-                        vec!["static_source_1".to_string(), common_name.to_string()],
-                        tx,
-                        cx,
-                    )
-                },
-                cx,
-            );
-            inventory.add_source(
-                TaskSourceKind::AbsPath {
-                    id_base: "test source".into(),
-                    abs_path: path_2.to_path_buf(),
-                },
-                |tx, cx| {
-                    static_test_source(
-                        vec!["static_source_2".to_string(), common_name.to_string()],
-                        tx,
-                        cx,
-                    )
-                },
-                cx,
-            );
-            inventory.add_source(
-                TaskSourceKind::Worktree {
-                    id: worktree_1,
-                    abs_path: worktree_path_1.to_path_buf(),
-                    id_base: "test_source".into(),
-                },
-                |tx, cx| {
-                    static_test_source(
-                        vec!["worktree_1".to_string(), common_name.to_string()],
-                        tx,
-                        cx,
-                    )
-                },
-                cx,
-            );
-            inventory.add_source(
-                TaskSourceKind::Worktree {
-                    id: worktree_2,
-                    abs_path: worktree_path_2.to_path_buf(),
-                    id_base: "test_source".into(),
-                },
-                |tx, cx| {
-                    static_test_source(
-                        vec!["worktree_2".to_string(), common_name.to_string()],
-                        tx,
-                        cx,
-                    )
-                },
-                cx,
-            );
-        });
+
         cx.run_until_parked();
         let worktree_independent_tasks = vec![
             (
                 TaskSourceKind::AbsPath {
-                    id_base: "test source".into(),
-                    abs_path: path_1.to_path_buf(),
-                },
-                "static_source_1".to_string(),
-            ),
-            (
-                TaskSourceKind::AbsPath {
-                    id_base: "test source".into(),
-                    abs_path: path_1.to_path_buf(),
+                    id_base: "global tasks.json".into(),
+                    abs_path: paths::tasks_file().clone(),
                 },
                 common_name.to_string(),
             ),
             (
                 TaskSourceKind::AbsPath {
-                    id_base: "test source".into(),
-                    abs_path: path_2.to_path_buf(),
+                    id_base: "global tasks.json".into(),
+                    abs_path: paths::tasks_file().clone(),
                 },
-                common_name.to_string(),
+                "static_source_1".to_string(),
             ),
             (
                 TaskSourceKind::AbsPath {
-                    id_base: "test source".into(),
-                    abs_path: path_2.to_path_buf(),
+                    id_base: "global tasks.json".into(),
+                    abs_path: paths::tasks_file().clone(),
                 },
                 "static_source_2".to_string(),
             ),
-            (TaskSourceKind::UserInput, common_name.to_string()),
-            (TaskSourceKind::UserInput, "user_input".to_string()),
         ];
         let worktree_1_tasks = [
             (
                 TaskSourceKind::Worktree {
                     id: worktree_1,
-                    abs_path: worktree_path_1.to_path_buf(),
-                    id_base: "test_source".into(),
+                    directory_in_worktree: PathBuf::from(".zed"),
+                    id_base: "local worktree tasks from directory \".zed\"".into(),
                 },
                 common_name.to_string(),
             ),
             (
                 TaskSourceKind::Worktree {
                     id: worktree_1,
-                    abs_path: worktree_path_1.to_path_buf(),
-                    id_base: "test_source".into(),
+                    directory_in_worktree: PathBuf::from(".zed"),
+                    id_base: "local worktree tasks from directory \".zed\"".into(),
                 },
                 "worktree_1".to_string(),
             ),
@@ -945,36 +739,63 @@ mod tests {
             (
                 TaskSourceKind::Worktree {
                     id: worktree_2,
-                    abs_path: worktree_path_2.to_path_buf(),
-                    id_base: "test_source".into(),
+                    directory_in_worktree: PathBuf::from(".zed"),
+                    id_base: "local worktree tasks from directory \".zed\"".into(),
                 },
                 common_name.to_string(),
             ),
             (
                 TaskSourceKind::Worktree {
                     id: worktree_2,
-                    abs_path: worktree_path_2.to_path_buf(),
-                    id_base: "test_source".into(),
+                    directory_in_worktree: PathBuf::from(".zed"),
+                    id_base: "local worktree tasks from directory \".zed\"".into(),
                 },
                 "worktree_2".to_string(),
             ),
         ];
 
-        let all_tasks = worktree_1_tasks
-            .iter()
-            .chain(worktree_2_tasks.iter())
-            // worktree-less tasks come later in the list
-            .chain(worktree_independent_tasks.iter())
-            .cloned()
-            .sorted_by_key(|(kind, label)| (task_source_kind_preference(kind), label.clone()))
-            .collect::<Vec<_>>();
+        inventory.update(cx, |inventory, _| {
+            inventory
+                .update_file_based_tasks(
+                    None,
+                    Some(&mock_tasks_from_names(
+                        worktree_independent_tasks
+                            .iter()
+                            .map(|(_, name)| name.as_str()),
+                    )),
+                )
+                .unwrap();
+            inventory
+                .update_file_based_tasks(
+                    Some(SettingsLocation {
+                        worktree_id: worktree_1,
+                        path: Path::new(".zed"),
+                    }),
+                    Some(&mock_tasks_from_names(
+                        worktree_1_tasks.iter().map(|(_, name)| name.as_str()),
+                    )),
+                )
+                .unwrap();
+            inventory
+                .update_file_based_tasks(
+                    Some(SettingsLocation {
+                        worktree_id: worktree_2,
+                        path: Path::new(".zed"),
+                    }),
+                    Some(&mock_tasks_from_names(
+                        worktree_2_tasks.iter().map(|(_, name)| name.as_str()),
+                    )),
+                )
+                .unwrap();
+        });
 
         assert_eq!(
-            list_tasks(&inventory_with_statics, None, cx).await,
-            all_tasks
+            list_tasks(&inventory, None, cx).await,
+            worktree_independent_tasks,
+            "Without a worktree, only worktree-independent tasks should be listed"
         );
         assert_eq!(
-            list_tasks(&inventory_with_statics, Some(worktree_1), cx).await,
+            list_tasks(&inventory, Some(worktree_1), cx).await,
             worktree_1_tasks
                 .iter()
                 .chain(worktree_independent_tasks.iter())
@@ -983,7 +804,7 @@ mod tests {
                 .collect::<Vec<_>>(),
         );
         assert_eq!(
-            list_tasks(&inventory_with_statics, Some(worktree_2), cx).await,
+            list_tasks(&inventory, Some(worktree_2), cx).await,
             worktree_2_tasks
                 .iter()
                 .chain(worktree_independent_tasks.iter())
@@ -993,25 +814,39 @@ mod tests {
         );
     }
 
+    fn init_test(_cx: &mut TestAppContext) {
+        if std::env::var("RUST_LOG").is_ok() {
+            env_logger::try_init().ok();
+        }
+        TaskStore::init(None);
+    }
+
     pub(super) async fn resolved_task_names(
         inventory: &Model<Inventory>,
         worktree: Option<WorktreeId>,
         cx: &mut TestAppContext,
     ) -> Vec<String> {
-        let (used, current) = inventory
-            .update(cx, |inventory, cx| {
-                inventory.used_and_current_resolved_tasks(
-                    None,
-                    worktree,
-                    None,
-                    &TaskContext::default(),
-                    cx,
-                )
-            })
-            .await;
+        let (used, current) = inventory.update(cx, |inventory, cx| {
+            inventory.used_and_current_resolved_tasks(worktree, None, &TaskContext::default(), cx)
+        });
         used.into_iter()
             .chain(current)
             .map(|(_, task)| task.original_task().label.clone())
             .collect()
     }
+
+    fn mock_tasks_from_names<'a>(task_names: impl Iterator<Item = &'a str> + 'a) -> String {
+        serde_json::to_string(&serde_json::Value::Array(
+            task_names
+                .map(|task_name| {
+                    json!({
+                        "label": task_name,
+                        "command": "echo",
+                        "args": vec![task_name],
+                    })
+                })
+                .collect::<Vec<_>>(),
+        ))
+        .unwrap()
+    }
 }
diff --git a/crates/project/src/task_store.rs b/crates/project/src/task_store.rs
new file mode 100644
index 00000000000000..55ee780fc56e98
--- /dev/null
+++ b/crates/project/src/task_store.rs
@@ -0,0 +1,432 @@
+use std::{path::PathBuf, sync::Arc};
+
+use anyhow::Context as _;
+use collections::HashMap;
+use fs::Fs;
+use futures::StreamExt as _;
+use gpui::{AppContext, AsyncAppContext, EventEmitter, Model, ModelContext, Task, WeakModel};
+use language::{
+    proto::{deserialize_anchor, serialize_anchor},
+    ContextProvider as _, Location,
+};
+use rpc::{proto, AnyProtoClient, TypedEnvelope};
+use settings::{watch_config_file, SettingsLocation};
+use task::{TaskContext, TaskVariables, VariableName};
+use text::BufferId;
+use util::ResultExt;
+
+use crate::{
+    buffer_store::BufferStore, worktree_store::WorktreeStore, BasicContextProvider, Inventory,
+    ProjectEnvironment,
+};
+
+pub enum TaskStore {
+    Functional(StoreState),
+    Noop,
+}
+
+pub struct StoreState {
+    mode: StoreMode,
+    task_inventory: Model<Inventory>,
+    buffer_store: WeakModel<BufferStore>,
+    worktree_store: Model<WorktreeStore>,
+    _global_task_config_watcher: Task<()>,
+}
+
+enum StoreMode {
+    Local {
+        downstream_client: Option<(AnyProtoClient, u64)>,
+        environment: Model<ProjectEnvironment>,
+    },
+    Remote {
+        upstream_client: AnyProtoClient,
+        project_id: u64,
+    },
+}
+
+impl EventEmitter<crate::Event> for TaskStore {}
+
+impl TaskStore {
+    pub fn init(client: Option<&AnyProtoClient>) {
+        if let Some(client) = client {
+            client.add_model_request_handler(Self::handle_task_context_for_location);
+        }
+    }
+
+    async fn handle_task_context_for_location(
+        store: Model<Self>,
+        envelope: TypedEnvelope<proto::TaskContextForLocation>,
+        mut cx: AsyncAppContext,
+    ) -> anyhow::Result<proto::TaskContext> {
+        let location = envelope
+            .payload
+            .location
+            .context("no location given for task context handling")?;
+        let (buffer_store, is_remote) = store.update(&mut cx, |store, _| {
+            Ok(match store {
+                TaskStore::Functional(state) => (
+                    state.buffer_store.clone(),
+                    match &state.mode {
+                        StoreMode::Local { .. } => false,
+                        StoreMode::Remote { .. } => true,
+                    },
+                ),
+                TaskStore::Noop => {
+                    anyhow::bail!("empty task store cannot handle task context requests")
+                }
+            })
+        })??;
+        let buffer_store = buffer_store
+            .upgrade()
+            .context("no buffer store when handling task context request")?;
+
+        let buffer_id = BufferId::new(location.buffer_id).with_context(|| {
+            format!(
+                "cannot handle task context request for invalid buffer id: {}",
+                location.buffer_id
+            )
+        })?;
+
+        let start = location
+            .start
+            .and_then(deserialize_anchor)
+            .context("missing task context location start")?;
+        let end = location
+            .end
+            .and_then(deserialize_anchor)
+            .context("missing task context location end")?;
+        let buffer = buffer_store
+            .update(&mut cx, |buffer_store, cx| {
+                if is_remote {
+                    buffer_store.wait_for_remote_buffer(buffer_id, cx)
+                } else {
+                    Task::ready(
+                        buffer_store
+                            .get(buffer_id)
+                            .with_context(|| format!("no local buffer with id {buffer_id}")),
+                    )
+                }
+            })?
+            .await?;
+
+        let location = Location {
+            buffer,
+            range: start..end,
+        };
+        let context_task = store.update(&mut cx, |store, cx| {
+            let captured_variables = {
+                let mut variables = TaskVariables::from_iter(
+                    envelope
+                        .payload
+                        .task_variables
+                        .into_iter()
+                        .filter_map(|(k, v)| Some((k.parse().log_err()?, v))),
+                );
+
+                for range in location
+                    .buffer
+                    .read(cx)
+                    .snapshot()
+                    .runnable_ranges(location.range.clone())
+                {
+                    for (capture_name, value) in range.extra_captures {
+                        variables.insert(VariableName::Custom(capture_name.into()), value);
+                    }
+                }
+                variables
+            };
+            store.task_context_for_location(captured_variables, location, cx)
+        })?;
+        let task_context = context_task.await.unwrap_or_default();
+        Ok(proto::TaskContext {
+            project_env: task_context.project_env.into_iter().collect(),
+            cwd: task_context
+                .cwd
+                .map(|cwd| cwd.to_string_lossy().to_string()),
+            task_variables: task_context
+                .task_variables
+                .into_iter()
+                .map(|(variable_name, variable_value)| (variable_name.to_string(), variable_value))
+                .collect(),
+        })
+    }
+
+    pub fn local(
+        fs: Arc<dyn Fs>,
+        buffer_store: WeakModel<BufferStore>,
+        worktree_store: Model<WorktreeStore>,
+        environment: Model<ProjectEnvironment>,
+        cx: &mut ModelContext<'_, Self>,
+    ) -> Self {
+        Self::Functional(StoreState {
+            mode: StoreMode::Local {
+                downstream_client: None,
+                environment,
+            },
+            task_inventory: Inventory::new(cx),
+            buffer_store,
+            worktree_store,
+            _global_task_config_watcher: Self::subscribe_to_global_task_file_changes(fs, cx),
+        })
+    }
+
+    pub fn remote(
+        fs: Arc<dyn Fs>,
+        buffer_store: WeakModel<BufferStore>,
+        worktree_store: Model<WorktreeStore>,
+        upstream_client: AnyProtoClient,
+        project_id: u64,
+        cx: &mut ModelContext<'_, Self>,
+    ) -> Self {
+        Self::Functional(StoreState {
+            mode: StoreMode::Remote {
+                upstream_client,
+                project_id,
+            },
+            task_inventory: Inventory::new(cx),
+            buffer_store,
+            worktree_store,
+            _global_task_config_watcher: Self::subscribe_to_global_task_file_changes(fs, cx),
+        })
+    }
+
+    pub fn task_context_for_location(
+        &self,
+        captured_variables: TaskVariables,
+        location: Location,
+        cx: &mut AppContext,
+    ) -> Task<Option<TaskContext>> {
+        match self {
+            TaskStore::Functional(state) => match &state.mode {
+                StoreMode::Local { environment, .. } => local_task_context_for_location(
+                    state.worktree_store.clone(),
+                    environment.clone(),
+                    captured_variables,
+                    location,
+                    cx,
+                ),
+                StoreMode::Remote {
+                    upstream_client,
+                    project_id,
+                } => remote_task_context_for_location(
+                    *project_id,
+                    upstream_client,
+                    state.worktree_store.clone(),
+                    captured_variables,
+                    location,
+                    cx,
+                ),
+            },
+            TaskStore::Noop => Task::ready(None),
+        }
+    }
+
+    pub fn task_inventory(&self) -> Option<&Model<Inventory>> {
+        match self {
+            TaskStore::Functional(state) => Some(&state.task_inventory),
+            TaskStore::Noop => None,
+        }
+    }
+
+    pub fn shared(
+        &mut self,
+        remote_id: u64,
+        new_downstream_client: AnyProtoClient,
+        _cx: &mut AppContext,
+    ) {
+        if let Self::Functional(StoreState {
+            mode: StoreMode::Local {
+                downstream_client, ..
+            },
+            ..
+        }) = self
+        {
+            *downstream_client = Some((new_downstream_client, remote_id));
+        }
+    }
+
+    pub fn unshared(&mut self, _: &mut ModelContext<Self>) {
+        if let Self::Functional(StoreState {
+            mode: StoreMode::Local {
+                downstream_client, ..
+            },
+            ..
+        }) = self
+        {
+            *downstream_client = None;
+        }
+    }
+
+    pub(super) fn update_user_tasks(
+        &self,
+        location: Option<SettingsLocation<'_>>,
+        raw_tasks_json: Option<&str>,
+        cx: &mut ModelContext<'_, Self>,
+    ) -> anyhow::Result<()> {
+        let task_inventory = match self {
+            TaskStore::Functional(state) => &state.task_inventory,
+            TaskStore::Noop => return Ok(()),
+        };
+        let raw_tasks_json = raw_tasks_json
+            .map(|json| json.trim())
+            .filter(|json| !json.is_empty());
+
+        task_inventory.update(cx, |inventory, _| {
+            inventory.update_file_based_tasks(location, raw_tasks_json)
+        })
+    }
+
+    fn subscribe_to_global_task_file_changes(
+        fs: Arc<dyn Fs>,
+        cx: &mut ModelContext<'_, Self>,
+    ) -> Task<()> {
+        let mut user_tasks_file_rx =
+            watch_config_file(&cx.background_executor(), fs, paths::tasks_file().clone());
+        let user_tasks_content = cx.background_executor().block(user_tasks_file_rx.next());
+        cx.spawn(move |task_store, mut cx| async move {
+            if let Some(user_tasks_content) = user_tasks_content {
+                let Ok(_) = task_store.update(&mut cx, |task_store, cx| {
+                    task_store
+                        .update_user_tasks(None, Some(&user_tasks_content), cx)
+                        .log_err();
+                }) else {
+                    return;
+                };
+            }
+            while let Some(user_tasks_content) = user_tasks_file_rx.next().await {
+                let Ok(()) = task_store.update(&mut cx, |task_store, cx| {
+                    let result = task_store.update_user_tasks(None, Some(&user_tasks_content), cx);
+                    if let Err(err) = &result {
+                        log::error!("Failed to load user tasks: {err}");
+                        cx.emit(crate::Event::Notification(format!(
+                            "Invalid global tasks file\n{err}"
+                        )));
+                    }
+                    cx.refresh();
+                }) else {
+                    break; // App dropped
+                };
+            }
+        })
+    }
+}
+
+fn local_task_context_for_location(
+    worktree_store: Model<WorktreeStore>,
+    environment: Model<ProjectEnvironment>,
+    captured_variables: TaskVariables,
+    location: Location,
+    cx: &AppContext,
+) -> Task<Option<TaskContext>> {
+    let worktree_id = location.buffer.read(cx).file().map(|f| f.worktree_id(cx));
+    let worktree_abs_path = worktree_id
+        .and_then(|worktree_id| worktree_store.read(cx).worktree_for_id(worktree_id, cx))
+        .map(|worktree| worktree.read(cx).abs_path());
+
+    cx.spawn(|mut cx| async move {
+        let worktree_abs_path = worktree_abs_path.clone();
+        let project_env = environment
+            .update(&mut cx, |environment, cx| {
+                environment.get_environment(worktree_id, worktree_abs_path.clone(), cx)
+            })
+            .ok()?
+            .await;
+
+        let mut task_variables = cx
+            .update(|cx| {
+                combine_task_variables(
+                    captured_variables,
+                    location,
+                    project_env.as_ref(),
+                    BasicContextProvider::new(worktree_store),
+                    cx,
+                )
+                .log_err()
+            })
+            .ok()
+            .flatten()?;
+        // Remove all custom entries starting with _, as they're not intended for use by the end user.
+        task_variables.sweep();
+
+        Some(TaskContext {
+            project_env: project_env.unwrap_or_default(),
+            cwd: worktree_abs_path.map(|p| p.to_path_buf()),
+            task_variables,
+        })
+    })
+}
+
+fn remote_task_context_for_location(
+    project_id: u64,
+    upstream_client: &AnyProtoClient,
+    worktree_store: Model<WorktreeStore>,
+    captured_variables: TaskVariables,
+    location: Location,
+    cx: &mut AppContext,
+) -> Task<Option<TaskContext>> {
+    // We need to gather a client context, as the headless one may lack certain information (e.g. tree-sitter parsing is disabled there, so symbols are not available).
+    let mut remote_context = BasicContextProvider::new(worktree_store)
+        .build_context(&TaskVariables::default(), &location, None, cx)
+        .log_err()
+        .unwrap_or_default();
+    remote_context.extend(captured_variables);
+
+    let context_task = upstream_client.request(proto::TaskContextForLocation {
+        project_id,
+        location: Some(proto::Location {
+            buffer_id: location.buffer.read(cx).remote_id().into(),
+            start: Some(serialize_anchor(&location.range.start)),
+            end: Some(serialize_anchor(&location.range.end)),
+        }),
+        task_variables: remote_context
+            .into_iter()
+            .map(|(k, v)| (k.to_string(), v))
+            .collect(),
+    });
+    cx.spawn(|_| async move {
+        let task_context = context_task.await.log_err()?;
+        Some(TaskContext {
+            cwd: task_context.cwd.map(PathBuf::from),
+            task_variables: task_context
+                .task_variables
+                .into_iter()
+                .filter_map(
+                    |(variable_name, variable_value)| match variable_name.parse() {
+                        Ok(variable_name) => Some((variable_name, variable_value)),
+                        Err(()) => {
+                            log::error!("Unknown variable name: {variable_name}");
+                            None
+                        }
+                    },
+                )
+                .collect(),
+            project_env: task_context.project_env.into_iter().collect(),
+        })
+    })
+}
+
+fn combine_task_variables(
+    mut captured_variables: TaskVariables,
+    location: Location,
+    project_env: Option<&HashMap<String, String>>,
+    baseline: BasicContextProvider,
+    cx: &mut AppContext,
+) -> anyhow::Result<TaskVariables> {
+    let language_context_provider = location
+        .buffer
+        .read(cx)
+        .language()
+        .and_then(|language| language.context_provider());
+    let baseline = baseline
+        .build_context(&captured_variables, &location, project_env, cx)
+        .context("building basic default context")?;
+    captured_variables.extend(baseline);
+    if let Some(provider) = language_context_provider {
+        captured_variables.extend(
+            provider
+                .build_context(&captured_variables, &location, project_env, cx)
+                .context("building provider context")?,
+        );
+    }
+    Ok(captured_variables)
+}
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index 4e101f4305f044..aac2c9ae4d55ec 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -245,8 +245,6 @@ message Envelope {
 
         TaskContextForLocation task_context_for_location = 203;
         TaskContext task_context = 204;
-        TaskTemplatesResponse task_templates_response = 205;
-        TaskTemplates task_templates = 206;
 
         LinkedEditingRange linked_editing_range = 209;
         LinkedEditingRangeResponse linked_editing_range_response = 210;
@@ -290,6 +288,7 @@ message Envelope {
     reserved 87 to 88;
     reserved 158 to 161;
     reserved 166 to 169;
+    reserved 205 to 206;
     reserved 224 to 229;
     reserved 247 to 254;
 }
@@ -2260,6 +2259,7 @@ message GetSupermavenApiKeyResponse {
 message TaskContextForLocation {
     uint64 project_id = 1;
     Location location = 2;
+    map<string, string> task_variables = 3;
 }
 
 message TaskContext {
@@ -2268,35 +2268,6 @@ message TaskContext {
     map<string, string> project_env = 3;
 }
 
-message TaskTemplates {
-    uint64 project_id = 1;
-    optional Location location = 2;
-    optional uint64 worktree_id = 3;
-}
-
-message TaskTemplatesResponse {
-    repeated TemplatePair templates = 1;
-}
-
-message TemplatePair {
-    TaskSourceKind kind = 1;
-    TaskTemplate template = 2;
-}
-
-message TaskTemplate {
-    string label = 1;
-    string command = 2;
-    repeated string args = 3;
-    map<string, string> env = 4;
-    optional string cwd = 5;
-    bool use_new_terminal = 6;
-    bool allow_concurrent_runs = 7;
-    RevealStrategy reveal = 8;
-    HideStrategy hide = 10;
-    repeated string tags = 9;
-    Shell shell = 11;
-}
-
 message Shell {
     message WithArguments {
         string program = 1;
@@ -2323,32 +2294,6 @@ enum HideStrategy {
     HideOnSuccess = 2;
 }
 
-message TaskSourceKind {
-    oneof kind {
-        UserInput user_input = 1;
-        Worktree worktree = 2;
-        AbsPath abs_path = 3;
-        Language language = 4;
-    }
-
-    message UserInput {}
-
-    message Worktree {
-        uint64 id = 1;
-        string abs_path = 2;
-        string id_base = 3;
-    }
-
-    message AbsPath {
-        string id_base = 1;
-        string abs_path = 2;
-    }
-
-    message Language {
-        string name = 1;
-    }
-}
-
 message ContextMessageStatus {
     oneof variant {
         Done done = 1;
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 48733c449c69f6..ae28555a2c315a 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -290,8 +290,6 @@ messages!(
     (SynchronizeBuffersResponse, Foreground),
     (TaskContextForLocation, Background),
     (TaskContext, Background),
-    (TaskTemplates, Background),
-    (TaskTemplatesResponse, Background),
     (Test, Foreground),
     (Unfollow, Foreground),
     (UnshareProject, Foreground),
@@ -460,7 +458,6 @@ request_messages!(
     (ShareProject, ShareProjectResponse),
     (SynchronizeBuffers, SynchronizeBuffersResponse),
     (TaskContextForLocation, TaskContext),
-    (TaskTemplates, TaskTemplatesResponse),
     (Test, Test),
     (UpdateBuffer, Ack),
     (UpdateParticipantLocation, Ack),
@@ -543,7 +540,6 @@ entity_messages!(
     StartLanguageServer,
     SynchronizeBuffers,
     TaskContextForLocation,
-    TaskTemplates,
     UnshareProject,
     UpdateBuffer,
     UpdateBufferFile,
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 0ad16caacc3cdc..8ebe8905add129 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -7,6 +7,7 @@ use project::{
     buffer_store::{BufferStore, BufferStoreEvent},
     project_settings::SettingsObserver,
     search::SearchQuery,
+    task_store::TaskStore,
     worktree_store::WorktreeStore,
     LspStore, LspStoreEvent, PrettierStore, ProjectPath, WorktreeId,
 };
@@ -29,6 +30,7 @@ pub struct HeadlessProject {
     pub worktree_store: Model<WorktreeStore>,
     pub buffer_store: Model<BufferStore>,
     pub lsp_store: Model<LspStore>,
+    pub task_store: Model<TaskStore>,
     pub settings_observer: Model<SettingsObserver>,
     pub next_entry_id: Arc<AtomicUsize>,
     pub languages: Arc<LanguageRegistry>,
@@ -68,12 +70,28 @@ impl HeadlessProject {
             )
         });
 
+        let environment = project::ProjectEnvironment::new(&worktree_store, None, cx);
+        let task_store = cx.new_model(|cx| {
+            let mut task_store = TaskStore::local(
+                fs.clone(),
+                buffer_store.downgrade(),
+                worktree_store.clone(),
+                environment.clone(),
+                cx,
+            );
+            task_store.shared(SSH_PROJECT_ID, session.clone().into(), cx);
+            task_store
+        });
         let settings_observer = cx.new_model(|cx| {
-            let mut observer = SettingsObserver::new_local(fs.clone(), worktree_store.clone(), cx);
+            let mut observer = SettingsObserver::new_local(
+                fs.clone(),
+                worktree_store.clone(),
+                task_store.clone(),
+                cx,
+            );
             observer.shared(SSH_PROJECT_ID, session.clone().into(), cx);
             observer
         });
-        let environment = project::ProjectEnvironment::new(&worktree_store, None, cx);
         let lsp_store = cx.new_model(|cx| {
             let mut lsp_store = LspStore::new_local(
                 buffer_store.clone(),
@@ -108,6 +126,7 @@ impl HeadlessProject {
         session.subscribe_to_entity(SSH_PROJECT_ID, &buffer_store);
         session.subscribe_to_entity(SSH_PROJECT_ID, &cx.handle());
         session.subscribe_to_entity(SSH_PROJECT_ID, &lsp_store);
+        session.subscribe_to_entity(SSH_PROJECT_ID, &task_store);
         session.subscribe_to_entity(SSH_PROJECT_ID, &settings_observer);
 
         client.add_request_handler(cx.weak_model(), Self::handle_list_remote_directory);
@@ -126,6 +145,7 @@ impl HeadlessProject {
         WorktreeStore::init(&client);
         SettingsObserver::init(&client);
         LspStore::init(&client);
+        TaskStore::init(Some(&client));
 
         HeadlessProject {
             session: client,
@@ -134,6 +154,7 @@ impl HeadlessProject {
             worktree_store,
             buffer_store,
             lsp_store,
+            task_store,
             next_entry_id: Default::default(),
             languages,
         }
diff --git a/crates/settings/src/settings.rs b/crates/settings/src/settings.rs
index 2ed01dc7c722fd..1092a9bd4d64ff 100644
--- a/crates/settings/src/settings.rs
+++ b/crates/settings/src/settings.rs
@@ -14,8 +14,8 @@ pub use json_schema::*;
 pub use keymap_file::KeymapFile;
 pub use settings_file::*;
 pub use settings_store::{
-    InvalidSettingsError, LocalSettingsKind, Settings, SettingsLocation, SettingsSources,
-    SettingsStore,
+    parse_json_with_comments, InvalidSettingsError, LocalSettingsKind, Settings, SettingsLocation,
+    SettingsSources, SettingsStore,
 };
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
diff --git a/crates/settings/src/settings_store.rs b/crates/settings/src/settings_store.rs
index 445420c1db8a7d..c8768f007db352 100644
--- a/crates/settings/src/settings_store.rs
+++ b/crates/settings/src/settings_store.rs
@@ -515,13 +515,11 @@ impl SettingsStore {
         } else {
             parse_json_with_comments(user_settings_content)?
         };
-        if settings.is_object() {
-            self.raw_user_settings = settings;
-            self.recompute_values(None, cx)?;
-            Ok(())
-        } else {
-            Err(anyhow!("settings must be an object"))
-        }
+
+        anyhow::ensure!(settings.is_object(), "settings must be an object");
+        self.raw_user_settings = settings;
+        self.recompute_values(None, cx)?;
+        Ok(())
     }
 
     /// Add or remove a set of local settings via a JSON string.
@@ -533,16 +531,29 @@ impl SettingsStore {
         settings_content: Option<&str>,
         cx: &mut AppContext,
     ) -> Result<()> {
+        anyhow::ensure!(
+            kind != LocalSettingsKind::Tasks,
+            "Attempted to submit tasks into the settings store"
+        );
+
         let raw_local_settings = self
             .raw_local_settings
             .entry((root_id, directory_path.clone()))
             .or_default();
-        if settings_content.is_some_and(|content| !content.is_empty()) {
-            raw_local_settings.insert(kind, parse_json_with_comments(settings_content.unwrap())?);
+        let changed = if settings_content.is_some_and(|content| !content.is_empty()) {
+            let new_contents = parse_json_with_comments(settings_content.unwrap())?;
+            if Some(&new_contents) == raw_local_settings.get(&kind) {
+                false
+            } else {
+                raw_local_settings.insert(kind, new_contents);
+                true
+            }
         } else {
-            raw_local_settings.remove(&kind);
+            raw_local_settings.remove(&kind).is_some()
+        };
+        if changed {
+            self.recompute_values(Some((root_id, &directory_path)), cx)?;
         }
-        self.recompute_values(Some((root_id, &directory_path)), cx)?;
         Ok(())
     }
 
diff --git a/crates/task/src/lib.rs b/crates/task/src/lib.rs
index 8321518e0323d4..1687f8f6964e6d 100644
--- a/crates/task/src/lib.rs
+++ b/crates/task/src/lib.rs
@@ -140,8 +140,13 @@ impl FromStr for VariableName {
         let without_prefix = s.strip_prefix(ZED_VARIABLE_NAME_PREFIX).ok_or(())?;
         let value = match without_prefix {
             "FILE" => Self::File,
+            "FILENAME" => Self::Filename,
+            "RELATIVE_FILE" => Self::RelativeFile,
+            "DIRNAME" => Self::Dirname,
+            "STEM" => Self::Stem,
             "WORKTREE_ROOT" => Self::WorktreeRoot,
             "SYMBOL" => Self::Symbol,
+            "RUNNABLE_SYMBOL" => Self::RunnableSymbol,
             "SELECTED_TEXT" => Self::SelectedText,
             "ROW" => Self::Row,
             "COLUMN" => Self::Column,
diff --git a/crates/tasks_ui/src/lib.rs b/crates/tasks_ui/src/lib.rs
index fd14f9aaef2a40..38b15403e27ed5 100644
--- a/crates/tasks_ui/src/lib.rs
+++ b/crates/tasks_ui/src/lib.rs
@@ -18,10 +18,14 @@ pub fn init(cx: &mut AppContext) {
             workspace
                 .register_action(spawn_task_or_modal)
                 .register_action(move |workspace, action: &modal::Rerun, cx| {
-                    if let Some((task_source_kind, mut last_scheduled_task)) =
-                        workspace.project().update(cx, |project, cx| {
-                            project
-                                .task_inventory()
+                    if let Some((task_source_kind, mut last_scheduled_task)) = workspace
+                        .project()
+                        .read(cx)
+                        .task_store()
+                        .read(cx)
+                        .task_inventory()
+                        .and_then(|inventory| {
+                            inventory
                                 .read(cx)
                                 .last_scheduled_task(action.task_id.as_ref())
                         })
@@ -86,23 +90,26 @@ fn spawn_task_or_modal(workspace: &mut Workspace, action: &Spawn, cx: &mut ViewC
 }
 
 fn toggle_modal(workspace: &mut Workspace, cx: &mut ViewContext<'_, Workspace>) -> AsyncTask<()> {
-    let project = workspace.project().clone();
+    let task_store = workspace.project().read(cx).task_store().clone();
     let workspace_handle = workspace.weak_handle();
-    let context_task = task_context(workspace, cx);
-    cx.spawn(|workspace, mut cx| async move {
-        let task_context = context_task.await;
-        workspace
-            .update(&mut cx, |workspace, cx| {
-                if workspace.project().update(cx, |project, cx| {
-                    project.is_local() || project.ssh_connection_string(cx).is_some()
-                }) {
+    let can_open_modal = workspace.project().update(cx, |project, cx| {
+        project.is_local() || project.ssh_connection_string(cx).is_some() || project.is_via_ssh()
+    });
+    if can_open_modal {
+        let context_task = task_context(workspace, cx);
+        cx.spawn(|workspace, mut cx| async move {
+            let task_context = context_task.await;
+            workspace
+                .update(&mut cx, |workspace, cx| {
                     workspace.toggle_modal(cx, |cx| {
-                        TasksModal::new(project, task_context, workspace_handle, cx)
+                        TasksModal::new(task_store.clone(), task_context, workspace_handle, cx)
                     })
-                }
-            })
-            .ok();
-    })
+                })
+                .ok();
+        })
+    } else {
+        AsyncTask::ready(())
+    }
 }
 
 fn spawn_task_with_name(
@@ -113,14 +120,31 @@ fn spawn_task_with_name(
         let context_task =
             workspace.update(&mut cx, |workspace, cx| task_context(workspace, cx))?;
         let task_context = context_task.await;
-        let tasks = workspace
-            .update(&mut cx, |workspace, cx| {
-                let (worktree, location) = active_item_selection_properties(workspace, cx);
-                workspace.project().update(cx, |project, cx| {
-                    project.task_templates(worktree, location, cx)
+        let tasks = workspace.update(&mut cx, |workspace, cx| {
+            let Some(task_inventory) = workspace
+                .project()
+                .read(cx)
+                .task_store()
+                .read(cx)
+                .task_inventory()
+                .cloned()
+            else {
+                return Vec::new();
+            };
+            let (worktree, location) = active_item_selection_properties(workspace, cx);
+            let (file, language) = location
+                .map(|location| {
+                    let buffer = location.buffer.read(cx);
+                    (
+                        buffer.file().cloned(),
+                        buffer.language_at(location.range.start),
+                    )
                 })
-            })?
-            .await?;
+                .unwrap_or_default();
+            task_inventory
+                .read(cx)
+                .list_tasks(file, language, worktree, cx)
+        })?;
 
         let did_spawn = workspace
             .update(&mut cx, |workspace, cx| {
@@ -185,7 +209,7 @@ mod tests {
     use editor::Editor;
     use gpui::{Entity, TestAppContext};
     use language::{Language, LanguageConfig};
-    use project::{BasicContextProvider, FakeFs, Project};
+    use project::{task_store::TaskStore, BasicContextProvider, FakeFs, Project};
     use serde_json::json;
     use task::{TaskContext, TaskVariables, VariableName};
     use ui::VisualContext;
@@ -223,6 +247,7 @@ mod tests {
         )
         .await;
         let project = Project::test(fs, ["/dir".as_ref()], cx).await;
+        let worktree_store = project.update(cx, |project, _| project.worktree_store().clone());
         let rust_language = Arc::new(
             Language::new(
                 LanguageConfig::default(),
@@ -234,7 +259,9 @@ mod tests {
             name: (_) @name) @item"#,
             )
             .unwrap()
-            .with_context_provider(Some(Arc::new(BasicContextProvider::new(project.clone())))),
+            .with_context_provider(Some(Arc::new(BasicContextProvider::new(
+                worktree_store.clone(),
+            )))),
         );
 
         let typescript_language = Arc::new(
@@ -252,7 +279,9 @@ mod tests {
                       ")" @context)) @item"#,
             )
             .unwrap()
-            .with_context_provider(Some(Arc::new(BasicContextProvider::new(project.clone())))),
+            .with_context_provider(Some(Arc::new(BasicContextProvider::new(
+                worktree_store.clone(),
+            )))),
         );
 
         let worktree_id = project.update(cx, |project, cx| {
@@ -373,6 +402,7 @@ mod tests {
             editor::init(cx);
             workspace::init_settings(cx);
             Project::init_settings(cx);
+            TaskStore::init(None);
             state
         })
     }
diff --git a/crates/tasks_ui/src/modal.rs b/crates/tasks_ui/src/modal.rs
index 662e3f11fd05c4..f11f58e010cdc9 100644
--- a/crates/tasks_ui/src/modal.rs
+++ b/crates/tasks_ui/src/modal.rs
@@ -8,7 +8,7 @@ use gpui::{
     View, ViewContext, VisualContext, WeakView,
 };
 use picker::{highlighted_match_with_paths::HighlightedText, Picker, PickerDelegate};
-use project::{Project, TaskSourceKind};
+use project::{task_store::TaskStore, TaskSourceKind};
 use task::{ResolvedTask, TaskContext, TaskId, TaskTemplate};
 use ui::{
     div, h_flex, v_flex, ActiveTheme, Button, ButtonCommon, ButtonSize, Clickable, Color,
@@ -63,7 +63,7 @@ impl_actions!(task, [Rerun, Spawn]);
 
 /// A modal used to spawn new tasks.
 pub(crate) struct TasksModalDelegate {
-    project: Model<Project>,
+    task_store: Model<TaskStore>,
     candidates: Option<Vec<(TaskSourceKind, ResolvedTask)>>,
     last_used_candidate_index: Option<usize>,
     divider_index: Option<usize>,
@@ -77,12 +77,12 @@ pub(crate) struct TasksModalDelegate {
 
 impl TasksModalDelegate {
     fn new(
-        project: Model<Project>,
+        task_store: Model<TaskStore>,
         task_context: TaskContext,
         workspace: WeakView<Workspace>,
     ) -> Self {
         Self {
-            project,
+            task_store,
             workspace,
             candidates: None,
             matches: Vec::new(),
@@ -124,11 +124,11 @@ impl TasksModalDelegate {
         // it doesn't make sense to requery the inventory for new candidates, as that's potentially costly and more often than not it should just return back
         // the original list without a removed entry.
         candidates.remove(ix);
-        self.project.update(cx, |project, cx| {
-            project.task_inventory().update(cx, |inventory, _| {
+        if let Some(inventory) = self.task_store.read(cx).task_inventory().cloned() {
+            inventory.update(cx, |inventory, _| {
                 inventory.delete_previously_used(&task.id);
             })
-        });
+        };
     }
 }
 
@@ -139,14 +139,14 @@ pub(crate) struct TasksModal {
 
 impl TasksModal {
     pub(crate) fn new(
-        project: Model<Project>,
+        task_store: Model<TaskStore>,
         task_context: TaskContext,
         workspace: WeakView<Workspace>,
         cx: &mut ViewContext<Self>,
     ) -> Self {
         let picker = cx.new_view(|cx| {
             Picker::uniform_list(
-                TasksModalDelegate::new(project, task_context, workspace),
+                TasksModalDelegate::new(task_store, task_context, workspace),
                 cx,
             )
         });
@@ -204,71 +204,46 @@ impl PickerDelegate for TasksModalDelegate {
         cx: &mut ViewContext<picker::Picker<Self>>,
     ) -> Task<()> {
         cx.spawn(move |picker, mut cx| async move {
-            let Some(candidates_task) = picker
+            let Some(candidates) = picker
                 .update(&mut cx, |picker, cx| {
                     match &mut picker.delegate.candidates {
-                        Some(candidates) => {
-                            Task::ready(Ok(string_match_candidates(candidates.iter())))
-                        }
+                        Some(candidates) => string_match_candidates(candidates.iter()),
                         None => {
                             let Ok((worktree, location)) =
                                 picker.delegate.workspace.update(cx, |workspace, cx| {
                                     active_item_selection_properties(workspace, cx)
                                 })
                             else {
-                                return Task::ready(Ok(Vec::new()));
+                                return Vec::new();
+                            };
+                            let Some(task_inventory) = picker
+                                .delegate
+                                .task_store
+                                .read(cx)
+                                .task_inventory()
+                                .cloned()
+                            else {
+                                return Vec::new();
                             };
 
-                            let resolved_task =
-                                picker.delegate.project.update(cx, |project, cx| {
-                                    let ssh_connection_string = project.ssh_connection_string(cx);
-                                    if project.is_via_collab() && ssh_connection_string.is_none() {
-                                        Task::ready((Vec::new(), Vec::new()))
-                                    } else {
-                                        let remote_templates = if project.is_local() {
-                                            None
-                                        } else {
-                                            project
-                                                .remote_id()
-                                                .filter(|_| ssh_connection_string.is_some())
-                                                .map(|project_id| {
-                                                    project.query_remote_task_templates(
-                                                        project_id,
-                                                        worktree,
-                                                        location.as_ref(),
-                                                        cx,
-                                                    )
-                                                })
-                                        };
-                                        project
-                                            .task_inventory()
-                                            .read(cx)
-                                            .used_and_current_resolved_tasks(
-                                                remote_templates,
-                                                worktree,
-                                                location,
-                                                &picker.delegate.task_context,
-                                                cx,
-                                            )
-                                    }
-                                });
-                            cx.spawn(|picker, mut cx| async move {
-                                let (used, current) = resolved_task.await;
-                                picker.update(&mut cx, |picker, _| {
-                                    picker.delegate.last_used_candidate_index = if used.is_empty() {
-                                        None
-                                    } else {
-                                        Some(used.len() - 1)
-                                    };
-
-                                    let mut new_candidates = used;
-                                    new_candidates.extend(current);
-                                    let match_candidates =
-                                        string_match_candidates(new_candidates.iter());
-                                    let _ = picker.delegate.candidates.insert(new_candidates);
-                                    match_candidates
-                                })
-                            })
+                            let (used, current) =
+                                task_inventory.read(cx).used_and_current_resolved_tasks(
+                                    worktree,
+                                    location,
+                                    &picker.delegate.task_context,
+                                    cx,
+                                );
+                            picker.delegate.last_used_candidate_index = if used.is_empty() {
+                                None
+                            } else {
+                                Some(used.len() - 1)
+                            };
+
+                            let mut new_candidates = used;
+                            new_candidates.extend(current);
+                            let match_candidates = string_match_candidates(new_candidates.iter());
+                            let _ = picker.delegate.candidates.insert(new_candidates);
+                            match_candidates
                         }
                     }
                 })
@@ -276,11 +251,6 @@ impl PickerDelegate for TasksModalDelegate {
             else {
                 return;
             };
-            let Some(candidates): Option<Vec<StringMatchCandidate>> =
-                candidates_task.await.log_err()
-            else {
-                return;
-            };
             let matches = fuzzy::match_strings(
                 &candidates,
                 &query,
@@ -492,9 +462,9 @@ impl PickerDelegate for TasksModalDelegate {
         let is_recent_selected = self.divider_index >= Some(self.selected_index);
         let current_modifiers = cx.modifiers();
         let left_button = if self
-            .project
+            .task_store
             .read(cx)
-            .task_inventory()
+            .task_inventory()?
             .read(cx)
             .last_scheduled_task(None)
             .is_some()
@@ -646,6 +616,20 @@ mod tests {
             "",
             "Initial query should be empty"
         );
+        assert_eq!(
+            task_names(&tasks_picker, cx),
+            Vec::<String>::new(),
+            "With no global tasks and no open item, no tasks should be listed"
+        );
+        drop(tasks_picker);
+
+        let _ = workspace
+            .update(cx, |workspace, cx| {
+                workspace.open_abs_path(PathBuf::from("/dir/a.ts"), true, cx)
+            })
+            .await
+            .unwrap();
+        let tasks_picker = open_spawn_tasks(&workspace, cx);
         assert_eq!(
             task_names(&tasks_picker, cx),
             vec!["another one", "example task"],
@@ -951,8 +935,9 @@ mod tests {
         let tasks_picker = open_spawn_tasks(&workspace, cx);
         assert_eq!(
             task_names(&tasks_picker, cx),
-            vec!["TypeScript task from file /dir/a1.ts", "TypeScript task from file /dir/a1.ts", "Another task from file /dir/a1.ts", "Task without variables"],
-            "After spawning the task and getting it into the history, it should be up in the sort as recently used"
+            vec!["TypeScript task from file /dir/a1.ts", "Another task from file /dir/a1.ts", "Task without variables"],
+            "After spawning the task and getting it into the history, it should be up in the sort as recently used.
+            Tasks with the same labels and context are deduplicated."
         );
         tasks_picker.update(cx, |_, cx| {
             cx.emit(DismissEvent);
@@ -1035,10 +1020,12 @@ mod tests {
                 .unwrap()
         });
         project.update(cx, |project, cx| {
-            project.task_inventory().update(cx, |inventory, _| {
-                let (kind, task) = scheduled_task;
-                inventory.task_scheduled(kind, task);
-            })
+            if let Some(task_inventory) = project.task_store().read(cx).task_inventory().cloned() {
+                task_inventory.update(cx, |inventory, _| {
+                    let (kind, task) = scheduled_task;
+                    inventory.task_scheduled(kind, task);
+                });
+            }
         });
         tasks_picker.update(cx, |_, cx| {
             cx.emit(DismissEvent);
diff --git a/crates/workspace/src/tasks.rs b/crates/workspace/src/tasks.rs
index 98726096cb748d..377875ee1b2a4a 100644
--- a/crates/workspace/src/tasks.rs
+++ b/crates/workspace/src/tasks.rs
@@ -36,9 +36,13 @@ pub fn schedule_resolved_task(
         if !omit_history {
             resolved_task.resolved = Some(spawn_in_terminal.clone());
             workspace.project().update(cx, |project, cx| {
-                project.task_inventory().update(cx, |inventory, _| {
-                    inventory.task_scheduled(task_source_kind, resolved_task);
-                })
+                if let Some(task_inventory) =
+                    project.task_store().read(cx).task_inventory().cloned()
+                {
+                    task_inventory.update(cx, |inventory, _| {
+                        inventory.task_scheduled(task_source_kind, resolved_task);
+                    })
+                }
             });
         }
         cx.emit(crate::Event::SpawnTask(Box::new(spawn_in_terminal)));
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index eb60ab9fa8b69a..f5bc3a1847c6d5 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -27,19 +27,17 @@ use anyhow::Context as _;
 use assets::Assets;
 use futures::{channel::mpsc, select_biased, StreamExt};
 use outline_panel::OutlinePanel;
-use project::TaskSourceKind;
 use project_panel::ProjectPanel;
 use quick_action_bar::QuickActionBar;
 use release_channel::{AppCommitSha, ReleaseChannel};
 use rope::Rope;
 use search::project_search::ProjectSearchBar;
 use settings::{
-    initial_local_settings_content, initial_tasks_content, watch_config_file, KeymapFile, Settings,
-    SettingsStore, DEFAULT_KEYMAP_PATH,
+    initial_local_settings_content, initial_tasks_content, KeymapFile, Settings, SettingsStore,
+    DEFAULT_KEYMAP_PATH,
 };
 use std::any::TypeId;
 use std::{borrow::Cow, ops::Deref, path::Path, sync::Arc};
-use task::static_source::{StaticSource, TrackedFile};
 use theme::ActiveTheme;
 use workspace::notifications::NotificationId;
 use workspace::CloseIntent;
@@ -229,27 +227,6 @@ pub fn initialize_workspace(
                 .unwrap_or(true)
         });
 
-        let project = workspace.project().clone();
-        if project.update(cx, |project, cx| {
-            project.is_local() || project.is_via_ssh() || project.ssh_connection_string(cx).is_some()
-        }) {
-            project.update(cx, |project, cx| {
-                let fs = app_state.fs.clone();
-                project.task_inventory().update(cx, |inventory, cx| {
-                    let tasks_file_rx =
-                        watch_config_file(cx.background_executor(), fs, paths::tasks_file().clone());
-                    inventory.add_source(
-                        TaskSourceKind::AbsPath {
-                            id_base: "global_tasks".into(),
-                            abs_path: paths::tasks_file().clone(),
-                        },
-                        |tx, cx| StaticSource::new(TrackedFile::new(tasks_file_rx, tx, cx)),
-                        cx,
-                    );
-                })
-            });
-        }
-
         let prompt_builder = prompt_builder.clone();
         cx.spawn(|workspace_handle, mut cx| async move {
             let assistant_panel =

From 711180981bc51ab8aaeaccaf84f5ed338be87bdb Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 9 Oct 2024 22:39:54 +0300
Subject: [PATCH 561/762] Tone down model summarization logs (#18943)

Release Notes:

- N/A
---
 crates/semantic_index/src/summary_index.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/semantic_index/src/summary_index.rs b/crates/semantic_index/src/summary_index.rs
index f4c6d4726c508b..1cbb6703973265 100644
--- a/crates/semantic_index/src/summary_index.rs
+++ b/crates/semantic_index/src/summary_index.rs
@@ -239,7 +239,7 @@ impl SummaryIndex {
                 persist
             )?;
 
-            log::info!("Summarizing updated entries took {:?}", start.elapsed());
+            log::debug!("Summarizing updated entries took {:?}", start.elapsed());
 
             Ok(())
         }

From d316577fd544dc71c44a4cd3ef552acf2cde5765 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 9 Oct 2024 16:29:07 -0400
Subject: [PATCH 562/762] collab: Add billing preferences for maximum LLM
 monthly spend (#18948)

This PR adds a new `billing_preferences` table.

Right now there is a single preference: the maximum monthly spend for
LLM usage.

Release Notes:

- N/A

---------

Co-authored-by: Richard <richard@zed.dev>
---
 .../20221109000000_test_schema.sql            |  9 ++
 ...20241009190639_add_billing_preferences.sql |  8 ++
 crates/collab/src/api/billing.rs              | 84 ++++++++++++++++++-
 crates/collab/src/db.rs                       |  3 +
 crates/collab/src/db/ids.rs                   |  1 +
 crates/collab/src/db/queries.rs               |  1 +
 .../src/db/queries/billing_preferences.rs     | 75 +++++++++++++++++
 crates/collab/src/db/tables.rs                |  1 +
 .../src/db/tables/billing_preference.rs       | 30 +++++++
 crates/collab/src/llm.rs                      |  6 ++
 10 files changed, 216 insertions(+), 2 deletions(-)
 create mode 100644 crates/collab/migrations/20241009190639_add_billing_preferences.sql
 create mode 100644 crates/collab/src/db/queries/billing_preferences.rs
 create mode 100644 crates/collab/src/db/tables/billing_preference.rs

diff --git a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
index 5764aceea5fc4a..7d8bd8eb1b7d7d 100644
--- a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
+++ b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
@@ -422,6 +422,15 @@ CREATE TABLE dev_server_projects (
     paths TEXT NOT NULL
 );
 
+CREATE TABLE IF NOT EXISTS billing_preferences (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    user_id INTEGER NOT NULL REFERENCES users(id),
+    max_monthly_llm_usage_spending_in_cents INTEGER NOT NULL
+);
+
+CREATE UNIQUE INDEX "uix_billing_preferences_on_user_id" ON billing_preferences (user_id);
+
 CREATE TABLE IF NOT EXISTS billing_customers (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
diff --git a/crates/collab/migrations/20241009190639_add_billing_preferences.sql b/crates/collab/migrations/20241009190639_add_billing_preferences.sql
new file mode 100644
index 00000000000000..9aa5a1a303668e
--- /dev/null
+++ b/crates/collab/migrations/20241009190639_add_billing_preferences.sql
@@ -0,0 +1,8 @@
+create table if not exists billing_preferences (
+    id serial primary key,
+    created_at timestamp without time zone not null default now(),
+    user_id integer not null references users(id) on delete cascade,
+    max_monthly_llm_usage_spending_in_cents integer not null
+);
+
+create unique index "uix_billing_preferences_on_user_id" on billing_preferences (user_id);
diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index d2e43714a811e7..dca5a772f45d81 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -26,15 +26,19 @@ use crate::db::billing_subscription::{self, StripeSubscriptionStatus};
 use crate::db::{
     billing_customer, BillingSubscriptionId, CreateBillingCustomerParams,
     CreateBillingSubscriptionParams, CreateProcessedStripeEventParams, UpdateBillingCustomerParams,
-    UpdateBillingSubscriptionParams,
+    UpdateBillingPreferencesParams, UpdateBillingSubscriptionParams,
 };
 use crate::llm::db::LlmDatabase;
-use crate::llm::FREE_TIER_MONTHLY_SPENDING_LIMIT;
+use crate::llm::{DEFAULT_MAX_MONTHLY_SPEND, FREE_TIER_MONTHLY_SPENDING_LIMIT};
 use crate::rpc::ResultExt as _;
 use crate::{AppState, Error, Result};
 
 pub fn router() -> Router {
     Router::new()
+        .route(
+            "/billing/preferences",
+            get(get_billing_preferences).put(update_billing_preferences),
+        )
         .route(
             "/billing/subscriptions",
             get(list_billing_subscriptions).post(create_billing_subscription),
@@ -45,6 +49,82 @@ pub fn router() -> Router {
         )
 }
 
+#[derive(Debug, Deserialize)]
+struct GetBillingPreferencesParams {
+    github_user_id: i32,
+}
+
+#[derive(Debug, Serialize)]
+struct BillingPreferencesResponse {
+    max_monthly_llm_usage_spending_in_cents: i32,
+}
+
+async fn get_billing_preferences(
+    Extension(app): Extension<Arc<AppState>>,
+    Query(params): Query<GetBillingPreferencesParams>,
+) -> Result<Json<BillingPreferencesResponse>> {
+    let user = app
+        .db
+        .get_user_by_github_user_id(params.github_user_id)
+        .await?
+        .ok_or_else(|| anyhow!("user not found"))?;
+
+    let preferences = app.db.get_billing_preferences(user.id).await?;
+
+    Ok(Json(BillingPreferencesResponse {
+        max_monthly_llm_usage_spending_in_cents: preferences
+            .map_or(DEFAULT_MAX_MONTHLY_SPEND.0 as i32, |preferences| {
+                preferences.max_monthly_llm_usage_spending_in_cents
+            }),
+    }))
+}
+
+#[derive(Debug, Deserialize)]
+struct UpdateBillingPreferencesBody {
+    github_user_id: i32,
+    max_monthly_llm_usage_spending_in_cents: i32,
+}
+
+async fn update_billing_preferences(
+    Extension(app): Extension<Arc<AppState>>,
+    extract::Json(body): extract::Json<UpdateBillingPreferencesBody>,
+) -> Result<Json<BillingPreferencesResponse>> {
+    let user = app
+        .db
+        .get_user_by_github_user_id(body.github_user_id)
+        .await?
+        .ok_or_else(|| anyhow!("user not found"))?;
+
+    let billing_preferences =
+        if let Some(_billing_preferences) = app.db.get_billing_preferences(user.id).await? {
+            app.db
+                .update_billing_preferences(
+                    user.id,
+                    &UpdateBillingPreferencesParams {
+                        max_monthly_llm_usage_spending_in_cents: ActiveValue::set(
+                            body.max_monthly_llm_usage_spending_in_cents,
+                        ),
+                    },
+                )
+                .await?
+        } else {
+            app.db
+                .create_billing_preferences(
+                    user.id,
+                    &crate::db::CreateBillingPreferencesParams {
+                        max_monthly_llm_usage_spending_in_cents: body
+                            .max_monthly_llm_usage_spending_in_cents,
+                    },
+                )
+                .await?
+        };
+
+    Ok(Json(BillingPreferencesResponse {
+        max_monthly_llm_usage_spending_in_cents: billing_preferences
+            .max_monthly_llm_usage_spending_in_cents,
+    }))
+}
+
 #[derive(Debug, Deserialize)]
 struct ListBillingSubscriptionsParams {
     github_user_id: i32,
diff --git a/crates/collab/src/db.rs b/crates/collab/src/db.rs
index f717566824e7b9..e9665484931434 100644
--- a/crates/collab/src/db.rs
+++ b/crates/collab/src/db.rs
@@ -42,6 +42,9 @@ pub use tests::TestDb;
 
 pub use ids::*;
 pub use queries::billing_customers::{CreateBillingCustomerParams, UpdateBillingCustomerParams};
+pub use queries::billing_preferences::{
+    CreateBillingPreferencesParams, UpdateBillingPreferencesParams,
+};
 pub use queries::billing_subscriptions::{
     CreateBillingSubscriptionParams, UpdateBillingSubscriptionParams,
 };
diff --git a/crates/collab/src/db/ids.rs b/crates/collab/src/db/ids.rs
index 9bf767329d0024..3a5bcff558db83 100644
--- a/crates/collab/src/db/ids.rs
+++ b/crates/collab/src/db/ids.rs
@@ -72,6 +72,7 @@ macro_rules! id_type {
 id_type!(AccessTokenId);
 id_type!(BillingCustomerId);
 id_type!(BillingSubscriptionId);
+id_type!(BillingPreferencesId);
 id_type!(BufferId);
 id_type!(ChannelBufferCollaboratorId);
 id_type!(ChannelChatParticipantId);
diff --git a/crates/collab/src/db/queries.rs b/crates/collab/src/db/queries.rs
index 459f66d89af48e..9c277790f9f084 100644
--- a/crates/collab/src/db/queries.rs
+++ b/crates/collab/src/db/queries.rs
@@ -2,6 +2,7 @@ use super::*;
 
 pub mod access_tokens;
 pub mod billing_customers;
+pub mod billing_preferences;
 pub mod billing_subscriptions;
 pub mod buffers;
 pub mod channels;
diff --git a/crates/collab/src/db/queries/billing_preferences.rs b/crates/collab/src/db/queries/billing_preferences.rs
new file mode 100644
index 00000000000000..fa35ffc068126a
--- /dev/null
+++ b/crates/collab/src/db/queries/billing_preferences.rs
@@ -0,0 +1,75 @@
+use super::*;
+
+#[derive(Debug)]
+pub struct CreateBillingPreferencesParams {
+    pub max_monthly_llm_usage_spending_in_cents: i32,
+}
+
+#[derive(Debug, Default)]
+pub struct UpdateBillingPreferencesParams {
+    pub max_monthly_llm_usage_spending_in_cents: ActiveValue<i32>,
+}
+
+impl Database {
+    /// Returns the billing preferences for the given user, if they exist.
+    pub async fn get_billing_preferences(
+        &self,
+        user_id: UserId,
+    ) -> Result<Option<billing_preference::Model>> {
+        self.transaction(|tx| async move {
+            Ok(billing_preference::Entity::find()
+                .filter(billing_preference::Column::UserId.eq(user_id))
+                .one(&*tx)
+                .await?)
+        })
+        .await
+    }
+
+    /// Creates new billing preferences for the given user.
+    pub async fn create_billing_preferences(
+        &self,
+        user_id: UserId,
+        params: &CreateBillingPreferencesParams,
+    ) -> Result<billing_preference::Model> {
+        self.transaction(|tx| async move {
+            let preferences = billing_preference::Entity::insert(billing_preference::ActiveModel {
+                user_id: ActiveValue::set(user_id),
+                max_monthly_llm_usage_spending_in_cents: ActiveValue::set(
+                    params.max_monthly_llm_usage_spending_in_cents,
+                ),
+                ..Default::default()
+            })
+            .exec_with_returning(&*tx)
+            .await?;
+
+            Ok(preferences)
+        })
+        .await
+    }
+
+    /// Updates the billing preferences for the given user.
+    pub async fn update_billing_preferences(
+        &self,
+        user_id: UserId,
+        params: &UpdateBillingPreferencesParams,
+    ) -> Result<billing_preference::Model> {
+        self.transaction(|tx| async move {
+            let preferences = billing_preference::Entity::update_many()
+                .set(billing_preference::ActiveModel {
+                    max_monthly_llm_usage_spending_in_cents: params
+                        .max_monthly_llm_usage_spending_in_cents
+                        .clone(),
+                    ..Default::default()
+                })
+                .filter(billing_preference::Column::UserId.eq(user_id))
+                .exec_with_returning(&*tx)
+                .await?;
+
+            Ok(preferences
+                .into_iter()
+                .next()
+                .ok_or_else(|| anyhow!("billing preferences not found"))?)
+        })
+        .await
+    }
+}
diff --git a/crates/collab/src/db/tables.rs b/crates/collab/src/db/tables.rs
index 07d070b5694bab..01d3835dc1c79a 100644
--- a/crates/collab/src/db/tables.rs
+++ b/crates/collab/src/db/tables.rs
@@ -1,5 +1,6 @@
 pub mod access_token;
 pub mod billing_customer;
+pub mod billing_preference;
 pub mod billing_subscription;
 pub mod buffer;
 pub mod buffer_operation;
diff --git a/crates/collab/src/db/tables/billing_preference.rs b/crates/collab/src/db/tables/billing_preference.rs
new file mode 100644
index 00000000000000..0ad92c25d6abd6
--- /dev/null
+++ b/crates/collab/src/db/tables/billing_preference.rs
@@ -0,0 +1,30 @@
+use crate::db::{BillingPreferencesId, UserId};
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "billing_preferences")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: BillingPreferencesId,
+    pub created_at: DateTime,
+    pub user_id: UserId,
+    pub max_monthly_llm_usage_spending_in_cents: i32,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::user::Entity",
+        from = "Column::UserId",
+        to = "super::user::Column::Id"
+    )]
+    User,
+}
+
+impl Related<super::user::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::User.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index c733beb596d912..efe28a81c73ba8 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -442,6 +442,12 @@ fn normalize_model_name(known_models: Vec<String>, name: String) -> String {
 /// before they have to pay.
 pub const FREE_TIER_MONTHLY_SPENDING_LIMIT: Cents = Cents::from_dollars(5);
 
+/// The default value to use for maximum spend per month if the user did not
+/// explicitly set a maximum spend.
+///
+/// Used to prevent surprise bills.
+pub const DEFAULT_MAX_MONTHLY_SPEND: Cents = Cents::from_dollars(10);
+
 /// The maximum lifetime spending an individual user can reach before being cut off.
 const LIFETIME_SPENDING_LIMIT: Cents = Cents::from_dollars(1_000);
 

From 99a6a3d5e3e6235be3f2f195bdc5e14e19f898c3 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 9 Oct 2024 17:19:11 -0400
Subject: [PATCH 563/762] Update cloudflare/wrangler-action digest to 9681c29
 (#18949)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
|
[cloudflare/wrangler-action](https://redirect.github.com/cloudflare/wrangler-action)
| action | digest | `168bc28` -> `9681c29` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4xMTQuMCIsInVwZGF0ZWRJblZlciI6IjM4LjExNC4wIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6W119-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 .github/workflows/deploy_cloudflare.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/deploy_cloudflare.yml b/.github/workflows/deploy_cloudflare.yml
index 5c09c29b0f44f2..1a4c91e23703d9 100644
--- a/.github/workflows/deploy_cloudflare.yml
+++ b/.github/workflows/deploy_cloudflare.yml
@@ -36,28 +36,28 @@ jobs:
           mdbook build ./docs --dest-dir=../target/deploy/docs/
 
       - name: Deploy Docs
-        uses: cloudflare/wrangler-action@168bc28b7078db16f6f1ecc26477fc2248592143 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: pages deploy target/deploy --project-name=docs
 
       - name: Deploy Install
-        uses: cloudflare/wrangler-action@168bc28b7078db16f6f1ecc26477fc2248592143 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: r2 object put -f script/install.sh zed-open-source-website-assets/install.sh
 
       - name: Deploy Docs Workers
-        uses: cloudflare/wrangler-action@168bc28b7078db16f6f1ecc26477fc2248592143 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           command: deploy .cloudflare/docs-proxy/src/worker.js
 
       - name: Deploy Install Workers
-        uses: cloudflare/wrangler-action@168bc28b7078db16f6f1ecc26477fc2248592143 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
         with:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}

From 3db789ed90f1cd7c39c5d9c5fc4b8fe414fa63e5 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 9 Oct 2024 17:39:34 -0400
Subject: [PATCH 564/762] collab: Include max monthly spend preference in LLM
 token (#18955)

This PR updates the LLM token claims to include the maximum monthly
spend.

Release Notes:

- N/A
---
 crates/collab/src/llm/token.rs | 19 ++++++++++++++++++-
 crates/collab/src/rpc.rs       |  4 ++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/crates/collab/src/llm/token.rs b/crates/collab/src/llm/token.rs
index 6098a1cd138069..17f6a8c22660b6 100644
--- a/crates/collab/src/llm/token.rs
+++ b/crates/collab/src/llm/token.rs
@@ -1,4 +1,8 @@
-use crate::{db::UserId, Config};
+use crate::llm::DEFAULT_MAX_MONTHLY_SPEND;
+use crate::{
+    db::{billing_preference, UserId},
+    Config,
+};
 use anyhow::{anyhow, Result};
 use chrono::Utc;
 use jsonwebtoken::{DecodingKey, EncodingKey, Header, Validation};
@@ -22,16 +26,24 @@ pub struct LlmTokenClaims {
     // this change has been deployed).
     #[serde(default)]
     pub has_llm_subscription: Option<bool>,
+    // This field is temporarily optional so it can be added
+    // in a backwards-compatible way. We can make it required
+    // once all of the LLM tokens have cycled (~1 hour after
+    // this change has been deployed).
+    #[serde(default)]
+    pub max_monthly_spend_in_cents: Option<u32>,
     pub plan: rpc::proto::Plan,
 }
 
 const LLM_TOKEN_LIFETIME: Duration = Duration::from_secs(60 * 60);
 
 impl LlmTokenClaims {
+    #[allow(clippy::too_many_arguments)]
     pub fn create(
         user_id: UserId,
         github_user_login: String,
         is_staff: bool,
+        billing_preferences: Option<billing_preference::Model>,
         has_llm_closed_beta_feature_flag: bool,
         has_llm_subscription: bool,
         plan: rpc::proto::Plan,
@@ -52,6 +64,11 @@ impl LlmTokenClaims {
             is_staff,
             has_llm_closed_beta_feature_flag,
             has_llm_subscription: Some(has_llm_subscription),
+            max_monthly_spend_in_cents: Some(
+                billing_preferences.map_or(DEFAULT_MAX_MONTHLY_SPEND.0, |preferences| {
+                    preferences.max_monthly_llm_usage_spending_in_cents as u32
+                }),
+            ),
             plan,
         };
 
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index e5e401e493e9ac..2b861dd403120d 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -4917,10 +4917,14 @@ async fn get_llm_api_token(
     if Utc::now().naive_utc() - account_created_at < MIN_ACCOUNT_AGE_FOR_LLM_USE {
         Err(anyhow!("account too young"))?
     }
+
+    let billing_preferences = db.get_billing_preferences(user.id).await?;
+
     let token = LlmTokenClaims::create(
         user.id,
         user.github_login.clone(),
         session.is_staff(),
+        billing_preferences,
         has_llm_closed_beta_feature_flag,
         session.has_llm_subscription(&db).await?,
         session.current_plan(&db).await?,

From 66ea96839ab814947d5a9390f777e123a322ab6c Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 9 Oct 2024 17:49:21 -0400
Subject: [PATCH 565/762] Update Rust crate clap to v4.5.20 (#18953)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [clap](https://redirect.github.com/clap-rs/clap) |
workspace.dependencies | patch | `4.5.19` -> `4.5.20` |

---

### Release Notes

<details>
<summary>clap-rs/clap (clap)</summary>

###
[`v4.5.20`](https://redirect.github.com/clap-rs/clap/blob/HEAD/CHANGELOG.md#4520---2024-10-08)

[Compare
Source](https://redirect.github.com/clap-rs/clap/compare/v4.5.19...v4.5.20)

##### Features

-   *(unstable)* Add `CommandExt`

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4xMTQuMCIsInVwZGF0ZWRJblZlciI6IjM4LjExNC4wIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6W119-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 65deb35f66c450..04cffcd04ac9c0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2282,9 +2282,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.19"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7be5744db7978a28d9df86a214130d106a89ce49644cbc4e3f0c22c3fba30615"
+checksum = "b97f376d85a664d5837dbae44bf546e6477a679ff6610010f17276f686d867e8"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -2292,9 +2292,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.19"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5fbc17d3ef8278f55b282b2a2e75ae6f6c7d4bb70ed3d0382375104bfafdb4b"
+checksum = "19bc80abd44e4bed93ca373a0704ccbd1b710dc5749406201bb018272808dc54"
 dependencies = [
  "anstream",
  "anstyle",
@@ -6474,7 +6474,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
  "cfg-if",
- "windows-targets 0.52.6",
+ "windows-targets 0.48.5",
 ]
 
 [[package]]
@@ -13542,7 +13542,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]

From b2e15728207b2c46c65ae4bdd41b31947f33c940 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 9 Oct 2024 18:24:10 -0400
Subject: [PATCH 566/762] Update actions/checkout digest to eef6144 (#18940)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [actions/checkout](https://redirect.github.com/actions/checkout) |
action | digest | `692973e` -> `eef6144` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4xMTQuMCIsInVwZGF0ZWRJblZlciI6IjM4LjExNC4wIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6W119-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 .github/workflows/bump_collab_staging.yml          |  2 +-
 .github/workflows/bump_patch_version.yml           |  2 +-
 .github/workflows/ci.yml                           | 14 +++++++-------
 .github/workflows/danger.yml                       |  2 +-
 .github/workflows/deploy_cloudflare.yml            |  2 +-
 .github/workflows/deploy_collab.yml                |  8 ++++----
 .github/workflows/docs.yml                         |  2 +-
 .github/workflows/publish_extension_cli.yml        |  2 +-
 .github/workflows/randomized_tests.yml             |  2 +-
 .github/workflows/release_nightly.yml              | 12 ++++++------
 .../workflows/update_all_top_ranking_issues.yml    |  2 +-
 .../workflows/update_weekly_top_ranking_issues.yml |  2 +-
 12 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/.github/workflows/bump_collab_staging.yml b/.github/workflows/bump_collab_staging.yml
index 224325d53ffc2e..d0da0a94053b33 100644
--- a/.github/workflows/bump_collab_staging.yml
+++ b/.github/workflows/bump_collab_staging.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           fetch-depth: 0
 
diff --git a/.github/workflows/bump_patch_version.yml b/.github/workflows/bump_patch_version.yml
index b875ff7b221028..dbd0b2b3e1f6e1 100644
--- a/.github/workflows/bump_patch_version.yml
+++ b/.github/workflows/bump_patch_version.yml
@@ -18,7 +18,7 @@ jobs:
       - buildjet-16vcpu-ubuntu-2204
     steps:
       - name: Checkout code
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           ref: ${{ github.event.inputs.branch }}
           ssh-key: ${{ secrets.ZED_BOT_DEPLOY_KEY }}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6718b91ade4007..379bab88bc61d8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -34,7 +34,7 @@ jobs:
       - test
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
           fetch-depth: 0
@@ -85,7 +85,7 @@ jobs:
       - test
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
@@ -111,7 +111,7 @@ jobs:
         run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
 
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
@@ -140,7 +140,7 @@ jobs:
     runs-on: hosted-windows-1
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
@@ -181,7 +181,7 @@ jobs:
           node-version: "18"
 
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           # We need to fetch more than one commit so that `script/draft-release-notes`
           # is able to diff between the current and previous tag.
@@ -266,7 +266,7 @@ jobs:
       ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
@@ -313,7 +313,7 @@ jobs:
       ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
diff --git a/.github/workflows/danger.yml b/.github/workflows/danger.yml
index 0278bbce02154b..2828cb42eab51f 100644
--- a/.github/workflows/danger.yml
+++ b/.github/workflows/danger.yml
@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+      - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
 
       - uses: pnpm/action-setup@fe02b34f77f8bc703788d5817da081398fad5dd2 # v4.0.0
         with:
diff --git a/.github/workflows/deploy_cloudflare.yml b/.github/workflows/deploy_cloudflare.yml
index 1a4c91e23703d9..029a2092d98349 100644
--- a/.github/workflows/deploy_cloudflare.yml
+++ b/.github/workflows/deploy_cloudflare.yml
@@ -12,7 +12,7 @@ jobs:
 
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
diff --git a/.github/workflows/deploy_collab.yml b/.github/workflows/deploy_collab.yml
index 1e6e6cf2803e20..0eaf1697df2f62 100644
--- a/.github/workflows/deploy_collab.yml
+++ b/.github/workflows/deploy_collab.yml
@@ -17,7 +17,7 @@ jobs:
       - test
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
           fetch-depth: 0
@@ -36,7 +36,7 @@ jobs:
     needs: style
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
           fetch-depth: 0
@@ -71,7 +71,7 @@ jobs:
         run: doctl registry login
 
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
@@ -97,7 +97,7 @@ jobs:
 
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 7d7b564a548831..0b291ca3742fce 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+      - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
 
       - uses: pnpm/action-setup@fe02b34f77f8bc703788d5817da081398fad5dd2 # v4.0.0
         with:
diff --git a/.github/workflows/publish_extension_cli.yml b/.github/workflows/publish_extension_cli.yml
index 7c47ec5dedfdd1..e222a1cdaa738b 100644
--- a/.github/workflows/publish_extension_cli.yml
+++ b/.github/workflows/publish_extension_cli.yml
@@ -16,7 +16,7 @@ jobs:
       - ubuntu-latest
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
diff --git a/.github/workflows/randomized_tests.yml b/.github/workflows/randomized_tests.yml
index 947b5059bd7120..af604e6abbfd7c 100644
--- a/.github/workflows/randomized_tests.yml
+++ b/.github/workflows/randomized_tests.yml
@@ -27,7 +27,7 @@ jobs:
           node-version: "18"
 
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml
index 349d14f990fcbf..9d5581ebdcf220 100644
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -23,7 +23,7 @@ jobs:
       - test
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
           fetch-depth: 0
@@ -44,7 +44,7 @@ jobs:
     needs: style
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
@@ -75,7 +75,7 @@ jobs:
           node-version: "18"
 
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
@@ -109,7 +109,7 @@ jobs:
       ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
@@ -149,7 +149,7 @@ jobs:
       ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
 
@@ -182,7 +182,7 @@ jobs:
       - bundle-linux-arm
     steps:
       - name: Checkout repo
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           fetch-depth: 0
 
diff --git a/.github/workflows/update_all_top_ranking_issues.yml b/.github/workflows/update_all_top_ranking_issues.yml
index 6a5ccbcc05d6d3..8ce5a3ad1c3a3a 100644
--- a/.github/workflows/update_all_top_ranking_issues.yml
+++ b/.github/workflows/update_all_top_ranking_issues.yml
@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     if: github.repository_owner == 'zed-industries'
     steps:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+      - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
       - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3 # v5
         with:
           python-version: "3.11"
diff --git a/.github/workflows/update_weekly_top_ranking_issues.yml b/.github/workflows/update_weekly_top_ranking_issues.yml
index 40aa3a7ff812c7..129c58a6a9ad9d 100644
--- a/.github/workflows/update_weekly_top_ranking_issues.yml
+++ b/.github/workflows/update_weekly_top_ranking_issues.yml
@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     if: github.repository_owner == 'zed-industries'
     steps:
-      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+      - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
       - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3 # v5
         with:
           python-version: "3.11"

From 69711660ab7a007ed60675f42da4cd447828e706 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 9 Oct 2024 18:42:22 -0400
Subject: [PATCH 567/762] collab: Make LLM billing fields required in
 `LlmTokenClaims` (#18959)

This PR makes the `has_llm_subscription` and
`max_monthly_spend_in_cents` fields in the `LlmTokenClaims` required.

This change will be safe to deploy in ~45 minutes.

Release Notes:

- N/A
---
 crates/collab/src/llm.rs       |  2 +-
 crates/collab/src/llm/token.rs | 21 +++++----------------
 2 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index efe28a81c73ba8..c389a4de62fed0 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -470,7 +470,7 @@ async fn check_usage_limit(
 
     if state.config.is_llm_billing_enabled() {
         if usage.spending_this_month >= FREE_TIER_MONTHLY_SPENDING_LIMIT {
-            if !claims.has_llm_subscription.unwrap_or(false) {
+            if !claims.has_llm_subscription {
                 return Err(Error::http(
                     StatusCode::PAYMENT_REQUIRED,
                     "Maximum spending limit reached for this month.".to_string(),
diff --git a/crates/collab/src/llm/token.rs b/crates/collab/src/llm/token.rs
index 17f6a8c22660b6..28f52b5164832d 100644
--- a/crates/collab/src/llm/token.rs
+++ b/crates/collab/src/llm/token.rs
@@ -20,18 +20,8 @@ pub struct LlmTokenClaims {
     pub github_user_login: String,
     pub is_staff: bool,
     pub has_llm_closed_beta_feature_flag: bool,
-    // This field is temporarily optional so it can be added
-    // in a backwards-compatible way. We can make it required
-    // once all of the LLM tokens have cycled (~1 hour after
-    // this change has been deployed).
-    #[serde(default)]
-    pub has_llm_subscription: Option<bool>,
-    // This field is temporarily optional so it can be added
-    // in a backwards-compatible way. We can make it required
-    // once all of the LLM tokens have cycled (~1 hour after
-    // this change has been deployed).
-    #[serde(default)]
-    pub max_monthly_spend_in_cents: Option<u32>,
+    pub has_llm_subscription: bool,
+    pub max_monthly_spend_in_cents: u32,
     pub plan: rpc::proto::Plan,
 }
 
@@ -63,12 +53,11 @@ impl LlmTokenClaims {
             github_user_login,
             is_staff,
             has_llm_closed_beta_feature_flag,
-            has_llm_subscription: Some(has_llm_subscription),
-            max_monthly_spend_in_cents: Some(
-                billing_preferences.map_or(DEFAULT_MAX_MONTHLY_SPEND.0, |preferences| {
+            has_llm_subscription,
+            max_monthly_spend_in_cents: billing_preferences
+                .map_or(DEFAULT_MAX_MONTHLY_SPEND.0, |preferences| {
                     preferences.max_monthly_llm_usage_spending_in_cents as u32
                 }),
-            ),
             plan,
         };
 

From cae548a50dc190b7a1d7a16ee48d636842a21c35 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 9 Oct 2024 19:15:38 -0400
Subject: [PATCH 568/762] collab: Fix issues with syncing LLM usage to Stripe
 (#18970)

This PR fixes some issues with our previous approach to synching LLM
usage over to Stripe.

We now have a separate LLM access price in Stripe that is a marker price
to allow us to create the initial subscription with that as its
subscription item

We then dynamically set the LLM usage price during the reconciliation
sync based on the usage for the current month.

Release Notes:

- N/A

---------

Co-authored-by: Antonio <antonio@zed.dev>
Co-authored-by: Richard <richard@zed.dev>
---
 crates/collab/src/api/billing.rs       | 51 ++++++++++++++++----------
 crates/collab/src/lib.rs               |  2 +
 crates/collab/src/main.rs              |  3 +-
 crates/collab/src/tests/test_server.rs |  1 +
 4 files changed, 36 insertions(+), 21 deletions(-)

diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index dca5a772f45d81..838dea19819194 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -197,10 +197,10 @@ async fn create_billing_subscription(
         .await?
         .ok_or_else(|| anyhow!("user not found"))?;
 
-    let Some((stripe_client, stripe_price_id)) = app
+    let Some((stripe_client, stripe_access_price_id)) = app
         .stripe_client
         .clone()
-        .zip(app.config.stripe_llm_usage_price_id.clone())
+        .zip(app.config.stripe_llm_access_price_id.clone())
     else {
         log::error!("failed to retrieve Stripe client or price ID");
         Err(Error::http(
@@ -232,8 +232,8 @@ async fn create_billing_subscription(
         params.customer = Some(customer_id);
         params.client_reference_id = Some(user.github_login.as_str());
         params.line_items = Some(vec![CreateCheckoutSessionLineItems {
-            price: Some(stripe_price_id.to_string()),
-            quantity: Some(0),
+            price: Some(stripe_access_price_id.to_string()),
+            quantity: Some(1),
             ..Default::default()
         }]);
         let success_url = format!("{}/account", app.config.zed_dot_dev_url());
@@ -787,22 +787,33 @@ async fn update_stripe_subscription(
         monthly_spending.saturating_sub(FREE_TIER_MONTHLY_SPENDING_LIMIT);
 
     let new_quantity = (monthly_spending_over_free_tier.0 as f32 / 100.).ceil();
-    Subscription::update(
-        stripe_client,
-        &subscription_id,
-        stripe::UpdateSubscription {
-            items: Some(vec![stripe::UpdateSubscriptionItems {
-                // TODO: Do we need to send up the `id` if a subscription item
-                // with this price already exists, or will Stripe take care of
-                // it?
-                id: None,
-                price: Some(stripe_llm_usage_price_id.to_string()),
-                quantity: Some(new_quantity as u64),
-                ..Default::default()
-            }]),
+    let current_subscription = Subscription::retrieve(stripe_client, &subscription_id, &[]).await?;
+
+    let mut update_params = stripe::UpdateSubscription {
+        proration_behavior: Some(
+            stripe::generated::billing::subscription::SubscriptionProrationBehavior::None,
+        ),
+        ..Default::default()
+    };
+
+    if let Some(existing_item) = current_subscription.items.data.iter().find(|item| {
+        item.price.as_ref().map_or(false, |price| {
+            price.id == stripe_llm_usage_price_id.as_ref()
+        })
+    }) {
+        update_params.items = Some(vec![stripe::UpdateSubscriptionItems {
+            id: Some(existing_item.id.to_string()),
+            quantity: Some(new_quantity as u64),
             ..Default::default()
-        },
-    )
-    .await?;
+        }]);
+    } else {
+        update_params.items = Some(vec![stripe::UpdateSubscriptionItems {
+            price: Some(stripe_llm_usage_price_id.to_string()),
+            quantity: Some(new_quantity as u64),
+            ..Default::default()
+        }]);
+    }
+
+    Subscription::update(stripe_client, &subscription_id, update_params).await?;
     Ok(())
 }
diff --git a/crates/collab/src/lib.rs b/crates/collab/src/lib.rs
index a6141abb888730..3896926f4372fe 100644
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -176,6 +176,7 @@ pub struct Config {
     pub slack_panics_webhook: Option<String>,
     pub auto_join_channel_id: Option<ChannelId>,
     pub stripe_api_key: Option<String>,
+    pub stripe_llm_access_price_id: Option<Arc<str>>,
     pub stripe_llm_usage_price_id: Option<Arc<str>>,
     pub supermaven_admin_api_key: Option<Arc<str>>,
     pub user_backfiller_github_access_token: Option<Arc<str>>,
@@ -237,6 +238,7 @@ impl Config {
             migrations_path: None,
             seed_path: None,
             stripe_api_key: None,
+            stripe_llm_access_price_id: None,
             stripe_llm_usage_price_id: None,
             supermaven_admin_api_key: None,
             user_backfiller_github_access_token: None,
diff --git a/crates/collab/src/main.rs b/crates/collab/src/main.rs
index bbbd4e562cb901..bd227f17c70404 100644
--- a/crates/collab/src/main.rs
+++ b/crates/collab/src/main.rs
@@ -155,7 +155,8 @@ async fn main() -> Result<()> {
                     .await
                     .trace_err();
 
-                    if let Some(llm_db) = llm_db {
+                    if let Some(mut llm_db) = llm_db {
+                        llm_db.initialize().await?;
                         sync_llm_usage_with_stripe_periodically(state.clone(), llm_db);
                     }
 
diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs
index 55bc279c8eaf6e..683a53a2f56618 100644
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -677,6 +677,7 @@ impl TestServer {
                 migrations_path: None,
                 seed_path: None,
                 stripe_api_key: None,
+                stripe_llm_access_price_id: None,
                 stripe_llm_usage_price_id: None,
                 supermaven_admin_api_key: None,
                 user_backfiller_github_access_token: None,

From 53cc82b132e826b3eb0a6337dc09922ceda7e735 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Wed, 9 Oct 2024 16:55:25 -0700
Subject: [PATCH 569/762] Fix some issues with branch buffers (#18945)

* `Open Excerpts` command always opens the locations in the base buffer
* LSP features like document-highlights, go-to-def, and inlay hints work
correctly in branch buffers
* Other LSP features like completions, code actions, and rename are
disabled in branch buffers

Release Notes:

- N/A
---
 crates/assistant/src/assistant_panel.rs       |   2 +-
 crates/assistant/src/prompt_library.rs        |   4 +-
 .../src/chat_panel/message_editor.rs          |   2 +-
 crates/editor/src/editor.rs                   | 348 +++++++++++++-----
 crates/editor/src/hover_links.rs              | 102 +++--
 crates/editor/src/hover_popover.rs            |  47 +--
 crates/editor/src/inlay_hint_cache.rs         |  73 ++--
 crates/editor/src/proposed_changes_editor.rs  | 119 +++++-
 crates/language/src/buffer_tests.rs           |  82 +++--
 crates/project/src/project.rs                 |   4 +-
 crates/project/src/project_tests.rs           |   2 +-
 .../remote_server/src/remote_editing_tests.rs |   2 +-
 crates/text/src/text.rs                       |  36 ++
 13 files changed, 555 insertions(+), 268 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index c3b4fcc4dc9218..e4d02e5bb733a7 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -1560,7 +1560,7 @@ impl ContextEditor {
             editor.set_show_runnables(false, cx);
             editor.set_show_wrap_guides(false, cx);
             editor.set_show_indent_guides(false, cx);
-            editor.set_completion_provider(Box::new(completion_provider));
+            editor.set_completion_provider(Some(Box::new(completion_provider)));
             editor.set_collaboration_hub(Box::new(project.clone()));
             editor
         });
diff --git a/crates/assistant/src/prompt_library.rs b/crates/assistant/src/prompt_library.rs
index 6c43579d6ebd02..298bb322265c5f 100644
--- a/crates/assistant/src/prompt_library.rs
+++ b/crates/assistant/src/prompt_library.rs
@@ -521,9 +521,9 @@ impl PromptLibrary {
                             editor.set_show_indent_guides(false, cx);
                             editor.set_use_modal_editing(false);
                             editor.set_current_line_highlight(Some(CurrentLineHighlight::None));
-                            editor.set_completion_provider(Box::new(
+                            editor.set_completion_provider(Some(Box::new(
                                 SlashCommandCompletionProvider::new(None, None),
-                            ));
+                            )));
                             if focus {
                                 editor.focus(cx);
                             }
diff --git a/crates/collab_ui/src/chat_panel/message_editor.rs b/crates/collab_ui/src/chat_panel/message_editor.rs
index 38aaf2faa3b329..7023a8d07ed76c 100644
--- a/crates/collab_ui/src/chat_panel/message_editor.rs
+++ b/crates/collab_ui/src/chat_panel/message_editor.rs
@@ -111,7 +111,7 @@ impl MessageEditor {
             editor.set_show_gutter(false, cx);
             editor.set_show_wrap_guides(false, cx);
             editor.set_show_indent_guides(false, cx);
-            editor.set_completion_provider(Box::new(MessageEditorCompletionProvider(this)));
+            editor.set_completion_provider(Some(Box::new(MessageEditorCompletionProvider(this))));
             editor.set_auto_replace_emoji_shortcode(
                 MessageEditorSettings::get_global(cx)
                     .auto_replace_emoji_shortcode
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 15b833c1dcbba5..5b5401af178fb7 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -121,10 +121,11 @@ use multi_buffer::{
 };
 use ordered_float::OrderedFloat;
 use parking_lot::{Mutex, RwLock};
-use project::project_settings::{GitGutterSetting, ProjectSettings};
 use project::{
-    lsp_store::FormatTrigger, CodeAction, Completion, CompletionIntent, Item, Location, Project,
-    ProjectPath, ProjectTransaction, TaskSourceKind,
+    lsp_store::FormatTrigger,
+    project_settings::{GitGutterSetting, ProjectSettings},
+    CodeAction, Completion, CompletionIntent, DocumentHighlight, InlayHint, Item, Location,
+    LocationLink, Project, ProjectPath, ProjectTransaction, TaskSourceKind,
 };
 use rand::prelude::*;
 use rpc::{proto::*, ErrorExt};
@@ -546,6 +547,7 @@ pub struct Editor {
     active_diagnostics: Option<ActiveDiagnosticGroup>,
     soft_wrap_mode_override: Option<language_settings::SoftWrap>,
     project: Option<Model<Project>>,
+    semantics_provider: Option<Rc<dyn SemanticsProvider>>,
     completion_provider: Option<Box<dyn CompletionProvider>>,
     collaboration_hub: Option<Box<dyn CollaborationHub>>,
     blink_manager: Model<BlinkManager>,
@@ -884,12 +886,12 @@ enum ContextMenu {
 impl ContextMenu {
     fn select_first(
         &mut self,
-        project: Option<&Model<Project>>,
+        provider: Option<&dyn CompletionProvider>,
         cx: &mut ViewContext<Editor>,
     ) -> bool {
         if self.visible() {
             match self {
-                ContextMenu::Completions(menu) => menu.select_first(project, cx),
+                ContextMenu::Completions(menu) => menu.select_first(provider, cx),
                 ContextMenu::CodeActions(menu) => menu.select_first(cx),
             }
             true
@@ -900,12 +902,12 @@ impl ContextMenu {
 
     fn select_prev(
         &mut self,
-        project: Option<&Model<Project>>,
+        provider: Option<&dyn CompletionProvider>,
         cx: &mut ViewContext<Editor>,
     ) -> bool {
         if self.visible() {
             match self {
-                ContextMenu::Completions(menu) => menu.select_prev(project, cx),
+                ContextMenu::Completions(menu) => menu.select_prev(provider, cx),
                 ContextMenu::CodeActions(menu) => menu.select_prev(cx),
             }
             true
@@ -916,12 +918,12 @@ impl ContextMenu {
 
     fn select_next(
         &mut self,
-        project: Option<&Model<Project>>,
+        provider: Option<&dyn CompletionProvider>,
         cx: &mut ViewContext<Editor>,
     ) -> bool {
         if self.visible() {
             match self {
-                ContextMenu::Completions(menu) => menu.select_next(project, cx),
+                ContextMenu::Completions(menu) => menu.select_next(provider, cx),
                 ContextMenu::CodeActions(menu) => menu.select_next(cx),
             }
             true
@@ -932,12 +934,12 @@ impl ContextMenu {
 
     fn select_last(
         &mut self,
-        project: Option<&Model<Project>>,
+        provider: Option<&dyn CompletionProvider>,
         cx: &mut ViewContext<Editor>,
     ) -> bool {
         if self.visible() {
             match self {
-                ContextMenu::Completions(menu) => menu.select_last(project, cx),
+                ContextMenu::Completions(menu) => menu.select_last(provider, cx),
                 ContextMenu::CodeActions(menu) => menu.select_last(cx),
             }
             true
@@ -991,39 +993,55 @@ struct CompletionsMenu {
 }
 
 impl CompletionsMenu {
-    fn select_first(&mut self, project: Option<&Model<Project>>, cx: &mut ViewContext<Editor>) {
+    fn select_first(
+        &mut self,
+        provider: Option<&dyn CompletionProvider>,
+        cx: &mut ViewContext<Editor>,
+    ) {
         self.selected_item = 0;
         self.scroll_handle.scroll_to_item(self.selected_item);
-        self.attempt_resolve_selected_completion_documentation(project, cx);
+        self.attempt_resolve_selected_completion_documentation(provider, cx);
         cx.notify();
     }
 
-    fn select_prev(&mut self, project: Option<&Model<Project>>, cx: &mut ViewContext<Editor>) {
+    fn select_prev(
+        &mut self,
+        provider: Option<&dyn CompletionProvider>,
+        cx: &mut ViewContext<Editor>,
+    ) {
         if self.selected_item > 0 {
             self.selected_item -= 1;
         } else {
             self.selected_item = self.matches.len() - 1;
         }
         self.scroll_handle.scroll_to_item(self.selected_item);
-        self.attempt_resolve_selected_completion_documentation(project, cx);
+        self.attempt_resolve_selected_completion_documentation(provider, cx);
         cx.notify();
     }
 
-    fn select_next(&mut self, project: Option<&Model<Project>>, cx: &mut ViewContext<Editor>) {
+    fn select_next(
+        &mut self,
+        provider: Option<&dyn CompletionProvider>,
+        cx: &mut ViewContext<Editor>,
+    ) {
         if self.selected_item + 1 < self.matches.len() {
             self.selected_item += 1;
         } else {
             self.selected_item = 0;
         }
         self.scroll_handle.scroll_to_item(self.selected_item);
-        self.attempt_resolve_selected_completion_documentation(project, cx);
+        self.attempt_resolve_selected_completion_documentation(provider, cx);
         cx.notify();
     }
 
-    fn select_last(&mut self, project: Option<&Model<Project>>, cx: &mut ViewContext<Editor>) {
+    fn select_last(
+        &mut self,
+        provider: Option<&dyn CompletionProvider>,
+        cx: &mut ViewContext<Editor>,
+    ) {
         self.selected_item = self.matches.len() - 1;
         self.scroll_handle.scroll_to_item(self.selected_item);
-        self.attempt_resolve_selected_completion_documentation(project, cx);
+        self.attempt_resolve_selected_completion_documentation(provider, cx);
         cx.notify();
     }
 
@@ -1059,7 +1077,7 @@ impl CompletionsMenu {
 
     fn attempt_resolve_selected_completion_documentation(
         &mut self,
-        project: Option<&Model<Project>>,
+        provider: Option<&dyn CompletionProvider>,
         cx: &mut ViewContext<Editor>,
     ) {
         let settings = EditorSettings::get_global(cx);
@@ -1068,18 +1086,16 @@ impl CompletionsMenu {
         }
 
         let completion_index = self.matches[self.selected_item].candidate_id;
-        let Some(project) = project else {
+        let Some(provider) = provider else {
             return;
         };
 
-        let resolve_task = project.update(cx, |project, cx| {
-            project.resolve_completions(
-                self.buffer.clone(),
-                vec![completion_index],
-                self.completions.clone(),
-                cx,
-            )
-        });
+        let resolve_task = provider.resolve_completions(
+            self.buffer.clone(),
+            vec![completion_index],
+            self.completions.clone(),
+            cx,
+        );
 
         let delay_ms =
             EditorSettings::get_global(cx).completion_documentation_secondary_query_debounce;
@@ -1671,7 +1687,7 @@ pub(crate) struct NavigationData {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum GotoDefinitionKind {
+pub enum GotoDefinitionKind {
     Symbol,
     Declaration,
     Type,
@@ -1937,6 +1953,7 @@ impl Editor {
             active_diagnostics: None,
             soft_wrap_mode_override,
             completion_provider: project.clone().map(|project| Box::new(project) as _),
+            semantics_provider: project.clone().map(|project| Rc::new(project) as _),
             collaboration_hub: project.clone().map(|project| Box::new(project) as _),
             project,
             blink_manager: blink_manager.clone(),
@@ -2305,8 +2322,16 @@ impl Editor {
         self.custom_context_menu = Some(Box::new(f))
     }
 
-    pub fn set_completion_provider(&mut self, provider: Box<dyn CompletionProvider>) {
-        self.completion_provider = Some(provider);
+    pub fn set_completion_provider(&mut self, provider: Option<Box<dyn CompletionProvider>>) {
+        self.completion_provider = provider;
+    }
+
+    pub fn semantics_provider(&self) -> Option<Rc<dyn SemanticsProvider>> {
+        self.semantics_provider.clone()
+    }
+
+    pub fn set_semantics_provider(&mut self, provider: Option<Rc<dyn SemanticsProvider>>) {
+        self.semantics_provider = provider;
     }
 
     pub fn set_inline_completion_provider<T>(
@@ -4041,7 +4066,7 @@ impl Editor {
     }
 
     fn refresh_inlay_hints(&mut self, reason: InlayHintRefreshReason, cx: &mut ViewContext<Self>) {
-        if self.project.is_none() || self.mode != EditorMode::Full {
+        if self.semantics_provider.is_none() || self.mode != EditorMode::Full {
             return;
         }
 
@@ -4942,6 +4967,11 @@ impl Editor {
         Ok(())
     }
 
+    pub fn clear_code_action_providers(&mut self) {
+        self.code_action_providers.clear();
+        self.available_code_actions.take();
+    }
+
     pub fn push_code_action_provider(
         &mut self,
         provider: Arc<dyn CodeActionProvider>,
@@ -5029,7 +5059,7 @@ impl Editor {
             return None;
         }
 
-        let project = self.project.clone()?;
+        let provider = self.semantics_provider.clone()?;
         let buffer = self.buffer.read(cx);
         let newest_selection = self.selections.newest_anchor().clone();
         let cursor_position = newest_selection.head();
@@ -5045,11 +5075,12 @@ impl Editor {
                 .timer(DOCUMENT_HIGHLIGHTS_DEBOUNCE_TIMEOUT)
                 .await;
 
-            let highlights = if let Some(highlights) = project
-                .update(&mut cx, |project, cx| {
-                    project.document_highlights(&cursor_buffer, cursor_buffer_position, cx)
+            let highlights = if let Some(highlights) = cx
+                .update(|cx| {
+                    provider.document_highlights(&cursor_buffer, cursor_buffer_position, cx)
                 })
-                .log_err()
+                .ok()
+                .flatten()
             {
                 highlights.await.log_err()
             } else {
@@ -7471,7 +7502,7 @@ impl Editor {
             .context_menu
             .write()
             .as_mut()
-            .map(|menu| menu.select_first(self.project.as_ref(), cx))
+            .map(|menu| menu.select_first(self.completion_provider.as_deref(), cx))
             .unwrap_or(false)
         {
             return;
@@ -7580,7 +7611,7 @@ impl Editor {
             .context_menu
             .write()
             .as_mut()
-            .map(|menu| menu.select_last(self.project.as_ref(), cx))
+            .map(|menu| menu.select_last(self.completion_provider.as_deref(), cx))
             .unwrap_or(false)
         {
             return;
@@ -7632,25 +7663,25 @@ impl Editor {
 
     pub fn context_menu_first(&mut self, _: &ContextMenuFirst, cx: &mut ViewContext<Self>) {
         if let Some(context_menu) = self.context_menu.write().as_mut() {
-            context_menu.select_first(self.project.as_ref(), cx);
+            context_menu.select_first(self.completion_provider.as_deref(), cx);
         }
     }
 
     pub fn context_menu_prev(&mut self, _: &ContextMenuPrev, cx: &mut ViewContext<Self>) {
         if let Some(context_menu) = self.context_menu.write().as_mut() {
-            context_menu.select_prev(self.project.as_ref(), cx);
+            context_menu.select_prev(self.completion_provider.as_deref(), cx);
         }
     }
 
     pub fn context_menu_next(&mut self, _: &ContextMenuNext, cx: &mut ViewContext<Self>) {
         if let Some(context_menu) = self.context_menu.write().as_mut() {
-            context_menu.select_next(self.project.as_ref(), cx);
+            context_menu.select_next(self.completion_provider.as_deref(), cx);
         }
     }
 
     pub fn context_menu_last(&mut self, _: &ContextMenuLast, cx: &mut ViewContext<Self>) {
         if let Some(context_menu) = self.context_menu.write().as_mut() {
-            context_menu.select_last(self.project.as_ref(), cx);
+            context_menu.select_last(self.completion_provider.as_deref(), cx);
         }
     }
 
@@ -9623,7 +9654,7 @@ impl Editor {
         split: bool,
         cx: &mut ViewContext<Self>,
     ) -> Task<Result<Navigated>> {
-        let Some(workspace) = self.workspace() else {
+        let Some(provider) = self.semantics_provider.clone() else {
             return Task::ready(Ok(Navigated::No));
         };
         let buffer = self.buffer.read(cx);
@@ -9634,13 +9665,9 @@ impl Editor {
             return Task::ready(Ok(Navigated::No));
         };
 
-        let project = workspace.read(cx).project().clone();
-        let definitions = project.update(cx, |project, cx| match kind {
-            GotoDefinitionKind::Symbol => project.definition(&buffer, head, cx),
-            GotoDefinitionKind::Declaration => project.declaration(&buffer, head, cx),
-            GotoDefinitionKind::Type => project.type_definition(&buffer, head, cx),
-            GotoDefinitionKind::Implementation => project.implementation(&buffer, head, cx),
-        });
+        let Some(definitions) = provider.definitions(&buffer, head, kind, cx) else {
+            return Task::ready(Ok(Navigated::No));
+        };
 
         cx.spawn(|editor, mut cx| async move {
             let definitions = definitions.await?;
@@ -9697,9 +9724,7 @@ impl Editor {
             return;
         };
 
-        let Some(project) = self.project.clone() else {
-            return;
-        };
+        let project = self.project.clone();
 
         cx.spawn(|_, mut cx| async move {
             let result = find_file(&buffer, project, buffer_position, &mut cx).await;
@@ -10101,7 +10126,7 @@ impl Editor {
     pub fn rename(&mut self, _: &Rename, cx: &mut ViewContext<Self>) -> Option<Task<Result<()>>> {
         use language::ToOffset as _;
 
-        let project = self.project.clone()?;
+        let provider = self.semantics_provider.clone()?;
         let selection = self.selections.newest_anchor().clone();
         let (cursor_buffer, cursor_buffer_position) = self
             .buffer
@@ -10118,9 +10143,9 @@ impl Editor {
         let snapshot = cursor_buffer.read(cx).snapshot();
         let cursor_buffer_offset = cursor_buffer_position.to_offset(&snapshot);
         let cursor_buffer_offset_end = cursor_buffer_position_end.to_offset(&snapshot);
-        let prepare_rename = project.update(cx, |project, cx| {
-            project.prepare_rename(cursor_buffer.clone(), cursor_buffer_offset, cx)
-        });
+        let prepare_rename = provider
+            .range_for_rename(&cursor_buffer, cursor_buffer_position, cx)
+            .unwrap_or_else(|| Task::ready(Ok(None)));
         drop(snapshot);
 
         Some(cx.spawn(|this, mut cx| async move {
@@ -10291,32 +10316,28 @@ impl Editor {
         cx: &mut ViewContext<Self>,
     ) -> Option<Task<Result<()>>> {
         let rename = self.take_rename(false, cx)?;
-        let workspace = self.workspace()?;
-        let (start_buffer, start) = self
+        let workspace = self.workspace()?.downgrade();
+        let (buffer, start) = self
             .buffer
             .read(cx)
             .text_anchor_for_position(rename.range.start, cx)?;
-        let (end_buffer, end) = self
+        let (end_buffer, _) = self
             .buffer
             .read(cx)
             .text_anchor_for_position(rename.range.end, cx)?;
-        if start_buffer != end_buffer {
+        if buffer != end_buffer {
             return None;
         }
 
-        let buffer = start_buffer;
-        let range = start..end;
         let old_name = rename.old_name;
         let new_name = rename.editor.read(cx).text(cx);
 
-        let rename = workspace
-            .read(cx)
-            .project()
-            .clone()
-            .update(cx, |project, cx| {
-                project.perform_rename(buffer.clone(), range.start, new_name.clone(), true, cx)
-            });
-        let workspace = workspace.downgrade();
+        let rename = self.semantics_provider.as_ref()?.perform_rename(
+            &buffer,
+            start,
+            new_name.clone(),
+            cx,
+        )?;
 
         Some(cx.spawn(|editor, mut cx| async move {
             let project_transaction = rename.await?;
@@ -12371,14 +12392,22 @@ impl Editor {
 
         let mut new_selections_by_buffer = HashMap::default();
         for selection in self.selections.all::<usize>(cx) {
-            for (buffer, mut range, _) in
-                buffer.range_to_buffer_ranges(selection.start..selection.end, cx)
+            for (mut buffer_handle, mut range, _) in
+                buffer.range_to_buffer_ranges(selection.range(), cx)
             {
+                // When editing branch buffers, jump to the corresponding location
+                // in their base buffer.
+                let buffer = buffer_handle.read(cx);
+                if let Some(base_buffer) = buffer.diff_base_buffer() {
+                    range = buffer.range_to_version(range, &base_buffer.read(cx).version());
+                    buffer_handle = base_buffer;
+                }
+
                 if selection.reversed {
                     mem::swap(&mut range.start, &mut range.end);
                 }
                 new_selections_by_buffer
-                    .entry(buffer)
+                    .entry(buffer_handle)
                     .or_insert(Vec::new())
                     .push(range)
             }
@@ -12663,24 +12692,13 @@ impl Editor {
     }
 
     pub fn supports_inlay_hints(&self, cx: &AppContext) -> bool {
-        let Some(project) = self.project.as_ref() else {
+        let Some(provider) = self.semantics_provider.as_ref() else {
             return false;
         };
-        let project = project.read(cx);
 
         let mut supports = false;
         self.buffer().read(cx).for_each_buffer(|buffer| {
-            if !supports {
-                supports = project
-                    .language_servers_for_buffer(buffer.read(cx), cx)
-                    .any(
-                        |(_, server)| match server.capabilities().inlay_hint_provider {
-                            Some(lsp::OneOf::Left(enabled)) => enabled,
-                            Some(lsp::OneOf::Right(_)) => true,
-                            None => false,
-                        },
-                    )
-            }
+            supports |= provider.supports_inlay_hints(buffer, cx);
         });
         supports
     }
@@ -12946,6 +12964,62 @@ impl CollaborationHub for Model<Project> {
     }
 }
 
+pub trait SemanticsProvider {
+    fn hover(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        cx: &mut AppContext,
+    ) -> Option<Task<Vec<project::Hover>>>;
+
+    fn inlay_hints(
+        &self,
+        buffer_handle: Model<Buffer>,
+        range: Range<text::Anchor>,
+        cx: &mut AppContext,
+    ) -> Option<Task<anyhow::Result<Vec<InlayHint>>>>;
+
+    fn resolve_inlay_hint(
+        &self,
+        hint: InlayHint,
+        buffer_handle: Model<Buffer>,
+        server_id: LanguageServerId,
+        cx: &mut AppContext,
+    ) -> Option<Task<anyhow::Result<InlayHint>>>;
+
+    fn supports_inlay_hints(&self, buffer: &Model<Buffer>, cx: &AppContext) -> bool;
+
+    fn document_highlights(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        cx: &mut AppContext,
+    ) -> Option<Task<Result<Vec<DocumentHighlight>>>>;
+
+    fn definitions(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        kind: GotoDefinitionKind,
+        cx: &mut AppContext,
+    ) -> Option<Task<Result<Vec<LocationLink>>>>;
+
+    fn range_for_rename(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        cx: &mut AppContext,
+    ) -> Option<Task<Result<Option<Range<text::Anchor>>>>>;
+
+    fn perform_rename(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        new_name: String,
+        cx: &mut AppContext,
+    ) -> Option<Task<Result<ProjectTransaction>>>;
+}
+
 pub trait CompletionProvider {
     fn completions(
         &self,
@@ -13197,6 +13271,102 @@ impl CompletionProvider for Model<Project> {
     }
 }
 
+impl SemanticsProvider for Model<Project> {
+    fn hover(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        cx: &mut AppContext,
+    ) -> Option<Task<Vec<project::Hover>>> {
+        Some(self.update(cx, |project, cx| project.hover(buffer, position, cx)))
+    }
+
+    fn document_highlights(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        cx: &mut AppContext,
+    ) -> Option<Task<Result<Vec<DocumentHighlight>>>> {
+        Some(self.update(cx, |project, cx| {
+            project.document_highlights(buffer, position, cx)
+        }))
+    }
+
+    fn definitions(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        kind: GotoDefinitionKind,
+        cx: &mut AppContext,
+    ) -> Option<Task<Result<Vec<LocationLink>>>> {
+        Some(self.update(cx, |project, cx| match kind {
+            GotoDefinitionKind::Symbol => project.definition(&buffer, position, cx),
+            GotoDefinitionKind::Declaration => project.declaration(&buffer, position, cx),
+            GotoDefinitionKind::Type => project.type_definition(&buffer, position, cx),
+            GotoDefinitionKind::Implementation => project.implementation(&buffer, position, cx),
+        }))
+    }
+
+    fn supports_inlay_hints(&self, buffer: &Model<Buffer>, cx: &AppContext) -> bool {
+        // TODO: make this work for remote projects
+        self.read(cx)
+            .language_servers_for_buffer(buffer.read(cx), cx)
+            .any(
+                |(_, server)| match server.capabilities().inlay_hint_provider {
+                    Some(lsp::OneOf::Left(enabled)) => enabled,
+                    Some(lsp::OneOf::Right(_)) => true,
+                    None => false,
+                },
+            )
+    }
+
+    fn inlay_hints(
+        &self,
+        buffer_handle: Model<Buffer>,
+        range: Range<text::Anchor>,
+        cx: &mut AppContext,
+    ) -> Option<Task<anyhow::Result<Vec<InlayHint>>>> {
+        Some(self.update(cx, |project, cx| {
+            project.inlay_hints(buffer_handle, range, cx)
+        }))
+    }
+
+    fn resolve_inlay_hint(
+        &self,
+        hint: InlayHint,
+        buffer_handle: Model<Buffer>,
+        server_id: LanguageServerId,
+        cx: &mut AppContext,
+    ) -> Option<Task<anyhow::Result<InlayHint>>> {
+        Some(self.update(cx, |project, cx| {
+            project.resolve_inlay_hint(hint, buffer_handle, server_id, cx)
+        }))
+    }
+
+    fn range_for_rename(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        cx: &mut AppContext,
+    ) -> Option<Task<Result<Option<Range<text::Anchor>>>>> {
+        Some(self.update(cx, |project, cx| {
+            project.prepare_rename(buffer.clone(), position, cx)
+        }))
+    }
+
+    fn perform_rename(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        new_name: String,
+        cx: &mut AppContext,
+    ) -> Option<Task<Result<ProjectTransaction>>> {
+        Some(self.update(cx, |project, cx| {
+            project.perform_rename(buffer.clone(), position, new_name, cx)
+        }))
+    }
+}
+
 fn inlay_hint_settings(
     location: Anchor,
     snapshot: &MultiBufferSnapshot,
diff --git a/crates/editor/src/hover_links.rs b/crates/editor/src/hover_links.rs
index ac30b9199601ae..4a636f673abb7d 100644
--- a/crates/editor/src/hover_links.rs
+++ b/crates/editor/src/hover_links.rs
@@ -1,8 +1,8 @@
 use crate::{
     hover_popover::{self, InlayHover},
     scroll::ScrollAmount,
-    Anchor, Editor, EditorSnapshot, FindAllReferences, GoToDefinition, GoToTypeDefinition, InlayId,
-    Navigated, PointForPosition, SelectPhase,
+    Anchor, Editor, EditorSnapshot, FindAllReferences, GoToDefinition, GoToTypeDefinition,
+    GotoDefinitionKind, InlayId, Navigated, PointForPosition, SelectPhase,
 };
 use gpui::{px, AppContext, AsyncWindowContext, Model, Modifiers, Task, ViewContext};
 use language::{Bias, ToOffset};
@@ -14,12 +14,12 @@ use project::{
 };
 use std::ops::Range;
 use theme::ActiveTheme as _;
-use util::{maybe, ResultExt, TryFutureExt};
+use util::{maybe, ResultExt, TryFutureExt as _};
 
 #[derive(Debug)]
 pub struct HoveredLinkState {
     pub last_trigger_point: TriggerPoint,
-    pub preferred_kind: LinkDefinitionKind,
+    pub preferred_kind: GotoDefinitionKind,
     pub symbol_range: Option<RangeInEditor>,
     pub links: Vec<HoverLink>,
     pub task: Option<Task<Option<()>>>,
@@ -428,12 +428,6 @@ pub fn update_inlay_link_and_hover_points(
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum LinkDefinitionKind {
-    Symbol,
-    Type,
-}
-
 pub fn show_link_definition(
     shift_held: bool,
     editor: &mut Editor,
@@ -442,8 +436,8 @@ pub fn show_link_definition(
     cx: &mut ViewContext<Editor>,
 ) {
     let preferred_kind = match trigger_point {
-        TriggerPoint::Text(_) if !shift_held => LinkDefinitionKind::Symbol,
-        _ => LinkDefinitionKind::Type,
+        TriggerPoint::Text(_) if !shift_held => GotoDefinitionKind::Symbol,
+        _ => GotoDefinitionKind::Type,
     };
 
     let (mut hovered_link_state, is_cached) =
@@ -505,6 +499,7 @@ pub fn show_link_definition(
         editor.hide_hovered_link(cx)
     }
     let project = editor.project.clone();
+    let provider = editor.semantics_provider.clone();
 
     let snapshot = snapshot.buffer_snapshot.clone();
     hovered_link_state.task = Some(cx.spawn(|this, mut cx| {
@@ -522,54 +517,40 @@ pub fn show_link_definition(
                             (range, vec![HoverLink::Url(url)])
                         })
                         .ok()
-                    } else if let Some(project) = project {
-                        if let Some((filename_range, filename)) =
-                            find_file(&buffer, project.clone(), buffer_position, &mut cx).await
-                        {
-                            let range = maybe!({
-                                let start =
-                                    snapshot.anchor_in_excerpt(excerpt_id, filename_range.start)?;
-                                let end =
-                                    snapshot.anchor_in_excerpt(excerpt_id, filename_range.end)?;
-                                Some(RangeInEditor::Text(start..end))
-                            });
-
-                            Some((range, vec![HoverLink::File(filename)]))
+                    } else if let Some((filename_range, filename)) =
+                        find_file(&buffer, project.clone(), buffer_position, &mut cx).await
+                    {
+                        let range = maybe!({
+                            let start =
+                                snapshot.anchor_in_excerpt(excerpt_id, filename_range.start)?;
+                            let end = snapshot.anchor_in_excerpt(excerpt_id, filename_range.end)?;
+                            Some(RangeInEditor::Text(start..end))
+                        });
+
+                        Some((range, vec![HoverLink::File(filename)]))
+                    } else if let Some(provider) = provider {
+                        let task = cx.update(|cx| {
+                            provider.definitions(&buffer, buffer_position, preferred_kind, cx)
+                        })?;
+                        if let Some(task) = task {
+                            task.await.ok().map(|definition_result| {
+                                (
+                                    definition_result.iter().find_map(|link| {
+                                        link.origin.as_ref().and_then(|origin| {
+                                            let start = snapshot.anchor_in_excerpt(
+                                                excerpt_id,
+                                                origin.range.start,
+                                            )?;
+                                            let end = snapshot
+                                                .anchor_in_excerpt(excerpt_id, origin.range.end)?;
+                                            Some(RangeInEditor::Text(start..end))
+                                        })
+                                    }),
+                                    definition_result.into_iter().map(HoverLink::Text).collect(),
+                                )
+                            })
                         } else {
-                            // query the LSP for definition info
-                            project
-                                .update(&mut cx, |project, cx| match preferred_kind {
-                                    LinkDefinitionKind::Symbol => {
-                                        project.definition(&buffer, buffer_position, cx)
-                                    }
-
-                                    LinkDefinitionKind::Type => {
-                                        project.type_definition(&buffer, buffer_position, cx)
-                                    }
-                                })?
-                                .await
-                                .ok()
-                                .map(|definition_result| {
-                                    (
-                                        definition_result.iter().find_map(|link| {
-                                            link.origin.as_ref().and_then(|origin| {
-                                                let start = snapshot.anchor_in_excerpt(
-                                                    excerpt_id,
-                                                    origin.range.start,
-                                                )?;
-                                                let end = snapshot.anchor_in_excerpt(
-                                                    excerpt_id,
-                                                    origin.range.end,
-                                                )?;
-                                                Some(RangeInEditor::Text(start..end))
-                                            })
-                                        }),
-                                        definition_result
-                                            .into_iter()
-                                            .map(HoverLink::Text)
-                                            .collect(),
-                                    )
-                                })
+                            None
                         }
                     } else {
                         None
@@ -708,10 +689,11 @@ pub(crate) fn find_url(
 
 pub(crate) async fn find_file(
     buffer: &Model<language::Buffer>,
-    project: Model<Project>,
+    project: Option<Model<Project>>,
     position: text::Anchor,
     cx: &mut AsyncWindowContext,
 ) -> Option<(Range<text::Anchor>, ResolvedPath)> {
+    let project = project?;
     let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot()).ok()?;
     let scope = snapshot.language_scope_at(position);
     let (range, candidate_file_path) = surrounding_filename(snapshot, position)?;
diff --git a/crates/editor/src/hover_popover.rs b/crates/editor/src/hover_popover.rs
index e20b6a3dc85d73..da232431880b37 100644
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -195,32 +195,22 @@ fn show_hover(
     anchor: Anchor,
     ignore_timeout: bool,
     cx: &mut ViewContext<Editor>,
-) {
+) -> Option<()> {
     if editor.pending_rename.is_some() {
-        return;
+        return None;
     }
 
     let snapshot = editor.snapshot(cx);
 
-    let (buffer, buffer_position) =
-        if let Some(output) = editor.buffer.read(cx).text_anchor_for_position(anchor, cx) {
-            output
-        } else {
-            return;
-        };
+    let (buffer, buffer_position) = editor
+        .buffer
+        .read(cx)
+        .text_anchor_for_position(anchor, cx)?;
 
-    let excerpt_id =
-        if let Some((excerpt_id, _, _)) = editor.buffer().read(cx).excerpt_containing(anchor, cx) {
-            excerpt_id
-        } else {
-            return;
-        };
+    let (excerpt_id, _, _) = editor.buffer().read(cx).excerpt_containing(anchor, cx)?;
 
-    let project = if let Some(project) = editor.project.clone() {
-        project
-    } else {
-        return;
-    };
+    let language_registry = editor.project.as_ref()?.read(cx).languages().clone();
+    let provider = editor.semantics_provider.clone()?;
 
     if !ignore_timeout {
         if same_info_hover(editor, &snapshot, anchor)
@@ -228,7 +218,7 @@ fn show_hover(
             || editor.hover_state.diagnostic_popover.is_some()
         {
             // Hover triggered from same location as last time. Don't show again.
-            return;
+            return None;
         } else {
             hide_hover(editor, cx);
         }
@@ -240,7 +230,7 @@ fn show_hover(
             .cmp(&anchor, &snapshot.buffer_snapshot)
             .is_eq()
         {
-            return;
+            return None;
         }
     }
 
@@ -262,12 +252,7 @@ fn show_hover(
                 total_delay
             };
 
-            // query the LSP for hover info
-            let hover_request = cx.update(|cx| {
-                project.update(cx, |project, cx| {
-                    project.hover(&buffer, buffer_position, cx)
-                })
-            })?;
+            let hover_request = cx.update(|cx| provider.hover(&buffer, buffer_position, cx))?;
 
             if let Some(delay) = delay {
                 delay.await;
@@ -377,8 +362,11 @@ fn show_hover(
                 this.hover_state.diagnostic_popover = diagnostic_popover;
             })?;
 
-            let hovers_response = hover_request.await;
-            let language_registry = project.update(&mut cx, |p, _| p.languages().clone())?;
+            let hovers_response = if let Some(hover_request) = hover_request {
+                hover_request.await
+            } else {
+                Vec::new()
+            };
             let snapshot = this.update(&mut cx, |this, cx| this.snapshot(cx))?;
             let mut hover_highlights = Vec::with_capacity(hovers_response.len());
             let mut info_popovers = Vec::with_capacity(hovers_response.len());
@@ -451,6 +439,7 @@ fn show_hover(
     });
 
     editor.hover_state.info_task = Some(task);
+    None
 }
 
 fn same_info_hover(editor: &Editor, snapshot: &EditorSnapshot, anchor: Anchor) -> bool {
diff --git a/crates/editor/src/inlay_hint_cache.rs b/crates/editor/src/inlay_hint_cache.rs
index ca2db70a70c2ad..877f02eefe203d 100644
--- a/crates/editor/src/inlay_hint_cache.rs
+++ b/crates/editor/src/inlay_hint_cache.rs
@@ -591,21 +591,13 @@ impl InlayHintCache {
                     drop(guard);
                     cx.spawn(|editor, mut cx| async move {
                         let resolved_hint_task = editor.update(&mut cx, |editor, cx| {
-                            editor
-                                .buffer()
-                                .read(cx)
-                                .buffer(buffer_id)
-                                .and_then(|buffer| {
-                                    let project = editor.project.as_ref()?;
-                                    Some(project.update(cx, |project, cx| {
-                                        project.resolve_inlay_hint(
-                                            hint_to_resolve,
-                                            buffer,
-                                            server_id,
-                                            cx,
-                                        )
-                                    }))
-                                })
+                            let buffer = editor.buffer().read(cx).buffer(buffer_id)?;
+                            editor.semantics_provider.as_ref()?.resolve_inlay_hint(
+                                hint_to_resolve,
+                                buffer,
+                                server_id,
+                                cx,
+                            )
                         })?;
                         if let Some(resolved_hint_task) = resolved_hint_task {
                             let mut resolved_hint =
@@ -895,11 +887,13 @@ fn fetch_and_update_hints(
 ) -> Task<anyhow::Result<()>> {
     cx.spawn(|editor, mut cx| async move {
         let buffer_snapshot = excerpt_buffer.update(&mut cx, |buffer, _| buffer.snapshot())?;
-        let (lsp_request_limiter, multi_buffer_snapshot) = editor.update(&mut cx, |editor, cx| {
-            let multi_buffer_snapshot  = editor.buffer().update(cx, |buffer, cx| buffer.snapshot(cx));
-            let lsp_request_limiter = Arc::clone(&editor.inlay_hint_cache.lsp_request_limiter);
-            (lsp_request_limiter, multi_buffer_snapshot)
-        })?;
+        let (lsp_request_limiter, multi_buffer_snapshot) =
+            editor.update(&mut cx, |editor, cx| {
+                let multi_buffer_snapshot =
+                    editor.buffer().update(cx, |buffer, cx| buffer.snapshot(cx));
+                let lsp_request_limiter = Arc::clone(&editor.inlay_hint_cache.lsp_request_limiter);
+                (lsp_request_limiter, multi_buffer_snapshot)
+            })?;
 
         let (lsp_request_guard, got_throttled) = if query.invalidate.should_invalidate() {
             (None, false)
@@ -909,12 +903,15 @@ fn fetch_and_update_hints(
                 None => (Some(lsp_request_limiter.acquire().await), true),
             }
         };
-        let fetch_range_to_log =
-            fetch_range.start.to_point(&buffer_snapshot)..fetch_range.end.to_point(&buffer_snapshot);
+        let fetch_range_to_log = fetch_range.start.to_point(&buffer_snapshot)
+            ..fetch_range.end.to_point(&buffer_snapshot);
         let inlay_hints_fetch_task = editor
             .update(&mut cx, |editor, cx| {
                 if got_throttled {
-                    let query_not_around_visible_range = match editor.excerpts_for_inlay_hints_query(None, cx).remove(&query.excerpt_id) {
+                    let query_not_around_visible_range = match editor
+                        .excerpts_for_inlay_hints_query(None, cx)
+                        .remove(&query.excerpt_id)
+                    {
                         Some((_, _, current_visible_range)) => {
                             let visible_offset_length = current_visible_range.len();
                             let double_visible_range = current_visible_range
@@ -928,11 +925,11 @@ fn fetch_and_update_hints(
                                 .contains(&fetch_range.start.to_offset(&buffer_snapshot))
                                 && !double_visible_range
                                     .contains(&fetch_range.end.to_offset(&buffer_snapshot))
-                        },
+                        }
                         None => true,
                     };
                     if query_not_around_visible_range {
-                        log::trace!("Fetching inlay hints for range {fetch_range_to_log:?} got throttled and fell off the current visible range, skipping.");
+                        // log::trace!("Fetching inlay hints for range {fetch_range_to_log:?} got throttled and fell off the current visible range, skipping.");
                         if let Some(task_ranges) = editor
                             .inlay_hint_cache
                             .update_tasks
@@ -943,16 +940,12 @@ fn fetch_and_update_hints(
                         return None;
                     }
                 }
+
+                let buffer = editor.buffer().read(cx).buffer(query.buffer_id)?;
                 editor
-                    .buffer()
-                    .read(cx)
-                    .buffer(query.buffer_id)
-                    .and_then(|buffer| {
-                        let project = editor.project.as_ref()?;
-                        Some(project.update(cx, |project, cx| {
-                            project.inlay_hints(buffer, fetch_range.clone(), cx)
-                        }))
-                    })
+                    .semantics_provider
+                    .as_ref()?
+                    .inlay_hints(buffer, fetch_range.clone(), cx)
             })
             .ok()
             .flatten();
@@ -1004,12 +997,12 @@ fn fetch_and_update_hints(
             })
             .await;
         if let Some(new_update) = new_update {
-            log::debug!(
-                "Applying update for range {fetch_range_to_log:?}: remove from editor: {}, remove from cache: {}, add to cache: {}",
-                new_update.remove_from_visible.len(),
-                new_update.remove_from_cache.len(),
-                new_update.add_to_cache.len()
-            );
+            // log::debug!(
+            //     "Applying update for range {fetch_range_to_log:?}: remove from editor: {}, remove from cache: {}, add to cache: {}",
+            //     new_update.remove_from_visible.len(),
+            //     new_update.remove_from_cache.len(),
+            //     new_update.add_to_cache.len()
+            // );
             log::trace!("New update: {new_update:?}");
             editor
                 .update(&mut cx, |editor, cx| {
diff --git a/crates/editor/src/proposed_changes_editor.rs b/crates/editor/src/proposed_changes_editor.rs
index 8c8aa710a2f72c..056daf28a839e9 100644
--- a/crates/editor/src/proposed_changes_editor.rs
+++ b/crates/editor/src/proposed_changes_editor.rs
@@ -1,4 +1,4 @@
-use crate::{Editor, EditorEvent};
+use crate::{Editor, EditorEvent, SemanticsProvider};
 use collections::HashSet;
 use futures::{channel::mpsc, future::join_all};
 use gpui::{AppContext, EventEmitter, FocusableView, Model, Render, Subscription, Task, View};
@@ -6,7 +6,7 @@ use language::{Buffer, BufferEvent, Capability};
 use multi_buffer::{ExcerptRange, MultiBuffer};
 use project::Project;
 use smol::stream::StreamExt;
-use std::{any::TypeId, ops::Range, time::Duration};
+use std::{any::TypeId, ops::Range, rc::Rc, time::Duration};
 use text::ToOffset;
 use ui::prelude::*;
 use workspace::{
@@ -35,6 +35,12 @@ struct RecalculateDiff {
     debounce: bool,
 }
 
+/// A provider of code semantics for branch buffers.
+///
+/// Requests in edited regions will return nothing, but requests in unchanged
+/// regions will be translated into the base buffer's coordinates.
+struct BranchBufferSemanticsProvider(Rc<dyn SemanticsProvider>);
+
 impl ProposedChangesEditor {
     pub fn new<T: ToOffset>(
         buffers: Vec<ProposedChangesBuffer<T>>,
@@ -66,6 +72,13 @@ impl ProposedChangesEditor {
             editor: cx.new_view(|cx| {
                 let mut editor = Editor::for_multibuffer(multibuffer.clone(), project, true, cx);
                 editor.set_expand_all_diff_hunks();
+                editor.set_completion_provider(None);
+                editor.clear_code_action_providers();
+                editor.set_semantics_provider(
+                    editor
+                        .semantics_provider()
+                        .map(|provider| Rc::new(BranchBufferSemanticsProvider(provider)) as _),
+                );
                 editor
             }),
             recalculate_diffs_tx,
@@ -76,7 +89,7 @@ impl ProposedChangesEditor {
 
                     while recalculate_diff.debounce {
                         cx.background_executor()
-                            .timer(Duration::from_millis(250))
+                            .timer(Duration::from_millis(50))
                             .await;
                         let mut had_further_changes = false;
                         while let Ok(next_recalculate_diff) = recalculate_diffs_rx.try_next() {
@@ -245,3 +258,103 @@ impl ToolbarItemView for ProposedChangesEditorToolbar {
         self.get_toolbar_item_location()
     }
 }
+
+impl BranchBufferSemanticsProvider {
+    fn to_base(
+        &self,
+        buffer: &Model<Buffer>,
+        positions: &[text::Anchor],
+        cx: &AppContext,
+    ) -> Option<Model<Buffer>> {
+        let base_buffer = buffer.read(cx).diff_base_buffer()?;
+        let version = base_buffer.read(cx).version();
+        if positions
+            .iter()
+            .any(|position| !version.observed(position.timestamp))
+        {
+            return None;
+        }
+        Some(base_buffer)
+    }
+}
+
+impl SemanticsProvider for BranchBufferSemanticsProvider {
+    fn hover(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        cx: &mut AppContext,
+    ) -> Option<Task<Vec<project::Hover>>> {
+        let buffer = self.to_base(buffer, &[position], cx)?;
+        self.0.hover(&buffer, position, cx)
+    }
+
+    fn inlay_hints(
+        &self,
+        buffer: Model<Buffer>,
+        range: Range<text::Anchor>,
+        cx: &mut AppContext,
+    ) -> Option<Task<anyhow::Result<Vec<project::InlayHint>>>> {
+        let buffer = self.to_base(&buffer, &[range.start, range.end], cx)?;
+        self.0.inlay_hints(buffer, range, cx)
+    }
+
+    fn resolve_inlay_hint(
+        &self,
+        hint: project::InlayHint,
+        buffer: Model<Buffer>,
+        server_id: lsp::LanguageServerId,
+        cx: &mut AppContext,
+    ) -> Option<Task<anyhow::Result<project::InlayHint>>> {
+        let buffer = self.to_base(&buffer, &[], cx)?;
+        self.0.resolve_inlay_hint(hint, buffer, server_id, cx)
+    }
+
+    fn supports_inlay_hints(&self, buffer: &Model<Buffer>, cx: &AppContext) -> bool {
+        if let Some(buffer) = self.to_base(&buffer, &[], cx) {
+            self.0.supports_inlay_hints(&buffer, cx)
+        } else {
+            false
+        }
+    }
+
+    fn document_highlights(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        cx: &mut AppContext,
+    ) -> Option<Task<gpui::Result<Vec<project::DocumentHighlight>>>> {
+        let buffer = self.to_base(&buffer, &[position], cx)?;
+        self.0.document_highlights(&buffer, position, cx)
+    }
+
+    fn definitions(
+        &self,
+        buffer: &Model<Buffer>,
+        position: text::Anchor,
+        kind: crate::GotoDefinitionKind,
+        cx: &mut AppContext,
+    ) -> Option<Task<gpui::Result<Vec<project::LocationLink>>>> {
+        let buffer = self.to_base(&buffer, &[position], cx)?;
+        self.0.definitions(&buffer, position, kind, cx)
+    }
+
+    fn range_for_rename(
+        &self,
+        _: &Model<Buffer>,
+        _: text::Anchor,
+        _: &mut AppContext,
+    ) -> Option<Task<gpui::Result<Option<Range<text::Anchor>>>>> {
+        None
+    }
+
+    fn perform_rename(
+        &self,
+        _: &Model<Buffer>,
+        _: text::Anchor,
+        _: String,
+        _: &mut AppContext,
+    ) -> Option<Task<gpui::Result<project::ProjectTransaction>>> {
+        None
+    }
+}
diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs
index 83c35cbeca56bd..be6fb4f631f2d1 100644
--- a/crates/language/src/buffer_tests.rs
+++ b/crates/language/src/buffer_tests.rs
@@ -2381,20 +2381,14 @@ async fn test_find_matching_indent(cx: &mut TestAppContext) {
 fn test_branch_and_merge(cx: &mut TestAppContext) {
     cx.update(|cx| init_settings(cx, |_| {}));
 
-    let base_buffer = cx.new_model(|cx| Buffer::local("one\ntwo\nthree\n", cx));
+    let base = cx.new_model(|cx| Buffer::local("one\ntwo\nthree\n", cx));
 
     // Create a remote replica of the base buffer.
-    let base_buffer_replica = cx.new_model(|cx| {
-        Buffer::from_proto(
-            1,
-            Capability::ReadWrite,
-            base_buffer.read(cx).to_proto(cx),
-            None,
-        )
-        .unwrap()
+    let base_replica = cx.new_model(|cx| {
+        Buffer::from_proto(1, Capability::ReadWrite, base.read(cx).to_proto(cx), None).unwrap()
     });
-    base_buffer.update(cx, |_buffer, cx| {
-        cx.subscribe(&base_buffer_replica, |this, _, event, cx| {
+    base.update(cx, |_buffer, cx| {
+        cx.subscribe(&base_replica, |this, _, event, cx| {
             if let BufferEvent::Operation {
                 operation,
                 is_local: true,
@@ -2407,14 +2401,14 @@ fn test_branch_and_merge(cx: &mut TestAppContext) {
     });
 
     // Create a branch, which initially has the same state as the base buffer.
-    let branch_buffer = base_buffer.update(cx, |buffer, cx| buffer.branch(cx));
-    branch_buffer.read_with(cx, |buffer, _| {
+    let branch = base.update(cx, |buffer, cx| buffer.branch(cx));
+    branch.read_with(cx, |buffer, _| {
         assert_eq!(buffer.text(), "one\ntwo\nthree\n");
     });
 
     // Edits to the branch are not applied to the base.
-    branch_buffer.update(cx, |branch_buffer, cx| {
-        branch_buffer.edit(
+    branch.update(cx, |buffer, cx| {
+        buffer.edit(
             [
                 (Point::new(1, 0)..Point::new(1, 0), "1.5\n"),
                 (Point::new(2, 0)..Point::new(2, 5), "THREE"),
@@ -2423,64 +2417,74 @@ fn test_branch_and_merge(cx: &mut TestAppContext) {
             cx,
         )
     });
-    branch_buffer.read_with(cx, |branch_buffer, cx| {
-        assert_eq!(base_buffer.read(cx).text(), "one\ntwo\nthree\n");
-        assert_eq!(branch_buffer.text(), "one\n1.5\ntwo\nTHREE\n");
+    branch.read_with(cx, |buffer, cx| {
+        assert_eq!(base.read(cx).text(), "one\ntwo\nthree\n");
+        assert_eq!(buffer.text(), "one\n1.5\ntwo\nTHREE\n");
+    });
+
+    // Convert from branch buffer ranges to the corresoponing ranges in the
+    // base buffer.
+    branch.read_with(cx, |buffer, cx| {
+        assert_eq!(
+            buffer.range_to_version(4..7, &base.read(cx).version()),
+            4..4
+        );
+        assert_eq!(
+            buffer.range_to_version(2..9, &base.read(cx).version()),
+            2..5
+        );
     });
 
     // The branch buffer maintains a diff with respect to its base buffer.
-    start_recalculating_diff(&branch_buffer, cx);
+    start_recalculating_diff(&branch, cx);
     cx.run_until_parked();
     assert_diff_hunks(
-        &branch_buffer,
+        &branch,
         cx,
         &[(1..2, "", "1.5\n"), (3..4, "three\n", "THREE\n")],
     );
 
     // Edits to the base are applied to the branch.
-    base_buffer.update(cx, |buffer, cx| {
+    base.update(cx, |buffer, cx| {
         buffer.edit([(Point::new(0, 0)..Point::new(0, 0), "ZERO\n")], None, cx)
     });
-    branch_buffer.read_with(cx, |branch_buffer, cx| {
-        assert_eq!(base_buffer.read(cx).text(), "ZERO\none\ntwo\nthree\n");
-        assert_eq!(branch_buffer.text(), "ZERO\none\n1.5\ntwo\nTHREE\n");
+    branch.read_with(cx, |buffer, cx| {
+        assert_eq!(base.read(cx).text(), "ZERO\none\ntwo\nthree\n");
+        assert_eq!(buffer.text(), "ZERO\none\n1.5\ntwo\nTHREE\n");
     });
 
     // Until the git diff recalculation is complete, the git diff references
     // the previous content of the base buffer, so that it stays in sync.
-    start_recalculating_diff(&branch_buffer, cx);
+    start_recalculating_diff(&branch, cx);
     assert_diff_hunks(
-        &branch_buffer,
+        &branch,
         cx,
         &[(2..3, "", "1.5\n"), (4..5, "three\n", "THREE\n")],
     );
     cx.run_until_parked();
     assert_diff_hunks(
-        &branch_buffer,
+        &branch,
         cx,
         &[(2..3, "", "1.5\n"), (4..5, "three\n", "THREE\n")],
     );
 
     // Edits to any replica of the base are applied to the branch.
-    base_buffer_replica.update(cx, |buffer, cx| {
+    base_replica.update(cx, |buffer, cx| {
         buffer.edit([(Point::new(2, 0)..Point::new(2, 0), "2.5\n")], None, cx)
     });
-    branch_buffer.read_with(cx, |branch_buffer, cx| {
-        assert_eq!(base_buffer.read(cx).text(), "ZERO\none\ntwo\n2.5\nthree\n");
-        assert_eq!(branch_buffer.text(), "ZERO\none\n1.5\ntwo\n2.5\nTHREE\n");
+    branch.read_with(cx, |buffer, cx| {
+        assert_eq!(base.read(cx).text(), "ZERO\none\ntwo\n2.5\nthree\n");
+        assert_eq!(buffer.text(), "ZERO\none\n1.5\ntwo\n2.5\nTHREE\n");
     });
 
     // Merging the branch applies all of its changes to the base.
-    branch_buffer.update(cx, |branch_buffer, cx| {
-        branch_buffer.merge_into_base(Vec::new(), cx);
+    branch.update(cx, |buffer, cx| {
+        buffer.merge_into_base(Vec::new(), cx);
     });
 
-    branch_buffer.update(cx, |branch_buffer, cx| {
-        assert_eq!(
-            base_buffer.read(cx).text(),
-            "ZERO\none\n1.5\ntwo\n2.5\nTHREE\n"
-        );
-        assert_eq!(branch_buffer.text(), "ZERO\none\n1.5\ntwo\n2.5\nTHREE\n");
+    branch.update(cx, |buffer, cx| {
+        assert_eq!(base.read(cx).text(), "ZERO\none\n1.5\ntwo\n2.5\nTHREE\n");
+        assert_eq!(buffer.text(), "ZERO\none\n1.5\ntwo\n2.5\nTHREE\n");
     });
 }
 
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 214436231dd82a..7f02d3f6dd76e6 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -2724,16 +2724,16 @@ impl Project {
             cx,
         )
     }
+
     pub fn perform_rename<T: ToPointUtf16>(
         &mut self,
         buffer: Model<Buffer>,
         position: T,
         new_name: String,
-        push_to_history: bool,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<ProjectTransaction>> {
         let position = position.to_point_utf16(buffer.read(cx));
-        self.perform_rename_impl(buffer, position, new_name, push_to_history, cx)
+        self.perform_rename_impl(buffer, position, new_name, true, cx)
     }
 
     pub fn on_type_format<T: ToPointUtf16>(
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index ee448543be9701..f5cfba2ffdbacc 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -3892,7 +3892,7 @@ async fn test_rename(cx: &mut gpui::TestAppContext) {
     assert_eq!(range, 6..9);
 
     let response = project.update(cx, |project, cx| {
-        project.perform_rename(buffer.clone(), 7, "THREE".to_string(), true, cx)
+        project.perform_rename(buffer.clone(), 7, "THREE".to_string(), cx)
     });
     fake_server
         .handle_request::<lsp::request::Rename, _, _>(|params, _| async move {
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 6e962a134a3f16..10cfb517abb802 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -434,7 +434,7 @@ async fn test_remote_lsp(cx: &mut TestAppContext, server_cx: &mut TestAppContext
 
     project
         .update(cx, |project, cx| {
-            project.perform_rename(buffer.clone(), 3, "two".to_string(), true, cx)
+            project.perform_rename(buffer.clone(), 3, "two".to_string(), cx)
         })
         .await
         .unwrap();
diff --git a/crates/text/src/text.rs b/crates/text/src/text.rs
index 6c941401be37cb..b1e6be8a1cb74f 100644
--- a/crates/text/src/text.rs
+++ b/crates/text/src/text.rs
@@ -2439,6 +2439,42 @@ impl BufferSnapshot {
         }
         false
     }
+
+    pub fn range_to_version(&self, range: Range<usize>, version: &clock::Global) -> Range<usize> {
+        let mut offsets = self.offsets_to_version([range.start, range.end], version);
+        offsets.next().unwrap()..offsets.next().unwrap()
+    }
+
+    /// Converts the given sequence of offsets into their corresponding offsets
+    /// at a prior version of this buffer.
+    pub fn offsets_to_version<'a>(
+        &'a self,
+        offsets: impl 'a + IntoIterator<Item = usize>,
+        version: &'a clock::Global,
+    ) -> impl 'a + Iterator<Item = usize> {
+        let mut edits = self.edits_since(version).peekable();
+        let mut last_old_end = 0;
+        let mut last_new_end = 0;
+        offsets.into_iter().map(move |new_offset| {
+            while let Some(edit) = edits.peek() {
+                if edit.new.start > new_offset {
+                    break;
+                }
+
+                if edit.new.end <= new_offset {
+                    last_new_end = edit.new.end;
+                    last_old_end = edit.old.end;
+                    edits.next();
+                    continue;
+                }
+
+                let overshoot = new_offset - edit.new.start;
+                return (edit.old.start + overshoot).min(edit.old.end);
+            }
+
+            last_old_end + new_offset.saturating_sub(last_new_end)
+        })
+    }
 }
 
 struct RopeBuilder<'a> {

From ab34342664501b9fa946727b12fb99b4bd854847 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Wed, 9 Oct 2024 21:35:20 -0400
Subject: [PATCH 570/762] Close unlabeled issues (#18992)

Release Notes:

- N/A
---
 .github/workflows/close_unlabeled_issues.yml | 32 ++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 .github/workflows/close_unlabeled_issues.yml

diff --git a/.github/workflows/close_unlabeled_issues.yml b/.github/workflows/close_unlabeled_issues.yml
new file mode 100644
index 00000000000000..a5dc89a46d9d1d
--- /dev/null
+++ b/.github/workflows/close_unlabeled_issues.yml
@@ -0,0 +1,32 @@
+name: Close Unlabeled Issues
+
+on:
+  issues:
+    types: [opened]
+  workflow_dispatch:
+
+jobs:
+  close-unlabeled-issue:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check for labels and close if unlabeled
+        uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          script: |
+            const issue = context.payload.issue;
+            if (issue.labels.length === 0) {
+              const issueNumber = issue.number;
+              await github.rest.issues.update({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                state: 'closed'
+              });
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                body: 'This issue has been automatically closed because it was created without using an issue template. Please reopen your issue using one of the following issue templates:\n\nhttps://github.com/zed-industries/zed/issues/new/choose'
+              });
+            }

From ed484ecf5f9559331ac969d6f654f3eb2a647328 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Wed, 9 Oct 2024 21:39:30 -0400
Subject: [PATCH 571/762] Run action to close unlabeled issues every hour
 (#18995)

Release Notes:

- N/A
---
 .github/workflows/close_unlabeled_issues.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/close_unlabeled_issues.yml b/.github/workflows/close_unlabeled_issues.yml
index a5dc89a46d9d1d..0f010fdbbc124e 100644
--- a/.github/workflows/close_unlabeled_issues.yml
+++ b/.github/workflows/close_unlabeled_issues.yml
@@ -1,8 +1,8 @@
 name: Close Unlabeled Issues
 
 on:
-  issues:
-    types: [opened]
+  schedule:
+    - cron: "0 * * * *"
   workflow_dispatch:
 
 jobs:

From 285fb5177136fb960d8a4139c3d5a576317da958 Mon Sep 17 00:00:00 2001
From: Joseph T Lyons <JosephTLyons@gmail.com>
Date: Wed, 9 Oct 2024 22:09:28 -0400
Subject: [PATCH 572/762] Move label data to a data file so multiple scripts
 can reference them

---
 script/label_data.json                   | 13 +++++++
 script/update_top_ranking_issues/main.py | 43 +++++++++++-------------
 2 files changed, 32 insertions(+), 24 deletions(-)
 create mode 100644 script/label_data.json

diff --git a/script/label_data.json b/script/label_data.json
new file mode 100644
index 00000000000000..48c5d52200e084
--- /dev/null
+++ b/script/label_data.json
@@ -0,0 +1,13 @@
+{
+  "core_labels": [
+    "defect",
+    "design",
+    "documentation",
+    "duplicate",
+    "enhancement",
+    "panic / crash",
+    "support"
+  ],
+  "additional_labels": ["ai", "linux", "vim", "windows"],
+  "ignored_label": "ignore top-ranking issues"
+}
diff --git a/script/update_top_ranking_issues/main.py b/script/update_top_ranking_issues/main.py
index bba2df4486ad68..534b5e67213408 100644
--- a/script/update_top_ranking_issues/main.py
+++ b/script/update_top_ranking_issues/main.py
@@ -1,38 +1,33 @@
+import json
 import os
+import pathlib
 from collections import defaultdict
 from datetime import datetime, timedelta
 from typing import Optional
 
+import typer
 from github import Github
 from github.Issue import Issue
 from github.Repository import Repository
 from pytz import timezone
-
-import typer
 from typer import Typer
 
 app: Typer = typer.Typer()
 
 DATETIME_FORMAT: str = "%m/%d/%Y %I:%M %p"
-CORE_LABELS: set[str] = {
-    "defect",
-    "design",
-    "documentation",
-    "duplicate",
-    "enhancement",
-    "panic / crash",
-    "support",
-}
-# A set of labels for adding in labels that we want present in the final
-# report, but that we don't want being defined as a core label, since issues
-# with without core labels are flagged as errors.
-ADDITIONAL_LABELS: set[str] = {
-    "ai",
-    "linux",
-    "vim",
-    "windows",
-}
-IGNORED_LABEL_TEXT: str = "ignore top-ranking issues"
+
+label_data_file_path = pathlib.Path(__file__).parent.parent / "label_data.json"
+
+with open(label_data_file_path, "r") as label_data_file:
+    label_data = json.load(label_data_file)
+    CORE_LABELS: set[str] = set(label_data["core_labels"])
+    # A set of labels for adding in labels that we want present in the final
+    # report, but that we don't want being defined as a core label, since issues
+    # with without core labels are flagged as errors.
+    ADDITIONAL_LABELS: set[str] = set(label_data["additional_labels"])
+    IGNORED_LABEL: str = label_data["ignored_label"]
+
+
 ISSUES_PER_LABEL: int = 20
 
 
@@ -153,7 +148,7 @@ def get_label_to_issues(
     )
 
     for label in labels:
-        query: str = f'repo:{repository.full_name} is:open is:issue {date_query} label:"{label}" -label:"{IGNORED_LABEL_TEXT}" sort:reactions-+1-desc'
+        query: str = f'repo:{repository.full_name} is:open is:issue {date_query} label:"{label}" -label:"{IGNORED_LABEL}" sort:reactions-+1-desc'
 
         issues = github.search_issues(query)
 
@@ -191,7 +186,7 @@ def get_error_message_to_erroneous_issues(
     error_message_to_erroneous_issues: defaultdict[str, list[Issue]] = defaultdict(list)
 
     # Query for all open issues that don't have either a core or the ignored label and mark those as erroneous
-    filter_labels: set[str] = CORE_LABELS | {IGNORED_LABEL_TEXT}
+    filter_labels: set[str] = CORE_LABELS | {IGNORED_LABEL}
     filter_labels_text: str = " ".join([f'-label:"{label}"' for label in filter_labels])
     query: str = f"repo:{repository.full_name} is:open is:issue {filter_labels_text}"
 
@@ -245,7 +240,7 @@ def get_issue_text(
             [
                 "## errors with issues (this section only shows when there are errors with issues)\n",
                 f"This script expects every issue to have at least one of the following core labels: {core_labels_text}",
-                f"This script currently ignores issues that have the following label: {IGNORED_LABEL_TEXT}\n",
+                f"This script currently ignores issues that have the following label: {IGNORED_LABEL}\n",
                 "### what to do?\n",
                 "- Adjust the core labels on an issue to put it into a correct state or add a currently-ignored label to the issue",
                 "- Adjust the core and ignored labels registered in this script",

From fcfd769b3936cfb4dcd4cc9ec8dbd2fff5be76be Mon Sep 17 00:00:00 2001
From: Joseph T Lyons <JosephTLyons@gmail.com>
Date: Wed, 9 Oct 2024 22:27:10 -0400
Subject: [PATCH 573/762] Delete close_unlabeled_issues.yml

I'm going to write something more robust using PyGitHub.
---
 .github/workflows/close_unlabeled_issues.yml | 32 --------------------
 1 file changed, 32 deletions(-)
 delete mode 100644 .github/workflows/close_unlabeled_issues.yml

diff --git a/.github/workflows/close_unlabeled_issues.yml b/.github/workflows/close_unlabeled_issues.yml
deleted file mode 100644
index 0f010fdbbc124e..00000000000000
--- a/.github/workflows/close_unlabeled_issues.yml
+++ /dev/null
@@ -1,32 +0,0 @@
-name: Close Unlabeled Issues
-
-on:
-  schedule:
-    - cron: "0 * * * *"
-  workflow_dispatch:
-
-jobs:
-  close-unlabeled-issue:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check for labels and close if unlabeled
-        uses: actions/github-script@v6
-        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
-          script: |
-            const issue = context.payload.issue;
-            if (issue.labels.length === 0) {
-              const issueNumber = issue.number;
-              await github.rest.issues.update({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: issueNumber,
-                state: 'closed'
-              });
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: issueNumber,
-                body: 'This issue has been automatically closed because it was created without using an issue template. Please reopen your issue using one of the following issue templates:\n\nhttps://github.com/zed-industries/zed/issues/new/choose'
-              });
-            }

From d8484c57e115987797bfe3addb316c86e8295752 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Wed, 9 Oct 2024 22:53:01 -0400
Subject: [PATCH 574/762] Use uv (#18997)

Release Notes:

- N/A
---
 .../update_all_top_ranking_issues.yml         |  17 +-
 .../update_top_ranking_issues/.python-version |   1 +
 script/update_top_ranking_issues/poetry.lock  | 533 ------------------
 .../update_top_ranking_issues/pyproject.toml  |  25 +-
 script/update_top_ranking_issues/uv.lock      | 399 +++++++++++++
 5 files changed, 420 insertions(+), 555 deletions(-)
 create mode 100644 script/update_top_ranking_issues/.python-version
 delete mode 100644 script/update_top_ranking_issues/poetry.lock
 create mode 100644 script/update_top_ranking_issues/uv.lock

diff --git a/.github/workflows/update_all_top_ranking_issues.yml b/.github/workflows/update_all_top_ranking_issues.yml
index 8ce5a3ad1c3a3a..8cc0c39fc80256 100644
--- a/.github/workflows/update_all_top_ranking_issues.yml
+++ b/.github/workflows/update_all_top_ranking_issues.yml
@@ -9,10 +9,15 @@ jobs:
     if: github.repository_owner == 'zed-industries'
     steps:
       - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
-      - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3 # v5
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v3
         with:
-          python-version: "3.11"
-          architecture: "x64"
-          cache: "pip"
-      - run: pip install -r script/update_top_ranking_issues/requirements.txt
-      - run: python script/update_top_ranking_issues/main.py --github-token ${{ secrets.GITHUB_TOKEN }} --issue-reference-number 5393
+          version: "latest"
+          enable-cache: true
+          cache-dependency-glob: "script/update_top_ranking_issues/pyproject.toml"
+      - name: Install Python 3.12
+        run: uv python install 3.12
+      - name: Install dependencies
+        run: uv sync --project script/update_top_ranking_issues -p 3.12
+      - name: Run script
+        run: uv run --project script/update_top_ranking_issues script/update_top_ranking_issues/main.py --github-token ${{ secrets.GITHUB_TOKEN }} --issue-reference-number 5393
diff --git a/script/update_top_ranking_issues/.python-version b/script/update_top_ranking_issues/.python-version
new file mode 100644
index 00000000000000..e4fba218358722
--- /dev/null
+++ b/script/update_top_ranking_issues/.python-version
@@ -0,0 +1 @@
+3.12
diff --git a/script/update_top_ranking_issues/poetry.lock b/script/update_top_ranking_issues/poetry.lock
deleted file mode 100644
index c151c8bc1ddd74..00000000000000
--- a/script/update_top_ranking_issues/poetry.lock
+++ /dev/null
@@ -1,533 +0,0 @@
-# This file is automatically @generated by Poetry 1.6.1 and should not be changed by hand.
-
-[[package]]
-name = "certifi"
-version = "2023.11.17"
-description = "Python package for providing Mozilla's CA Bundle."
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "certifi-2023.11.17-py3-none-any.whl", hash = "sha256:e036ab49d5b79556f99cfc2d9320b34cfbe5be05c5871b51de9329f0603b0474"},
-    {file = "certifi-2023.11.17.tar.gz", hash = "sha256:9b469f3a900bf28dc19b8cfbf8019bf47f7fdd1a65a1d4ffb98fc14166beb4d1"},
-]
-
-[[package]]
-name = "cffi"
-version = "1.16.0"
-description = "Foreign Function Interface for Python calling C code."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"},
-    {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"},
-    {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"},
-    {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"},
-    {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"},
-    {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"},
-    {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"},
-    {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"},
-    {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"},
-    {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"},
-    {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"},
-    {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"},
-    {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"},
-    {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"},
-    {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"},
-    {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"},
-    {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"},
-    {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"},
-    {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"},
-    {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"},
-    {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"},
-    {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"},
-    {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"},
-    {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"},
-    {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"},
-    {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"},
-    {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"},
-    {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"},
-    {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"},
-    {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"},
-    {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"},
-    {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"},
-    {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"},
-    {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"},
-    {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"},
-    {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"},
-    {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"},
-    {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"},
-    {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"},
-    {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"},
-    {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"},
-    {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"},
-    {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"},
-    {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"},
-    {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"},
-    {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"},
-    {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"},
-    {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"},
-    {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"},
-    {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"},
-    {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"},
-    {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"},
-]
-
-[package.dependencies]
-pycparser = "*"
-
-[[package]]
-name = "charset-normalizer"
-version = "3.3.2"
-description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
-optional = false
-python-versions = ">=3.7.0"
-files = [
-    {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"},
-    {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"},
-]
-
-[[package]]
-name = "click"
-version = "8.1.7"
-description = "Composable command line interface toolkit"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"},
-    {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"},
-]
-
-[package.dependencies]
-colorama = {version = "*", markers = "platform_system == \"Windows\""}
-
-[[package]]
-name = "colorama"
-version = "0.4.6"
-description = "Cross-platform colored terminal text."
-optional = false
-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
-files = [
-    {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
-    {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
-]
-
-[[package]]
-name = "deprecated"
-version = "1.2.14"
-description = "Python @deprecated decorator to deprecate old python classes, functions or methods."
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
-files = [
-    {file = "Deprecated-1.2.14-py2.py3-none-any.whl", hash = "sha256:6fac8b097794a90302bdbb17b9b815e732d3c4720583ff1b198499d78470466c"},
-    {file = "Deprecated-1.2.14.tar.gz", hash = "sha256:e5323eb936458dccc2582dc6f9c322c852a775a27065ff2b0c4970b9d53d01b3"},
-]
-
-[package.dependencies]
-wrapt = ">=1.10,<2"
-
-[package.extras]
-dev = ["PyTest", "PyTest-Cov", "bump2version (<1)", "sphinx (<2)", "tox"]
-
-[[package]]
-name = "idna"
-version = "3.6"
-description = "Internationalized Domain Names in Applications (IDNA)"
-optional = false
-python-versions = ">=3.5"
-files = [
-    {file = "idna-3.6-py3-none-any.whl", hash = "sha256:c05567e9c24a6b9faaa835c4821bad0590fbb9d5779e7caa6e1cc4978e7eb24f"},
-    {file = "idna-3.6.tar.gz", hash = "sha256:9ecdbbd083b06798ae1e86adcbfe8ab1479cf864e4ee30fe4e46a003d12491ca"},
-]
-
-[[package]]
-name = "mypy"
-version = "1.6.0"
-description = "Optional static typing for Python"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "mypy-1.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:091f53ff88cb093dcc33c29eee522c087a438df65eb92acd371161c1f4380ff0"},
-    {file = "mypy-1.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:eb7ff4007865833c470a601498ba30462b7374342580e2346bf7884557e40531"},
-    {file = "mypy-1.6.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49499cf1e464f533fc45be54d20a6351a312f96ae7892d8e9f1708140e27ce41"},
-    {file = "mypy-1.6.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4c192445899c69f07874dabda7e931b0cc811ea055bf82c1ababf358b9b2a72c"},
-    {file = "mypy-1.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:3df87094028e52766b0a59a3e46481bb98b27986ed6ded6a6cc35ecc75bb9182"},
-    {file = "mypy-1.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c8835a07b8442da900db47ccfda76c92c69c3a575872a5b764332c4bacb5a0a"},
-    {file = "mypy-1.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:24f3de8b9e7021cd794ad9dfbf2e9fe3f069ff5e28cb57af6f873ffec1cb0425"},
-    {file = "mypy-1.6.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:856bad61ebc7d21dbc019b719e98303dc6256cec6dcc9ebb0b214b81d6901bd8"},
-    {file = "mypy-1.6.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:89513ddfda06b5c8ebd64f026d20a61ef264e89125dc82633f3c34eeb50e7d60"},
-    {file = "mypy-1.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:9f8464ed410ada641c29f5de3e6716cbdd4f460b31cf755b2af52f2d5ea79ead"},
-    {file = "mypy-1.6.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:971104bcb180e4fed0d7bd85504c9036346ab44b7416c75dd93b5c8c6bb7e28f"},
-    {file = "mypy-1.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab98b8f6fdf669711f3abe83a745f67f50e3cbaea3998b90e8608d2b459fd566"},
-    {file = "mypy-1.6.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a69db3018b87b3e6e9dd28970f983ea6c933800c9edf8c503c3135b3274d5ad"},
-    {file = "mypy-1.6.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:dccd850a2e3863891871c9e16c54c742dba5470f5120ffed8152956e9e0a5e13"},
-    {file = "mypy-1.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:f8598307150b5722854f035d2e70a1ad9cc3c72d392c34fffd8c66d888c90f17"},
-    {file = "mypy-1.6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:fea451a3125bf0bfe716e5d7ad4b92033c471e4b5b3e154c67525539d14dc15a"},
-    {file = "mypy-1.6.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:e28d7b221898c401494f3b77db3bac78a03ad0a0fff29a950317d87885c655d2"},
-    {file = "mypy-1.6.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4b7a99275a61aa22256bab5839c35fe8a6887781862471df82afb4b445daae6"},
-    {file = "mypy-1.6.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:7469545380dddce5719e3656b80bdfbb217cfe8dbb1438532d6abc754b828fed"},
-    {file = "mypy-1.6.0-cp38-cp38-win_amd64.whl", hash = "sha256:7807a2a61e636af9ca247ba8494031fb060a0a744b9fee7de3a54bed8a753323"},
-    {file = "mypy-1.6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d2dad072e01764823d4b2f06bc7365bb1d4b6c2f38c4d42fade3c8d45b0b4b67"},
-    {file = "mypy-1.6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b19006055dde8a5425baa5f3b57a19fa79df621606540493e5e893500148c72f"},
-    {file = "mypy-1.6.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:31eba8a7a71f0071f55227a8057468b8d2eb5bf578c8502c7f01abaec8141b2f"},
-    {file = "mypy-1.6.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8e0db37ac4ebb2fee7702767dfc1b773c7365731c22787cb99f507285014fcaf"},
-    {file = "mypy-1.6.0-cp39-cp39-win_amd64.whl", hash = "sha256:c69051274762cccd13498b568ed2430f8d22baa4b179911ad0c1577d336ed849"},
-    {file = "mypy-1.6.0-py3-none-any.whl", hash = "sha256:9e1589ca150a51d9d00bb839bfeca2f7a04f32cd62fad87a847bc0818e15d7dc"},
-    {file = "mypy-1.6.0.tar.gz", hash = "sha256:4f3d27537abde1be6d5f2c96c29a454da333a2a271ae7d5bc7110e6d4b7beb3f"},
-]
-
-[package.dependencies]
-mypy-extensions = ">=1.0.0"
-typing-extensions = ">=4.1.0"
-
-[package.extras]
-dmypy = ["psutil (>=4.0)"]
-install-types = ["pip"]
-reports = ["lxml"]
-
-[[package]]
-name = "mypy-extensions"
-version = "1.0.0"
-description = "Type system extensions for programs checked with the mypy type checker."
-optional = false
-python-versions = ">=3.5"
-files = [
-    {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"},
-    {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"},
-]
-
-[[package]]
-name = "pycparser"
-version = "2.21"
-description = "C parser in Python"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
-files = [
-    {file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"},
-    {file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"},
-]
-
-[[package]]
-name = "pygithub"
-version = "1.55"
-description = "Use the full Github API v3"
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "PyGithub-1.55-py3-none-any.whl", hash = "sha256:2caf0054ea079b71e539741ae56c5a95e073b81fa472ce222e81667381b9601b"},
-    {file = "PyGithub-1.55.tar.gz", hash = "sha256:1bbfff9372047ff3f21d5cd8e07720f3dbfdaf6462fcaed9d815f528f1ba7283"},
-]
-
-[package.dependencies]
-deprecated = "*"
-pyjwt = ">=2.0"
-pynacl = ">=1.4.0"
-requests = ">=2.14.0"
-
-[package.extras]
-integrations = ["cryptography"]
-
-[[package]]
-name = "pyjwt"
-version = "2.8.0"
-description = "JSON Web Token implementation in Python"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "PyJWT-2.8.0-py3-none-any.whl", hash = "sha256:59127c392cc44c2da5bb3192169a91f429924e17aff6534d70fdc02ab3e04320"},
-    {file = "PyJWT-2.8.0.tar.gz", hash = "sha256:57e28d156e3d5c10088e0c68abb90bfac3df82b40a71bd0daa20c65ccd5c23de"},
-]
-
-[package.extras]
-crypto = ["cryptography (>=3.4.0)"]
-dev = ["coverage[toml] (==5.0.4)", "cryptography (>=3.4.0)", "pre-commit", "pytest (>=6.0.0,<7.0.0)", "sphinx (>=4.5.0,<5.0.0)", "sphinx-rtd-theme", "zope.interface"]
-docs = ["sphinx (>=4.5.0,<5.0.0)", "sphinx-rtd-theme", "zope.interface"]
-tests = ["coverage[toml] (==5.0.4)", "pytest (>=6.0.0,<7.0.0)"]
-
-[[package]]
-name = "pynacl"
-version = "1.5.0"
-description = "Python binding to the Networking and Cryptography (NaCl) library"
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "PyNaCl-1.5.0-cp36-abi3-macosx_10_10_universal2.whl", hash = "sha256:401002a4aaa07c9414132aaed7f6836ff98f59277a234704ff66878c2ee4a0d1"},
-    {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:52cb72a79269189d4e0dc537556f4740f7f0a9ec41c1322598799b0bdad4ef92"},
-    {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a36d4a9dda1f19ce6e03c9a784a2921a4b726b02e1c736600ca9c22029474394"},
-    {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:0c84947a22519e013607c9be43706dd42513f9e6ae5d39d3613ca1e142fba44d"},
-    {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06b8f6fa7f5de8d5d2f7573fe8c863c051225a27b61e6860fd047b1775807858"},
-    {file = "PyNaCl-1.5.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:a422368fc821589c228f4c49438a368831cb5bbc0eab5ebe1d7fac9dded6567b"},
-    {file = "PyNaCl-1.5.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:61f642bf2378713e2c2e1de73444a3778e5f0a38be6fee0fe532fe30060282ff"},
-    {file = "PyNaCl-1.5.0-cp36-abi3-win32.whl", hash = "sha256:e46dae94e34b085175f8abb3b0aaa7da40767865ac82c928eeb9e57e1ea8a543"},
-    {file = "PyNaCl-1.5.0-cp36-abi3-win_amd64.whl", hash = "sha256:20f42270d27e1b6a29f54032090b972d97f0a1b0948cc52392041ef7831fee93"},
-    {file = "PyNaCl-1.5.0.tar.gz", hash = "sha256:8ac7448f09ab85811607bdd21ec2464495ac8b7c66d146bf545b0f08fb9220ba"},
-]
-
-[package.dependencies]
-cffi = ">=1.4.1"
-
-[package.extras]
-docs = ["sphinx (>=1.6.5)", "sphinx-rtd-theme"]
-tests = ["hypothesis (>=3.27.0)", "pytest (>=3.2.1,!=3.3.0)"]
-
-[[package]]
-name = "pytz"
-version = "2022.1"
-description = "World timezone definitions, modern and historical"
-optional = false
-python-versions = "*"
-files = [
-    {file = "pytz-2022.1-py2.py3-none-any.whl", hash = "sha256:e68985985296d9a66a881eb3193b0906246245294a881e7c8afe623866ac6a5c"},
-    {file = "pytz-2022.1.tar.gz", hash = "sha256:1e760e2fe6a8163bc0b3d9a19c4f84342afa0a2affebfaa84b01b978a02ecaa7"},
-]
-
-[[package]]
-name = "requests"
-version = "2.31.0"
-description = "Python HTTP for Humans."
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"},
-    {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"},
-]
-
-[package.dependencies]
-certifi = ">=2017.4.17"
-charset-normalizer = ">=2,<4"
-idna = ">=2.5,<4"
-urllib3 = ">=1.21.1,<3"
-
-[package.extras]
-socks = ["PySocks (>=1.5.6,!=1.5.7)"]
-use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
-
-[[package]]
-name = "typer"
-version = "0.9.0"
-description = "Typer, build great CLIs. Easy to code. Based on Python type hints."
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "typer-0.9.0-py3-none-any.whl", hash = "sha256:5d96d986a21493606a358cae4461bd8cdf83cbf33a5aa950ae629ca3b51467ee"},
-    {file = "typer-0.9.0.tar.gz", hash = "sha256:50922fd79aea2f4751a8e0408ff10d2662bd0c8bbfa84755a699f3bada2978b2"},
-]
-
-[package.dependencies]
-click = ">=7.1.1,<9.0.0"
-typing-extensions = ">=3.7.4.3"
-
-[package.extras]
-all = ["colorama (>=0.4.3,<0.5.0)", "rich (>=10.11.0,<14.0.0)", "shellingham (>=1.3.0,<2.0.0)"]
-dev = ["autoflake (>=1.3.1,<2.0.0)", "flake8 (>=3.8.3,<4.0.0)", "pre-commit (>=2.17.0,<3.0.0)"]
-doc = ["cairosvg (>=2.5.2,<3.0.0)", "mdx-include (>=1.4.1,<2.0.0)", "mkdocs (>=1.1.2,<2.0.0)", "mkdocs-material (>=8.1.4,<9.0.0)", "pillow (>=9.3.0,<10.0.0)"]
-test = ["black (>=22.3.0,<23.0.0)", "coverage (>=6.2,<7.0)", "isort (>=5.0.6,<6.0.0)", "mypy (==0.910)", "pytest (>=4.4.0,<8.0.0)", "pytest-cov (>=2.10.0,<5.0.0)", "pytest-sugar (>=0.9.4,<0.10.0)", "pytest-xdist (>=1.32.0,<4.0.0)", "rich (>=10.11.0,<14.0.0)", "shellingham (>=1.3.0,<2.0.0)"]
-
-[[package]]
-name = "types-pytz"
-version = "2023.3.1.1"
-description = "Typing stubs for pytz"
-optional = false
-python-versions = "*"
-files = [
-    {file = "types-pytz-2023.3.1.1.tar.gz", hash = "sha256:cc23d0192cd49c8f6bba44ee0c81e4586a8f30204970fc0894d209a6b08dab9a"},
-    {file = "types_pytz-2023.3.1.1-py3-none-any.whl", hash = "sha256:1999a123a3dc0e39a2ef6d19f3f8584211de9e6a77fe7a0259f04a524e90a5cf"},
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.9.0"
-description = "Backported and Experimental Type Hints for Python 3.8+"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "typing_extensions-4.9.0-py3-none-any.whl", hash = "sha256:af72aea155e91adfc61c3ae9e0e342dbc0cba726d6cba4b6c72c1f34e47291cd"},
-    {file = "typing_extensions-4.9.0.tar.gz", hash = "sha256:23478f88c37f27d76ac8aee6c905017a143b0b1b886c3c9f66bc2fd94f9f5783"},
-]
-
-[[package]]
-name = "urllib3"
-version = "2.1.0"
-description = "HTTP library with thread-safe connection pooling, file post, and more."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "urllib3-2.1.0-py3-none-any.whl", hash = "sha256:55901e917a5896a349ff771be919f8bd99aff50b79fe58fec595eb37bbc56bb3"},
-    {file = "urllib3-2.1.0.tar.gz", hash = "sha256:df7aa8afb0148fa78488e7899b2c59b5f4ffcfa82e6c54ccb9dd37c1d7b52d54"},
-]
-
-[package.extras]
-brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"]
-socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
-zstd = ["zstandard (>=0.18.0)"]
-
-[[package]]
-name = "wrapt"
-version = "1.16.0"
-description = "Module for decorators, wrappers and monkey patching."
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "wrapt-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ffa565331890b90056c01db69c0fe634a776f8019c143a5ae265f9c6bc4bd6d4"},
-    {file = "wrapt-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e4fdb9275308292e880dcbeb12546df7f3e0f96c6b41197e0cf37d2826359020"},
-    {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb2dee3874a500de01c93d5c71415fcaef1d858370d405824783e7a8ef5db440"},
-    {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2a88e6010048489cda82b1326889ec075a8c856c2e6a256072b28eaee3ccf487"},
-    {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac83a914ebaf589b69f7d0a1277602ff494e21f4c2f743313414378f8f50a4cf"},
-    {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:73aa7d98215d39b8455f103de64391cb79dfcad601701a3aa0dddacf74911d72"},
-    {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:807cc8543a477ab7422f1120a217054f958a66ef7314f76dd9e77d3f02cdccd0"},
-    {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bf5703fdeb350e36885f2875d853ce13172ae281c56e509f4e6eca049bdfb136"},
-    {file = "wrapt-1.16.0-cp310-cp310-win32.whl", hash = "sha256:f6b2d0c6703c988d334f297aa5df18c45e97b0af3679bb75059e0e0bd8b1069d"},
-    {file = "wrapt-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:decbfa2f618fa8ed81c95ee18a387ff973143c656ef800c9f24fb7e9c16054e2"},
-    {file = "wrapt-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1a5db485fe2de4403f13fafdc231b0dbae5eca4359232d2efc79025527375b09"},
-    {file = "wrapt-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:75ea7d0ee2a15733684badb16de6794894ed9c55aa5e9903260922f0482e687d"},
-    {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a452f9ca3e3267cd4d0fcf2edd0d035b1934ac2bd7e0e57ac91ad6b95c0c6389"},
-    {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:43aa59eadec7890d9958748db829df269f0368521ba6dc68cc172d5d03ed8060"},
-    {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:72554a23c78a8e7aa02abbd699d129eead8b147a23c56e08d08dfc29cfdddca1"},
-    {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d2efee35b4b0a347e0d99d28e884dfd82797852d62fcd7ebdeee26f3ceb72cf3"},
-    {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:6dcfcffe73710be01d90cae08c3e548d90932d37b39ef83969ae135d36ef3956"},
-    {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:eb6e651000a19c96f452c85132811d25e9264d836951022d6e81df2fff38337d"},
-    {file = "wrapt-1.16.0-cp311-cp311-win32.whl", hash = "sha256:66027d667efe95cc4fa945af59f92c5a02c6f5bb6012bff9e60542c74c75c362"},
-    {file = "wrapt-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:aefbc4cb0a54f91af643660a0a150ce2c090d3652cf4052a5397fb2de549cd89"},
-    {file = "wrapt-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5eb404d89131ec9b4f748fa5cfb5346802e5ee8836f57d516576e61f304f3b7b"},
-    {file = "wrapt-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9090c9e676d5236a6948330e83cb89969f433b1943a558968f659ead07cb3b36"},
-    {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94265b00870aa407bd0cbcfd536f17ecde43b94fb8d228560a1e9d3041462d73"},
-    {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2058f813d4f2b5e3a9eb2eb3faf8f1d99b81c3e51aeda4b168406443e8ba809"},
-    {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98b5e1f498a8ca1858a1cdbffb023bfd954da4e3fa2c0cb5853d40014557248b"},
-    {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:14d7dc606219cdd7405133c713f2c218d4252f2a469003f8c46bb92d5d095d81"},
-    {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:49aac49dc4782cb04f58986e81ea0b4768e4ff197b57324dcbd7699c5dfb40b9"},
-    {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:418abb18146475c310d7a6dc71143d6f7adec5b004ac9ce08dc7a34e2babdc5c"},
-    {file = "wrapt-1.16.0-cp312-cp312-win32.whl", hash = "sha256:685f568fa5e627e93f3b52fda002c7ed2fa1800b50ce51f6ed1d572d8ab3e7fc"},
-    {file = "wrapt-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:dcdba5c86e368442528f7060039eda390cc4091bfd1dca41e8046af7c910dda8"},
-    {file = "wrapt-1.16.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:d462f28826f4657968ae51d2181a074dfe03c200d6131690b7d65d55b0f360f8"},
-    {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a33a747400b94b6d6b8a165e4480264a64a78c8a4c734b62136062e9a248dd39"},
-    {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3646eefa23daeba62643a58aac816945cadc0afaf21800a1421eeba5f6cfb9c"},
-    {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ebf019be5c09d400cf7b024aa52b1f3aeebeff51550d007e92c3c1c4afc2a40"},
-    {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:0d2691979e93d06a95a26257adb7bfd0c93818e89b1406f5a28f36e0d8c1e1fc"},
-    {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:1acd723ee2a8826f3d53910255643e33673e1d11db84ce5880675954183ec47e"},
-    {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:bc57efac2da352a51cc4658878a68d2b1b67dbe9d33c36cb826ca449d80a8465"},
-    {file = "wrapt-1.16.0-cp36-cp36m-win32.whl", hash = "sha256:da4813f751142436b075ed7aa012a8778aa43a99f7b36afe9b742d3ed8bdc95e"},
-    {file = "wrapt-1.16.0-cp36-cp36m-win_amd64.whl", hash = "sha256:6f6eac2360f2d543cc875a0e5efd413b6cbd483cb3ad7ebf888884a6e0d2e966"},
-    {file = "wrapt-1.16.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a0ea261ce52b5952bf669684a251a66df239ec6d441ccb59ec7afa882265d593"},
-    {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7bd2d7ff69a2cac767fbf7a2b206add2e9a210e57947dd7ce03e25d03d2de292"},
-    {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9159485323798c8dc530a224bd3ffcf76659319ccc7bbd52e01e73bd0241a0c5"},
-    {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a86373cf37cd7764f2201b76496aba58a52e76dedfaa698ef9e9688bfd9e41cf"},
-    {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:73870c364c11f03ed072dda68ff7aea6d2a3a5c3fe250d917a429c7432e15228"},
-    {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:b935ae30c6e7400022b50f8d359c03ed233d45b725cfdd299462f41ee5ffba6f"},
-    {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:db98ad84a55eb09b3c32a96c576476777e87c520a34e2519d3e59c44710c002c"},
-    {file = "wrapt-1.16.0-cp37-cp37m-win32.whl", hash = "sha256:9153ed35fc5e4fa3b2fe97bddaa7cbec0ed22412b85bcdaf54aeba92ea37428c"},
-    {file = "wrapt-1.16.0-cp37-cp37m-win_amd64.whl", hash = "sha256:66dfbaa7cfa3eb707bbfcd46dab2bc6207b005cbc9caa2199bcbc81d95071a00"},
-    {file = "wrapt-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1dd50a2696ff89f57bd8847647a1c363b687d3d796dc30d4dd4a9d1689a706f0"},
-    {file = "wrapt-1.16.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:44a2754372e32ab315734c6c73b24351d06e77ffff6ae27d2ecf14cf3d229202"},
-    {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e9723528b9f787dc59168369e42ae1c3b0d3fadb2f1a71de14531d321ee05b0"},
-    {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dbed418ba5c3dce92619656802cc5355cb679e58d0d89b50f116e4a9d5a9603e"},
-    {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:941988b89b4fd6b41c3f0bfb20e92bd23746579736b7343283297c4c8cbae68f"},
-    {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6a42cd0cfa8ffc1915aef79cb4284f6383d8a3e9dcca70c445dcfdd639d51267"},
-    {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:1ca9b6085e4f866bd584fb135a041bfc32cab916e69f714a7d1d397f8c4891ca"},
-    {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d5e49454f19ef621089e204f862388d29e6e8d8b162efce05208913dde5b9ad6"},
-    {file = "wrapt-1.16.0-cp38-cp38-win32.whl", hash = "sha256:c31f72b1b6624c9d863fc095da460802f43a7c6868c5dda140f51da24fd47d7b"},
-    {file = "wrapt-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:490b0ee15c1a55be9c1bd8609b8cecd60e325f0575fc98f50058eae366e01f41"},
-    {file = "wrapt-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9b201ae332c3637a42f02d1045e1d0cccfdc41f1f2f801dafbaa7e9b4797bfc2"},
-    {file = "wrapt-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2076fad65c6736184e77d7d4729b63a6d1ae0b70da4868adeec40989858eb3fb"},
-    {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5cd603b575ebceca7da5a3a251e69561bec509e0b46e4993e1cac402b7247b8"},
-    {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b47cfad9e9bbbed2339081f4e346c93ecd7ab504299403320bf85f7f85c7d46c"},
-    {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8212564d49c50eb4565e502814f694e240c55551a5f1bc841d4fcaabb0a9b8a"},
-    {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:5f15814a33e42b04e3de432e573aa557f9f0f56458745c2074952f564c50e664"},
-    {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:db2e408d983b0e61e238cf579c09ef7020560441906ca990fe8412153e3b291f"},
-    {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:edfad1d29c73f9b863ebe7082ae9321374ccb10879eeabc84ba3b69f2579d537"},
-    {file = "wrapt-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed867c42c268f876097248e05b6117a65bcd1e63b779e916fe2e33cd6fd0d3c3"},
-    {file = "wrapt-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:eb1b046be06b0fce7249f1d025cd359b4b80fc1c3e24ad9eca33e0dcdb2e4a35"},
-    {file = "wrapt-1.16.0-py3-none-any.whl", hash = "sha256:6906c4100a8fcbf2fa735f6059214bb13b97f75b1a61777fcf6432121ef12ef1"},
-    {file = "wrapt-1.16.0.tar.gz", hash = "sha256:5f370f952971e7d17c7d1ead40e49f32345a7f7a5373571ef44d800d06b1899d"},
-]
-
-[metadata]
-lock-version = "2.0"
-python-versions = "3.12.7"
-content-hash = "809bd421af8a34dd500ba704d954ae8e1f6edf15b6af74a0d3fda987b69c8cbe"
diff --git a/script/update_top_ranking_issues/pyproject.toml b/script/update_top_ranking_issues/pyproject.toml
index cd5cd2cc2ed270..49ce0568e1d404 100644
--- a/script/update_top_ranking_issues/pyproject.toml
+++ b/script/update_top_ranking_issues/pyproject.toml
@@ -1,19 +1,12 @@
-[tool.poetry]
+[project]
 name = "update-top-ranking-issues"
 version = "0.1.0"
-description = ""
-authors = ["Joseph T. Lyons <JosephTLyons@gmail.com>"]
 readme = "README.md"
-
-[tool.poetry.dependencies]
-mypy = "1.6.0"
-PyGithub = "1.55"
-python = "3.12.7"
-pytz = "2022.1"
-typer = "0.9.0"
-types-pytz = "2023.3.1.1"
-
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
+requires-python = ">=3.12"
+dependencies = [
+    "mypy>=1.11.2",
+    "pygithub>=2.4.0",
+    "pytz>=2024.2",
+    "typer>=0.12.5",
+    "types-pytz>=2024.2.0.20241003",
+]
diff --git a/script/update_top_ranking_issues/uv.lock b/script/update_top_ranking_issues/uv.lock
new file mode 100644
index 00000000000000..47fdf5f32c226f
--- /dev/null
+++ b/script/update_top_ranking_issues/uv.lock
@@ -0,0 +1,399 @@
+version = 1
+requires-python = ">=3.12"
+
+[[package]]
+name = "certifi"
+version = "2024.8.30"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/ee/9b19140fe824b367c04c5e1b369942dd754c4c5462d5674002f75c4dedc1/certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9", size = 168507 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", size = 167321 },
+]
+
+[[package]]
+name = "cffi"
+version = "1.17.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 },
+    { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 },
+    { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 },
+    { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 },
+    { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 },
+    { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 },
+    { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 },
+    { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 },
+    { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 },
+    { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 },
+    { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 },
+    { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 },
+    { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 },
+    { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893 },
+    { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810 },
+    { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200 },
+    { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447 },
+    { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358 },
+    { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 },
+    { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 },
+    { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", size = 106620 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d3/0b/4b7a70987abf9b8196845806198975b6aab4ce016632f817ad758a5aa056/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6", size = 194445 },
+    { url = "https://files.pythonhosted.org/packages/50/89/354cc56cf4dd2449715bc9a0f54f3aef3dc700d2d62d1fa5bbea53b13426/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf", size = 125275 },
+    { url = "https://files.pythonhosted.org/packages/fa/44/b730e2a2580110ced837ac083d8ad222343c96bb6b66e9e4e706e4d0b6df/charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db", size = 119020 },
+    { url = "https://files.pythonhosted.org/packages/9d/e4/9263b8240ed9472a2ae7ddc3e516e71ef46617fe40eaa51221ccd4ad9a27/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1", size = 139128 },
+    { url = "https://files.pythonhosted.org/packages/6b/e3/9f73e779315a54334240353eaea75854a9a690f3f580e4bd85d977cb2204/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03", size = 149277 },
+    { url = "https://files.pythonhosted.org/packages/1a/cf/f1f50c2f295312edb8a548d3fa56a5c923b146cd3f24114d5adb7e7be558/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284", size = 142174 },
+    { url = "https://files.pythonhosted.org/packages/16/92/92a76dc2ff3a12e69ba94e7e05168d37d0345fa08c87e1fe24d0c2a42223/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15", size = 143838 },
+    { url = "https://files.pythonhosted.org/packages/a4/01/2117ff2b1dfc61695daf2babe4a874bca328489afa85952440b59819e9d7/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8", size = 146149 },
+    { url = "https://files.pythonhosted.org/packages/f6/9b/93a332b8d25b347f6839ca0a61b7f0287b0930216994e8bf67a75d050255/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2", size = 140043 },
+    { url = "https://files.pythonhosted.org/packages/ab/f6/7ac4a01adcdecbc7a7587767c776d53d369b8b971382b91211489535acf0/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719", size = 148229 },
+    { url = "https://files.pythonhosted.org/packages/9d/be/5708ad18161dee7dc6a0f7e6cf3a88ea6279c3e8484844c0590e50e803ef/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631", size = 151556 },
+    { url = "https://files.pythonhosted.org/packages/5a/bb/3d8bc22bacb9eb89785e83e6723f9888265f3a0de3b9ce724d66bd49884e/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b", size = 149772 },
+    { url = "https://files.pythonhosted.org/packages/f7/fa/d3fc622de05a86f30beea5fc4e9ac46aead4731e73fd9055496732bcc0a4/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565", size = 144800 },
+    { url = "https://files.pythonhosted.org/packages/9a/65/bdb9bc496d7d190d725e96816e20e2ae3a6fa42a5cac99c3c3d6ff884118/charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7", size = 94836 },
+    { url = "https://files.pythonhosted.org/packages/3e/67/7b72b69d25b89c0b3cea583ee372c43aa24df15f0e0f8d3982c57804984b/charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9", size = 102187 },
+    { url = "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", size = 194617 },
+    { url = "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", size = 125310 },
+    { url = "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", size = 119126 },
+    { url = "https://files.pythonhosted.org/packages/ff/6e/e445afe4f7fda27a533f3234b627b3e515a1b9429bc981c9a5e2aa5d97b6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920", size = 139342 },
+    { url = "https://files.pythonhosted.org/packages/a1/b2/4af9993b532d93270538ad4926c8e37dc29f2111c36f9c629840c57cd9b3/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64", size = 149383 },
+    { url = "https://files.pythonhosted.org/packages/fb/6f/4e78c3b97686b871db9be6f31d64e9264e889f8c9d7ab33c771f847f79b7/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23", size = 142214 },
+    { url = "https://files.pythonhosted.org/packages/2b/c9/1c8fe3ce05d30c87eff498592c89015b19fade13df42850aafae09e94f35/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc", size = 144104 },
+    { url = "https://files.pythonhosted.org/packages/ee/68/efad5dcb306bf37db7db338338e7bb8ebd8cf38ee5bbd5ceaaaa46f257e6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d", size = 146255 },
+    { url = "https://files.pythonhosted.org/packages/0c/75/1ed813c3ffd200b1f3e71121c95da3f79e6d2a96120163443b3ad1057505/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88", size = 140251 },
+    { url = "https://files.pythonhosted.org/packages/7d/0d/6f32255c1979653b448d3c709583557a4d24ff97ac4f3a5be156b2e6a210/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90", size = 148474 },
+    { url = "https://files.pythonhosted.org/packages/ac/a0/c1b5298de4670d997101fef95b97ac440e8c8d8b4efa5a4d1ef44af82f0d/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b", size = 151849 },
+    { url = "https://files.pythonhosted.org/packages/04/4f/b3961ba0c664989ba63e30595a3ed0875d6790ff26671e2aae2fdc28a399/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d", size = 149781 },
+    { url = "https://files.pythonhosted.org/packages/d8/90/6af4cd042066a4adad58ae25648a12c09c879efa4849c705719ba1b23d8c/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482", size = 144970 },
+    { url = "https://files.pythonhosted.org/packages/cc/67/e5e7e0cbfefc4ca79025238b43cdf8a2037854195b37d6417f3d0895c4c2/charset_normalizer-3.4.0-cp313-cp313-win32.whl", hash = "sha256:f19c1585933c82098c2a520f8ec1227f20e339e33aca8fa6f956f6691b784e67", size = 94973 },
+    { url = "https://files.pythonhosted.org/packages/65/97/fc9bbc54ee13d33dc54a7fcf17b26368b18505500fc01e228c27b5222d80/charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b", size = 102308 },
+    { url = "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", size = 49446 },
+]
+
+[[package]]
+name = "click"
+version = "8.1.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "platform_system == 'Windows'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/d3/f04c7bfcf5c1862a2a5b845c6b2b360488cf47af55dfa79c98f6a6bf98b5/click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de", size = 336121 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28", size = 97941 },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
+]
+
+[[package]]
+name = "cryptography"
+version = "43.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/ba/0664727028b37e249e73879348cc46d45c5c1a2a2e81e8166462953c5755/cryptography-43.0.1.tar.gz", hash = "sha256:203e92a75716d8cfb491dc47c79e17d0d9207ccffcbcb35f598fbe463ae3444d", size = 686927 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/28/b92c98a04ba762f8cdeb54eba5c4c84e63cac037a7c5e70117d337b15ad6/cryptography-43.0.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:8385d98f6a3bf8bb2d65a73e17ed87a3ba84f6991c155691c51112075f9ffc5d", size = 6223222 },
+    { url = "https://files.pythonhosted.org/packages/33/13/1193774705783ba364121aa2a60132fa31a668b8ababd5edfa1662354ccd/cryptography-43.0.1-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27e613d7077ac613e399270253259d9d53872aaf657471473ebfc9a52935c062", size = 3794751 },
+    { url = "https://files.pythonhosted.org/packages/5e/4b/39bb3c4c8cfb3e94e736b8d8859ce5c81536e91a1033b1d26770c4249000/cryptography-43.0.1-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68aaecc4178e90719e95298515979814bda0cbada1256a4485414860bd7ab962", size = 3981827 },
+    { url = "https://files.pythonhosted.org/packages/ce/dc/1471d4d56608e1013237af334b8a4c35d53895694fbb73882d1c4fd3f55e/cryptography-43.0.1-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:de41fd81a41e53267cb020bb3a7212861da53a7d39f863585d13ea11049cf277", size = 3780034 },
+    { url = "https://files.pythonhosted.org/packages/ad/43/7a9920135b0d5437cc2f8f529fa757431eb6a7736ddfadfdee1cc5890800/cryptography-43.0.1-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f98bf604c82c416bc829e490c700ca1553eafdf2912a91e23a79d97d9801372a", size = 3993407 },
+    { url = "https://files.pythonhosted.org/packages/cc/42/9ab8467af6c0b76f3d9b8f01d1cf25b9c9f3f2151f4acfab888d21c55a72/cryptography-43.0.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:61ec41068b7b74268fa86e3e9e12b9f0c21fcf65434571dbb13d954bceb08042", size = 3886457 },
+    { url = "https://files.pythonhosted.org/packages/a4/65/430509e31700286ec02868a2457d2111d03ccefc20349d24e58d171ae0a7/cryptography-43.0.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:014f58110f53237ace6a408b5beb6c427b64e084eb451ef25a28308270086494", size = 4081499 },
+    { url = "https://files.pythonhosted.org/packages/bb/18/a04b6467e6e09df8c73b91dcee8878f4a438a43a3603dc3cd6f8003b92d8/cryptography-43.0.1-cp37-abi3-win32.whl", hash = "sha256:2bd51274dcd59f09dd952afb696bf9c61a7a49dfc764c04dd33ef7a6b502a1e2", size = 2616504 },
+    { url = "https://files.pythonhosted.org/packages/cc/73/0eacbdc437202edcbdc07f3576ed8fb8b0ab79d27bf2c5d822d758a72faa/cryptography-43.0.1-cp37-abi3-win_amd64.whl", hash = "sha256:666ae11966643886c2987b3b721899d250855718d6d9ce41b521252a17985f4d", size = 3067456 },
+    { url = "https://files.pythonhosted.org/packages/8a/b6/bc54b371f02cffd35ff8dc6baba88304d7cf8e83632566b4b42e00383e03/cryptography-43.0.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:ac119bb76b9faa00f48128b7f5679e1d8d437365c5d26f1c2c3f0da4ce1b553d", size = 6225263 },
+    { url = "https://files.pythonhosted.org/packages/00/0e/8217e348a1fa417ec4c78cd3cdf24154f5e76fd7597343a35bd403650dfd/cryptography-43.0.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1bbcce1a551e262dfbafb6e6252f1ae36a248e615ca44ba302df077a846a8806", size = 3794368 },
+    { url = "https://files.pythonhosted.org/packages/3d/ed/38b6be7254d8f7251fde8054af597ee8afa14f911da67a9410a45f602fc3/cryptography-43.0.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58d4e9129985185a06d849aa6df265bdd5a74ca6e1b736a77959b498e0505b85", size = 3981750 },
+    { url = "https://files.pythonhosted.org/packages/64/f3/b7946c3887cf7436f002f4cbb1e6aec77b8d299b86be48eeadfefb937c4b/cryptography-43.0.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d03a475165f3134f773d1388aeb19c2d25ba88b6a9733c5c590b9ff7bbfa2e0c", size = 3778925 },
+    { url = "https://files.pythonhosted.org/packages/ac/7e/ebda4dd4ae098a0990753efbb4b50954f1d03003846b943ea85070782da7/cryptography-43.0.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:511f4273808ab590912a93ddb4e3914dfd8a388fed883361b02dea3791f292e1", size = 3993152 },
+    { url = "https://files.pythonhosted.org/packages/43/f6/feebbd78a3e341e3913846a3bb2c29d0b09b1b3af1573c6baabc2533e147/cryptography-43.0.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:80eda8b3e173f0f247f711eef62be51b599b5d425c429b5d4ca6a05e9e856baa", size = 3886392 },
+    { url = "https://files.pythonhosted.org/packages/bd/4c/ab0b9407d5247576290b4fd8abd06b7f51bd414f04eef0f2800675512d61/cryptography-43.0.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:38926c50cff6f533f8a2dae3d7f19541432610d114a70808f0926d5aaa7121e4", size = 4082606 },
+    { url = "https://files.pythonhosted.org/packages/05/36/e532a671998d6fcfdb9122da16434347a58a6bae9465e527e450e0bc60a5/cryptography-43.0.1-cp39-abi3-win32.whl", hash = "sha256:a575913fb06e05e6b4b814d7f7468c2c660e8bb16d8d5a1faf9b33ccc569dd47", size = 2617948 },
+    { url = "https://files.pythonhosted.org/packages/b3/c6/c09cee6968add5ff868525c3815e5dccc0e3c6e89eec58dc9135d3c40e88/cryptography-43.0.1-cp39-abi3-win_amd64.whl", hash = "sha256:d75601ad10b059ec832e78823b348bfa1a59f6b8d545db3a24fd44362a1564cb", size = 3070445 },
+]
+
+[[package]]
+name = "deprecated"
+version = "1.2.14"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/92/14/1e41f504a246fc224d2ac264c227975427a85caf37c3979979edb9b1b232/Deprecated-1.2.14.tar.gz", hash = "sha256:e5323eb936458dccc2582dc6f9c322c852a775a27065ff2b0c4970b9d53d01b3", size = 2974416 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/8d/778b7d51b981a96554f29136cd59ca7880bf58094338085bcf2a979a0e6a/Deprecated-1.2.14-py2.py3-none-any.whl", hash = "sha256:6fac8b097794a90302bdbb17b9b815e732d3c4720583ff1b198499d78470466c", size = 9561 },
+]
+
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 },
+]
+
+[[package]]
+name = "mypy"
+version = "1.11.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mypy-extensions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5c/86/5d7cbc4974fd564550b80fbb8103c05501ea11aa7835edf3351d90095896/mypy-1.11.2.tar.gz", hash = "sha256:7f9993ad3e0ffdc95c2a14b66dee63729f021968bff8ad911867579c65d13a79", size = 3078806 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/35/3a/ed7b12ecc3f6db2f664ccf85cb2e004d3e90bec928e9d7be6aa2f16b7cdf/mypy-1.11.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:e8960dbbbf36906c5c0b7f4fbf2f0c7ffb20f4898e6a879fcf56a41a08b0d318", size = 10990335 },
+    { url = "https://files.pythonhosted.org/packages/04/e4/1a9051e2ef10296d206519f1df13d2cc896aea39e8683302f89bf5792a59/mypy-1.11.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:06d26c277962f3fb50e13044674aa10553981ae514288cb7d0a738f495550b36", size = 10007119 },
+    { url = "https://files.pythonhosted.org/packages/f3/3c/350a9da895f8a7e87ade0028b962be0252d152e0c2fbaafa6f0658b4d0d4/mypy-1.11.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6e7184632d89d677973a14d00ae4d03214c8bc301ceefcdaf5c474866814c987", size = 12506856 },
+    { url = "https://files.pythonhosted.org/packages/b6/49/ee5adf6a49ff13f4202d949544d3d08abb0ea1f3e7f2a6d5b4c10ba0360a/mypy-1.11.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3a66169b92452f72117e2da3a576087025449018afc2d8e9bfe5ffab865709ca", size = 12952066 },
+    { url = "https://files.pythonhosted.org/packages/27/c0/b19d709a42b24004d720db37446a42abadf844d5c46a2c442e2a074d70d9/mypy-1.11.2-cp312-cp312-win_amd64.whl", hash = "sha256:969ea3ef09617aff826885a22ece0ddef69d95852cdad2f60c8bb06bf1f71f70", size = 9664000 },
+    { url = "https://files.pythonhosted.org/packages/42/3a/bdf730640ac523229dd6578e8a581795720a9321399de494374afc437ec5/mypy-1.11.2-py3-none-any.whl", hash = "sha256:b499bc07dbdcd3de92b0a8b29fdf592c111276f6a12fe29c30f6c417dd546d12", size = 2619625 },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 },
+]
+
+[[package]]
+name = "pycparser"
+version = "2.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 },
+]
+
+[[package]]
+name = "pygithub"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "deprecated" },
+    { name = "pyjwt", extra = ["crypto"] },
+    { name = "pynacl" },
+    { name = "requests" },
+    { name = "typing-extensions" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f1/a0/1e8b8ca88df9857836f5bf8e3ee15dfb810d19814ef700b12f99ce11f691/pygithub-2.4.0.tar.gz", hash = "sha256:6601e22627e87bac192f1e2e39c6e6f69a43152cfb8f307cee575879320b3051", size = 3476673 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/f3/e185613c411757c0c18b904ea2db173f2872397eddf444a3fe8cdde47077/PyGithub-2.4.0-py3-none-any.whl", hash = "sha256:81935aa4bdc939fba98fee1cb47422c09157c56a27966476ff92775602b9ee24", size = 362599 },
+]
+
+[[package]]
+name = "pygments"
+version = "2.18.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/62/8336eff65bcbc8e4cb5d05b55faf041285951b6e80f33e2bff2024788f31/pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199", size = 4891905 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/3f/01c8b82017c199075f8f788d0d906b9ffbbc5a47dc9918a945e13d5a2bda/pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a", size = 1205513 },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fb/68/ce067f09fca4abeca8771fe667d89cc347d1e99da3e093112ac329c6020e/pyjwt-2.9.0.tar.gz", hash = "sha256:7e1e5b56cc735432a7369cbfa0efe50fa113ebecdc04ae6922deba8b84582d0c", size = 78825 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/84/0fdf9b18ba31d69877bd39c9cd6052b47f3761e9910c15de788e519f079f/PyJWT-2.9.0-py3-none-any.whl", hash = "sha256:3b02fb0f44517787776cf48f2ae25d8e14f300e6d7545a4315cee571a415e850", size = 22344 },
+]
+
+[package.optional-dependencies]
+crypto = [
+    { name = "cryptography" },
+]
+
+[[package]]
+name = "pynacl"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a7/22/27582568be639dfe22ddb3902225f91f2f17ceff88ce80e4db396c8986da/PyNaCl-1.5.0.tar.gz", hash = "sha256:8ac7448f09ab85811607bdd21ec2464495ac8b7c66d146bf545b0f08fb9220ba", size = 3392854 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/75/0b8ede18506041c0bf23ac4d8e2971b4161cd6ce630b177d0a08eb0d8857/PyNaCl-1.5.0-cp36-abi3-macosx_10_10_universal2.whl", hash = "sha256:401002a4aaa07c9414132aaed7f6836ff98f59277a234704ff66878c2ee4a0d1", size = 349920 },
+    { url = "https://files.pythonhosted.org/packages/59/bb/fddf10acd09637327a97ef89d2a9d621328850a72f1fdc8c08bdf72e385f/PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:52cb72a79269189d4e0dc537556f4740f7f0a9ec41c1322598799b0bdad4ef92", size = 601722 },
+    { url = "https://files.pythonhosted.org/packages/5d/70/87a065c37cca41a75f2ce113a5a2c2aa7533be648b184ade58971b5f7ccc/PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a36d4a9dda1f19ce6e03c9a784a2921a4b726b02e1c736600ca9c22029474394", size = 680087 },
+    { url = "https://files.pythonhosted.org/packages/ee/87/f1bb6a595f14a327e8285b9eb54d41fef76c585a0edef0a45f6fc95de125/PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:0c84947a22519e013607c9be43706dd42513f9e6ae5d39d3613ca1e142fba44d", size = 856678 },
+    { url = "https://files.pythonhosted.org/packages/66/28/ca86676b69bf9f90e710571b67450508484388bfce09acf8a46f0b8c785f/PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06b8f6fa7f5de8d5d2f7573fe8c863c051225a27b61e6860fd047b1775807858", size = 1133660 },
+    { url = "https://files.pythonhosted.org/packages/3d/85/c262db650e86812585e2bc59e497a8f59948a005325a11bbbc9ecd3fe26b/PyNaCl-1.5.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:a422368fc821589c228f4c49438a368831cb5bbc0eab5ebe1d7fac9dded6567b", size = 663824 },
+    { url = "https://files.pythonhosted.org/packages/fd/1a/cc308a884bd299b651f1633acb978e8596c71c33ca85e9dc9fa33a5399b9/PyNaCl-1.5.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:61f642bf2378713e2c2e1de73444a3778e5f0a38be6fee0fe532fe30060282ff", size = 1117912 },
+    { url = "https://files.pythonhosted.org/packages/25/2d/b7df6ddb0c2a33afdb358f8af6ea3b8c4d1196ca45497dd37a56f0c122be/PyNaCl-1.5.0-cp36-abi3-win32.whl", hash = "sha256:e46dae94e34b085175f8abb3b0aaa7da40767865ac82c928eeb9e57e1ea8a543", size = 204624 },
+    { url = "https://files.pythonhosted.org/packages/5e/22/d3db169895faaf3e2eda892f005f433a62db2decbcfbc2f61e6517adfa87/PyNaCl-1.5.0-cp36-abi3-win_amd64.whl", hash = "sha256:20f42270d27e1b6a29f54032090b972d97f0a1b0948cc52392041ef7831fee93", size = 212141 },
+]
+
+[[package]]
+name = "pytz"
+version = "2024.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 },
+]
+
+[[package]]
+name = "rich"
+version = "13.9.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/9e/1784d15b057b0075e5136445aaea92d23955aad2c93eaede673718a40d95/rich-13.9.2.tar.gz", hash = "sha256:51a2c62057461aaf7152b4d611168f93a9fc73068f8ded2790f29fe2b5366d0c", size = 222843 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/67/91/5474b84e505a6ccc295b2d322d90ff6aa0746745717839ee0c5fb4fdcceb/rich-13.9.2-py3-none-any.whl", hash = "sha256:8c82a3d3f8dcfe9e734771313e606b39d8247bb6b826e196f4914b333b743cf1", size = 242117 },
+]
+
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755 },
+]
+
+[[package]]
+name = "typer"
+version = "0.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "rich" },
+    { name = "shellingham" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c5/58/a79003b91ac2c6890fc5d90145c662fd5771c6f11447f116b63300436bc9/typer-0.12.5.tar.gz", hash = "sha256:f592f089bedcc8ec1b974125d64851029c3b1af145f04aca64d69410f0c9b722", size = 98953 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/2b/886d13e742e514f704c33c4caa7df0f3b89e5a25ef8db02aa9ca3d9535d5/typer-0.12.5-py3-none-any.whl", hash = "sha256:62fe4e471711b147e3365034133904df3e235698399bc4de2b36c8579298d52b", size = 47288 },
+]
+
+[[package]]
+name = "types-pytz"
+version = "2024.2.0.20241003"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/d0/73aa3063a9ef9881bd7103cb4ae379bfd8fafda0e86b01b694d676313a4b/types-pytz-2024.2.0.20241003.tar.gz", hash = "sha256:575dc38f385a922a212bac00a7d6d2e16e141132a3c955078f4a4fd13ed6cb44", size = 5474 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/86/60/2a2977ce0f91255bbb668350b127a801a06ad37c326a2e5bfd52f03e0784/types_pytz-2024.2.0.20241003-py3-none-any.whl", hash = "sha256:3e22df1336c0c6ad1d29163c8fda82736909eb977281cb823c57f8bae07118b7", size = 5245 },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 },
+]
+
+[[package]]
+name = "update-top-ranking-issues"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "mypy" },
+    { name = "pygithub" },
+    { name = "pytz" },
+    { name = "typer" },
+    { name = "types-pytz" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "mypy", specifier = ">=1.11.2" },
+    { name = "pygithub", specifier = ">=2.4.0" },
+    { name = "pytz", specifier = ">=2024.2" },
+    { name = "typer", specifier = ">=0.12.5" },
+    { name = "types-pytz", specifier = ">=2024.2.0.20241003" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", size = 300677 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", size = 126338 },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/4c/063a912e20bcef7124e0df97282a8af3ff3e4b603ce84c481d6d7346be0a/wrapt-1.16.0.tar.gz", hash = "sha256:5f370f952971e7d17c7d1ead40e49f32345a7f7a5373571ef44d800d06b1899d", size = 53972 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/17/224132494c1e23521868cdd57cd1e903f3b6a7ba6996b7b8f077ff8ac7fe/wrapt-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5eb404d89131ec9b4f748fa5cfb5346802e5ee8836f57d516576e61f304f3b7b", size = 37614 },
+    { url = "https://files.pythonhosted.org/packages/6a/d7/cfcd73e8f4858079ac59d9db1ec5a1349bc486ae8e9ba55698cc1f4a1dff/wrapt-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9090c9e676d5236a6948330e83cb89969f433b1943a558968f659ead07cb3b36", size = 38316 },
+    { url = "https://files.pythonhosted.org/packages/7e/79/5ff0a5c54bda5aec75b36453d06be4f83d5cd4932cc84b7cb2b52cee23e2/wrapt-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94265b00870aa407bd0cbcfd536f17ecde43b94fb8d228560a1e9d3041462d73", size = 86322 },
+    { url = "https://files.pythonhosted.org/packages/c4/81/e799bf5d419f422d8712108837c1d9bf6ebe3cb2a81ad94413449543a923/wrapt-1.16.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2058f813d4f2b5e3a9eb2eb3faf8f1d99b81c3e51aeda4b168406443e8ba809", size = 79055 },
+    { url = "https://files.pythonhosted.org/packages/62/62/30ca2405de6a20448ee557ab2cd61ab9c5900be7cbd18a2639db595f0b98/wrapt-1.16.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98b5e1f498a8ca1858a1cdbffb023bfd954da4e3fa2c0cb5853d40014557248b", size = 87291 },
+    { url = "https://files.pythonhosted.org/packages/49/4e/5d2f6d7b57fc9956bf06e944eb00463551f7d52fc73ca35cfc4c2cdb7aed/wrapt-1.16.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:14d7dc606219cdd7405133c713f2c218d4252f2a469003f8c46bb92d5d095d81", size = 90374 },
+    { url = "https://files.pythonhosted.org/packages/a6/9b/c2c21b44ff5b9bf14a83252a8b973fb84923764ff63db3e6dfc3895cf2e0/wrapt-1.16.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:49aac49dc4782cb04f58986e81ea0b4768e4ff197b57324dcbd7699c5dfb40b9", size = 83896 },
+    { url = "https://files.pythonhosted.org/packages/14/26/93a9fa02c6f257df54d7570dfe8011995138118d11939a4ecd82cb849613/wrapt-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:418abb18146475c310d7a6dc71143d6f7adec5b004ac9ce08dc7a34e2babdc5c", size = 91738 },
+    { url = "https://files.pythonhosted.org/packages/a2/5b/4660897233eb2c8c4de3dc7cefed114c61bacb3c28327e64150dc44ee2f6/wrapt-1.16.0-cp312-cp312-win32.whl", hash = "sha256:685f568fa5e627e93f3b52fda002c7ed2fa1800b50ce51f6ed1d572d8ab3e7fc", size = 35568 },
+    { url = "https://files.pythonhosted.org/packages/5c/cc/8297f9658506b224aa4bd71906447dea6bb0ba629861a758c28f67428b91/wrapt-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:dcdba5c86e368442528f7060039eda390cc4091bfd1dca41e8046af7c910dda8", size = 37653 },
+    { url = "https://files.pythonhosted.org/packages/ff/21/abdedb4cdf6ff41ebf01a74087740a709e2edb146490e4d9beea054b0b7a/wrapt-1.16.0-py3-none-any.whl", hash = "sha256:6906c4100a8fcbf2fa735f6059214bb13b97f75b1a61777fcf6432121ef12ef1", size = 23362 },
+]

From 05b2010db553ca6651e273110afdfa4e32643cbd Mon Sep 17 00:00:00 2001
From: Joseph T Lyons <JosephTLyons@gmail.com>
Date: Wed, 9 Oct 2024 23:02:41 -0400
Subject: [PATCH 575/762] Use uv

---
 .../update_weekly_top_ranking_issues.yml        | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/update_weekly_top_ranking_issues.yml b/.github/workflows/update_weekly_top_ranking_issues.yml
index 129c58a6a9ad9d..14c15c530e42f2 100644
--- a/.github/workflows/update_weekly_top_ranking_issues.yml
+++ b/.github/workflows/update_weekly_top_ranking_issues.yml
@@ -9,10 +9,15 @@ jobs:
     if: github.repository_owner == 'zed-industries'
     steps:
       - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
-      - uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3 # v5
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v3
         with:
-          python-version: "3.11"
-          architecture: "x64"
-          cache: "pip"
-      - run: pip install -r script/update_top_ranking_issues/requirements.txt
-      - run: python script/update_top_ranking_issues/main.py --github-token ${{ secrets.GITHUB_TOKEN }} --issue-reference-number 6952 --query-day-interval 7
+          version: "latest"
+          enable-cache: true
+          cache-dependency-glob: "script/update_top_ranking_issues/pyproject.toml"
+      - name: Install Python 3.12
+        run: uv python install 3.12
+      - name: Install dependencies
+        run: uv sync --project script/update_top_ranking_issues -p 3.12
+      - name: Run script
+        run: uv run --project script/update_top_ranking_issues script/update_top_ranking_issues/main.py --github-token ${{ secrets.GITHUB_TOKEN }} --issue-reference-number 6952 --query-day-interval 7

From 5cf4ac16d6dabe81b6b65ba60f741eb8f535af34 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Wed, 9 Oct 2024 20:41:58 -0700
Subject: [PATCH 576/762] Don't disable auto-indent when typing in multi
 buffers (#18984)

Release Notes:

- Fixed a bug where auto-indent was not enabled while typing in
multi-buffers
---
 crates/multi_buffer/src/multi_buffer.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index 18af28498fbe51..a239b5b77049e5 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -724,7 +724,7 @@ impl MultiBuffer {
                                     original_indent_columns: Default::default(),
                                 })
                             } else {
-                                None
+                                autoindent_mode.clone()
                             };
                         let insertion_autoindent_mode =
                             if let Some(AutoindentMode::Block { .. }) = autoindent_mode {
@@ -732,7 +732,7 @@ impl MultiBuffer {
                                     original_indent_columns,
                                 })
                             } else {
-                                None
+                                autoindent_mode.clone()
                             };
 
                         buffer.edit(deletions, deletion_autoindent_mode, cx);

From fe1078ef685d4e34ea079f779c2ac0c87ca806c9 Mon Sep 17 00:00:00 2001
From: Cody <30978270+NukaCody@users.noreply.github.com>
Date: Thu, 10 Oct 2024 01:50:12 -0400
Subject: [PATCH 577/762] Add basic vi motion support for terminal (#18715)

Closes #7417

Release Notes:

- Added basic support for Alacritty's [vi
mode](https://github.com/alacritty/alacritty/blob/master/docs/features.md#vi-mode)
to the built-in terminal (which is using Alacritty under the hood.) The
vi mode can be activated with `ctrl-shift-space` and then supports some
basic motions to navigate through the terminal's scrollback buffer.

## Details

Leverages existing selection functionality from mouse_drag and the
ViMotion API of alacritty to add basic vi motions in the terminal.
Please note, this is only basic functionality (move, select, and yank to
system clipboard) and not a fully functional vim environment (e.g.
search, configurable keybindings, and paste). I figured this would be an
interim solution to the long term, more fleshed out, solution proposed
by @mrnugget.

Ctrl+Shift+Space to enter Vi mode while in the terminal (Same default
binding in alacritty)
---
 assets/keymaps/default-linux.json         |   3 +-
 assets/keymaps/default-macos.json         |   3 +-
 crates/terminal/src/terminal.rs           | 153 ++++++++++++++++++++++
 crates/terminal_view/src/terminal_view.rs |   8 +-
 4 files changed, 164 insertions(+), 3 deletions(-)

diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index d33df0274725af..fca38a45a436fc 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -664,7 +664,8 @@
       "shift-up": "terminal::ScrollLineUp",
       "shift-down": "terminal::ScrollLineDown",
       "shift-home": "terminal::ScrollToTop",
-      "shift-end": "terminal::ScrollToBottom"
+      "shift-end": "terminal::ScrollToBottom",
+      "ctrl-shift-space": "terminal::ToggleViMode"
     }
   },
   {
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index de929b8dd17b22..3de9a1495eb3b7 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -678,7 +678,8 @@
       "cmd-home": "terminal::ScrollToTop",
       "cmd-end": "terminal::ScrollToBottom",
       "shift-home": "terminal::ScrollToTop",
-      "shift-end": "terminal::ScrollToBottom"
+      "shift-end": "terminal::ScrollToBottom",
+      "ctrl-shift-space": "terminal::ToggleViMode"
     }
   }
 ]
diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs
index 9412999cbfa0a9..76c2fa892cb086 100644
--- a/crates/terminal/src/terminal.rs
+++ b/crates/terminal/src/terminal.rs
@@ -18,6 +18,7 @@ use alacritty_terminal::{
         Config, RenderableCursor, TermMode,
     },
     tty::{self},
+    vi_mode::{ViModeCursor, ViMotion},
     vte::ansi::{
         ClearMode, CursorStyle as AlacCursorStyle, Handler, NamedPrivateMode, PrivateMode,
     },
@@ -78,6 +79,7 @@ actions!(
         ScrollPageDown,
         ScrollToTop,
         ScrollToBottom,
+        ToggleViMode,
     ]
 );
 
@@ -139,6 +141,9 @@ enum InternalEvent {
     // Adjusted mouse position, should open
     FindHyperlink(Point<Pixels>, bool),
     Copy,
+    // Vi mode events
+    ToggleViMode,
+    ViMotion(ViMotion),
 }
 
 ///A translation struct for Alacritty to communicate with us from their event loop
@@ -447,6 +452,7 @@ impl TerminalBuilder {
             hovered_word: false,
             url_regex,
             word_regex,
+            vi_mode_enabled: false,
         };
 
         Ok(TerminalBuilder {
@@ -602,6 +608,7 @@ pub struct Terminal {
     url_regex: RegexSearch,
     word_regex: RegexSearch,
     task: Option<TaskState>,
+    vi_mode_enabled: bool,
 }
 
 pub struct TaskState {
@@ -767,6 +774,43 @@ impl Terminal {
             InternalEvent::Scroll(scroll) => {
                 term.scroll_display(*scroll);
                 self.refresh_hovered_word();
+
+                if self.vi_mode_enabled {
+                    match *scroll {
+                        AlacScroll::Delta(delta) => {
+                            term.vi_mode_cursor = term.vi_mode_cursor.scroll(&term, delta);
+                        }
+                        AlacScroll::PageUp => {
+                            let lines = term.screen_lines() as i32;
+                            term.vi_mode_cursor = term.vi_mode_cursor.scroll(&term, lines);
+                        }
+                        AlacScroll::PageDown => {
+                            let lines = -(term.screen_lines() as i32);
+                            term.vi_mode_cursor = term.vi_mode_cursor.scroll(&term, lines);
+                        }
+                        AlacScroll::Top => {
+                            let point = AlacPoint::new(term.topmost_line(), Column(0));
+                            term.vi_mode_cursor = ViModeCursor::new(point);
+                        }
+                        AlacScroll::Bottom => {
+                            let point = AlacPoint::new(term.bottommost_line(), Column(0));
+                            term.vi_mode_cursor = ViModeCursor::new(point);
+                        }
+                    }
+                    if let Some(mut selection) = term.selection.take() {
+                        let point = term.vi_mode_cursor.point;
+                        selection.update(point, AlacDirection::Right);
+                        term.selection = Some(selection);
+
+                        #[cfg(target_os = "linux")]
+                        if let Some(selection_text) = term.selection_to_string() {
+                            cx.write_to_primary(ClipboardItem::new_string(selection_text));
+                        }
+
+                        self.selection_head = Some(point);
+                        cx.emit(Event::SelectionsChanged)
+                    }
+                }
             }
             InternalEvent::SetSelection(selection) => {
                 term.selection = selection.as_ref().map(|(sel, _)| sel.clone());
@@ -811,6 +855,13 @@ impl Terminal {
                 term.scroll_to_point(*point);
                 self.refresh_hovered_word();
             }
+            InternalEvent::ToggleViMode => {
+                self.vi_mode_enabled = !self.vi_mode_enabled;
+                term.toggle_vi_mode();
+            }
+            InternalEvent::ViMotion(motion) => {
+                term.vi_motion(*motion);
+            }
             InternalEvent::FindHyperlink(position, open) => {
                 let prev_hovered_word = self.last_content.last_hovered_word.take();
 
@@ -1092,7 +1143,109 @@ impl Terminal {
         self.write_bytes_to_pty(input);
     }
 
+    pub fn toggle_vi_mode(&mut self) {
+        self.events.push_back(InternalEvent::ToggleViMode);
+    }
+
+    pub fn vi_motion(&mut self, keystroke: &Keystroke) {
+        if !self.vi_mode_enabled {
+            return;
+        }
+
+        let mut key = keystroke.key.clone();
+        if keystroke.modifiers.shift {
+            key = key.to_uppercase();
+        }
+
+        let motion: Option<ViMotion> = match key.as_str() {
+            "h" => Some(ViMotion::Left),
+            "j" => Some(ViMotion::Down),
+            "k" => Some(ViMotion::Up),
+            "l" => Some(ViMotion::Right),
+            "w" => Some(ViMotion::WordRight),
+            "b" if !keystroke.modifiers.control => Some(ViMotion::WordLeft),
+            "e" => Some(ViMotion::WordRightEnd),
+            "%" => Some(ViMotion::Bracket),
+            "$" => Some(ViMotion::Last),
+            "0" => Some(ViMotion::First),
+            "^" => Some(ViMotion::FirstOccupied),
+            "H" => Some(ViMotion::High),
+            "M" => Some(ViMotion::Middle),
+            "L" => Some(ViMotion::Low),
+            _ => None,
+        };
+
+        if let Some(motion) = motion {
+            let cursor = self.last_content.cursor.point;
+            let cursor_pos = Point {
+                x: cursor.column.0 as f32 * self.last_content.size.cell_width,
+                y: cursor.line.0 as f32 * self.last_content.size.line_height,
+            };
+            self.events
+                .push_back(InternalEvent::UpdateSelection(cursor_pos));
+            self.events.push_back(InternalEvent::ViMotion(motion));
+            return;
+        }
+
+        let scroll_motion = match key.as_str() {
+            "g" => Some(AlacScroll::Top),
+            "G" => Some(AlacScroll::Bottom),
+            "b" if keystroke.modifiers.control => Some(AlacScroll::PageUp),
+            "f" if keystroke.modifiers.control => Some(AlacScroll::PageDown),
+            "d" if keystroke.modifiers.control => {
+                let amount = self.last_content.size.line_height().to_f64() as i32 / 2;
+                Some(AlacScroll::Delta(-amount))
+            }
+            "u" if keystroke.modifiers.control => {
+                let amount = self.last_content.size.line_height().to_f64() as i32 / 2;
+                Some(AlacScroll::Delta(amount))
+            }
+            _ => None,
+        };
+
+        if let Some(scroll_motion) = scroll_motion {
+            self.events.push_back(InternalEvent::Scroll(scroll_motion));
+            return;
+        }
+
+        match key.as_str() {
+            "v" => {
+                let point = self.last_content.cursor.point;
+                let selection_type = SelectionType::Simple;
+                let side = AlacDirection::Right;
+                let selection = Selection::new(selection_type, point, side);
+                self.events
+                    .push_back(InternalEvent::SetSelection(Some((selection, point))));
+                return;
+            }
+
+            "escape" => {
+                self.events.push_back(InternalEvent::SetSelection(None));
+                return;
+            }
+
+            "y" => {
+                self.events.push_back(InternalEvent::Copy);
+                self.events.push_back(InternalEvent::SetSelection(None));
+                return;
+            }
+
+            "i" => {
+                self.scroll_to_bottom();
+                self.toggle_vi_mode();
+                return;
+            }
+            _ => {}
+        }
+    }
+
     pub fn try_keystroke(&mut self, keystroke: &Keystroke, alt_is_meta: bool) -> bool {
+        if self.vi_mode_enabled {
+            self.vi_motion(keystroke);
+            return true;
+        }
+
+        // Keep default terminal behavior
         let esc = to_esc_str(keystroke, &self.last_content.mode, alt_is_meta);
         if let Some(esc) = esc {
             self.input(esc);
diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs
index ce65be30c6d4f2..28a3d61d654282 100644
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -22,7 +22,7 @@ use terminal::{
     terminal_settings::{CursorShape, TerminalBlink, TerminalSettings, WorkingDirectory},
     Clear, Copy, Event, MaybeNavigationTarget, Paste, ScrollLineDown, ScrollLineUp, ScrollPageDown,
     ScrollPageUp, ScrollToBottom, ScrollToTop, ShowCharacterPalette, TaskStatus, Terminal,
-    TerminalSize,
+    TerminalSize, ToggleViMode,
 };
 use terminal_element::{is_blank, TerminalElement};
 use terminal_panel::TerminalPanel;
@@ -431,6 +431,11 @@ impl TerminalView {
         cx.notify();
     }
 
+    fn toggle_vi_mode(&mut self, _: &ToggleViMode, cx: &mut ViewContext<Self>) {
+        self.terminal.update(cx, |term, _| term.toggle_vi_mode());
+        cx.notify();
+    }
+
     pub fn should_show_cursor(&self, focused: bool, cx: &mut gpui::ViewContext<Self>) -> bool {
         //Don't blink the cursor when not focused, blinking is disabled, or paused
         if !focused
@@ -968,6 +973,7 @@ impl Render for TerminalView {
             .on_action(cx.listener(TerminalView::scroll_page_down))
             .on_action(cx.listener(TerminalView::scroll_to_top))
             .on_action(cx.listener(TerminalView::scroll_to_bottom))
+            .on_action(cx.listener(TerminalView::toggle_vi_mode))
             .on_action(cx.listener(TerminalView::show_character_palette))
             .on_action(cx.listener(TerminalView::select_all))
             .on_key_down(cx.listener(Self::key_down))

From db50467bbc160556b474edce651b2495e6e06a55 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 10 Oct 2024 10:49:02 +0200
Subject: [PATCH 578/762] remote ssh: Show connection status in tooltip
 (#19006)

Release Notes:

- N/A

---------

Co-authored-by: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
---
 crates/title_bar/src/title_bar.rs | 36 +++++++++++++++++++++++++------
 1 file changed, 30 insertions(+), 6 deletions(-)

diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index 6fda4d594fe50e..999165b9d856c7 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -264,20 +264,43 @@ impl TitleBar {
 
     fn render_ssh_project_host(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
         let host = self.project.read(cx).ssh_connection_string(cx)?;
-        let meta = SharedString::from(format!("Connected to: {host}"));
-        let indicator_color = match self.project.read(cx).ssh_connection_state(cx)? {
+
+        let (indicator_color, meta) = match self.project.read(cx).ssh_connection_state(cx)? {
+            remote::ConnectionState::Connecting => (Color::Info, format!("Connecting to: {host}")),
+            remote::ConnectionState::Connected => (Color::Success, format!("Connected to: {host}")),
+            remote::ConnectionState::HeartbeatMissed => (
+                Color::Warning,
+                format!("Connection attempt to {host} missed. Retrying..."),
+            ),
+            remote::ConnectionState::Reconnecting => (
+                Color::Warning,
+                format!("Lost connection to {host}. Reconnecting..."),
+            ),
+            remote::ConnectionState::Disconnected => {
+                (Color::Error, format!("Disconnected from {host}"))
+            }
+        };
+
+        let indicator_border_color = cx.theme().colors().title_bar_background;
+
+        let icon_color = match self.project.read(cx).ssh_connection_state(cx)? {
             remote::ConnectionState::Connecting => Color::Info,
-            remote::ConnectionState::Connected => Color::Success,
+            remote::ConnectionState::Connected => Color::Default,
             remote::ConnectionState::HeartbeatMissed => Color::Warning,
             remote::ConnectionState::Reconnecting => Color::Warning,
             remote::ConnectionState::Disconnected => Color::Error,
         };
+
+        let meta = SharedString::from(meta);
+
         let indicator = div()
             .absolute()
-            .size_1p5()
-            .right_0p5()
-            .bottom_0p5()
+            .size_2p5()
+            .right_0()
+            .bottom_0()
             .rounded_full()
+            .border_2()
+            .border_color(indicator_border_color)
             .bg(indicator_color.color(cx));
 
         Some(
@@ -287,6 +310,7 @@ impl TitleBar {
                     IconButton::new("ssh-server-icon", IconName::Server)
                         .icon_size(IconSize::Small)
                         .shape(IconButtonShape::Square)
+                        .icon_color(icon_color)
                         .tooltip(move |cx| {
                             Tooltip::with_meta(
                                 "Remote Project",

From f6f5ad138dc23405208299bd35d53d2507c012a6 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Thu, 10 Oct 2024 11:15:46 +0200
Subject: [PATCH 579/762] project panel: Make intermediate folded directories
 clickable (#18956)

- Closes: https://github.com/zed-industries/zed/issues/18770


Release Notes:

- Intermediate auto-folded project panel entries are now clickable.
---
 crates/project_panel/src/project_panel.rs | 113 ++++++++++------------
 1 file changed, 52 insertions(+), 61 deletions(-)

diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 53b274ee6fa964..39130513ee37a5 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -2434,71 +2434,62 @@ impl ProjectPanel {
                         if let (Some(editor), true) = (Some(&self.filename_editor), show_editor) {
                             h_flex().h_6().w_full().child(editor.clone())
                         } else {
-                            h_flex().h_6().map(|this| {
+                            h_flex().h_6().map(|mut this| {
                                 if let Some(folded_ancestors) =
                                     is_active.then(|| self.ancestors.get(&entry_id)).flatten()
                                 {
-                                    let Some(part_to_highlight) = Path::new(&file_name)
-                                        .ancestors()
-                                        .nth(folded_ancestors.current_ancestor_depth)
-                                    else {
-                                        return this;
-                                    };
-
-                                    let suffix = Path::new(&file_name)
-                                        .strip_prefix(part_to_highlight)
-                                        .ok()
-                                        .filter(|suffix| !suffix.as_os_str().is_empty());
-                                    let prefix = part_to_highlight
-                                        .parent()
-                                        .filter(|prefix| !prefix.as_os_str().is_empty());
-                                    let Some(part_to_highlight) = part_to_highlight
-                                        .file_name()
-                                        .and_then(|name| name.to_str().map(String::from))
-                                    else {
-                                        return this;
-                                    };
+                                    let components = Path::new(&file_name)
+                                        .components()
+                                        .map(|comp| {
+                                            let comp_str =
+                                                comp.as_os_str().to_string_lossy().into_owned();
+                                            comp_str
+                                        })
+                                        .collect::<Vec<_>>();
+                                    let components_len = components.len();
+                                    let active_index = components_len
+                                        - 1
+                                        - folded_ancestors.current_ancestor_depth;
+                                    const DELIMITER: SharedString =
+                                        SharedString::new_static(std::path::MAIN_SEPARATOR_STR);
+                                    for (index, component) in components.into_iter().enumerate() {
+                                        if index != 0 {
+                                            this = this.child(
+                                                Label::new(DELIMITER.clone())
+                                                    .single_line()
+                                                    .color(filename_text_color),
+                                            );
+                                        }
+                                        let id = SharedString::from(format!(
+                                            "project_panel_path_component_{}_{index}",
+                                            entry_id.to_usize()
+                                        ));
+                                        let label = div()
+                                            .id(id)
+                                            .on_click(cx.listener(move |this, _, cx| {
+                                                if index != active_index {
+                                                    if let Some(folds) =
+                                                        this.ancestors.get_mut(&entry_id)
+                                                    {
+                                                        folds.current_ancestor_depth =
+                                                            components_len - 1 - index;
+                                                        cx.notify();
+                                                    }
+                                                }
+                                            }))
+                                            .child(
+                                                Label::new(component)
+                                                    .single_line()
+                                                    .color(filename_text_color)
+                                                    .when(index == active_index, |this| {
+                                                        this.underline(true)
+                                                    }),
+                                            );
+
+                                        this = this.child(label);
+                                    }
 
-                                    this.children(prefix.and_then(|prefix| {
-                                        Some(
-                                            h_flex()
-                                                .child(
-                                                    Label::new(prefix.to_str().map(String::from)?)
-                                                        .single_line()
-                                                        .color(filename_text_color),
-                                                )
-                                                .child(
-                                                    Label::new(std::path::MAIN_SEPARATOR_STR)
-                                                        .single_line()
-                                                        .color(filename_text_color),
-                                                ),
-                                        )
-                                    }))
-                                    .child(
-                                        Label::new(part_to_highlight)
-                                            .single_line()
-                                            .color(filename_text_color)
-                                            .underline(true),
-                                    )
-                                    .children(
-                                        suffix.and_then(|suffix| {
-                                            Some(
-                                                h_flex()
-                                                    .child(
-                                                        Label::new(std::path::MAIN_SEPARATOR_STR)
-                                                            .single_line()
-                                                            .color(filename_text_color),
-                                                    )
-                                                    .child(
-                                                        Label::new(
-                                                            suffix.to_str().map(String::from)?,
-                                                        )
-                                                        .single_line()
-                                                        .color(filename_text_color),
-                                                    ),
-                                            )
-                                        }),
-                                    )
+                                    this
                                 } else {
                                     this.child(
                                         Label::new(file_name)

From 5841ac406d10b8c64296b902edcee32fa1a59c7c Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Thu, 10 Oct 2024 12:53:02 +0300
Subject: [PATCH 580/762] Fix the completions being too slow (#19013)

Closes https://github.com/zed-industries/zed/issues/19005

Release Notes:

- Fixed completion items inserted with a delay
([#19005](https://github.com/zed-industries/zed/issues/19005))

---------

Co-authored-by: Antonio Scandurra <antonio@zed.dev>
---
 crates/collab/src/tests/editor_tests.rs       | 84 ++++++-------------
 .../src/copilot_completion_provider.rs        | 10 +--
 crates/editor/src/debounced_delay.rs          | 22 ++---
 crates/editor/src/editor.rs                   | 47 ++---------
 crates/editor/src/editor_tests.rs             | 18 ++--
 crates/editor/src/hover_popover.rs            | 17 ++--
 crates/editor/src/test/editor_test_context.rs |  1 -
 crates/lsp/src/lsp.rs                         |  3 +-
 crates/vim/src/normal/repeat.rs               |  6 +-
 9 files changed, 64 insertions(+), 144 deletions(-)

diff --git a/crates/collab/src/tests/editor_tests.rs b/crates/collab/src/tests/editor_tests.rs
index e35cf873801af2..f9bc21efb1abdf 100644
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -379,75 +379,51 @@ async fn test_collaborating_with_completion(cx_a: &mut TestAppContext, cx_b: &mu
         .next()
         .await
         .unwrap();
+    cx_a.executor().finish_waiting();
+
     // Open the buffer on the host.
     let buffer_a = project_a
         .update(cx_a, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx))
         .await
         .unwrap();
+    cx_a.executor().run_until_parked();
 
     buffer_a.read_with(cx_a, |buffer, _| {
         assert_eq!(buffer.text(), "fn main() { a. }")
     });
 
+    // Confirm a completion on the guest.
+    editor_b.update(cx_b, |editor, cx| {
+        assert!(editor.context_menu_visible());
+        editor.confirm_completion(&ConfirmCompletion { item_ix: Some(0) }, cx);
+        assert_eq!(editor.text(cx), "fn main() { a.first_method() }");
+    });
+
     // Return a resolved completion from the host's language server.
     // The resolved completion has an additional text edit.
     fake_language_server.handle_request::<lsp::request::ResolveCompletionItem, _, _>(
         |params, _| async move {
-            Ok(match params.label.as_str() {
-                "first_method(…)" => lsp::CompletionItem {
-                    label: "first_method(…)".into(),
-                    detail: Some("fn(&mut self, B) -> C".into()),
-                    text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
-                        new_text: "first_method($1)".to_string(),
-                        range: lsp::Range::new(
-                            lsp::Position::new(0, 14),
-                            lsp::Position::new(0, 14),
-                        ),
-                    })),
-                    additional_text_edits: Some(vec![lsp::TextEdit {
-                        new_text: "use d::SomeTrait;\n".to_string(),
-                        range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 0)),
-                    }]),
-                    insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
-                    ..Default::default()
-                },
-                "second_method(…)" => lsp::CompletionItem {
-                    label: "second_method(…)".into(),
-                    detail: Some("fn(&mut self, C) -> D<E>".into()),
-                    text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
-                        new_text: "second_method()".to_string(),
-                        range: lsp::Range::new(
-                            lsp::Position::new(0, 14),
-                            lsp::Position::new(0, 14),
-                        ),
-                    })),
-                    insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
-                    additional_text_edits: Some(vec![lsp::TextEdit {
-                        new_text: "use d::SomeTrait;\n".to_string(),
-                        range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 0)),
-                    }]),
-                    ..Default::default()
-                },
-                _ => panic!("unexpected completion label: {:?}", params.label),
+            assert_eq!(params.label, "first_method(…)");
+            Ok(lsp::CompletionItem {
+                label: "first_method(…)".into(),
+                detail: Some("fn(&mut self, B) -> C".into()),
+                text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
+                    new_text: "first_method($1)".to_string(),
+                    range: lsp::Range::new(lsp::Position::new(0, 14), lsp::Position::new(0, 14)),
+                })),
+                additional_text_edits: Some(vec![lsp::TextEdit {
+                    new_text: "use d::SomeTrait;\n".to_string(),
+                    range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 0)),
+                }]),
+                insert_text_format: Some(lsp::InsertTextFormat::SNIPPET),
+                ..Default::default()
             })
         },
     );
-    cx_a.executor().finish_waiting();
-    cx_a.executor().run_until_parked();
 
-    // Confirm a completion on the guest.
-    editor_b
-        .update(cx_b, |editor, cx| {
-            assert!(editor.context_menu_visible());
-            editor.confirm_completion(&ConfirmCompletion { item_ix: Some(0) }, cx)
-        })
-        .unwrap()
-        .await
-        .unwrap();
+    // The additional edit is applied.
     cx_a.executor().run_until_parked();
-    cx_b.executor().run_until_parked();
 
-    // The additional edit is applied.
     buffer_a.read_with(cx_a, |buffer, _| {
         assert_eq!(
             buffer.text(),
@@ -540,15 +516,9 @@ async fn test_collaborating_with_completion(cx_a: &mut TestAppContext, cx_b: &mu
     cx_b.executor().run_until_parked();
 
     // When accepting the completion, the snippet is insert.
-    editor_b
-        .update(cx_b, |editor, cx| {
-            assert!(editor.context_menu_visible());
-            editor.confirm_completion(&ConfirmCompletion { item_ix: Some(0) }, cx)
-        })
-        .unwrap()
-        .await
-        .unwrap();
     editor_b.update(cx_b, |editor, cx| {
+        assert!(editor.context_menu_visible());
+        editor.confirm_completion(&ConfirmCompletion { item_ix: Some(0) }, cx);
         assert_eq!(
             editor.text(cx),
             "use d::SomeTrait;\nfn main() { a.first_method(); a.third_method(, , ) }"
diff --git a/crates/copilot/src/copilot_completion_provider.rs b/crates/copilot/src/copilot_completion_provider.rs
index f03d6137faedfb..3a3361cda1996d 100644
--- a/crates/copilot/src/copilot_completion_provider.rs
+++ b/crates/copilot/src/copilot_completion_provider.rs
@@ -363,12 +363,10 @@ mod tests {
 
             // Confirming a completion inserts it and hides the context menu, without showing
             // the copilot suggestion afterwards.
-            editor.confirm_completion(&Default::default(), cx).unwrap()
-        })
-        .await
-        .unwrap();
-
-        cx.update_editor(|editor, cx| {
+            editor
+                .confirm_completion(&Default::default(), cx)
+                .unwrap()
+                .detach();
             assert!(!editor.context_menu_visible());
             assert!(!editor.has_active_inline_completion(cx));
             assert_eq!(editor.text(cx), "one.completion_a\ntwo\nthree\n");
diff --git a/crates/editor/src/debounced_delay.rs b/crates/editor/src/debounced_delay.rs
index 1f009c7d7939fa..0dbf36d49e38aa 100644
--- a/crates/editor/src/debounced_delay.rs
+++ b/crates/editor/src/debounced_delay.rs
@@ -1,4 +1,4 @@
-use std::{ops::ControlFlow, time::Duration};
+use std::time::Duration;
 
 use futures::{channel::oneshot, FutureExt};
 use gpui::{Task, ViewContext};
@@ -7,7 +7,7 @@ use crate::Editor;
 
 pub struct DebouncedDelay {
     task: Option<Task<()>>,
-    cancel_channel: Option<oneshot::Sender<ControlFlow<()>>>,
+    cancel_channel: Option<oneshot::Sender<()>>,
 }
 
 impl DebouncedDelay {
@@ -23,22 +23,17 @@ impl DebouncedDelay {
         F: 'static + Send + FnOnce(&mut Editor, &mut ViewContext<Editor>) -> Task<()>,
     {
         if let Some(channel) = self.cancel_channel.take() {
-            channel.send(ControlFlow::Break(())).ok();
+            _ = channel.send(());
         }
 
-        let (sender, mut receiver) = oneshot::channel::<ControlFlow<()>>();
+        let (sender, mut receiver) = oneshot::channel::<()>();
         self.cancel_channel = Some(sender);
 
         drop(self.task.take());
         self.task = Some(cx.spawn(move |model, mut cx| async move {
             let mut timer = cx.background_executor().timer(delay).fuse();
             futures::select_biased! {
-                interrupt = receiver => {
-                    match interrupt {
-                        Ok(ControlFlow::Break(())) | Err(_) => return,
-                        Ok(ControlFlow::Continue(())) => {},
-                    }
-                }
+                _ = receiver => return,
                 _ = timer => {}
             }
 
@@ -47,11 +42,4 @@ impl DebouncedDelay {
             }
         }));
     }
-
-    pub fn start_now(&mut self) -> Option<Task<()>> {
-        if let Some(channel) = self.cancel_channel.take() {
-            channel.send(ControlFlow::Continue(())).ok();
-        }
-        self.task.take()
-    }
 }
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 5b5401af178fb7..e2818bcd96263c 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -4459,49 +4459,16 @@ impl Editor {
         &mut self,
         item_ix: Option<usize>,
         intent: CompletionIntent,
-        cx: &mut ViewContext<Self>,
-    ) -> Option<Task<anyhow::Result<()>>> {
+        cx: &mut ViewContext<Editor>,
+    ) -> Option<Task<std::result::Result<(), anyhow::Error>>> {
+        use language::ToOffset as _;
+
         let completions_menu = if let ContextMenu::Completions(menu) = self.hide_context_menu(cx)? {
             menu
         } else {
             return None;
         };
 
-        let mut resolve_task_store = completions_menu
-            .selected_completion_documentation_resolve_debounce
-            .lock();
-        let selected_completion_resolve = resolve_task_store.start_now();
-        let menu_pre_resolve = self
-            .completion_documentation_pre_resolve_debounce
-            .start_now();
-        drop(resolve_task_store);
-
-        Some(cx.spawn(|editor, mut cx| async move {
-            match (selected_completion_resolve, menu_pre_resolve) {
-                (None, None) => {}
-                (Some(resolve), None) | (None, Some(resolve)) => resolve.await,
-                (Some(resolve_1), Some(resolve_2)) => {
-                    futures::join!(resolve_1, resolve_2);
-                }
-            }
-            if let Some(apply_edits_task) = editor.update(&mut cx, |editor, cx| {
-                editor.apply_resolved_completion(completions_menu, item_ix, intent, cx)
-            })? {
-                apply_edits_task.await?;
-            }
-            Ok(())
-        }))
-    }
-
-    fn apply_resolved_completion(
-        &mut self,
-        completions_menu: CompletionsMenu,
-        item_ix: Option<usize>,
-        intent: CompletionIntent,
-        cx: &mut ViewContext<'_, Editor>,
-    ) -> Option<Task<anyhow::Result<Option<language::Transaction>>>> {
-        use language::ToOffset as _;
-
         let mat = completions_menu
             .matches
             .get(item_ix.unwrap_or(completions_menu.selected_item))?;
@@ -4660,7 +4627,11 @@ impl Editor {
             // so we should automatically call signature_help
             self.show_signature_help(&ShowSignatureHelp, cx);
         }
-        Some(apply_edits)
+
+        Some(cx.foreground_executor().spawn(async move {
+            apply_edits.await?;
+            Ok(())
+        }))
     }
 
     pub fn toggle_code_actions(&mut self, action: &ToggleCodeActions, cx: &mut ViewContext<Self>) {
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 5ab2c9e3a854cf..092afb394e42fb 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -7996,7 +7996,7 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
             .unwrap()
     });
     cx.assert_editor_state(indoc! {"
-        one.ˇ
+        one.second_completionˇ
         two
         three
     "});
@@ -8029,9 +8029,9 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
     cx.assert_editor_state(indoc! {"
         one.second_completionˇ
         two
-        thoverlapping additional editree
-
-        additional edit"});
+        three
+        additional edit
+    "});
 
     cx.set_state(indoc! {"
         one.second_completion
@@ -8091,8 +8091,8 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
     });
     cx.assert_editor_state(indoc! {"
         one.second_completion
-        two siˇ
-        three siˇ
+        two sixth_completionˇ
+        three sixth_completionˇ
         additional edit
     "});
 
@@ -8133,11 +8133,9 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
             .confirm_completion(&ConfirmCompletion::default(), cx)
             .unwrap()
     });
-    cx.assert_editor_state("editor.cloˇ");
+    cx.assert_editor_state("editor.closeˇ");
     handle_resolve_completion_request(&mut cx, None).await;
     apply_additional_edits.await.unwrap();
-    cx.assert_editor_state(indoc! {"
-    editor.closeˇ"});
 }
 
 #[gpui::test]
@@ -10142,7 +10140,7 @@ async fn test_completions_with_additional_edits(cx: &mut gpui::TestAppContext) {
             .confirm_completion(&ConfirmCompletion::default(), cx)
             .unwrap()
     });
-    cx.assert_editor_state(indoc! {"fn main() { let a = 2.ˇ; }"});
+    cx.assert_editor_state(indoc! {"fn main() { let a = 2.Some(2)ˇ; }"});
 
     cx.handle_request::<lsp::request::ResolveCompletionItem, _, _>(move |_, _, _| {
         let task_completion_item = completion_item.clone();
diff --git a/crates/editor/src/hover_popover.rs b/crates/editor/src/hover_popover.rs
index da232431880b37..269e9e9e03e061 100644
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -810,7 +810,7 @@ mod tests {
                 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
                 completion_provider: Some(lsp::CompletionOptions {
                     trigger_characters: Some(vec![".".to_string(), ":".to_string()]),
-                    resolve_provider: Some(false),
+                    resolve_provider: Some(true),
                     ..Default::default()
                 }),
                 ..Default::default()
@@ -902,15 +902,12 @@ mod tests {
         assert_eq!(counter.load(atomic::Ordering::Acquire), 1);
 
         //apply a completion and check it was successfully applied
-        let () = cx
-            .update_editor(|editor, cx| {
-                editor.context_menu_next(&Default::default(), cx);
-                editor
-                    .confirm_completion(&ConfirmCompletion::default(), cx)
-                    .unwrap()
-            })
-            .await
-            .unwrap();
+        let _apply_additional_edits = cx.update_editor(|editor, cx| {
+            editor.context_menu_next(&Default::default(), cx);
+            editor
+                .confirm_completion(&ConfirmCompletion::default(), cx)
+                .unwrap()
+        });
         cx.assert_editor_state(indoc! {"
             one.second_completionˇ
             two
diff --git a/crates/editor/src/test/editor_test_context.rs b/crates/editor/src/test/editor_test_context.rs
index 9406a487969fed..7234d97c5b77e4 100644
--- a/crates/editor/src/test/editor_test_context.rs
+++ b/crates/editor/src/test/editor_test_context.rs
@@ -13,7 +13,6 @@ use itertools::Itertools;
 use language::{Buffer, BufferSnapshot, LanguageRegistry};
 use multi_buffer::{ExcerptRange, ToPoint};
 use parking_lot::RwLock;
-use pretty_assertions::assert_eq;
 use project::{FakeFs, Project};
 use std::{
     any::TypeId,
diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs
index e380da052ddc95..8d67855e39019b 100644
--- a/crates/lsp/src/lsp.rs
+++ b/crates/lsp/src/lsp.rs
@@ -631,7 +631,8 @@ impl LanguageServer {
                                     "filterText".to_string(),
                                     "labelDetails".to_string(),
                                     "tags".to_string(),
-                                    "textEdit".to_string(),
+                                    // NB: Do not have this resolved, otherwise Zed becomes slow to complete things
+                                    // "textEdit".to_string(),
                                 ],
                             }),
                             insert_replace_support: Some(true),
diff --git a/crates/vim/src/normal/repeat.rs b/crates/vim/src/normal/repeat.rs
index 7f06c424f32c0d..e0e34ceda79d22 100644
--- a/crates/vim/src/normal/repeat.rs
+++ b/crates/vim/src/normal/repeat.rs
@@ -387,7 +387,7 @@ mod test {
             lsp::ServerCapabilities {
                 completion_provider: Some(lsp::CompletionOptions {
                     trigger_characters: Some(vec![".".to_string(), ":".to_string()]),
-                    resolve_provider: Some(false),
+                    resolve_provider: Some(true),
                     ..Default::default()
                 }),
                 ..Default::default()
@@ -432,9 +432,7 @@ mod test {
         request.next().await;
         cx.condition(|editor, _| editor.context_menu_visible())
             .await;
-        cx.simulate_keystrokes("down enter");
-        cx.run_until_parked();
-        cx.simulate_keystrokes("! escape");
+        cx.simulate_keystrokes("down enter ! escape");
 
         cx.assert_state(
             indoc! {"

From e3ff2ced79946c196b7536c216cd63bd1e4aa8a7 Mon Sep 17 00:00:00 2001
From: Shish <webmaster@shishnet.org>
Date: Thu, 10 Oct 2024 11:56:48 +0100
Subject: [PATCH 581/762] [terminal] Consider "main.cs(20,5)" to be a single
 clickable word (#19004)

[terminal] Consider "main.cs(20,5)" to be a single clickable word

First, adding unit tests for the regexes because I'm not certain how
these regexes are _intended_ to work, and unit tests work nicely as
demonstrations of intended behaviour.

The comment string, and the regex itself, seem to imply that
"main.cs(20,5)" is supposed be a single "word" (for the purposes of
being clicked on)... but the regex doesn't actually work like that. This
PR makes it work :)

(I don't know _why_ "word with an optional `(\d+,\d+)` on the end"
doesn't match the full string, while "word with a required `(\d+,\d+)`
on the end" _does_ match the full string - aren't regexes supposed to
match as much as possible, so it should take the optional extra whenever
the extra exists? Either way, "word with a required (\d+,\d+), or word
by itself" has the correct behaviour, as demonstrated by the unit test)

Release Notes:

- N/A
---
 Cargo.lock                      |  1 +
 crates/terminal/Cargo.toml      |  1 +
 crates/terminal/src/terminal.rs | 69 +++++++++++++++++++++++++++++----
 3 files changed, 63 insertions(+), 8 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 04cffcd04ac9c0..a9738c338c4a86 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11407,6 +11407,7 @@ dependencies = [
  "gpui",
  "libc",
  "rand 0.8.5",
+ "regex",
  "release_channel",
  "schemars",
  "serde",
diff --git a/crates/terminal/Cargo.toml b/crates/terminal/Cargo.toml
index 5c64d844335e8e..75dbb93bae7604 100644
--- a/crates/terminal/Cargo.toml
+++ b/crates/terminal/Cargo.toml
@@ -37,3 +37,4 @@ windows.workspace = true
 
 [dev-dependencies]
 rand.workspace = true
+regex.workspace = true
diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs
index 76c2fa892cb086..092f8c63777bce 100644
--- a/crates/terminal/src/terminal.rs
+++ b/crates/terminal/src/terminal.rs
@@ -307,6 +307,11 @@ impl Display for TerminalError {
 // https://github.com/alacritty/alacritty/blob/cb3a79dbf6472740daca8440d5166c1d4af5029e/extra/man/alacritty.5.scd?plain=1#L207-L213
 const DEFAULT_SCROLL_HISTORY_LINES: usize = 10_000;
 const MAX_SCROLL_HISTORY_LINES: usize = 100_000;
+const URL_REGEX: &str = r#"(ipfs:|ipns:|magnet:|mailto:|gemini://|gopher://|https://|http://|news:|file://|git://|ssh:|ftp://)[^\u{0000}-\u{001F}\u{007F}-\u{009F}<>"\s{-}\^⟨⟩`]+"#;
+// Optional suffix matches MSBuild diagnostic suffixes for path parsing in PathLikeWithPosition
+// https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild-diagnostic-format-for-tasks
+const WORD_REGEX: &str =
+    r#"[\$\+\w.\[\]:/\\@\-~()]+(?:\((?:\d+|\d+,\d+)\))|[\$\+\w.\[\]:/\\@\-~()]+"#;
 
 pub struct TerminalBuilder {
     terminal: Terminal,
@@ -425,12 +430,6 @@ impl TerminalBuilder {
         let pty_tx = event_loop.channel();
         let _io_thread = event_loop.spawn(); // DANGER
 
-        let url_regex = RegexSearch::new(r#"(ipfs:|ipns:|magnet:|mailto:|gemini://|gopher://|https://|http://|news:|file://|git://|ssh:|ftp://)[^\u{0000}-\u{001F}\u{007F}-\u{009F}<>"\s{-}\^⟨⟩`]+"#).unwrap();
-        // Optional suffix matches MSBuild diagnostic suffixes for path parsing in PathLikeWithPosition
-        // https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild-diagnostic-format-for-tasks
-        let word_regex =
-            RegexSearch::new(r#"[\$\+\w.\[\]:/\\@\-~()]+(?:\((?:\d+|\d+,\d+)\))?"#).unwrap();
-
         let terminal = Terminal {
             task,
             pty_tx: Notifier(pty_tx),
@@ -450,8 +449,8 @@ impl TerminalBuilder {
             selection_phase: SelectionPhase::Ended,
             secondary_pressed: false,
             hovered_word: false,
-            url_regex,
-            word_regex,
+            url_regex: RegexSearch::new(URL_REGEX).unwrap(),
+            word_regex: RegexSearch::new(WORD_REGEX).unwrap(),
             vi_mode_enabled: false,
         };
 
@@ -2066,4 +2065,58 @@ mod tests {
             ..Default::default()
         }
     }
+
+    fn re_test(re: &str, hay: &str, expected: Vec<&str>) {
+        let results: Vec<_> = regex::Regex::new(re)
+            .unwrap()
+            .find_iter(hay)
+            .map(|m| m.as_str())
+            .collect();
+        assert_eq!(results, expected);
+    }
+    #[test]
+    fn test_url_regex() {
+        re_test(
+            crate::URL_REGEX,
+            "test http://example.com test mailto:bob@example.com train",
+            vec!["http://example.com", "mailto:bob@example.com"],
+        );
+    }
+    #[test]
+    fn test_word_regex() {
+        re_test(
+            crate::WORD_REGEX,
+            "hello, world! \"What\" is this?",
+            vec!["hello", "world", "What", "is", "this"],
+        );
+    }
+    #[test]
+    fn test_word_regex_with_linenum() {
+        // filename(line) and filename(line,col) as used in MSBuild output
+        // should be considered a single "word", even though comma is
+        // usually a word separator
+        re_test(
+            crate::WORD_REGEX,
+            "a Main.cs(20) b",
+            vec!["a", "Main.cs(20)", "b"],
+        );
+        re_test(
+            crate::WORD_REGEX,
+            "Main.cs(20,5) Error desc",
+            vec!["Main.cs(20,5)", "Error", "desc"],
+        );
+        // filename:line:col is a popular format for unix tools
+        re_test(
+            crate::WORD_REGEX,
+            "a Main.cs:20:5 b",
+            vec!["a", "Main.cs:20:5", "b"],
+        );
+        // Some tools output "filename:line:col:message", which currently isn't
+        // handled correctly, but might be in the future
+        re_test(
+            crate::WORD_REGEX,
+            "Main.cs:20:5:Error desc",
+            vec!["Main.cs:20:5:Error", "desc"],
+        );
+    }
 }

From b75532fad7a5e723c7233abebb0ac83cf45d8053 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 10 Oct 2024 12:59:09 +0200
Subject: [PATCH 582/762] ssh remote: Handle disconnect on project and show
 overlay (#19014)

Demo:



https://github.com/user-attachments/assets/e5edf8f3-8c15-482e-a792-6eb619f83de4


Release Notes:

- N/A

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/call/src/room.rs                       |   2 +-
 .../collab/src/tests/channel_guest_tests.rs   |   8 +-
 crates/collab/src/tests/dev_server_tests.rs   |   8 +-
 crates/collab/src/tests/editor_tests.rs       |   2 +-
 crates/collab/src/tests/integration_tests.rs  |  34 +++---
 .../random_project_collaboration_tests.rs     |   6 +-
 .../src/tests/randomized_test_helpers.rs      |   4 +-
 crates/project/src/lsp_store.rs               |  27 +++--
 crates/project/src/project.rs                 |  53 ++++++++-
 crates/project/src/worktree_store.rs          |   5 +
 crates/project_panel/src/project_panel.rs     |  29 +++--
 .../src/disconnected_overlay.rs               | 110 ++++++++++++++++--
 crates/remote/src/remote.rs                   |   1 +
 crates/remote/src/ssh_session.rs              |  37 +++++-
 crates/title_bar/src/title_bar.rs             |   2 +-
 crates/workspace/src/workspace.rs             |  14 ++-
 16 files changed, 264 insertions(+), 78 deletions(-)

diff --git a/crates/call/src/room.rs b/crates/call/src/room.rs
index 3c36c5f8775b78..a637bfd43fdf65 100644
--- a/crates/call/src/room.rs
+++ b/crates/call/src/room.rs
@@ -1178,7 +1178,7 @@ impl Room {
             this.update(&mut cx, |this, cx| {
                 this.joined_projects.retain(|project| {
                     if let Some(project) = project.upgrade() {
-                        !project.read(cx).is_disconnected()
+                        !project.read(cx).is_disconnected(cx)
                     } else {
                         false
                     }
diff --git a/crates/collab/src/tests/channel_guest_tests.rs b/crates/collab/src/tests/channel_guest_tests.rs
index 8df318dc290936..06b14bee5e6df6 100644
--- a/crates/collab/src/tests/channel_guest_tests.rs
+++ b/crates/collab/src/tests/channel_guest_tests.rs
@@ -50,7 +50,7 @@ async fn test_channel_guests(
         project_b.read_with(cx_b, |project, _| project.remote_id()),
         Some(project_id),
     );
-    assert!(project_b.read_with(cx_b, |project, _| project.is_read_only()));
+    assert!(project_b.read_with(cx_b, |project, cx| project.is_read_only(cx)));
     assert!(project_b
         .update(cx_b, |project, cx| {
             let worktree_id = project.worktrees(cx).next().unwrap().read(cx).id();
@@ -103,7 +103,7 @@ async fn test_channel_guest_promotion(cx_a: &mut TestAppContext, cx_b: &mut Test
             workspace.active_item_as::<Editor>(cx).unwrap(),
         )
     });
-    assert!(project_b.read_with(cx_b, |project, _| project.is_read_only()));
+    assert!(project_b.read_with(cx_b, |project, cx| project.is_read_only(cx)));
     assert!(editor_b.update(cx_b, |e, cx| e.read_only(cx)));
     assert!(room_b.read_with(cx_b, |room, _| !room.can_use_microphone()));
     assert!(room_b
@@ -127,7 +127,7 @@ async fn test_channel_guest_promotion(cx_a: &mut TestAppContext, cx_b: &mut Test
     cx_a.run_until_parked();
 
     // project and buffers are now editable
-    assert!(project_b.read_with(cx_b, |project, _| !project.is_read_only()));
+    assert!(project_b.read_with(cx_b, |project, cx| !project.is_read_only(cx)));
     assert!(editor_b.update(cx_b, |editor, cx| !editor.read_only(cx)));
 
     // B sees themselves as muted, and can unmute.
@@ -153,7 +153,7 @@ async fn test_channel_guest_promotion(cx_a: &mut TestAppContext, cx_b: &mut Test
     cx_a.run_until_parked();
 
     // project and buffers are no longer editable
-    assert!(project_b.read_with(cx_b, |project, _| project.is_read_only()));
+    assert!(project_b.read_with(cx_b, |project, cx| project.is_read_only(cx)));
     assert!(editor_b.update(cx_b, |editor, cx| editor.read_only(cx)));
     assert!(room_b
         .update(cx_b, |room, cx| room.share_microphone(cx))
diff --git a/crates/collab/src/tests/dev_server_tests.rs b/crates/collab/src/tests/dev_server_tests.rs
index 5acdeb706eb144..cbeb2a85a0ae0e 100644
--- a/crates/collab/src/tests/dev_server_tests.rs
+++ b/crates/collab/src/tests/dev_server_tests.rs
@@ -262,7 +262,7 @@ async fn test_dev_server_leave_room(
     cx1.executor().run_until_parked();
 
     let (workspace, cx2) = client2.active_workspace(cx2);
-    cx2.update(|cx| assert!(workspace.read(cx).project().read(cx).is_disconnected()));
+    cx2.update(|cx| assert!(workspace.read(cx).project().read(cx).is_disconnected(cx)));
 }
 
 #[gpui::test]
@@ -308,7 +308,7 @@ async fn test_dev_server_delete(
     cx1.executor().run_until_parked();
 
     let (workspace, cx2) = client2.active_workspace(cx2);
-    cx2.update(|cx| assert!(workspace.read(cx).project().read(cx).is_disconnected()));
+    cx2.update(|cx| assert!(workspace.read(cx).project().read(cx).is_disconnected(cx)));
 
     cx1.update(|cx| {
         dev_server_projects::Store::global(cx).update(cx, |store, _| {
@@ -418,12 +418,12 @@ async fn test_dev_server_refresh_access_token(
 
     // Assert that the other client was disconnected
     let (workspace, cx2) = client2.active_workspace(cx2);
-    cx2.update(|cx| assert!(workspace.read(cx).project().read(cx).is_disconnected()));
+    cx2.update(|cx| assert!(workspace.read(cx).project().read(cx).is_disconnected(cx)));
 
     // Assert that the owner of the dev server does not see the dev server as online anymore
     let (workspace, cx1) = client1.active_workspace(cx1);
     cx1.update(|cx| {
-        assert!(workspace.read(cx).project().read(cx).is_disconnected());
+        assert!(workspace.read(cx).project().read(cx).is_disconnected(cx));
         dev_server_projects::Store::global(cx).update(cx, |store, _| {
             assert_eq!(
                 store.dev_servers().first().unwrap().status,
diff --git a/crates/collab/src/tests/editor_tests.rs b/crates/collab/src/tests/editor_tests.rs
index f9bc21efb1abdf..16deef70d58aa8 100644
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -114,7 +114,7 @@ async fn test_host_disconnect(
 
     project_a.read_with(cx_a, |project, _| assert!(!project.is_shared()));
 
-    project_b.read_with(cx_b, |project, _| project.is_read_only());
+    project_b.read_with(cx_b, |project, cx| project.is_read_only(cx));
 
     assert!(worktree_a.read_with(cx_a, |tree, _| !tree.has_update_observer()));
 
diff --git a/crates/collab/src/tests/integration_tests.rs b/crates/collab/src/tests/integration_tests.rs
index 28591136344177..cc8c35fbc3cf7b 100644
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -1389,7 +1389,7 @@ async fn test_unshare_project(
         .unwrap();
     executor.run_until_parked();
 
-    assert!(project_b.read_with(cx_b, |project, _| project.is_disconnected()));
+    assert!(project_b.read_with(cx_b, |project, cx| project.is_disconnected(cx)));
 
     // Client C opens the project.
     let project_c = client_c.join_remote_project(project_id, cx_c).await;
@@ -1402,7 +1402,7 @@ async fn test_unshare_project(
 
     assert!(worktree_a.read_with(cx_a, |tree, _| !tree.has_update_observer()));
 
-    assert!(project_c.read_with(cx_c, |project, _| project.is_disconnected()));
+    assert!(project_c.read_with(cx_c, |project, cx| project.is_disconnected(cx)));
 
     // Client C can open the project again after client A re-shares.
     let project_id = active_call_a
@@ -1427,8 +1427,8 @@ async fn test_unshare_project(
 
     project_a.read_with(cx_a, |project, _| assert!(!project.is_shared()));
 
-    project_c2.read_with(cx_c, |project, _| {
-        assert!(project.is_disconnected());
+    project_c2.read_with(cx_c, |project, cx| {
+        assert!(project.is_disconnected(cx));
         assert!(project.collaborators().is_empty());
     });
 }
@@ -1560,8 +1560,8 @@ async fn test_project_reconnect(
         assert_eq!(project.collaborators().len(), 1);
     });
 
-    project_b1.read_with(cx_b, |project, _| {
-        assert!(!project.is_disconnected());
+    project_b1.read_with(cx_b, |project, cx| {
+        assert!(!project.is_disconnected(cx));
         assert_eq!(project.collaborators().len(), 1);
     });
 
@@ -1661,7 +1661,7 @@ async fn test_project_reconnect(
     });
 
     project_b1.read_with(cx_b, |project, cx| {
-        assert!(!project.is_disconnected());
+        assert!(!project.is_disconnected(cx));
         assert_eq!(
             project
                 .worktree_for_id(worktree1_id, cx)
@@ -1695,9 +1695,9 @@ async fn test_project_reconnect(
         );
     });
 
-    project_b2.read_with(cx_b, |project, _| assert!(project.is_disconnected()));
+    project_b2.read_with(cx_b, |project, cx| assert!(project.is_disconnected(cx)));
 
-    project_b3.read_with(cx_b, |project, _| assert!(!project.is_disconnected()));
+    project_b3.read_with(cx_b, |project, cx| assert!(!project.is_disconnected(cx)));
 
     buffer_a1.read_with(cx_a, |buffer, _| assert_eq!(buffer.text(), "WaZ"));
 
@@ -1754,7 +1754,7 @@ async fn test_project_reconnect(
     executor.run_until_parked();
 
     project_b1.read_with(cx_b, |project, cx| {
-        assert!(!project.is_disconnected());
+        assert!(!project.is_disconnected(cx));
         assert_eq!(
             project
                 .worktree_for_id(worktree1_id, cx)
@@ -1788,7 +1788,7 @@ async fn test_project_reconnect(
         );
     });
 
-    project_b3.read_with(cx_b, |project, _| assert!(project.is_disconnected()));
+    project_b3.read_with(cx_b, |project, cx| assert!(project.is_disconnected(cx)));
 
     buffer_a1.read_with(cx_a, |buffer, _| assert_eq!(buffer.text(), "WXaYZ"));
 
@@ -3816,8 +3816,8 @@ async fn test_leaving_project(
         assert_eq!(project.collaborators().len(), 1);
     });
 
-    project_b2.read_with(cx_b, |project, _| {
-        assert!(project.is_disconnected());
+    project_b2.read_with(cx_b, |project, cx| {
+        assert!(project.is_disconnected(cx));
     });
 
     project_c.read_with(cx_c, |project, _| {
@@ -3849,12 +3849,12 @@ async fn test_leaving_project(
         assert_eq!(project.collaborators().len(), 0);
     });
 
-    project_b2.read_with(cx_b, |project, _| {
-        assert!(project.is_disconnected());
+    project_b2.read_with(cx_b, |project, cx| {
+        assert!(project.is_disconnected(cx));
     });
 
-    project_c.read_with(cx_c, |project, _| {
-        assert!(project.is_disconnected());
+    project_c.read_with(cx_c, |project, cx| {
+        assert!(project.is_disconnected(cx));
     });
 }
 
diff --git a/crates/collab/src/tests/random_project_collaboration_tests.rs b/crates/collab/src/tests/random_project_collaboration_tests.rs
index 19d37f8786be6f..47f6a38073175b 100644
--- a/crates/collab/src/tests/random_project_collaboration_tests.rs
+++ b/crates/collab/src/tests/random_project_collaboration_tests.rs
@@ -1168,7 +1168,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                             Some((project, cx))
                         });
 
-                        if !guest_project.is_disconnected() {
+                        if !guest_project.is_disconnected(cx) {
                             if let Some((host_project, host_cx)) = host_project {
                                 let host_worktree_snapshots =
                                     host_project.read_with(host_cx, |host_project, cx| {
@@ -1254,8 +1254,8 @@ impl RandomizedTest for ProjectCollaborationTest {
 
             let buffers = client.buffers().clone();
             for (guest_project, guest_buffers) in &buffers {
-                let project_id = if guest_project.read_with(client_cx, |project, _| {
-                    project.is_local() || project.is_disconnected()
+                let project_id = if guest_project.read_with(client_cx, |project, cx| {
+                    project.is_local() || project.is_disconnected(cx)
                 }) {
                     continue;
                 } else {
diff --git a/crates/collab/src/tests/randomized_test_helpers.rs b/crates/collab/src/tests/randomized_test_helpers.rs
index c788dd28e0e526..7bf1034ceaab88 100644
--- a/crates/collab/src/tests/randomized_test_helpers.rs
+++ b/crates/collab/src/tests/randomized_test_helpers.rs
@@ -532,9 +532,9 @@ impl<T: RandomizedTest> TestPlan<T> {
                 server.allow_connections();
 
                 for project in client.dev_server_projects().iter() {
-                    project.read_with(&client_cx, |project, _| {
+                    project.read_with(&client_cx, |project, cx| {
                         assert!(
-                            project.is_disconnected(),
+                            project.is_disconnected(cx),
                             "project {:?} should be read only",
                             project.remote_id()
                         )
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index b33416228e0d81..7a7bd2863b9c9b 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -647,17 +647,10 @@ pub struct FormattableBuffer {
 }
 
 pub struct RemoteLspStore {
-    upstream_client: AnyProtoClient,
+    upstream_client: Option<AnyProtoClient>,
     upstream_project_id: u64,
 }
 
-impl RemoteLspStore {}
-
-// pub struct SshLspStore {
-//     upstream_client: AnyProtoClient,
-//     current_lsp_settings: HashMap<LanguageServerName, LspSettings>,
-// }
-
 #[allow(clippy::large_enum_variant)]
 pub enum LspStoreMode {
     Local(LocalLspStore),   // ssh host and collab host
@@ -808,10 +801,15 @@ impl LspStore {
     pub fn upstream_client(&self) -> Option<(AnyProtoClient, u64)> {
         match &self.mode {
             LspStoreMode::Remote(RemoteLspStore {
-                upstream_client,
+                upstream_client: Some(upstream_client),
                 upstream_project_id,
                 ..
             }) => Some((upstream_client.clone(), *upstream_project_id)),
+
+            LspStoreMode::Remote(RemoteLspStore {
+                upstream_client: None,
+                ..
+            }) => None,
             LspStoreMode::Local(_) => None,
         }
     }
@@ -924,7 +922,7 @@ impl LspStore {
 
         Self {
             mode: LspStoreMode::Remote(RemoteLspStore {
-                upstream_client,
+                upstream_client: Some(upstream_client),
                 upstream_project_id: project_id,
             }),
             downstream_client: None,
@@ -3099,6 +3097,15 @@ impl LspStore {
         self.downstream_client.take();
     }
 
+    pub fn disconnected_from_ssh_remote(&mut self) {
+        if let LspStoreMode::Remote(RemoteLspStore {
+            upstream_client, ..
+        }) = &mut self.mode
+        {
+            upstream_client.take();
+        }
+    }
+
     pub(crate) fn set_language_server_statuses_from_proto(
         &mut self,
         language_servers: Vec<proto::LanguageServer>,
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 7f02d3f6dd76e6..7f452e86439701 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -58,7 +58,7 @@ use node_runtime::NodeRuntime;
 use parking_lot::{Mutex, RwLock};
 pub use prettier_store::PrettierStore;
 use project_settings::{ProjectSettings, SettingsObserver, SettingsObserverEvent};
-use remote::SshRemoteClient;
+use remote::{SshConnectionOptions, SshRemoteClient};
 use rpc::{proto::SSH_PROJECT_ID, AnyProtoClient, ErrorCode};
 use search::{SearchInputKind, SearchQuery, SearchResult};
 use search_history::SearchHistory;
@@ -245,6 +245,7 @@ pub enum Event {
     },
     RemoteIdChanged(Option<u64>),
     DisconnectedFromHost,
+    DisconnectedFromSshRemote,
     Closed,
     DeletedEntry(ProjectEntryId),
     CollaboratorUpdated {
@@ -755,6 +756,8 @@ impl Project {
                 }
             })
             .detach();
+
+            cx.subscribe(&ssh, Self::on_ssh_event).detach();
             cx.observe(&ssh, |_, _, cx| cx.notify()).detach();
 
             let this = Self {
@@ -1313,6 +1316,12 @@ impl Project {
             .map(|ssh| ssh.read(cx).connection_state())
     }
 
+    pub fn ssh_connection_options(&self, cx: &AppContext) -> Option<SshConnectionOptions> {
+        self.ssh_client
+            .as_ref()
+            .map(|ssh| ssh.read(cx).connection_options())
+    }
+
     pub fn replica_id(&self) -> ReplicaId {
         match self.client_state {
             ProjectClientState::Remote { replica_id, .. } => replica_id,
@@ -1658,7 +1667,7 @@ impl Project {
     }
 
     pub fn disconnected_from_host(&mut self, cx: &mut ModelContext<Self>) {
-        if self.is_disconnected() {
+        if self.is_disconnected(cx) {
             return;
         }
         self.disconnected_from_host_internal(cx);
@@ -1708,16 +1717,24 @@ impl Project {
         cx.emit(Event::Closed);
     }
 
-    pub fn is_disconnected(&self) -> bool {
+    pub fn is_disconnected(&self, cx: &AppContext) -> bool {
         match &self.client_state {
             ProjectClientState::Remote {
                 sharing_has_stopped,
                 ..
             } => *sharing_has_stopped,
+            ProjectClientState::Local if self.is_via_ssh() => self.ssh_is_disconnected(cx),
             _ => false,
         }
     }
 
+    fn ssh_is_disconnected(&self, cx: &AppContext) -> bool {
+        self.ssh_client
+            .as_ref()
+            .map(|ssh| ssh.read(cx).is_disconnected())
+            .unwrap_or(false)
+    }
+
     pub fn capability(&self) -> Capability {
         match &self.client_state {
             ProjectClientState::Remote { capability, .. } => *capability,
@@ -1725,8 +1742,8 @@ impl Project {
         }
     }
 
-    pub fn is_read_only(&self) -> bool {
-        self.is_disconnected() || self.capability() == Capability::ReadOnly
+    pub fn is_read_only(&self, cx: &AppContext) -> bool {
+        self.is_disconnected(cx) || self.capability() == Capability::ReadOnly
     }
 
     pub fn is_local(&self) -> bool {
@@ -1807,7 +1824,7 @@ impl Project {
         path: impl Into<ProjectPath>,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Model<Buffer>>> {
-        if self.is_via_collab() && self.is_disconnected() {
+        if (self.is_via_collab() || self.is_via_ssh()) && self.is_disconnected(cx) {
             return Task::ready(Err(anyhow!(ErrorCode::Disconnected)));
         }
 
@@ -2114,6 +2131,30 @@ impl Project {
         }
     }
 
+    fn on_ssh_event(
+        &mut self,
+        _: Model<SshRemoteClient>,
+        event: &remote::SshRemoteEvent,
+        cx: &mut ModelContext<Self>,
+    ) {
+        match event {
+            remote::SshRemoteEvent::Disconnected => {
+                // if self.is_via_ssh() {
+                // self.collaborators.clear();
+                self.worktree_store.update(cx, |store, cx| {
+                    store.disconnected_from_host(cx);
+                });
+                self.buffer_store.update(cx, |buffer_store, cx| {
+                    buffer_store.disconnected_from_host(cx)
+                });
+                self.lsp_store.update(cx, |lsp_store, _cx| {
+                    lsp_store.disconnected_from_ssh_remote()
+                });
+                cx.emit(Event::DisconnectedFromSshRemote);
+            }
+        }
+    }
+
     fn on_settings_observer_event(
         &mut self,
         _: Model<SettingsObserver>,
diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 1fc04a0d0b4f44..41b475d785e88d 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -509,6 +509,11 @@ impl WorktreeStore {
         for worktree in &self.worktrees {
             if let Some(worktree) = worktree.upgrade() {
                 worktree.update(cx, |worktree, _| {
+                    println!(
+                        "worktree. is_local: {:?}, is_remote: {:?}",
+                        worktree.is_local(),
+                        worktree.is_remote()
+                    );
                     if let Some(worktree) = worktree.as_remote_mut() {
                         worktree.disconnected_from_host();
                     }
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 39130513ee37a5..26a2bf27e095dd 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -344,16 +344,17 @@ impl ProjectPanel {
                             let worktree_id = worktree.read(cx).id();
                             let entry_id = entry.id;
 
-                                project_panel.update(cx, |this, _| {
-                                    if !mark_selected {
-                                        this.marked_entries.clear();
-                                    }
-                                    this.marked_entries.insert(SelectedEntry {
-                                        worktree_id,
-                                        entry_id
-                                    });
-                                }).ok();
+                            project_panel.update(cx, |this, _| {
+                                if !mark_selected {
+                                    this.marked_entries.clear();
+                                }
+                                this.marked_entries.insert(SelectedEntry {
+                                    worktree_id,
+                                    entry_id
+                                });
+                            }).ok();
 
+                            let is_via_ssh = project.read(cx).is_via_ssh();
 
                             workspace
                                 .open_path_preview(
@@ -368,7 +369,11 @@ impl ProjectPanel {
                                 )
                                 .detach_and_prompt_err("Failed to open file", cx, move |e, _| {
                                     match e.error_code() {
-                                        ErrorCode::Disconnected => Some("Disconnected from remote project".to_string()),
+                                        ErrorCode::Disconnected => if is_via_ssh {
+                                            Some("Disconnected from SSH host".to_string())
+                                        } else {
+                                            Some("Disconnected from remote project".to_string())
+                                        },
                                         ErrorCode::UnsharedItem => Some(format!(
                                             "{} is not shared by the host. This could be because it has been marked as `private`",
                                             file_path.display()
@@ -493,7 +498,7 @@ impl ProjectPanel {
             let is_foldable = auto_fold_dirs && self.is_foldable(entry, worktree);
             let is_unfoldable = auto_fold_dirs && self.is_unfoldable(entry, worktree);
             let worktree_id = worktree.id();
-            let is_read_only = project.is_read_only();
+            let is_read_only = project.is_read_only(cx);
             let is_remote = project.is_via_collab() && project.dev_server_project_id().is_none();
             let is_local = project.is_local();
 
@@ -2901,7 +2906,7 @@ impl Render for ProjectPanel {
                 .on_action(cx.listener(Self::new_search_in_directory))
                 .on_action(cx.listener(Self::unfold_directory))
                 .on_action(cx.listener(Self::fold_directory))
-                .when(!project.is_read_only(), |el| {
+                .when(!project.is_read_only(cx), |el| {
                     el.on_action(cx.listener(Self::new_file))
                         .on_action(cx.listener(Self::new_directory))
                         .on_action(cx.listener(Self::rename))
diff --git a/crates/recent_projects/src/disconnected_overlay.rs b/crates/recent_projects/src/disconnected_overlay.rs
index f488150c836d1c..cec38ee598f8b6 100644
--- a/crates/recent_projects/src/disconnected_overlay.rs
+++ b/crates/recent_projects/src/disconnected_overlay.rs
@@ -1,19 +1,29 @@
+use std::path::PathBuf;
+
 use dev_server_projects::DevServer;
 use gpui::{ClickEvent, DismissEvent, EventEmitter, FocusHandle, FocusableView, Render, WeakView};
+use remote::SshConnectionOptions;
 use ui::{
     div, h_flex, rems, Button, ButtonCommon, ButtonStyle, Clickable, ElevationIndex, FluentBuilder,
     Headline, HeadlineSize, IconName, IconPosition, InteractiveElement, IntoElement, Label, Modal,
     ModalFooter, ModalHeader, ParentElement, Section, Styled, StyledExt, ViewContext,
 };
-use workspace::{notifications::DetachAndPromptErr, ModalView, Workspace};
+use workspace::{notifications::DetachAndPromptErr, ModalView, OpenOptions, Workspace};
 
 use crate::{
-    dev_servers::reconnect_to_dev_server_project, open_dev_server_project, DevServerProjects,
+    dev_servers::reconnect_to_dev_server_project, open_dev_server_project, open_ssh_project,
+    DevServerProjects,
 };
 
+enum Host {
+    RemoteProject,
+    DevServerProject(DevServer),
+    SshRemoteProject(SshConnectionOptions),
+}
+
 pub struct DisconnectedOverlay {
     workspace: WeakView<Workspace>,
-    dev_server: Option<DevServer>,
+    host: Host,
     focus_handle: FocusHandle,
 }
 
@@ -32,7 +42,10 @@ impl ModalView for DisconnectedOverlay {
 impl DisconnectedOverlay {
     pub fn register(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
         cx.subscribe(workspace.project(), |workspace, project, event, cx| {
-            if !matches!(event, project::Event::DisconnectedFromHost) {
+            if !matches!(
+                event,
+                project::Event::DisconnectedFromHost | project::Event::DisconnectedFromSshRemote
+            ) {
                 return;
             }
             let handle = cx.view().downgrade();
@@ -45,9 +58,19 @@ impl DisconnectedOverlay {
                         .dev_server_for_project(id)
                 })
                 .cloned();
+
+            let ssh_connection_options = project.read(cx).ssh_connection_options(cx);
+            let host = if let Some(dev_server) = dev_server {
+                Host::DevServerProject(dev_server)
+            } else if let Some(ssh_connection_options) = ssh_connection_options {
+                Host::SshRemoteProject(ssh_connection_options)
+            } else {
+                Host::RemoteProject
+            };
+
             workspace.toggle_modal(cx, |cx| DisconnectedOverlay {
                 workspace: handle,
-                dev_server,
+                host,
                 focus_handle: cx.focus_handle(),
             });
         })
@@ -56,12 +79,22 @@ impl DisconnectedOverlay {
 
     fn handle_reconnect(&mut self, _: &ClickEvent, cx: &mut ViewContext<Self>) {
         cx.emit(DismissEvent);
+
+        match &self.host {
+            Host::DevServerProject(dev_server) => {
+                self.reconnect_to_dev_server(dev_server.clone(), cx);
+            }
+            Host::SshRemoteProject(ssh_connection_options) => {
+                self.reconnect_to_ssh_remote(ssh_connection_options.clone(), cx);
+            }
+            _ => {}
+        }
+    }
+
+    fn reconnect_to_dev_server(&self, dev_server: DevServer, cx: &mut ViewContext<Self>) {
         let Some(workspace) = self.workspace.upgrade() else {
             return;
         };
-        let Some(dev_server) = self.dev_server.clone() else {
-            return;
-        };
         let Some(dev_server_project_id) = workspace
             .read(cx)
             .project()
@@ -102,6 +135,44 @@ impl DisconnectedOverlay {
         }
     }
 
+    fn reconnect_to_ssh_remote(
+        &self,
+        connection_options: SshConnectionOptions,
+        cx: &mut ViewContext<Self>,
+    ) {
+        let Some(workspace) = self.workspace.upgrade() else {
+            return;
+        };
+
+        let Some(ssh_project) = workspace.read(cx).serialized_ssh_project() else {
+            return;
+        };
+
+        let Some(window) = cx.window_handle().downcast::<Workspace>() else {
+            return;
+        };
+
+        let app_state = workspace.read(cx).app_state().clone();
+
+        let paths = ssh_project.paths.iter().map(PathBuf::from).collect();
+
+        cx.spawn(move |_, mut cx| async move {
+            open_ssh_project(
+                connection_options,
+                paths,
+                app_state,
+                OpenOptions {
+                    replace_window: Some(window),
+                    ..Default::default()
+                },
+                &mut cx,
+            )
+            .await?;
+            Ok(())
+        })
+        .detach_and_prompt_err("Failed to reconnect", cx, |_, _| None);
+    }
+
     fn cancel(&mut self, _: &menu::Cancel, cx: &mut ViewContext<Self>) {
         cx.emit(DismissEvent)
     }
@@ -109,6 +180,23 @@ impl DisconnectedOverlay {
 
 impl Render for DisconnectedOverlay {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let can_reconnect = matches!(
+            self.host,
+            Host::DevServerProject(_) | Host::SshRemoteProject(_)
+        );
+
+        let message = match &self.host {
+            Host::RemoteProject | Host::DevServerProject(_) => {
+                "Your connection to the remote project has been lost.".to_string()
+            }
+            Host::SshRemoteProject(options) => {
+                format!(
+                    "Your connection to {} has been lost",
+                    options.connection_string()
+                )
+            }
+        };
+
         div()
             .track_focus(&self.focus_handle)
             .elevation_3(cx)
@@ -123,9 +211,7 @@ impl Render for DisconnectedOverlay {
                             .show_dismiss_button(true)
                             .child(Headline::new("Disconnected").size(HeadlineSize::Small)),
                     )
-                    .section(Section::new().child(Label::new(
-                        "Your connection to the remote project has been lost.",
-                    )))
+                    .section(Section::new().child(Label::new(message)))
                     .footer(
                         ModalFooter::new().end_slot(
                             h_flex()
@@ -138,7 +224,7 @@ impl Render for DisconnectedOverlay {
                                             cx.remove_window();
                                         })),
                                 )
-                                .when_some(self.dev_server.clone(), |el, _| {
+                                .when(can_reconnect, |el| {
                                     el.child(
                                         Button::new("reconnect", "Reconnect")
                                             .style(ButtonStyle::Filled)
diff --git a/crates/remote/src/remote.rs b/crates/remote/src/remote.rs
index 382adf0dacd50f..43eb59c0aece4e 100644
--- a/crates/remote/src/remote.rs
+++ b/crates/remote/src/remote.rs
@@ -5,4 +5,5 @@ pub mod ssh_session;
 
 pub use ssh_session::{
     ConnectionState, SshClientDelegate, SshConnectionOptions, SshPlatform, SshRemoteClient,
+    SshRemoteEvent,
 };
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index e709fd726e9a7f..48b1641f3d244d 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -17,7 +17,8 @@ use futures::{
     StreamExt as _,
 };
 use gpui::{
-    AppContext, AsyncAppContext, Context, Model, ModelContext, SemanticVersion, Task, WeakModel,
+    AppContext, AsyncAppContext, Context, EventEmitter, Model, ModelContext, SemanticVersion, Task,
+    WeakModel,
 };
 use parking_lot::Mutex;
 use rpc::{
@@ -315,6 +316,10 @@ impl State {
         matches!(self, Self::ReconnectFailed { .. })
     }
 
+    fn is_reconnect_exhausted(&self) -> bool {
+        matches!(self, Self::ReconnectExhausted { .. })
+    }
+
     fn is_reconnecting(&self) -> bool {
         matches!(self, Self::Reconnecting { .. })
     }
@@ -376,7 +381,7 @@ impl State {
 }
 
 /// The state of the ssh connection.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum ConnectionState {
     Connecting,
     Connected,
@@ -411,6 +416,13 @@ impl Drop for SshRemoteClient {
     }
 }
 
+#[derive(Debug)]
+pub enum SshRemoteEvent {
+    Disconnected,
+}
+
+impl EventEmitter<SshRemoteEvent> for SshRemoteClient {}
+
 impl SshRemoteClient {
     pub fn new(
         unique_identifier: String,
@@ -672,6 +684,9 @@ impl SshRemoteClient {
 
                 if this.state_is(State::is_reconnect_failed) {
                     this.reconnect(cx)
+                } else if this.state_is(State::is_reconnect_exhausted) {
+                    cx.emit(SshRemoteEvent::Disconnected);
+                    Ok(())
                 } else {
                     log::debug!("State has transition from Reconnecting into new state while attempting reconnect. Ignoring new state.");
                     Ok(())
@@ -851,11 +866,15 @@ impl SshRemoteClient {
                                 log::error!("failed to reconnect because server is not running");
                                 this.update(&mut cx, |this, cx| {
                                     this.set_state(State::ServerNotRunning, cx);
+                                    cx.emit(SshRemoteEvent::Disconnected);
                                 })?;
                             }
                         }
                     } else if exit_code > 0 {
                         log::error!("proxy process terminated unexpectedly");
+                        this.update(&mut cx, |this, cx| {
+                            this.reconnect(cx).ok();
+                        })?;
                     }
                 }
                 Ok(None) => {}
@@ -963,6 +982,11 @@ impl SshRemoteClient {
         self.connection_options.connection_string()
     }
 
+    pub fn connection_options(&self) -> SshConnectionOptions {
+        self.connection_options.clone()
+    }
+
+    #[cfg(not(any(test, feature = "test-support")))]
     pub fn connection_state(&self) -> ConnectionState {
         self.state
             .lock()
@@ -971,6 +995,15 @@ impl SshRemoteClient {
             .unwrap_or(ConnectionState::Disconnected)
     }
 
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn connection_state(&self) -> ConnectionState {
+        ConnectionState::Connected
+    }
+
+    pub fn is_disconnected(&self) -> bool {
+        self.connection_state() == ConnectionState::Disconnected
+    }
+
     #[cfg(any(test, feature = "test-support"))]
     pub fn fake(
         client_cx: &mut gpui::TestAppContext,
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index 999165b9d856c7..4e196b8bbfc827 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -366,7 +366,7 @@ impl TitleBar {
             return self.render_ssh_project_host(cx);
         }
 
-        if self.project.read(cx).is_disconnected() {
+        if self.project.read(cx).is_disconnected(cx) {
             return Some(
                 Button::new("disconnected", "Disconnected")
                     .disabled(true)
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 814c7fa91510d7..11acee84939eb4 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -823,6 +823,10 @@ impl Workspace {
                     }
                 }
 
+                project::Event::DisconnectedFromSshRemote => {
+                    this.update_window_edited(cx);
+                }
+
                 project::Event::Closed => {
                     cx.remove_window();
                 }
@@ -1464,6 +1468,10 @@ impl Workspace {
         self.on_prompt_for_open_path = Some(prompt)
     }
 
+    pub fn serialized_ssh_project(&self) -> Option<SerializedSshProject> {
+        self.serialized_ssh_project.clone()
+    }
+
     pub fn set_serialized_ssh_project(&mut self, serialized_ssh_project: SerializedSshProject) {
         self.serialized_ssh_project = Some(serialized_ssh_project);
     }
@@ -1791,7 +1799,7 @@ impl Workspace {
         mut save_intent: SaveIntent,
         cx: &mut ViewContext<Self>,
     ) -> Task<Result<bool>> {
-        if self.project.read(cx).is_disconnected() {
+        if self.project.read(cx).is_disconnected(cx) {
             return Task::ready(Ok(true));
         }
         let dirty_items = self
@@ -3447,7 +3455,7 @@ impl Workspace {
     }
 
     fn update_window_edited(&mut self, cx: &mut WindowContext) {
-        let is_edited = !self.project.read(cx).is_disconnected()
+        let is_edited = !self.project.read(cx).is_disconnected(cx)
             && self
                 .items(cx)
                 .any(|item| item.has_conflict(cx) || item.is_dirty(cx));
@@ -4858,7 +4866,7 @@ impl Render for Workspace {
                         .children(self.render_notifications(cx)),
                 )
                 .child(self.status_bar.clone())
-                .children(if self.project.read(cx).is_disconnected() {
+                .children(if self.project.read(cx).is_disconnected(cx) {
                     if let Some(render) = self.render_disconnected_overlay.take() {
                         let result = render(self, cx);
                         self.render_disconnected_overlay = Some(render);

From 7c306a5a0e20811d1c75668516aa7f600444ce7d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E5=B0=8F=E7=99=BD?= <364772080@qq.com>
Date: Thu, 10 Oct 2024 19:09:50 +0800
Subject: [PATCH 583/762] gpui: Fix window display on Windows (#18705)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Closes #18610


This PR addresses the same issue as PR #18578. After a full day of
research and testing, I believe I’ve found the best solution to resolve
this issue. With this PR, the window creation behavior on Windows
becomes more consistent with macOS:

- When `params.show` is `true`: The window is created and immediately
displayed.
- When `params.show` is `false`: The window is created but remains
hidden until the first call to `activate_window`.

As I mentioned in #18578, `winit` creates hidden windows by setting the
window's `exstyle` to `WS_EX_NOACTIVATE | WS_EX_TRANSPARENT |
WS_EX_LAYERED | WS_EX_TOOLWINDOW`, which is different from the method
used in this PR. Here, the window is created with normal parameters, but
we do not call `ShowWindow` so the window is not shown.

I'm not sure why `winit` doesn't use a smilliar approach like this PR to
create hidden windows. My guess is that `winit` is creating this hidden
window to function as a "DispatchWindow" — serving a purpose similar to
`WindowsPlatform` in `zed`. To ensure the window stays hidden even if
`ShowWindow` is called, they use the `exstyle` approach.

With the method used in this PR, my initial tests haven't revealed any
issues.



Release Notes:

- N/A
---
 crates/gpui/src/platform/windows/window.rs | 90 ++++++++++++++--------
 1 file changed, 58 insertions(+), 32 deletions(-)

diff --git a/crates/gpui/src/platform/windows/window.rs b/crates/gpui/src/platform/windows/window.rs
index d7b9a469b7d4e5..3faaa6a8d2472b 100644
--- a/crates/gpui/src/platform/windows/window.rs
+++ b/crates/gpui/src/platform/windows/window.rs
@@ -52,6 +52,7 @@ pub struct WindowsWindowState {
 
     pub display: WindowsDisplay,
     fullscreen: Option<StyleAndBounds>,
+    initial_placement: Option<WINDOWPLACEMENT>,
     hwnd: HWND,
 }
 
@@ -97,6 +98,7 @@ impl WindowsWindowState {
         let system_settings = WindowsSystemSettings::new(display);
         let nc_button_pressed = None;
         let fullscreen = None;
+        let initial_placement = None;
 
         Ok(Self {
             origin,
@@ -114,6 +116,7 @@ impl WindowsWindowState {
             nc_button_pressed,
             display,
             fullscreen,
+            initial_placement,
             hwnd,
         })
     }
@@ -231,6 +234,14 @@ impl WindowsWindowStatePtr {
             main_receiver: context.main_receiver.clone(),
         }))
     }
+
+    fn set_window_placement(&self) -> Result<()> {
+        let Some(placement) = self.state.borrow_mut().initial_placement.take() else {
+            return Ok(());
+        };
+        unsafe { SetWindowPlacement(self.hwnd, &placement)? };
+        Ok(())
+    }
 }
 
 #[derive(Default)]
@@ -295,9 +306,6 @@ impl WindowsWindow {
                 WS_THICKFRAME | WS_SYSMENU | WS_MAXIMIZEBOX | WS_MINIMIZEBOX,
             )
         };
-        if !params.show {
-            dwstyle |= WS_MINIMIZE;
-        }
 
         let hinstance = get_module_handle();
         let display = if let Some(display_id) = params.display_id {
@@ -336,36 +344,24 @@ impl WindowsWindow {
                 lpparam,
             )
         };
-        // We should call `?` on state_ptr first, then call `?` on raw_hwnd.
+        // We should call `?` on state_ptr first, then call `?` on hwnd.
         // Or, we will lose the error info reported by `WindowsWindowState::new`
         let state_ptr = context.inner.take().unwrap()?;
-        let raw_hwnd = creation_result?;
+        let hwnd = creation_result?;
         register_drag_drop(state_ptr.clone())?;
 
-        unsafe {
-            let mut placement = WINDOWPLACEMENT {
-                length: std::mem::size_of::<WINDOWPLACEMENT>() as u32,
-                ..Default::default()
-            };
-            GetWindowPlacement(raw_hwnd, &mut placement)?;
-            // the bounds may be not inside the display
-            let bounds = if display.check_given_bounds(params.bounds) {
-                params.bounds
-            } else {
-                display.default_bounds()
-            };
-            let mut lock = state_ptr.state.borrow_mut();
-            let bounds = bounds.to_device_pixels(lock.scale_factor);
-            lock.border_offset.update(raw_hwnd)?;
-            placement.rcNormalPosition = calculate_window_rect(bounds, lock.border_offset);
-            drop(lock);
-            SetWindowPlacement(raw_hwnd, &placement)?;
-        }
-
+        state_ptr.state.borrow_mut().border_offset.update(hwnd)?;
+        let placement = retrieve_window_placement(
+            hwnd,
+            display,
+            params.bounds,
+            state_ptr.state.borrow().scale_factor,
+            state_ptr.state.borrow().border_offset,
+        )?;
         if params.show {
-            unsafe { ShowWindow(raw_hwnd, SW_SHOW).ok()? };
+            unsafe { SetWindowPlacement(hwnd, &placement)? };
         } else {
-            unsafe { ShowWindow(raw_hwnd, SW_HIDE).ok()? };
+            state_ptr.state.borrow_mut().initial_placement = Some(placement);
         }
 
         Ok(Self(state_ptr))
@@ -541,11 +537,18 @@ impl PlatformWindow for WindowsWindow {
 
     fn activate(&self) {
         let hwnd = self.0.hwnd;
-        unsafe { SetActiveWindow(hwnd).log_err() };
-        unsafe { SetFocus(hwnd).log_err() };
-        // todo(windows)
-        // crate `windows 0.56` reports true as Err
-        unsafe { SetForegroundWindow(hwnd).as_bool() };
+        let this = self.0.clone();
+        self.0
+            .executor
+            .spawn(async move {
+                this.set_window_placement().log_err();
+                unsafe { SetActiveWindow(hwnd).log_err() };
+                unsafe { SetFocus(hwnd).log_err() };
+                // todo(windows)
+                // crate `windows 0.56` reports true as Err
+                unsafe { SetForegroundWindow(hwnd).as_bool() };
+            })
+            .detach();
     }
 
     fn is_active(&self) -> bool {
@@ -1066,6 +1069,29 @@ fn calculate_client_rect(
     }
 }
 
+fn retrieve_window_placement(
+    hwnd: HWND,
+    display: WindowsDisplay,
+    initial_bounds: Bounds<Pixels>,
+    scale_factor: f32,
+    border_offset: WindowBorderOffset,
+) -> Result<WINDOWPLACEMENT> {
+    let mut placement = WINDOWPLACEMENT {
+        length: std::mem::size_of::<WINDOWPLACEMENT>() as u32,
+        ..Default::default()
+    };
+    unsafe { GetWindowPlacement(hwnd, &mut placement)? };
+    // the bounds may be not inside the display
+    let bounds = if display.check_given_bounds(initial_bounds) {
+        initial_bounds
+    } else {
+        display.default_bounds()
+    };
+    let bounds = bounds.to_device_pixels(scale_factor);
+    placement.rcNormalPosition = calculate_window_rect(bounds, border_offset);
+    Ok(placement)
+}
+
 mod windows_renderer {
     use std::{num::NonZeroIsize, sync::Arc};
 

From 68594820204e7e87e8b45efff4cbd65caff0936d Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 10 Oct 2024 14:10:35 +0300
Subject: [PATCH 584/762] Update Rust crate emojis to v0.6.4 (#18661)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [emojis](https://redirect.github.com/rossmacarthur/emojis) |
workspace.dependencies | patch | `0.6.3` -> `0.6.4` |

---

### Release Notes

<details>
<summary>rossmacarthur/emojis (emojis)</summary>

###
[`v0.6.4`](https://redirect.github.com/rossmacarthur/emojis/compare/0.6.3...0.6.4)

[Compare
Source](https://redirect.github.com/rossmacarthur/emojis/compare/0.6.3...0.6.4)

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguOTcuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a9738c338c4a86..23b27dfadd0de1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3840,9 +3840,9 @@ checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
 
 [[package]]
 name = "emojis"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e72f23d65b46527e461b161ab9a126c378aa2249d8a8d15718d23ab1fb4d8786"
+checksum = "99e1f1df1f181f2539bac8bf027d31ca5ffbf9e559e3f2d09413b9107b5c02f4"
 dependencies = [
  "phf",
 ]

From 281c60f12d5ab72ea923030f00269bb95b377f48 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 10 Oct 2024 14:10:45 +0300
Subject: [PATCH 585/762] Update Rust crate async-compression to v0.4.13
 (#18655)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
|
[async-compression](https://redirect.github.com/Nullus157/async-compression)
| workspace.dependencies | patch | `0.4.12` -> `0.4.13` |

---

### Release Notes

<details>
<summary>Nullus157/async-compression (async-compression)</summary>

###
[`v0.4.13`](https://redirect.github.com/Nullus157/async-compression/blob/HEAD/CHANGELOG.md#0413---2024-10-02)

[Compare
Source](https://redirect.github.com/Nullus157/async-compression/compare/v0.4.12...v0.4.13)

##### Feature

-   Update `brotli` dependency to to `7`.

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguOTcuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 23b27dfadd0de1..34c6fb685a6fe1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -535,9 +535,9 @@ dependencies = [
 
 [[package]]
 name = "async-compression"
-version = "0.4.12"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fec134f64e2bc57411226dfc4e52dec859ddfc7e711fc5e07b612584f000e4aa"
+checksum = "7e614738943d3f68c628ae3dbce7c3daffb196665f82f8c8ea6b65de73c79429"
 dependencies = [
  "deflate64",
  "flate2",

From 348e31769542ae8b73cea663e7a3fb8cc6b2a8d4 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 10 Oct 2024 14:10:56 +0300
Subject: [PATCH 586/762] Update Rust crate ipc-channel to v0.18.3 (#18663)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [ipc-channel](https://redirect.github.com/servo/ipc-channel) |
dependencies | patch | `0.18.2` -> `0.18.3` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguOTcuMCIsInRhcmdldEJyYW5jaCI6Im1haW4iLCJsYWJlbHMiOltdfQ==-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 34c6fb685a6fe1..0170438afb1241 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5956,9 +5956,9 @@ dependencies = [
 
 [[package]]
 name = "ipc-channel"
-version = "0.18.2"
+version = "0.18.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e46231d1db8ea8f874012b1b87efb9e968f763c577220372a9c7caadce1448da"
+checksum = "c7f4c80f2df4fc64fb7fc2cff69fc034af26e6e6617ea9f1313131af464b9ca0"
 dependencies = [
  "bincode",
  "crossbeam-channel",
@@ -5970,7 +5970,7 @@ dependencies = [
  "serde",
  "tempfile",
  "uuid",
- "windows 0.48.0",
+ "windows 0.58.0",
 ]
 
 [[package]]
@@ -13569,15 +13569,6 @@ dependencies = [
  "wasmtime-environ",
 ]
 
-[[package]]
-name = "windows"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
-dependencies = [
- "windows-targets 0.48.5",
-]
-
 [[package]]
 name = "windows"
 version = "0.54.0"

From 8c9a05b2a8863d03cdcc46839a528f44696c328d Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 10 Oct 2024 14:11:32 +0300
Subject: [PATCH 587/762] Update Rust crate proc-macro2 to v1.0.87 (#18957)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [proc-macro2](https://redirect.github.com/dtolnay/proc-macro2) |
dependencies | patch | `1.0.86` -> `1.0.87` |

---

### Release Notes

<details>
<summary>dtolnay/proc-macro2 (proc-macro2)</summary>

###
[`v1.0.87`](https://redirect.github.com/dtolnay/proc-macro2/releases/tag/1.0.87)

[Compare
Source](https://redirect.github.com/dtolnay/proc-macro2/compare/1.0.86...1.0.87)

- Check valid punctuation character in `Punct::new`
([#&#8203;470](https://redirect.github.com/dtolnay/proc-macro2/issues/470))

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4xMTQuMCIsInVwZGF0ZWRJblZlciI6IjM4LjExNC4wIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6W119-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0170438afb1241..48a8c95e052365 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8405,9 +8405,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "b3e4daa0dcf6feba26f985457cdf104d4b4256fc5a09547140f3631bb076b19a"
 dependencies = [
  "unicode-ident",
 ]

From 4de05d18edf4589e6158f1a28155b01cdf879540 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 10 Oct 2024 14:15:59 +0300
Subject: [PATCH 588/762] Update Rust crate ashpd to v0.9.2 (#18950)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [ashpd](https://redirect.github.com/bilelmoussaoui/ashpd) |
workspace.dependencies | patch | `0.9.1` -> `0.9.2` |

---

### Release Notes

<details>
<summary>bilelmoussaoui/ashpd (ashpd)</summary>

###
[`v0.9.2`](https://redirect.github.com/bilelmoussaoui/ashpd/releases/tag/0.9.2)

[Compare
Source](https://redirect.github.com/bilelmoussaoui/ashpd/compare/0.9.1...0.9.2)

#### What's Changed

- [desktop: Make trait SessionPortal
public](https://redirect.github.com/bilelmoussaoui/ashpd/pull/240/commits/0d2dad594ee9a98799895a92e23e52b2250eaf9c)
- [lib: Add Pid
type](https://redirect.github.com/bilelmoussaoui/ashpd/pull/240/commits/96b27e70692d34a10ed6537d732ced5e74f96b04)
- [desktop/game_mode: Use i32 for
pid](https://redirect.github.com/bilelmoussaoui/ashpd/pull/240/commits/336917a4ed4e88f536a9901c9befc0938f9fdcdb)
- [desktop/device: Use Pid type for
pids](https://redirect.github.com/bilelmoussaoui/ashpd/pull/240/commits/c05b3c17f8f6a4a769c69a778d4cd8fea22dd784)
- [flatpak: Use Pid type for
pids](https://redirect.github.com/bilelmoussaoui/ashpd/pull/240/commits/55a6ea0c9d89c34bf65a3be0c75a7d9771c3848c)
- [is_sandboxed: Don't unwrap OnceCell
set](https://redirect.github.com/bilelmoussaoui/ashpd/pull/240/commits/5d3cb4170772351095bed2bf55075c1498df139d)

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4xMTQuMCIsInVwZGF0ZWRJblZlciI6IjM4LjExNC4wIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6W119-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 48a8c95e052365..8567b4a55324ce 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -341,9 +341,9 @@ dependencies = [
 
 [[package]]
 name = "ashpd"
-version = "0.9.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfe7e0dd0ac5a401dc116ed9f9119cf9decc625600474cb41f0fc0a0050abc9a"
+checksum = "4d43c03d9e36dd40cab48435be0b09646da362c278223ca535493877b2c1dee9"
 dependencies = [
  "async-fs 2.1.2",
  "async-net 2.0.0",

From 21c27cecba7b0043cd464f67be7d9425f3c2f119 Mon Sep 17 00:00:00 2001
From: Kevin Wang <kevmo314@gmail.com>
Date: Thu, 10 Oct 2024 07:39:20 -0400
Subject: [PATCH 589/762] Track cursor offset before bias in Supermaven
 completion provider (#18858)

Track the cursor offset before biasing in the Supermaven completion
provider to better determine if the text should be suggested. The
underlying issue here is due to the way anchor biasing works, the
completion provider is not able to determine if a given suggestion's
cursor location no longer exists as it is always coalesced to a correct
location (specifically, the end of the line).

This change updates that logic so the offset is stored independently of
the buffer so it can be used to represent a location that may not exist
in the buffer anymore to represent locations that have been deleted.

The net effect is that suggestions can be backspaced much more cleanly
with Supermaven.


![image](https://github.com/user-attachments/assets/ff61aa09-54ea-4cad-b1ca-633a08bcdd96)


![image](https://github.com/user-attachments/assets/b49e2d6b-f1d3-41a1-9b75-c4bc3ac5f85b)

Release Notes:

- Improves https://github.com/zed-industries/zed/issues/17981 to prevent
suggesting completions based on out-of-date cursor locations.
---
 crates/supermaven/src/supermaven.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/supermaven/src/supermaven.rs b/crates/supermaven/src/supermaven.rs
index fc295b712becac..38e11a2300a642 100644
--- a/crates/supermaven/src/supermaven.rs
+++ b/crates/supermaven/src/supermaven.rs
@@ -141,6 +141,7 @@ impl Supermaven {
                 SupermavenCompletionState {
                     buffer_id,
                     prefix_anchor: cursor_position,
+                    prefix_offset: offset,
                     text: String::new(),
                     dedent: String::new(),
                     updates_tx,
@@ -216,7 +217,7 @@ fn find_relevant_completion<'a>(
         };
 
         let current_cursor_offset = cursor_position.to_offset(buffer);
-        let original_cursor_offset = state.prefix_anchor.to_offset(buffer);
+        let original_cursor_offset = state.prefix_offset;
         if current_cursor_offset < original_cursor_offset {
             continue;
         }
@@ -419,6 +420,9 @@ pub struct SupermavenCompletionStateId(usize);
 pub struct SupermavenCompletionState {
     buffer_id: EntityId,
     prefix_anchor: Anchor,
+    // prefix_offset is tracked independently because the anchor biases left which
+    // doesn't allow us to determine if the prior text has been deleted.
+    prefix_offset: usize,
     text: String,
     dedent: String,
     updates_tx: watch::Sender<()>,

From d2b4fa20efe944346ab53b809c662c9d1302a8f9 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 10 Oct 2024 14:50:52 +0300
Subject: [PATCH 590/762] Update actions/upload-artifact digest to 604373d
 (#18941)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
|
[actions/upload-artifact](https://redirect.github.com/actions/upload-artifact)
| action | digest | `5076954` -> `604373d` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4xMTQuMCIsInVwZGF0ZWRJblZlciI6IjM4LjExNC4wIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6W119-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 379bab88bc61d8..f322d44cca9685 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -219,20 +219,20 @@ jobs:
           mv target/x86_64-apple-darwin/release/Zed.dmg target/x86_64-apple-darwin/release/Zed-x86_64.dmg
 
       - name: Upload app bundle (universal) to workflow run if main branch or specific label
-        uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874 # v4
+        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: Zed_${{ github.event.pull_request.head.sha || github.sha }}.dmg
           path: target/release/Zed.dmg
       - name: Upload app bundle (aarch64) to workflow run if main branch or specific label
-        uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874 # v4
+        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: Zed_${{ github.event.pull_request.head.sha || github.sha }}-aarch64.dmg
           path: target/aarch64-apple-darwin/release/Zed-aarch64.dmg
 
       - name: Upload app bundle (x86_64) to workflow run if main branch or specific label
-        uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874 # v4
+        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: Zed_${{ github.event.pull_request.head.sha || github.sha }}-x86_64.dmg
@@ -283,7 +283,7 @@ jobs:
         run: script/bundle-linux
 
       - name: Upload Linux bundle to workflow run if main branch or specific label
-        uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874 # v4
+        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: zed-${{ github.event.pull_request.head.sha || github.sha }}-x86_64-unknown-linux-gnu.tar.gz
@@ -330,7 +330,7 @@ jobs:
         run: script/bundle-linux
 
       - name: Upload Linux bundle to workflow run if main branch or specific label
-        uses: actions/upload-artifact@50769540e7f4bd5e21e526ee35c689e35e0d6874 # v4
+        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: zed-${{ github.event.pull_request.head.sha || github.sha }}-aarch64-unknown-linux-gnu.tar.gz

From 972886c29e6141de2cfe0190a01c76821e64eae1 Mon Sep 17 00:00:00 2001
From: Peter Schilling <peter@schpet.com>
Date: Thu, 10 Oct 2024 05:15:12 -0700
Subject: [PATCH 591/762] Automatically indent JSX (#18816)

indents jsx in a way that is [consistent with
html](https://github.com/zed-industries/zed/blob/main/extensions/html/languages/html/indents.scm)

before, no automatic indentation would apply and it would even dedent
you when you add a line above the cursor (shift-o in vim mode)


https://github.com/user-attachments/assets/470fbdb2-3e31-42c4-b535-bb26ae1706ab


after, it applies automatic indentation when you hit return


https://github.com/user-attachments/assets/e86c739d-370d-490d-8c6f-d0190e65f832



Closes #16127

Release Notes:

- Improved automatic indentation behavior in JSX
([#16127](https://github.com/zed-industries/zed/issues/16127))
---
 crates/languages/src/javascript/indents.scm | 6 ++++++
 crates/languages/src/tsx/indents.scm        | 6 ++++++
 2 files changed, 12 insertions(+)

diff --git a/crates/languages/src/javascript/indents.scm b/crates/languages/src/javascript/indents.scm
index 107e6ff8e03b63..9897f3060eaf37 100644
--- a/crates/languages/src/javascript/indents.scm
+++ b/crates/languages/src/javascript/indents.scm
@@ -13,3 +13,9 @@
 (_ "<" ">" @end) @indent
 (_ "{" "}" @end) @indent
 (_ "(" ")" @end) @indent
+
+(jsx_opening_element ">" @end) @indent
+
+(jsx_element
+  (jsx_opening_element) @start
+  (jsx_closing_element)? @end) @indent
diff --git a/crates/languages/src/tsx/indents.scm b/crates/languages/src/tsx/indents.scm
index 107e6ff8e03b63..9897f3060eaf37 100644
--- a/crates/languages/src/tsx/indents.scm
+++ b/crates/languages/src/tsx/indents.scm
@@ -13,3 +13,9 @@
 (_ "<" ">" @end) @indent
 (_ "{" "}" @end) @indent
 (_ "(" ")" @end) @indent
+
+(jsx_opening_element ">" @end) @indent
+
+(jsx_element
+  (jsx_opening_element) @start
+  (jsx_closing_element)? @end) @indent

From 9bc4e3b4ae4c248ef0342529caa23bef4593e19b Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Thu, 10 Oct 2024 16:10:18 +0300
Subject: [PATCH 592/762] Do not resolve more completion fields  (#19021)

As Zed instantly shows completion items in the completion menu, and the
resolve will cause the details to appear, flickering.
We can safely resolve the `documentation`, `additionalTextEdits` and
`command` fields, the rest should be resolved eagerly for now.

Release Notes:

- Fixed completion menu rendering
---
 crates/lsp/src/lsp.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs
index 8d67855e39019b..a105c983f9ec36 100644
--- a/crates/lsp/src/lsp.rs
+++ b/crates/lsp/src/lsp.rs
@@ -626,11 +626,7 @@ impl LanguageServer {
                                 properties: vec![
                                     "additionalTextEdits".to_string(),
                                     "command".to_string(),
-                                    "detail".to_string(),
                                     "documentation".to_string(),
-                                    "filterText".to_string(),
-                                    "labelDetails".to_string(),
-                                    "tags".to_string(),
                                     // NB: Do not have this resolved, otherwise Zed becomes slow to complete things
                                     // "textEdit".to_string(),
                                 ],

From 596d8b2fe394421f9078fa91834b69fdb47ce251 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 10 Oct 2024 09:48:02 -0400
Subject: [PATCH 593/762] Update Rust crate wasmtime to v24.0.1 [SECURITY]
 (#18944)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [wasmtime](https://redirect.github.com/bytecodealliance/wasmtime) |
workspace.dependencies | patch | `24.0.0` -> `24.0.1` |

### GitHub Vulnerability Alerts

####
[CVE-2024-47763](https://redirect.github.com/bytecodealliance/wasmtime/security/advisories/GHSA-q8hx-mm92-4wvg)

### Impact

Wasmtime's implementation of WebAssembly tail calls combined with stack
traces can result in a runtime crash in certain WebAssembly modules. The
runtime crash may be undefined behavior if Wasmtime was compiled with
Rust 1.80 or prior. The runtime crash is a deterministic process abort
when Wasmtime is compiled with Rust 1.81 and later.

[WebAssembly tail
calls](https://redirect.github.com/webassembly/tail-call) are a proposal
which relatively recently reached stage 4 in the [standardization
process](https://redirect.github.com/WebAssembly/proposals/). Wasmtime
first enabled support for tail calls by default [in Wasmtime
21.0.0](https://redirect.github.com/bytecodealliance/wasmtime/pull/8540),
although that release contained a bug where it was only on-by-default
for some configurations. In [Wasmtime
22.0.0](https://redirect.github.com/bytecodealliance/wasmtime/pull/8682)
tail calls were enabled by default for all configurations.

The specific crash happens when an exported function in a WebAssembly
module (or component) performs a `return_call` (or
`return_call_indirect` or `return_call_ref`) to an imported host
function which captures a stack trace (for example, the host function
raises a trap). In this situation, the stack-walking code previously
assumed there was always at least one WebAssembly frame on the stack but
with tail calls that is no longer true. With the tail-call proposal it's
possible to have an entry trampoline appear as if it directly called the
exit trampoline. This situation triggers an internal assert in the
stack-walking code which raises a Rust `panic!()`.

When Wasmtime is compiled with Rust versions 1.80 and prior this means
that an `extern "C"` function in Rust is raising a `panic!()`. This is
technically undefined behavior and typically manifests as a process
abort when the unwinder fails to unwind Cranelift-generated frames. When
Wasmtime is compiled with Rust versions 1.81 and later this panic
becomes a deterministic process abort.

Overall the impact of this issue is that this is a denial-of-service
vector where a malicious WebAssembly module or component can cause the
host to crash. There is no other impact at this time other than
availability of a service as the result of the crash is always a crash
and no more.

This issue was discovered by routine fuzzing performed by the Wasmtime
project via Google's OSS-Fuzz infrastructure. We have no evidence that
it has ever been exploited by an attacker in the wild.

### Patches

All versions of Wasmtime which have tail calls enabled by default have
been patched:

* 21.0.x - patched in 21.0.2
* 22.0.x - patched in 22.0.1
* 23.0.x - patched in 23.0.3
* 24.0.x - patched in 24.0.1
* 25.0.x - patched in 25.0.2

Wasmtime versions from 12.0.x (the first release with experimental tail
call support) to 20.0.x (the last release with tail-calls
off-by-default) have support for tail calls but the support is disabled
by default. These versions are not affected in their default
configurations, but users who explicitly enabled tail call support will
need to either disable tail call support or upgrade to a patched version
of Wasmtime.

### Workarounds

The main workaround for this issue is to disable tail support for tail
calls in Wasmtime, for example with
[`Config::wasm_tail_call(false)`](https://docs.rs/wasmtime/latest/wasmtime/struct.Config.html#method.wasm_tail_call).
Users are otherwise encouraged to upgrade to patched versions.

### References

* [Wasmtime's initial implementation of tail
calls](https://redirect.github.com/bytecodealliance/wasmtime/pull/6774)
* [Enabling of tail calls in
21.0.0](https://redirect.github.com/bytecodealliance/wasmtime/pull/8540)
* [Fully enabling tail calls in
22.0.0](https://redirect.github.com/bytecodealliance/wasmtime/pull/8682)
* [The WebAssembly's `tail-call`
proposal](https://redirect.github.com/webassembly/tail-call)

####
[CVE-2024-47813](https://redirect.github.com/bytecodealliance/wasmtime/security/advisories/GHSA-7qmx-3fpx-r45m)

### Impact

Under certain concurrent event orderings, a `wasmtime::Engine`'s
internal type registry was susceptible to double-unregistration bugs due
to a race condition, leading to panics and potentially type registry
corruption. That registry corruption could, following an additional and
particular sequence of concurrent events, lead to violations of
WebAssembly's control-flow integrity (CFI) and type safety. Users that
do not use `wasmtime::Engine` across multiple threads are not affected.
Users that only create new modules across threads over time are
additionally not affected.

Reproducing this bug requires creating and dropping multiple type
instances (such as `wasmtime::FuncType` or `wasmtime::ArrayType`)
concurrently on multiple threads, where all types are associated with
the same `wasmtime::Engine`. **Wasm guests cannot trigger this bug.**
See the "References" section below for a list of Wasmtime types-related
APIs that are affected.

Wasmtime maintains an internal registry of types within a
`wasmtime::Engine` and an engine is shareable across threads. Types can
be created and referenced through creation of a `wasmtime::Module`,
creation of `wasmtime::FuncType`, or a number of other APIs where the
host creates a function (see "References" below). Each of these cases
interacts with an engine to deduplicate type information and manage type
indices that are used to implement type checks in WebAssembly's
`call_indirect` function, for example. This bug is a race condition in
this management where the internal type registry could be corrupted to
trigger an assert or contain invalid state.

Wasmtime's internal representation of a type has individual types (e.g.
one-per-host-function) maintain a registration count of how many time
it's been used. Types additionally have state within an engine behind a
read-write lock such as lookup/deduplication information. The race here
is a time-of-check versus time-of-use (TOCTOU) bug where one thread
atomically decrements a type entry's registration count, observes zero
registrations, and then acquires a lock in order to unregister that
entry. However, between when this first thread observed the
zero-registration count and when it acquires that lock, another thread
could perform the following sequence of events: re-register another copy
of the type, which deduplicates to that same entry, resurrecting it and
incrementing its registration count; then drop the type and decrement
its registration count; observe that the registration count is now zero;
acquire the type registry lock; and finally unregister the type. Now,
when the original thread finally acquires the lock and unregisters the
entry, it is the second time this entry has been unregistered.

| Thread A                          | Thread B                       |
|-----------------------------------|--------------------------------|
| `acquire(type registry lock)`     |                                |
|                                   | `decref(E) --> 0`              |
|                                   | `block_on(type registry lock)` |
| `register(E') == incref(E) --> 1` |                                |
| `release(type registry lock)`     |                                |
| `decref(E) --> 0`                 |                                |
| `acquire(type registry lock)`     |                                |
| `unregister(E)`                   |                                |
| `release(type registry lock)`     |                                |
|                                   | `acquire(type registry lock)`  |
|                                   | `unregister(E)`          |

This double-unregistration could then lead to a WebAssembly CFI
violation under the following conditions: a new WebAssembly module `X`
was loaded into the engine before the second, buggy unregistration
occurs; `X` defined a function type `F` that was allocated in the same
type registry slot where the original entry was allocated; the second,
buggy unregistration incorrectly unregistered `F`; another new
WebAssembly module `Y` was loaded into the engine; `Y` defined a
function type `G`, different from `F`, but which is also allocated in
the same type registry slot; a `funcref` of type `G` is created, either
by the host or by Wasm; that `funcref` is passed to a WebAssembly
instance of module `X`; that instance performs a `call_indirect` to that
`funcref`; the `call_indirect`'s dynamic type check, which preserves
CFI, could incorrectly pass in this case, because `F` and `G` were
assigned the same type registry slot. This would, ultimately, allow
calling a function with too many, too few, or wrongly-typed arguments,
violating CFI and type safety.

We were not able to reproduce this CFI violation in a vanilla Wasmtime
build, although it remains theoretically possible. However, by modifying
Wasmtime's source code to make losing the races described above more
likely (by disabling certain assertions, inserting panic catches, and
adding retry loops in a few places if we did *not* lose the race) we
were able to incorrectly get a `funcref` to pass a type check that it
should have failed, which would allow the CFI violation.

### Patches

This bug was originally introduced in Wasmtime 19's development of the
WebAssembly GC proposal. This bug affects users who are not using the GC
proposal, however, and affects Wasmtime in its default configuration
even when the GC proposal is disabled. Wasmtime users using 19.0.0 and
after are all affected by this issue. We have released the following
Wasmtime versions, all of which have a fix for this bug:

* 21.0.2
* 22.0.1
* 23.0.3
* 24.0.1
* 25.0.2

### Workarounds

If your application creates and drops Wasmtime types on multiple threads
concurrently, there are no known workarounds. Users are encouraged to
upgrade to a patched release.

### References

The following APIs create or drop types, and therefore are affected by
this race condition if performed on multiple threads concurrently and
are all associated with the same `wasmtime::Engine`:

*
[`wasmtime::FuncType::new`](https://docs.rs/wasmtime/latest/wasmtime/struct.FuncType.html#method.new)
* Also reachable from creation of
[`wasmtime::Func`](https://docs.rs/wasmtime/latest/wasmtime/struct.Func.html)
* Also reachable from
[`wasmtime::Linker::func_*`](https://docs.rs/wasmtime/latest/wasmtime/struct.Linker.html#method.func_new)
*
[`wasmtime::ArrayType::new`](https://docs.rs/wasmtime/latest/wasmtime/struct.ArrayType.html#method.new)
*
[`wasmtime::StructType::new`](https://docs.rs/wasmtime/latest/wasmtime/struct.StructType.html#method.new)
*
[`wasmtime::Func::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.Func.html#method.ty)
*
[`wasmtime::Global::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.Global.html#method.ty)
*
[`wasmtime::Table::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.Table.html#method.ty)
*
[`wasmtime::Extern::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.Extern.html#method.ty)
*
[`wasmtime::Export::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.Export.html#method.ty)
*
[`wasmtime::UnknownImportError::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.UnknownImportError.html#method.ty)
*
[`wasmtime::ImportType::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.ImportType.html#method.ty)
*
[`wasmtime::ExportType::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.ExportType.html#method.ty)
*
[`wasmtime::Val::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.Val.html#method.ty)
*
[`wasmtime::Ref::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.Ref.html#method.ty)
*
[`wasmtime::AnyRef::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.AnyRef.html#method.ty)
*
[`wasmtime::EqRef::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.EqRef.html#method.ty)
*
[`wasmtime::ArrayRef::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.ArrayRef.html#method.ty)
*
[`wasmtime::StructRef::ty`](https://docs.rs/wasmtime/latest/wasmtime/struct.StructRef.html#method.ty)
* Dropping a
[`wasmtime::FuncType`](https://docs.rs/wasmtime/latest/wasmtime/struct.FuncType.html)
* Dropping a
[`wasmtime::ArrayType`](https://docs.rs/wasmtime/latest/wasmtime/struct.ArrayType.html)
* Dropping a
[`wasmtime::StructType`](https://docs.rs/wasmtime/latest/wasmtime/struct.StructType.html)
* Dropping a
[`wasmtime::ExternType`](https://docs.rs/wasmtime/latest/wasmtime/struct.ExternType.html)
* Dropping a
[`wasmtime::GlobalType`](https://docs.rs/wasmtime/latest/wasmtime/struct.GlobalType.html)
* Dropping a
[`wasmtime::TableType`](https://docs.rs/wasmtime/latest/wasmtime/struct.TableType.html)
* Dropping a
[`wasmtime::ValType`](https://docs.rs/wasmtime/latest/wasmtime/struct.ValType.html)
* Dropping a
[`wasmtime::RefType`](https://docs.rs/wasmtime/latest/wasmtime/struct.RefType.html)
* Dropping a
[`wasmtime::HeapType`](https://docs.rs/wasmtime/latest/wasmtime/struct.HeapType.html)
* Dropping a
[`wasmtime::UnknownImportError`](https://docs.rs/wasmtime/latest/wasmtime/struct.UnknownImportError.html)
* Dropping a
[`wasmtime::Linker`](https://docs.rs/wasmtime/latest/wasmtime/struct.Linker.html)

The change which introduced this bug was
[#&#8203;7969](https://redirect.github.com/bytecodealliance/wasmtime/pull/7969)

---

### Release Notes

<details>
<summary>bytecodealliance/wasmtime (wasmtime)</summary>

###
[`v24.0.1`](https://redirect.github.com/bytecodealliance/wasmtime/releases/tag/v24.0.1)

[Compare
Source](https://redirect.github.com/bytecodealliance/wasmtime/compare/v24.0.0...v24.0.1)

#### 24.0.1

Released 2024-10-09.

##### Fixed

- Fix a runtime crash when combining tail-calls with host imports that
capture a
    stack trace or trap.

[GHSA-q8hx-mm92-4wvg](https://redirect.github.com/bytecodealliance/wasmtime/security/advisories/GHSA-q8hx-mm92-4wvg)

- Fix a race condition could lead to WebAssembly control-flow integrity
and type
    safety violations.

[GHSA-7qmx-3fpx-r45m](https://redirect.github.com/bytecodealliance/wasmtime/security/advisories/GHSA-7qmx-3fpx-r45m)

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "" in timezone America/New_York,
Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4xMTQuMCIsInVwZGF0ZWRJblZlciI6IjM4LjExNC4wIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6W119-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 102 ++++++++++++++++++++++++++---------------------------
 1 file changed, 51 insertions(+), 51 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8567b4a55324ce..b3aafb5d626ad6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1578,7 +1578,7 @@ dependencies = [
  "bitflags 2.6.0",
  "cexpr",
  "clang-sys",
- "itertools 0.12.1",
+ "itertools 0.10.5",
  "lazy_static",
  "lazycell",
  "proc-macro2",
@@ -3051,18 +3051,18 @@ dependencies = [
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.111.0"
+version = "0.111.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b80c3a50b9c4c7e5b5f73c0ed746687774fc9e36ef652b110da8daebf0c6e0e6"
+checksum = "32d69b774780246008783a75edfb943eccc2487b6a43808503a07cd563f2ffde"
 dependencies = [
  "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-bitset"
-version = "0.111.0"
+version = "0.111.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38778758c2ca918b05acb2199134e0c561fb577c50574259b26190b6c2d95ded"
+checksum = "a7d8d71c6b32c1a7cff254c5e5d7359872c1e5e610fbe963472afcddbd9cf303"
 dependencies = [
  "serde",
  "serde_derive",
@@ -3070,9 +3070,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.111.0"
+version = "0.111.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58258667ad10e468bfc13a8d620f50dfcd4bb35d668123e97defa2549b9ad397"
+checksum = "3ad3a906f2a3f3590ad9798d59a46959a8593258eb985af722f634723c063a2c"
 dependencies = [
  "bumpalo",
  "cranelift-bforest",
@@ -3093,33 +3093,33 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.111.0"
+version = "0.111.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "043f0b702e529dcb07ff92bd7d40e7d5317b5493595172c5eb0983343751ee06"
+checksum = "cd5e4ee12262a135efbef3ced4ab2153adafe4adc55f36af94f9d73be0f7505d"
 dependencies = [
  "cranelift-codegen-shared",
 ]
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.111.0"
+version = "0.111.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7763578888ab53eca5ce7da141953f828e82c2bfadcffc106d10d1866094ffbb"
+checksum = "5b9374a2a5f060f72e3080fe1c87c9ff4bef2cbe798faae60daf276fb1a13968"
 
 [[package]]
 name = "cranelift-control"
-version = "0.111.0"
+version = "0.111.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32db15f08c05df570f11e8ab33cb1ec449a64b37c8a3498377b77650bef33d8b"
+checksum = "fba3ca2f344bb22d265a928e7c3f5f46e1a2eb41f1393bd53538d07b6ffb5293"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.111.0"
+version = "0.111.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5289cdb399381a27e7bbfa1b42185916007c3d49aeef70b1d01cb4caa8010130"
+checksum = "a6aef77dfb018eed09d92d4244abe3c1c060cbbd900c24f75ddde7d75d0e781e"
 dependencies = [
  "cranelift-bitset",
  "serde",
@@ -3128,9 +3128,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.111.0"
+version = "0.111.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31ba8ab24eb9470477e98ddfa3c799a649ac5a0d9a2042868c4c952133c234e8"
+checksum = "7b1d6954f03d63df1cb95d66153c97df0201862220861349bbd5f583754b1917"
 dependencies = [
  "cranelift-codegen",
  "log",
@@ -3140,15 +3140,15 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.111.0"
+version = "0.111.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b72a3c5c166a70426dcb209bdd0bb71a787c1ea76023dc0974fbabca770e8f9"
+checksum = "f8b9b7e088b784796ea8aa5947c1cc12034c1b076a077ec2a5a287da717fa746"
 
 [[package]]
 name = "cranelift-native"
-version = "0.111.0"
+version = "0.111.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46a42424c956bbc31fc5c2706073df896156c5420ae8fa2a5d48dbc7b295d71b"
+checksum = "4cab7424083d070669ff3fdeea7c5b4b5013a055aa1ee0532703f17a5f62af64"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -3157,9 +3157,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-wasm"
-version = "0.111.0"
+version = "0.111.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49778df4289933d735b93c30a345513e030cf83101de0036e19b760f8aa09f68"
+checksum = "81a9f6d0495984eef1d753ec8748de0b216b37ade16d219f1c0f27d8188d7f77"
 dependencies = [
  "cranelift-codegen",
  "cranelift-entity",
@@ -13017,9 +13017,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a5883d64dfc8423c56e3d8df27cffc44db25336aa468e8e0724fddf30a333d7"
+checksum = "7e4a5b05e9f1797e557e79f0cf04348eaa7a232596939ef4762838ddf7a6127a"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -13063,9 +13063,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-asm-macros"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c4dc7e2a379c0dd6be5b55857d14c4b277f43a9c429a9e14403eb61776ae3be"
+checksum = "64414227e19556d4372f9688458c5673606de83473eb66cd0514d36ea8808cab"
 dependencies = [
  "cfg-if",
 ]
@@ -13096,9 +13096,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-component-macro"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b07773d1c3dab5f014ec61316ee317aa424033e17e70a63abdf7c3a47e58fcf"
+checksum = "d3ead31b73689602225742920adbcd881f5656702c1a3b4830862c0c66731727"
 dependencies = [
  "anyhow",
  "proc-macro2",
@@ -13111,15 +13111,15 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-component-util"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e38d735320f4e83478369ce649ad8fe87c6b893220902e798547a225fc0c5874"
+checksum = "ab2c778661800e1dcd8ba3e15ff042299709e0a4c512525d9cbb604a04c0421b"
 
 [[package]]
 name = "wasmtime-cranelift"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e570d831d0785d93d7d8c722b1eb9a34e0d0c1534317666f65892818358a2da9"
+checksum = "9f7ee1f436bcf7d213ef7c2e9d44caffcd57e540ccf997d013384c2ae9b82db7"
 dependencies = [
  "anyhow",
  "cfg-if",
@@ -13141,9 +13141,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-environ"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5fe80dfbd81687431a7d4f25929fae1ae96894786d5c96b14ae41164ee97377"
+checksum = "fa8c33adfb3b9f8d6ef716bc55aea5e6b2275cd5a6721ec8c837d1cb0c471516"
 dependencies = [
  "anyhow",
  "cpp_demangle",
@@ -13168,9 +13168,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-fiber"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f39043d13c7b58db69dc9a0feb191a961e75a9ec2402aebf42de183c022bb8a"
+checksum = "9f3227ed807c2dda9dd770c241023fcd6e48e6722c1c26ff79fc3604d412e884"
 dependencies = [
  "anyhow",
  "cc",
@@ -13183,9 +13183,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-jit-icache-coherence"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d15de8429db996f0d17a4163a35eccc3f874cbfb50f29c379951ea1bbb39452e"
+checksum = "fa89fc440f0edca882ba6d1890608898e6f0193afdc504c0a64478ec53622bd6"
 dependencies = [
  "anyhow",
  "cfg-if",
@@ -13195,15 +13195,15 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-slab"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f68d38fa6b30c5e1fc7d608263062997306f79e577ebd197ddcd6b0f55d87d1"
+checksum = "682b7a5b6772c4e4de8c696fc619ec97930b5e89098db9bee22c1136e002438b"
 
 [[package]]
 name = "wasmtime-types"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6634e7079d9c5cfc81af8610ed59b488cc5b7f9777a2f4c1667a2565c2e45249"
+checksum = "4a95ea5572f8c3ffe777af21aa00a92097ded291a342fecad9f2c6a972ecea99"
 dependencies = [
  "anyhow",
  "cranelift-entity",
@@ -13215,9 +13215,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-versioned-export-macros"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3850e3511d6c7f11a72d571890b0ed5f6204681f7f050b9de2690e7f13123fed"
+checksum = "ac3621bfccd4e4336ae141d62b96e96316c0f23c47d64e9700594ebe3c4d9a10"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -13257,9 +13257,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-winch"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a25199625effa4c13dd790d64bd56884b014c69829431bfe43991c740bd5bc1"
+checksum = "d1d3e99f6bba37864487c9356398667699935b9cfa3655ed2b153b9428b3dd21"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -13274,9 +13274,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-wit-bindgen"
-version = "24.0.0"
+version = "24.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cb331ac7ed1d5ba49cddcdb6b11973752a857148858bb308777d2fc5584121f"
+checksum = "ee0f4524da226d2cb503d794c8928de6bc24878758cebd4e383c946e9fdb8b3a"
 dependencies = [
  "anyhow",
  "heck 0.4.1",
@@ -13554,9 +13554,9 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "winch-codegen"
-version = "0.22.0"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "073efe897d9ead7fc609874f94580afc831114af5149b6a90ee0a3a39b497fe0"
+checksum = "c139fb9298d9651b6869afd544e567ca2448cd5f5ddcb24e4bb86a1ee187c8b3"
 dependencies = [
  "anyhow",
  "cranelift-codegen",

From 3c6989323f353cee4a7e664361a9563d37d8579f Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Thu, 10 Oct 2024 12:56:39 -0400
Subject: [PATCH 594/762] docs: Add XML (#19026)

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 docs/src/SUMMARY.md       |  1 +
 docs/src/languages.md     |  2 +-
 docs/src/languages/xml.md | 15 +++++++++++++++
 3 files changed, 17 insertions(+), 1 deletion(-)
 create mode 100644 docs/src/languages/xml.md

diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
index e7d837e479bce1..8d82dad8c9e2e1 100644
--- a/docs/src/SUMMARY.md
+++ b/docs/src/SUMMARY.md
@@ -110,6 +110,7 @@
 - [TypeScript](./languages/typescript.md)
 - [Uiua](./languages/uiua.md)
 - [Vue](./languages/vue.md)
+- [XML](./languages/xml.md)
 - [YAML](./languages/yaml.md)
 - [Yarn](./languages/yarn.md)
 - [Zig](./languages/zig.md)
diff --git a/docs/src/languages.md b/docs/src/languages.md
index 4bc6e7d3d732a5..bfda1e6b0efe72 100644
--- a/docs/src/languages.md
+++ b/docs/src/languages.md
@@ -61,6 +61,7 @@ Zed supports hundreds of programming languages and text formats. Some work out-o
 - [TypeScript](./languages/typescript.md)
 - [Uiua](./languages/uiua.md)
 - [Vue](./languages/vue.md)
+- [XML](./languages/xml.md)
 - [YAML](./languages/yaml.md)
 - [Yarn](./languages/yarn.md)
 - [Zig](./languages/zig.md)
@@ -157,4 +158,3 @@ Zed supports hundreds of programming languages and text formats. Some work out-o
 - [VHS](https://github.com/eth0net/zed-vhs)
 - [Wgsl](https://github.com/luan/zed-wgsl)
 - [WIT](https://github.com/valentinegb/zed-wit)
-- [XML](https://github.com/sweetppro/zed-xml)
diff --git a/docs/src/languages/xml.md b/docs/src/languages/xml.md
new file mode 100644
index 00000000000000..ab768dc9d9d27d
--- /dev/null
+++ b/docs/src/languages/xml.md
@@ -0,0 +1,15 @@
+# XML
+
+XML support is available through the [XML extension](https://github.com/sweetppro/zed-xml/).
+
+- Tree Sitter: [tree-sitter-grammars/tree-sitter-xml](https://github.com/tree-sitter-grammars/tree-sitter-xml)
+
+## Configuration
+
+If you have additional file extensions that are not being automatically recognized as XML just add them to [file_types](../configuring-zed.md#file-types) in your Zed settings:
+
+```json
+  "file_types": {
+    "XML": ["rdf", "gpx", "kml"]
+  }
+```

From eea600ecc370bf548ea1801cf30545e5474d40cf Mon Sep 17 00:00:00 2001
From: Henry Chu <henrytech@outlook.com>
Date: Fri, 11 Oct 2024 01:08:46 +0800
Subject: [PATCH 595/762] Fix macOS App shortcut (#18921)

- The App Shortcuts in macOS System Settings does not work for Zed since the menu items titles were not set.
- Previously you could set a shortcut for `Zoom`.
- This add support for `Window->Zoom` as well.
---
 crates/gpui/src/platform/mac/platform.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/gpui/src/platform/mac/platform.rs b/crates/gpui/src/platform/mac/platform.rs
index 50ef6dcf0f87c5..78465e8f8d696d 100644
--- a/crates/gpui/src/platform/mac/platform.rs
+++ b/crates/gpui/src/platform/mac/platform.rs
@@ -216,7 +216,8 @@ impl MacPlatform {
 
         for menu_config in menus {
             let menu = NSMenu::new(nil).autorelease();
-            menu.setTitle_(ns_string(&menu_config.name));
+            let menu_title = ns_string(&menu_config.name);
+            menu.setTitle_(menu_title);
             menu.setDelegate_(delegate);
 
             for item_config in menu_config.items {
@@ -229,6 +230,7 @@ impl MacPlatform {
             }
 
             let menu_item = NSMenuItem::new(nil).autorelease();
+            menu_item.setTitle_(menu_title);
             menu_item.setSubmenu_(menu);
             application_menu.addItem_(menu_item);
 

From e962839d137ac3a6a98af01bc2e02d7dbeaa2119 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Fri, 11 Oct 2024 01:36:40 +0300
Subject: [PATCH 596/762] Replace rpc with proto dependency for the headless
 server crate (#19048)

Release Notes:

- N/A
---
 Cargo.lock                      | 2 +-
 crates/headless/Cargo.toml      | 3 +--
 crates/headless/src/headless.rs | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b3aafb5d626ad6..846fd7b127b977 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5298,7 +5298,7 @@ dependencies = [
  "node_runtime",
  "postage",
  "project",
- "rpc",
+ "proto",
  "settings",
  "shellexpand 2.1.2",
  "signal-hook",
diff --git a/crates/headless/Cargo.toml b/crates/headless/Cargo.toml
index 6cbc3f4f326de8..209e843c0410a7 100644
--- a/crates/headless/Cargo.toml
+++ b/crates/headless/Cargo.toml
@@ -19,11 +19,11 @@ extension.workspace = true
 signal-hook.workspace = true
 gpui.workspace = true
 log.workspace = true
-rpc.workspace = true
 util.workspace = true
 node_runtime.workspace = true
 language.workspace = true
 project.workspace = true
+proto.workspace = true
 fs.workspace = true
 futures.workspace = true
 settings.workspace = true
@@ -34,5 +34,4 @@ postage.workspace = true
 client = { workspace = true, features = ["test-support"] }
 fs = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
-rpc = { workspace = true, features = ["test-support"] }
 util = { workspace = true, features = ["test-support"] }
diff --git a/crates/headless/src/headless.rs b/crates/headless/src/headless.rs
index 1405577643606a..6f8f42fc0f77f0 100644
--- a/crates/headless/src/headless.rs
+++ b/crates/headless/src/headless.rs
@@ -9,7 +9,7 @@ use language::LanguageRegistry;
 use node_runtime::NodeRuntime;
 use postage::stream::Stream;
 use project::Project;
-use rpc::{proto, ErrorCode, TypedEnvelope};
+use proto::{self, ErrorCode, TypedEnvelope};
 use settings::{Settings, SettingsStore};
 use std::path::Path;
 use std::{collections::HashMap, sync::Arc};

From 36b9e400852b47fe9464eb445c17cd2f1957d3c0 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Fri, 11 Oct 2024 10:06:33 +0200
Subject: [PATCH 597/762] vim: Reset search options whenever `/` is used
 (#19058)

This is a bit of a personal thing, but it's been bugging me for a while
now that the search options are sticky whenever I use `/` in Vim mode.

This change makes it so that the options are reset with each new `/`.

That means you can, for example, use `v` to create a visual selection,
then hit `*` to search for that (which activates a bunch of search
options), but then continue with `/` to get a normal search.

Release Notes:

- Changed `/` in Vim mode to always reset the search options in the
search bar back to regex-only. That means using `*` (in normal or visual
mode) still works with its options, but the next `/` will reset the
search options. That makes it much closer to how `/` behaves in Vim.
---
 crates/vim/src/normal/search.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/crates/vim/src/normal/search.rs b/crates/vim/src/normal/search.rs
index 6769238407e8ec..364e29242b3f3b 100644
--- a/crates/vim/src/normal/search.rs
+++ b/crates/vim/src/normal/search.rs
@@ -129,14 +129,13 @@ impl Vim {
                     search_bar.select_query(cx);
                     cx.focus_self();
 
-                    if query.is_empty() {
-                        search_bar.set_replacement(None, cx);
-                        search_bar.set_search_options(SearchOptions::REGEX, cx);
-                    }
+                    search_bar.set_replacement(None, cx);
+                    search_bar.set_search_options(SearchOptions::NONE | SearchOptions::REGEX, cx);
+
                     self.search = SearchState {
                         direction,
                         count,
-                        initial_query: query.clone(),
+                        initial_query: query,
                         prior_selections,
                         prior_operator: self.operator_stack.last().cloned(),
                         prior_mode: self.mode,

From 4726f30bd642e36d8decc89f2c47ea77e6f4edde Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 11 Oct 2024 04:44:21 -0400
Subject: [PATCH 598/762] Standardize on CursorShape::Underline not Underscore
 (#19028)

Currently terminal.cursor_shape uses `underline` and `cursor_shape` uses
`underscore`.
This standardizes them so they use the same settings value.

I think `underline` is the more common term and it matches the
terminology used by VSCode, Alacritty, iTerm, etc.

Note the protobuf enum `CursorShape::CursorUnderscore` remains
unchanged.

See also:
- https://github.com/zed-industries/zed/pull/18530
- https://github.com/zed-industries/zed/pull/17572

Release Notes:

- Settings: rename one `cursor_shape` from `underscore` to `underline`
(breaking change).
---
 assets/settings/default.json                 | 8 ++++----
 crates/editor/src/editor_settings.rs         | 2 +-
 crates/editor/src/element.rs                 | 2 +-
 crates/language/src/buffer.rs                | 2 +-
 crates/language/src/proto.rs                 | 4 ++--
 crates/terminal/src/terminal_settings.rs     | 2 +-
 crates/terminal_view/src/terminal_element.rs | 2 +-
 crates/vim/src/vim.rs                        | 4 ++--
 docs/src/configuring-zed.md                  | 4 ++--
 9 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index e5cbcd2f9c0c31..1aef3af63b3fab 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -118,8 +118,8 @@
   //     "bar"
   //  2. A block that surrounds the following character
   //     "block"
-  //  3. An underline that runs along the following character
-  //     "underscore"
+  //  3. An underline / underscore that runs along the following character
+  //     "underline"
   //  4. A box drawn around the following character
   //     "hollow"
   //
@@ -684,8 +684,8 @@
     //     "block"
     //  2. A vertical bar
     //     "bar"
-    //  3. An underline that runs along the following character
-    //     "underscore"
+    //  3. An underline / underscore that runs along the following character
+    //     "underline"
     //  4. A box drawn around the following character
     //     "hollow"
     //
diff --git a/crates/editor/src/editor_settings.rs b/crates/editor/src/editor_settings.rs
index 9137629241468c..f004206b173720 100644
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -179,7 +179,7 @@ pub struct EditorSettingsContent {
     /// Default: true
     pub cursor_blink: Option<bool>,
     /// Cursor shape for the default editor.
-    /// Can be "bar", "block", "underscore", or "hollow".
+    /// Can be "bar", "block", "underline", or "hollow".
     ///
     /// Default: None
     pub cursor_shape: Option<CursorShape>,
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 8a0735354720d1..89fa23ab1caacb 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -6060,7 +6060,7 @@ impl CursorLayout {
                 origin: self.origin + origin,
                 size: size(self.block_width, self.line_height),
             },
-            CursorShape::Underscore => Bounds {
+            CursorShape::Underline => Bounds {
                 origin: self.origin
                     + origin
                     + gpui::Point::new(Pixels::ZERO, self.line_height - px(2.0)),
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 13d07caa88a71d..28bbb25d1bb87f 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -184,7 +184,7 @@ pub enum CursorShape {
     /// A block that surrounds the following character
     Block,
     /// An underline that runs along the following character
-    Underscore,
+    Underline,
     /// A box drawn around the following character
     Hollow,
 }
diff --git a/crates/language/src/proto.rs b/crates/language/src/proto.rs
index 94b720c1fd8825..a8aa8378b11c6d 100644
--- a/crates/language/src/proto.rs
+++ b/crates/language/src/proto.rs
@@ -175,7 +175,7 @@ pub fn serialize_cursor_shape(cursor_shape: &CursorShape) -> proto::CursorShape
     match cursor_shape {
         CursorShape::Bar => proto::CursorShape::CursorBar,
         CursorShape::Block => proto::CursorShape::CursorBlock,
-        CursorShape::Underscore => proto::CursorShape::CursorUnderscore,
+        CursorShape::Underline => proto::CursorShape::CursorUnderscore,
         CursorShape::Hollow => proto::CursorShape::CursorHollow,
     }
 }
@@ -185,7 +185,7 @@ pub fn deserialize_cursor_shape(cursor_shape: proto::CursorShape) -> CursorShape
     match cursor_shape {
         proto::CursorShape::CursorBar => CursorShape::Bar,
         proto::CursorShape::CursorBlock => CursorShape::Block,
-        proto::CursorShape::CursorUnderscore => CursorShape::Underscore,
+        proto::CursorShape::CursorUnderscore => CursorShape::Underline,
         proto::CursorShape::CursorHollow => CursorShape::Hollow,
     }
 }
diff --git a/crates/terminal/src/terminal_settings.rs b/crates/terminal/src/terminal_settings.rs
index 956cde19d90ed7..51b8207f576d6e 100644
--- a/crates/terminal/src/terminal_settings.rs
+++ b/crates/terminal/src/terminal_settings.rs
@@ -134,7 +134,7 @@ pub struct TerminalSettingsContent {
     /// Default: {}
     pub env: Option<HashMap<String, String>>,
     /// Default cursor shape for the terminal.
-    /// Can be "bar", "block", "underscore", or "hollow".
+    /// Can be "bar", "block", "underline", or "hollow".
     ///
     /// Default: None
     pub cursor_shape: Option<CursorShape>,
diff --git a/crates/terminal_view/src/terminal_element.rs b/crates/terminal_view/src/terminal_element.rs
index db87fd8dc2d597..5998caa0daaffb 100644
--- a/crates/terminal_view/src/terminal_element.rs
+++ b/crates/terminal_view/src/terminal_element.rs
@@ -793,7 +793,7 @@ impl Element for TerminalElement {
                             let (shape, text) = match cursor.shape {
                                 AlacCursorShape::Block if !focused => (CursorShape::Hollow, None),
                                 AlacCursorShape::Block => (CursorShape::Block, Some(cursor_text)),
-                                AlacCursorShape::Underline => (CursorShape::Underscore, None),
+                                AlacCursorShape::Underline => (CursorShape::Underline, None),
                                 AlacCursorShape::Beam => (CursorShape::Bar, None),
                                 AlacCursorShape::HollowBlock => (CursorShape::Hollow, None),
                                 //This case is handled in the if wrapping the whole cursor layout
diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs
index 06116bff99de48..024379e6acf28b 100644
--- a/crates/vim/src/vim.rs
+++ b/crates/vim/src/vim.rs
@@ -545,10 +545,10 @@ impl Vim {
                 if self.operator_stack.is_empty() {
                     CursorShape::Block
                 } else {
-                    CursorShape::Underscore
+                    CursorShape::Underline
                 }
             }
-            Mode::Replace => CursorShape::Underscore,
+            Mode::Replace => CursorShape::Underline,
             Mode::Visual | Mode::VisualLine | Mode::VisualBlock => CursorShape::Block,
             Mode::Insert => CursorShape::Bar,
         }
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 6740d51364ce7e..ce5a6a97aca35e 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -371,10 +371,10 @@ List of `string` values
 "cursor_shape": "block"
 ```
 
-3. An underscore that runs along the following character:
+3. An underline / underscore that runs along the following character:
 
 ```json
-"cursor_shape": "underscore"
+"cursor_shape": "underline"
 ```
 
 4. An box drawn around the following character:

From 169165294870ef6e01f7ce624ef21e7ba8e4145f Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Fri, 11 Oct 2024 11:21:34 +0200
Subject: [PATCH 599/762] ssh: Fix abs paths in file history & repeated
 go-to-def (#19027)

This fixes two things:

- Go-to-def to absolute paths (i.e. opening stdlib files) multiple times
(opening, dropping, and re-opening worktrees)
- Re-opening abs paths from the file picker history that were added
there by go-to-def


Release Notes:

- N/A

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/file_finder/src/file_finder.rs        | 63 ++++++++-------
 crates/project/src/project.rs                | 84 +++++++++++++-------
 crates/project/src/worktree_store.rs         | 10 +--
 crates/proto/proto/zed.proto                 |  9 ++-
 crates/proto/src/proto.rs                    |  4 +-
 crates/remote_server/src/headless_project.rs | 47 +++++++++--
 6 files changed, 144 insertions(+), 73 deletions(-)

diff --git a/crates/file_finder/src/file_finder.rs b/crates/file_finder/src/file_finder.rs
index f63c499ee84c72..ba125b979cc60b 100644
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -758,11 +758,8 @@ impl FileFinderDelegate {
         cx: &mut ViewContext<'_, Picker<Self>>,
     ) -> Task<()> {
         cx.spawn(|picker, mut cx| async move {
-            let Some((project, fs)) = picker
-                .update(&mut cx, |picker, cx| {
-                    let fs = Arc::clone(&picker.delegate.project.read(cx).fs());
-                    (picker.delegate.project.clone(), fs)
-                })
+            let Some(project) = picker
+                .update(&mut cx, |picker, _| picker.delegate.project.clone())
                 .log_err()
             else {
                 return;
@@ -770,31 +767,36 @@ impl FileFinderDelegate {
 
             let query_path = Path::new(query.path_query());
             let mut path_matches = Vec::new();
-            match fs.metadata(query_path).await.log_err() {
-                Some(Some(_metadata)) => {
-                    let update_result = project
-                        .update(&mut cx, |project, cx| {
-                            if let Some((worktree, relative_path)) =
-                                project.find_worktree(query_path, cx)
-                            {
-                                path_matches.push(ProjectPanelOrdMatch(PathMatch {
-                                    score: 1.0,
-                                    positions: Vec::new(),
-                                    worktree_id: worktree.read(cx).id().to_usize(),
-                                    path: Arc::from(relative_path),
-                                    path_prefix: "".into(),
-                                    is_dir: false, // File finder doesn't support directories
-                                    distance_to_relative_ancestor: usize::MAX,
-                                }));
-                            }
-                        })
-                        .log_err();
-                    if update_result.is_none() {
-                        return;
-                    }
+
+            let abs_file_exists = if let Ok(task) = project.update(&mut cx, |this, cx| {
+                this.abs_file_path_exists(query.path_query(), cx)
+            }) {
+                task.await
+            } else {
+                false
+            };
+
+            if abs_file_exists {
+                let update_result = project
+                    .update(&mut cx, |project, cx| {
+                        if let Some((worktree, relative_path)) =
+                            project.find_worktree(query_path, cx)
+                        {
+                            path_matches.push(ProjectPanelOrdMatch(PathMatch {
+                                score: 1.0,
+                                positions: Vec::new(),
+                                worktree_id: worktree.read(cx).id().to_usize(),
+                                path: Arc::from(relative_path),
+                                path_prefix: "".into(),
+                                is_dir: false, // File finder doesn't support directories
+                                distance_to_relative_ancestor: usize::MAX,
+                            }));
+                        }
+                    })
+                    .log_err();
+                if update_result.is_none() {
+                    return;
                 }
-                Some(None) => {}
-                None => return,
             }
 
             picker
@@ -888,7 +890,8 @@ impl PickerDelegate for FileFinderDelegate {
                         project
                             .worktree_for_id(history_item.project.worktree_id, cx)
                             .is_some()
-                            || (project.is_local() && history_item.absolute.is_some())
+                            || ((project.is_local() || project.is_via_ssh())
+                                && history_item.absolute.is_some())
                     }),
                     self.currently_opened_path.as_ref(),
                     None,
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 7f452e86439701..f4d02f47f3e8da 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -2242,6 +2242,15 @@ impl Project {
             return;
         }
 
+        if let Some(ssh) = &self.ssh_client {
+            ssh.read(cx)
+                .to_proto_client()
+                .send(proto::RemoveWorktree {
+                    worktree_id: id_to_remove.to_proto(),
+                })
+                .log_err();
+        }
+
         cx.notify();
     }
 
@@ -3070,7 +3079,7 @@ impl Project {
         }
     }
 
-    // Returns the resolved version of `path`, that was found in `buffer`, if it exists.
+    /// Returns the resolved version of `path`, that was found in `buffer`, if it exists.
     pub fn resolve_existing_file_path(
         &self,
         path: &str,
@@ -3079,38 +3088,53 @@ impl Project {
     ) -> Task<Option<ResolvedPath>> {
         let path_buf = PathBuf::from(path);
         if path_buf.is_absolute() || path.starts_with("~") {
-            if self.is_local() {
-                let expanded = PathBuf::from(shellexpand::tilde(&path).into_owned());
+            self.resolve_abs_file_path(path, cx)
+        } else {
+            self.resolve_path_in_worktrees(path_buf, buffer, cx)
+        }
+    }
 
-                let fs = self.fs.clone();
-                cx.background_executor().spawn(async move {
-                    let path = expanded.as_path();
-                    let exists = fs.is_file(path).await;
+    pub fn abs_file_path_exists(&self, path: &str, cx: &mut ModelContext<Self>) -> Task<bool> {
+        let resolve_task = self.resolve_abs_file_path(path, cx);
+        cx.background_executor().spawn(async move {
+            let resolved_path = resolve_task.await;
+            resolved_path.is_some()
+        })
+    }
 
-                    exists.then(|| ResolvedPath::AbsPath(expanded))
-                })
-            } else if let Some(ssh_client) = self.ssh_client.as_ref() {
-                let request =
-                    ssh_client
-                        .read(cx)
-                        .to_proto_client()
-                        .request(proto::CheckFileExists {
-                            project_id: SSH_PROJECT_ID,
-                            path: path.to_string(),
-                        });
-                cx.background_executor().spawn(async move {
-                    let response = request.await.log_err()?;
-                    if response.exists {
-                        Some(ResolvedPath::AbsPath(PathBuf::from(response.path)))
-                    } else {
-                        None
-                    }
-                })
-            } else {
-                return Task::ready(None);
-            }
+    fn resolve_abs_file_path(
+        &self,
+        path: &str,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Option<ResolvedPath>> {
+        if self.is_local() {
+            let expanded = PathBuf::from(shellexpand::tilde(&path).into_owned());
+
+            let fs = self.fs.clone();
+            cx.background_executor().spawn(async move {
+                let path = expanded.as_path();
+                let exists = fs.is_file(path).await;
+
+                exists.then(|| ResolvedPath::AbsPath(expanded))
+            })
+        } else if let Some(ssh_client) = self.ssh_client.as_ref() {
+            let request = ssh_client
+                .read(cx)
+                .to_proto_client()
+                .request(proto::CheckFileExists {
+                    project_id: SSH_PROJECT_ID,
+                    path: path.to_string(),
+                });
+            cx.background_executor().spawn(async move {
+                let response = request.await.log_err()?;
+                if response.exists {
+                    Some(ResolvedPath::AbsPath(PathBuf::from(response.path)))
+                } else {
+                    None
+                }
+            })
         } else {
-            self.resolve_path_in_worktrees(path_buf, buffer, cx)
+            return Task::ready(None);
         }
     }
 
diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 41b475d785e88d..66fe14969676eb 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -237,10 +237,13 @@ impl WorktreeStore {
             .to_string_lossy()
             .to_string();
         cx.spawn(|this, mut cx| async move {
+            let this = this.upgrade().context("Dropped worktree store")?;
+
             let response = client
                 .request(proto::AddWorktree {
                     project_id: SSH_PROJECT_ID,
                     path: abs_path.clone(),
+                    visible,
                 })
                 .await?;
 
@@ -252,7 +255,7 @@ impl WorktreeStore {
 
             let worktree = cx.update(|cx| {
                 Worktree::remote(
-                    0,
+                    SSH_PROJECT_ID,
                     0,
                     proto::WorktreeMetadata {
                         id: response.worktree_id,
@@ -509,11 +512,6 @@ impl WorktreeStore {
         for worktree in &self.worktrees {
             if let Some(worktree) = worktree.upgrade() {
                 worktree.update(cx, |worktree, _| {
-                    println!(
-                        "worktree. is_local: {:?}, is_remote: {:?}",
-                        worktree.is_local(),
-                        worktree.is_remote()
-                    );
                     if let Some(worktree) = worktree.as_remote_mut() {
                         worktree.disconnected_from_host();
                     }
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index aac2c9ae4d55ec..e4e6ac42403012 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -282,7 +282,9 @@ message Envelope {
         CheckFileExists check_file_exists = 255;
         CheckFileExistsResponse check_file_exists_response = 256;
 
-        ShutdownRemoteServer shutdown_remote_server = 257; // current max
+        ShutdownRemoteServer shutdown_remote_server = 257;
+
+        RemoveWorktree remove_worktree = 258; // current max
     }
 
     reserved 87 to 88;
@@ -2432,6 +2434,7 @@ message GetLlmTokenResponse {
 message AddWorktree {
     uint64 project_id = 2;
     string path = 1;
+    bool visible = 3;
 }
 
 message AddWorktreeResponse {
@@ -2460,3 +2463,7 @@ message CheckFileExistsResponse {
 }
 
 message ShutdownRemoteServer {}
+
+message RemoveWorktree {
+    uint64 worktree_id = 1;
+}
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index ae28555a2c315a..93c92e9d476b38 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -364,6 +364,7 @@ messages!(
     (CheckFileExists, Background),
     (CheckFileExistsResponse, Background),
     (ShutdownRemoteServer, Foreground),
+    (RemoveWorktree, Foreground),
 );
 
 request_messages!(
@@ -486,7 +487,8 @@ request_messages!(
     (LspExtSwitchSourceHeader, LspExtSwitchSourceHeaderResponse),
     (AddWorktree, AddWorktreeResponse),
     (CheckFileExists, CheckFileExistsResponse),
-    (ShutdownRemoteServer, Ack)
+    (ShutdownRemoteServer, Ack),
+    (RemoveWorktree, Ack)
 );
 
 entity_messages!(
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 8ebe8905add129..96d769a50cae8f 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -135,6 +135,8 @@ impl HeadlessProject {
         client.add_request_handler(cx.weak_model(), Self::handle_ping);
 
         client.add_model_request_handler(Self::handle_add_worktree);
+        client.add_request_handler(cx.weak_model(), Self::handle_remove_worktree);
+
         client.add_model_request_handler(Self::handle_open_buffer_by_path);
         client.add_model_request_handler(Self::handle_find_search_candidates);
 
@@ -238,7 +240,7 @@ impl HeadlessProject {
             .update(&mut cx.clone(), |this, _| {
                 Worktree::local(
                     Arc::from(canonicalized),
-                    true,
+                    message.payload.visible,
                     this.fs.clone(),
                     this.next_entry_id.clone(),
                     &mut cx,
@@ -246,14 +248,49 @@ impl HeadlessProject {
             })?
             .await?;
 
-        this.update(&mut cx, |this, cx| {
-            this.worktree_store.update(cx, |worktree_store, cx| {
-                worktree_store.add(&worktree, cx);
-            });
+        let response = this.update(&mut cx, |_, cx| {
             worktree.update(cx, |worktree, _| proto::AddWorktreeResponse {
                 worktree_id: worktree.id().to_proto(),
             })
+        })?;
+
+        // We spawn this asynchronously, so that we can send the response back
+        // *before* `worktree_store.add()` can send out UpdateProject requests
+        // to the client about the new worktree.
+        //
+        // That lets the client manage the reference/handles of the newly-added
+        // worktree, before getting interrupted by an UpdateProject request.
+        //
+        // This fixes the problem of the client sending the AddWorktree request,
+        // headless project sending out a project update, client receiving it
+        // and immediately dropping the reference of the new client, causing it
+        // to be dropped on the headless project, and the client only then
+        // receiving a response to AddWorktree.
+        cx.spawn(|mut cx| async move {
+            this.update(&mut cx, |this, cx| {
+                this.worktree_store.update(cx, |worktree_store, cx| {
+                    worktree_store.add(&worktree, cx);
+                });
+            })
+            .log_err();
         })
+        .detach();
+
+        Ok(response)
+    }
+
+    pub async fn handle_remove_worktree(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::RemoveWorktree>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::Ack> {
+        let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
+        this.update(&mut cx, |this, cx| {
+            this.worktree_store.update(cx, |worktree_store, cx| {
+                worktree_store.remove_worktree(worktree_id, cx);
+            });
+        })?;
+        Ok(proto::Ack {})
     }
 
     pub async fn handle_open_buffer_by_path(

From ccaf3268f8dec1270599c720f3d81c4b9a04e6dd Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Fri, 11 Oct 2024 12:58:49 +0300
Subject: [PATCH 600/762] Check paths for FS existence before parsing them as
 paths with line numbers (#19057)

Closes https://github.com/zed-industries/zed/issues/18268

Release Notes:

- Fixed Zed not being open filenames with special combination of
brackets ([#18268](https://github.com/zed-industries/zed/issues/18268))
---
 crates/cli/src/main.rs              | 43 ++++++++++---------
 crates/util/src/paths.rs            | 44 +++++++++-----------
 crates/zed/src/main.rs              | 17 ++++----
 crates/zed/src/zed/open_listener.rs | 64 +++++++++++++++--------------
 4 files changed, 87 insertions(+), 81 deletions(-)

diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs
index a09deaaf943823..e69183d1ea98f7 100644
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -58,27 +58,32 @@ struct Args {
     dev_server_token: Option<String>,
 }
 
-fn parse_path_with_position(argument_str: &str) -> Result<String, std::io::Error> {
-    let path = PathWithPosition::parse_str(argument_str);
-    let curdir = env::current_dir()?;
-
-    let canonicalized = path.map_path(|path| match fs::canonicalize(&path) {
-        Ok(path) => Ok(path),
-        Err(e) => {
-            if let Some(mut parent) = path.parent() {
-                if parent == Path::new("") {
-                    parent = &curdir
-                }
-                match fs::canonicalize(parent) {
-                    Ok(parent) => Ok(parent.join(path.file_name().unwrap())),
-                    Err(_) => Err(e),
+fn parse_path_with_position(argument_str: &str) -> anyhow::Result<String> {
+    let canonicalized = match Path::new(argument_str).canonicalize() {
+        Ok(existing_path) => PathWithPosition::from_path(existing_path),
+        Err(_) => {
+            let path = PathWithPosition::parse_str(argument_str);
+            let curdir = env::current_dir().context("reteiving current directory")?;
+            path.map_path(|path| match fs::canonicalize(&path) {
+                Ok(path) => Ok(path),
+                Err(e) => {
+                    if let Some(mut parent) = path.parent() {
+                        if parent == Path::new("") {
+                            parent = &curdir
+                        }
+                        match fs::canonicalize(parent) {
+                            Ok(parent) => Ok(parent.join(path.file_name().unwrap())),
+                            Err(_) => Err(e),
+                        }
+                    } else {
+                        Err(e)
+                    }
                 }
-            } else {
-                Err(e)
-            }
+            })
         }
-    })?;
-    Ok(canonicalized.to_string(|path| path.display().to_string()))
+        .with_context(|| format!("parsing as path with position {argument_str}"))?,
+    };
+    Ok(canonicalized.to_string(|path| path.to_string_lossy().to_string()))
 }
 
 fn main() -> Result<()> {
diff --git a/crates/util/src/paths.rs b/crates/util/src/paths.rs
index f4ecfefc52a872..90b95f2c7ba0d0 100644
--- a/crates/util/src/paths.rs
+++ b/crates/util/src/paths.rs
@@ -221,11 +221,7 @@ impl PathWithPosition {
     pub fn parse_str(s: &str) -> Self {
         let trimmed = s.trim();
         let path = Path::new(trimmed);
-        let maybe_file_name_with_row_col = path
-            .file_name()
-            .unwrap_or_default()
-            .to_str()
-            .unwrap_or_default();
+        let maybe_file_name_with_row_col = path.file_name().unwrap_or_default().to_string_lossy();
         if maybe_file_name_with_row_col.is_empty() {
             return Self {
                 path: Path::new(s).to_path_buf(),
@@ -240,7 +236,7 @@ impl PathWithPosition {
         static SUFFIX_RE: LazyLock<Regex> =
             LazyLock::new(|| Regex::new(ROW_COL_CAPTURE_REGEX).unwrap());
         match SUFFIX_RE
-            .captures(maybe_file_name_with_row_col)
+            .captures(&maybe_file_name_with_row_col)
             .map(|caps| caps.extract())
         {
             Some((_, [file_name, maybe_row, maybe_column])) => {
@@ -361,26 +357,26 @@ pub fn compare_paths(
                 let b_is_file = components_b.peek().is_none() && b_is_file;
                 let ordering = a_is_file.cmp(&b_is_file).then_with(|| {
                     let path_a = Path::new(component_a.as_os_str());
-                    let num_and_remainder_a = NumericPrefixWithSuffix::from_numeric_prefixed_str(
-                        if a_is_file {
-                            path_a.file_stem()
-                        } else {
-                            path_a.file_name()
-                        }
-                        .and_then(|s| s.to_str())
-                        .unwrap_or_default(),
-                    );
+                    let path_string_a = if a_is_file {
+                        path_a.file_stem()
+                    } else {
+                        path_a.file_name()
+                    }
+                    .map(|s| s.to_string_lossy());
+                    let num_and_remainder_a = path_string_a
+                        .as_deref()
+                        .map(NumericPrefixWithSuffix::from_numeric_prefixed_str);
 
                     let path_b = Path::new(component_b.as_os_str());
-                    let num_and_remainder_b = NumericPrefixWithSuffix::from_numeric_prefixed_str(
-                        if b_is_file {
-                            path_b.file_stem()
-                        } else {
-                            path_b.file_name()
-                        }
-                        .and_then(|s| s.to_str())
-                        .unwrap_or_default(),
-                    );
+                    let path_string_b = if b_is_file {
+                        path_b.file_stem()
+                    } else {
+                        path_b.file_name()
+                    }
+                    .map(|s| s.to_string_lossy());
+                    let num_and_remainder_b = path_string_b
+                        .as_deref()
+                        .map(NumericPrefixWithSuffix::from_numeric_prefixed_str);
 
                     num_and_remainder_a.cmp(&num_and_remainder_b)
                 });
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 9857c60491b1cc..cd245dc12c5b4f 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -58,8 +58,9 @@ use workspace::{
     AppState, WorkspaceSettings, WorkspaceStore,
 };
 use zed::{
-    app_menus, build_window_options, handle_cli_connection, handle_keymap_file_changes,
-    initialize_workspace, open_paths_with_positions, OpenListener, OpenRequest,
+    app_menus, build_window_options, derive_paths_with_position, handle_cli_connection,
+    handle_keymap_file_changes, initialize_workspace, open_paths_with_positions, OpenListener,
+    OpenRequest,
 };
 
 use crate::zed::inline_completion_registry;
@@ -712,13 +713,11 @@ fn handle_open_request(
 
     if let Some(connection_info) = request.ssh_connection {
         cx.spawn(|mut cx| async move {
+            let paths_with_position =
+                derive_paths_with_position(app_state.fs.as_ref(), request.open_paths).await;
             open_ssh_project(
                 connection_info,
-                request
-                    .open_paths
-                    .into_iter()
-                    .map(|path| path.path)
-                    .collect::<Vec<_>>(),
+                paths_with_position.into_iter().map(|p| p.path).collect(),
                 app_state,
                 workspace::OpenOptions::default(),
                 &mut cx,
@@ -733,8 +732,10 @@ fn handle_open_request(
     if !request.open_paths.is_empty() {
         let app_state = app_state.clone();
         task = Some(cx.spawn(|mut cx| async move {
+            let paths_with_position =
+                derive_paths_with_position(app_state.fs.as_ref(), request.open_paths).await;
             let (_window, results) = open_paths_with_positions(
-                &request.open_paths,
+                &paths_with_position,
                 app_state,
                 workspace::OpenOptions::default(),
                 &mut cx,
diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs
index 7746337df1bbe2..c40876ad7a9f31 100644
--- a/crates/zed/src/zed/open_listener.rs
+++ b/crates/zed/src/zed/open_listener.rs
@@ -9,12 +9,15 @@ use collections::HashMap;
 use db::kvp::KEY_VALUE_STORE;
 use editor::scroll::Autoscroll;
 use editor::Editor;
+use fs::Fs;
 use futures::channel::mpsc::{UnboundedReceiver, UnboundedSender};
 use futures::channel::{mpsc, oneshot};
+use futures::future::join_all;
 use futures::{FutureExt, SinkExt, StreamExt};
 use gpui::{AppContext, AsyncAppContext, Global, WindowHandle};
 use language::{Bias, Point};
 use remote::SshConnectionOptions;
+use std::path::Path;
 use std::sync::Arc;
 use std::time::Duration;
 use std::{process, thread};
@@ -27,7 +30,7 @@ use workspace::{AppState, OpenOptions, Workspace};
 #[derive(Default, Debug)]
 pub struct OpenRequest {
     pub cli_connection: Option<(mpsc::Receiver<CliRequest>, IpcSender<CliResponse>)>,
-    pub open_paths: Vec<PathWithPosition>,
+    pub open_paths: Vec<String>,
     pub open_channel_notes: Vec<(u64, Option<String>)>,
     pub join_channel: Option<u64>,
     pub ssh_connection: Option<SshConnectionOptions>,
@@ -57,8 +60,7 @@ impl OpenRequest {
 
     fn parse_file_path(&mut self, file: &str) {
         if let Some(decoded) = urlencoding::decode(file).log_err() {
-            let path_buf = PathWithPosition::parse_str(&decoded);
-            self.open_paths.push(path_buf)
+            self.open_paths.push(decoded.into_owned())
         }
     }
 
@@ -369,26 +371,15 @@ async fn open_workspaces(
                             location
                                 .paths()
                                 .iter()
-                                .map(|path| PathWithPosition {
-                                    path: path.clone(),
-                                    row: None,
-                                    column: None,
-                                })
-                                .collect::<Vec<_>>()
+                                .map(|path| path.to_string_lossy().to_string())
+                                .collect()
                         })
                         .collect::<Vec<_>>()
                 })
                 .collect()
         }
     } else {
-        // If paths are provided, parse them (they include positions)
-        let paths_with_position = paths
-            .into_iter()
-            .map(|path_with_position_string| {
-                PathWithPosition::parse_str(&path_with_position_string)
-            })
-            .collect();
-        vec![paths_with_position]
+        vec![paths]
     };
 
     if grouped_paths.is_empty() {
@@ -441,7 +432,7 @@ async fn open_workspaces(
 }
 
 async fn open_workspace(
-    workspace_paths: Vec<PathWithPosition>,
+    workspace_paths: Vec<String>,
     open_new_workspace: Option<bool>,
     wait: bool,
     responses: &IpcSender<CliResponse>,
@@ -451,8 +442,10 @@ async fn open_workspace(
 ) -> bool {
     let mut errored = false;
 
+    let paths_with_position =
+        derive_paths_with_position(app_state.fs.as_ref(), workspace_paths).await;
     match open_paths_with_positions(
-        &workspace_paths,
+        &paths_with_position,
         app_state.clone(),
         workspace::OpenOptions {
             open_new_workspace,
@@ -466,7 +459,7 @@ async fn open_workspace(
         Ok((workspace, items)) => {
             let mut item_release_futures = Vec::new();
 
-            for (item, path) in items.into_iter().zip(&workspace_paths) {
+            for (item, path) in items.into_iter().zip(&paths_with_position) {
                 match item {
                     Some(Ok(item)) => {
                         cx.update(|cx| {
@@ -497,7 +490,7 @@ async fn open_workspace(
             if wait {
                 let background = cx.background_executor().clone();
                 let wait = async move {
-                    if workspace_paths.is_empty() {
+                    if paths_with_position.is_empty() {
                         let (done_tx, done_rx) = oneshot::channel();
                         let _subscription = workspace.update(cx, |_, cx| {
                             cx.on_release(move |_, _, _| {
@@ -532,7 +525,7 @@ async fn open_workspace(
             errored = true;
             responses
                 .send(CliResponse::Stderr {
-                    message: format!("error opening {workspace_paths:?}: {error}"),
+                    message: format!("error opening {paths_with_position:?}: {error}"),
                 })
                 .log_err();
         }
@@ -540,9 +533,26 @@ async fn open_workspace(
     errored
 }
 
+pub async fn derive_paths_with_position(
+    fs: &dyn Fs,
+    path_strings: impl IntoIterator<Item = impl AsRef<str>>,
+) -> Vec<PathWithPosition> {
+    join_all(path_strings.into_iter().map(|path_str| async move {
+        let canonicalized = fs.canonicalize(Path::new(path_str.as_ref())).await;
+        (path_str, canonicalized)
+    }))
+    .await
+    .into_iter()
+    .map(|(original, canonicalized)| match canonicalized {
+        Ok(canonicalized) => PathWithPosition::from_path(canonicalized),
+        Err(_) => PathWithPosition::parse_str(original.as_ref()),
+    })
+    .collect()
+}
+
 #[cfg(test)]
 mod tests {
-    use std::{path::PathBuf, sync::Arc};
+    use std::sync::Arc;
 
     use cli::{
         ipc::{self},
@@ -551,7 +561,6 @@ mod tests {
     use editor::Editor;
     use gpui::TestAppContext;
     use serde_json::json;
-    use util::paths::PathWithPosition;
     use workspace::{AppState, Workspace};
 
     use crate::zed::{open_listener::open_workspace, tests::init_test};
@@ -665,12 +674,7 @@ mod tests {
     ) {
         let (response_tx, _) = ipc::channel::<CliResponse>().unwrap();
 
-        let path = PathBuf::from(path);
-        let workspace_paths = vec![PathWithPosition {
-            path,
-            row: None,
-            column: None,
-        }];
+        let workspace_paths = vec![path.to_owned()];
 
         let errored = cx
             .spawn(|mut cx| async move {

From 518f8cc5b73c528f04a0d357936885aa6298fb74 Mon Sep 17 00:00:00 2001
From: Tim Havlicek <tim.h4vlicek@gmail.com>
Date: Fri, 11 Oct 2024 12:26:37 +0200
Subject: [PATCH 601/762] fix: Absolutize path to worktree root in
 `worktree.read_text_file` (#19064)

Closes #19050

Release Notes:

- Fixed `worktree.read_text_file` plugin API working incorrectly
([#19050](https://github.com/zed-industries/zed/issues/19050))
---
 crates/project/src/lsp_store.rs | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 7a7bd2863b9c9b..01e40ec6a00489 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -7663,10 +7663,16 @@ impl LspAdapterDelegate for LocalLspAdapterDelegate {
     }
 
     async fn read_text_file(&self, path: PathBuf) -> Result<String> {
-        if self.worktree.entry_for_path(&path).is_none() {
-            return Err(anyhow!("no such path {path:?}"));
-        };
-        self.fs.load(&path).await
+        let entry = self
+            .worktree
+            .entry_for_path(&path)
+            .with_context(|| format!("no worktree entry for path {path:?}"))?;
+        let abs_path = self
+            .worktree
+            .absolutize(&entry.path)
+            .with_context(|| format!("cannot absolutize path {path:?}"))?;
+
+        self.fs.load(&abs_path).await
     }
 }
 

From 0a7468c89f6dc72eeb27c0ea1113c95ee100ae2c Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Fri, 11 Oct 2024 12:33:08 +0200
Subject: [PATCH 602/762] lsp: Show error message in read only buffer (#19063)

Clicking on

<img width="361" alt="image"
src="https://github.com/user-attachments/assets/b55e2575-b438-4c26-922f-313dc1f41fea">

now opens a read only buffer

<img width="547" alt="image"
src="https://github.com/user-attachments/assets/af82e104-1603-4fe4-9351-635a02cfb4f9">

Previously the buffer would show up as a normal untitled buffer and
would open a prompt when closing the tab.

Co-Authored-by: Thorsten <thorsten@zed.dev>

Release Notes:

- N/A

Co-authored-by: Thorsten <thorsten@zed.dev>
---
 crates/activity_indicator/src/activity_indicator.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs
index 687519068d4c35..8020e0665a1af1 100644
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -101,6 +101,7 @@ impl ActivityIndicator {
                             None,
                             cx,
                         );
+                        buffer.set_capability(language::Capability::ReadOnly, cx);
                     })?;
                     workspace.update(&mut cx, |workspace, cx| {
                         workspace.add_item_to_active_pane(

From 79ed217e42430b94ee2d84c90cc0b8b3ddc19ed0 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Fri, 11 Oct 2024 15:38:12 +0300
Subject: [PATCH 603/762] Properly compute depth and path for project panel
 entries (#19068)

Closes https://github.com/zed-industries/zed/issues/18939

This fixes incorrect width estimates and horizontal scrollbar glitches

Release Notes:

- Fixes horizontal scrollbar not scrolling enough for certain paths
([#18939](https://github.com/zed-industries/zed/issues/18939))

Co-authored-by: Piotr Osiewicz <piotr@zed.dev>
---
 crates/project_panel/src/project_panel.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 26a2bf27e095dd..b4f07c66d30655 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -1911,11 +1911,9 @@ impl ProjectPanel {
                                     Some(Arc::<Path>::from(full_path.join(suffix)))
                                 })
                         })
+                        .or_else(|| entry.path.file_name().map(Path::new).map(Arc::from))
                         .unwrap_or_else(|| entry.path.clone());
-                    let depth = path
-                        .strip_prefix(worktree_abs_path)
-                        .map(|suffix| suffix.components().count())
-                        .unwrap_or_default();
+                    let depth = path.components().count();
                     (depth, path)
                 };
                 let width_estimate = item_width_estimate(

From d976c5f1b644a9e27d8612ff566dc036b3262828 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 11 Oct 2024 10:05:46 -0400
Subject: [PATCH 604/762] gleam: Extract to external repository (#19072)

This PR transfers the Gleam extension over to the @gleam-lang
organization:

https://github.com/gleam-lang/zed-gleam

Release Notes:

- N/A
---
 Cargo.lock                                    |  24 +-
 Cargo.toml                                    |   1 -
 docs/src/languages/gleam.md                   |   2 +-
 extensions/gleam/Cargo.toml                   |  17 -
 extensions/gleam/LICENSE-APACHE               |   1 -
 extensions/gleam/extension.toml               |  21 -
 extensions/gleam/languages/gleam/config.toml  |  12 -
 .../gleam/languages/gleam/highlights.scm      | 130 ----
 extensions/gleam/languages/gleam/indents.scm  |   3 -
 extensions/gleam/languages/gleam/outline.scm  |  33 -
 .../gleam/languages/gleam/runnables.scm       |  25 -
 extensions/gleam/languages/gleam/tasks.json   |  13 -
 extensions/gleam/packages.txt                 | 581 ------------------
 extensions/gleam/src/gleam.rs                 | 249 --------
 extensions/gleam/src/hexdocs.rs               | 215 -------
 15 files changed, 3 insertions(+), 1324 deletions(-)
 delete mode 100644 extensions/gleam/Cargo.toml
 delete mode 120000 extensions/gleam/LICENSE-APACHE
 delete mode 100644 extensions/gleam/extension.toml
 delete mode 100644 extensions/gleam/languages/gleam/config.toml
 delete mode 100644 extensions/gleam/languages/gleam/highlights.scm
 delete mode 100644 extensions/gleam/languages/gleam/indents.scm
 delete mode 100644 extensions/gleam/languages/gleam/outline.scm
 delete mode 100644 extensions/gleam/languages/gleam/runnables.scm
 delete mode 100644 extensions/gleam/languages/gleam/tasks.json
 delete mode 100644 extensions/gleam/packages.txt
 delete mode 100644 extensions/gleam/src/gleam.rs
 delete mode 100644 extensions/gleam/src/hexdocs.rs

diff --git a/Cargo.lock b/Cargo.lock
index 846fd7b127b977..018e9219c5d6af 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -395,7 +395,7 @@ dependencies = [
  "gpui",
  "handlebars 4.5.0",
  "heed",
- "html_to_markdown 0.1.0",
+ "html_to_markdown",
  "http_client",
  "indexed_docs",
  "indoc",
@@ -5461,18 +5461,6 @@ dependencies = [
  "regex",
 ]
 
-[[package]]
-name = "html_to_markdown"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e608e8dd0939bfb6b516d96a5919751b835297a02230aecb88d2fc84ebebaa8a"
-dependencies = [
- "anyhow",
- "html5ever",
- "markup5ever_rcdom",
- "regex",
-]
-
 [[package]]
 name = "http"
 version = "0.2.12"
@@ -5776,7 +5764,7 @@ dependencies = [
  "fuzzy",
  "gpui",
  "heed",
- "html_to_markdown 0.1.0",
+ "html_to_markdown",
  "http_client",
  "indexmap 1.9.3",
  "indoc",
@@ -14591,14 +14579,6 @@ dependencies = [
  "wit-bindgen",
 ]
 
-[[package]]
-name = "zed_gleam"
-version = "0.2.0"
-dependencies = [
- "html_to_markdown 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "zed_extension_api 0.1.0",
-]
-
 [[package]]
 name = "zed_glsl"
 version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index 887d9fb55a4e7f..fa4289b9a2167f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -144,7 +144,6 @@ members = [
     "extensions/elm",
     "extensions/emmet",
     "extensions/erlang",
-    "extensions/gleam",
     "extensions/glsl",
     "extensions/haskell",
     "extensions/html",
diff --git a/docs/src/languages/gleam.md b/docs/src/languages/gleam.md
index 0c5694b909caa6..25ab9b9a200d2b 100644
--- a/docs/src/languages/gleam.md
+++ b/docs/src/languages/gleam.md
@@ -1,6 +1,6 @@
 # Gleam
 
-Gleam support is available through the [Gleam extension](https://github.com/zed-industries/zed/tree/main/extensions/gleam). To learn about Gleam, see the [docs](https://gleam.run/documentation/) or check out the [`stdlib` reference](https://hexdocs.pm/gleam_stdlib/). The Gleam language server has a variety of features, including go-to definition, automatic imports, and [more](https://gleam.run/language-server/).
+Gleam support is available through the [Gleam extension](https://github.com/gleam-lang/zed-gleam). To learn about Gleam, see the [docs](https://gleam.run/documentation/) or check out the [`stdlib` reference](https://hexdocs.pm/gleam_stdlib/). The Gleam language server has a variety of features, including go-to definition, automatic imports, and [more](https://gleam.run/language-server/).
 
 - Tree Sitter: [gleam-lang/tree-sitter-gleam](https://github.com/gleam-lang/tree-sitter-gleam)
 - Language Server: [gleam lsp](https://github.com/gleam-lang/gleam/tree/main/compiler-core/src/language_server)
diff --git a/extensions/gleam/Cargo.toml b/extensions/gleam/Cargo.toml
deleted file mode 100644
index 7008c6e146a46e..00000000000000
--- a/extensions/gleam/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-name = "zed_gleam"
-version = "0.2.0"
-edition = "2021"
-publish = false
-license = "Apache-2.0"
-
-[lints]
-workspace = true
-
-[lib]
-path = "src/gleam.rs"
-crate-type = ["cdylib"]
-
-[dependencies]
-html_to_markdown = "0.1.0"
-zed_extension_api = "0.1.0"
diff --git a/extensions/gleam/LICENSE-APACHE b/extensions/gleam/LICENSE-APACHE
deleted file mode 120000
index 1cd601d0a3affa..00000000000000
--- a/extensions/gleam/LICENSE-APACHE
+++ /dev/null
@@ -1 +0,0 @@
-../../LICENSE-APACHE
\ No newline at end of file
diff --git a/extensions/gleam/extension.toml b/extensions/gleam/extension.toml
deleted file mode 100644
index 7cedbca5d463c8..00000000000000
--- a/extensions/gleam/extension.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-id = "gleam"
-name = "Gleam"
-description = "Gleam support."
-version = "0.2.0"
-schema_version = 1
-authors = ["Marshall Bowers <elliott.codes@gmail.com>"]
-repository = "https://github.com/zed-industries/zed"
-
-[language_servers.gleam]
-name = "Gleam LSP"
-language = "Gleam"
-
-[grammars.gleam]
-repository = "https://github.com/gleam-lang/tree-sitter-gleam"
-commit = "426e67087fd62be5f4533581b5916b2cf010fb5b"
-
-[slash_commands.gleam-project]
-description = "Returns information about the current Gleam project."
-requires_argument = false
-
-[indexed_docs_providers.gleam-hexdocs]
diff --git a/extensions/gleam/languages/gleam/config.toml b/extensions/gleam/languages/gleam/config.toml
deleted file mode 100644
index 51874945e2de6b..00000000000000
--- a/extensions/gleam/languages/gleam/config.toml
+++ /dev/null
@@ -1,12 +0,0 @@
-name = "Gleam"
-grammar = "gleam"
-path_suffixes = ["gleam"]
-line_comments = ["// ", "/// "]
-autoclose_before = ";:.,=}])>"
-brackets = [
-    { start = "{", end = "}", close = true, newline = true },
-    { start = "[", end = "]", close = true, newline = true },
-    { start = "(", end = ")", close = true, newline = true },
-    { start = "\"", end = "\"", close = true, newline = false, not_in = ["string", "comment"] },
-]
-tab_size = 2
diff --git a/extensions/gleam/languages/gleam/highlights.scm b/extensions/gleam/languages/gleam/highlights.scm
deleted file mode 100644
index 4b85b88d0151a1..00000000000000
--- a/extensions/gleam/languages/gleam/highlights.scm
+++ /dev/null
@@ -1,130 +0,0 @@
-; Comments
-(module_comment) @comment
-(statement_comment) @comment
-(comment) @comment
-
-; Constants
-(constant
-  name: (identifier) @constant)
-
-; Variables
-(identifier) @variable
-(discard) @comment.unused
-
-; Modules
-(module) @module
-(import alias: (identifier) @module)
-(remote_type_identifier
-  module: (identifier) @module)
-(remote_constructor_name
-  module: (identifier) @module)
-((field_access
-  record: (identifier) @module
-  field: (label) @function)
- (#is-not? local))
-
-; Functions
-(unqualified_import (identifier) @function)
-(unqualified_import "type" (type_identifier) @type)
-(unqualified_import (type_identifier) @constructor)
-(function
-  name: (identifier) @function)
-(external_function
-  name: (identifier) @function)
-(function_parameter
-  name: (identifier) @variable.parameter)
-((function_call
-   function: (identifier) @function)
- (#is-not? local))
-((binary_expression
-   operator: "|>"
-   right: (identifier) @function)
- (#is-not? local))
-
-; "Properties"
-; Assumed to be intended to refer to a name for a field; something that comes
-; before ":" or after "."
-; e.g. record field names, tuple indices, names for named arguments, etc
-(label) @property
-(tuple_access
-  index: (integer) @property)
-
-; Attributes
-(attribute
-  "@" @attribute
-  name: (identifier) @attribute)
-
-(attribute_value (identifier) @constant)
-
-; Type names
-(remote_type_identifier) @type
-(type_identifier) @type
-
-; Data constructors
-(constructor_name) @constructor
-
-; Literals
-(string) @string
-((escape_sequence) @warning
- ; Deprecated in v0.33.0-rc2:
- (#eq? @warning "\\e"))
-(escape_sequence) @string.escape
-(bit_string_segment_option) @function.builtin
-(integer) @number
-(float) @number
-
-; Reserved identifiers
-; TODO: when tree-sitter supports `#any-of?` in the Rust bindings,
-; refactor this to use `#any-of?` rather than `#match?`
-((identifier) @warning
- (#match? @warning "^(auto|delegate|derive|else|implement|macro|test|echo)$"))
-
-; Keywords
-[
-  (visibility_modifier) ; "pub"
-  (opacity_modifier) ; "opaque"
-  "as"
-  "assert"
-  "case"
-  "const"
-  ; DEPRECATED: 'external' was removed in v0.30.
-  "external"
-  "fn"
-  "if"
-  "import"
-  "let"
-  "panic"
-  "todo"
-  "type"
-  "use"
-] @keyword
-
-; Operators
-(binary_expression
-  operator: _ @operator)
-(boolean_negation "!" @operator)
-(integer_negation "-" @operator)
-
-; Punctuation
-[
-  "("
-  ")"
-  "["
-  "]"
-  "{"
-  "}"
-  "<<"
-  ">>"
-] @punctuation.bracket
-[
-  "."
-  ","
-  ;; Controversial -- maybe some are operators?
-  ":"
-  "#"
-  "="
-  "->"
-  ".."
-  "-"
-  "<-"
-] @punctuation.delimiter
diff --git a/extensions/gleam/languages/gleam/indents.scm b/extensions/gleam/languages/gleam/indents.scm
deleted file mode 100644
index 112b414aa45f27..00000000000000
--- a/extensions/gleam/languages/gleam/indents.scm
+++ /dev/null
@@ -1,3 +0,0 @@
-(_ "[" "]" @end) @indent
-(_ "{" "}" @end) @indent
-(_ "(" ")" @end) @indent
diff --git a/extensions/gleam/languages/gleam/outline.scm b/extensions/gleam/languages/gleam/outline.scm
deleted file mode 100644
index f0a7b127985305..00000000000000
--- a/extensions/gleam/languages/gleam/outline.scm
+++ /dev/null
@@ -1,33 +0,0 @@
-(external_type
-    (visibility_modifier)? @context
-    "type" @context
-    (type_name) @name) @item
-
-(type_definition
-    (visibility_modifier)? @context
-    (opacity_modifier)? @context
-    "type" @context
-    (type_name) @name) @item
-
-(data_constructor
-    (constructor_name) @name) @item
-
-(data_constructor_argument
-    (label) @name) @item
-
-(type_alias
-    (visibility_modifier)? @context
-    "type" @context
-    (type_name) @name) @item
-
-(function
-    (visibility_modifier)? @context
-    "fn" @context
-    name: (_) @name) @item
-
-(constant
-    (visibility_modifier)? @context
-    "const" @context
-    name: (_) @name) @item
-
-(statement_comment) @annotation
diff --git a/extensions/gleam/languages/gleam/runnables.scm b/extensions/gleam/languages/gleam/runnables.scm
deleted file mode 100644
index b0b37b11a44a3f..00000000000000
--- a/extensions/gleam/languages/gleam/runnables.scm
+++ /dev/null
@@ -1,25 +0,0 @@
-; Functions with names ending in `_test`.
-; This matches the standalone test style used by Startest and Gleeunit.
-(
-    (
-        (function name: (_) @run
-            (#match? @run ".*_test$"))
-    ) @gleam-test
-    (#set! tag gleam-test)
-)
-
-
-; `describe` API for Startest.
-(
-    (function_call
-        function: (_) @name
-        (#any-of? @name "describe" "it")
-        arguments: (arguments
-            .
-            (argument
-                value: (string (quoted_content) @run)
-            )
-        )
-    )
-    (#set! tag gleam-test)
-) @gleam-test
diff --git a/extensions/gleam/languages/gleam/tasks.json b/extensions/gleam/languages/gleam/tasks.json
deleted file mode 100644
index af1e8ca7b67060..00000000000000
--- a/extensions/gleam/languages/gleam/tasks.json
+++ /dev/null
@@ -1,13 +0,0 @@
-[
-  {
-    "label": "gleam test",
-    "command": "gleam",
-    "args": ["test"]
-  },
-  {
-    "label": "gleam test $ZED_SYMBOL",
-    "command": "gleam",
-    "args": ["test", "--", "--test-name-filter=$ZED_SYMBOL"],
-    "tags": ["gleam-test"]
-  }
-]
diff --git a/extensions/gleam/packages.txt b/extensions/gleam/packages.txt
deleted file mode 100644
index 04f0309e66476b..00000000000000
--- a/extensions/gleam/packages.txt
+++ /dev/null
@@ -1,581 +0,0 @@
-# The list of Gleam packages.
-# Sourced from `https://packages.gleam.run/packages.sqlite`.
-act
-adglent
-ag_html
-aham
-akaridb
-alanttest1
-alpaca
-amf0
-amnesiac
-antigone
-apollo
-aragorn2
-arcana_signals
-arctic
-argamak
-argus
-argv
-ask
-asterix
-atomic_array
-aws4_request
-bare_package1
-bare_package_one
-bare_package_two
-based
-based_pg
-based_sqlite
-beecrypt
-bidict
-bigben
-bigi
-binary_search
-birdie
-birl
-biscotto
-bison
-blah
-blask
-bliss
-bravo
-bungle
-bytesize
-cactus
-cake
-carpenter
-catppuccin
-cave3dplus
-cgi
-chatbot
-check_maybe_div_by_zero
-chip
-chomp
-chrobot
-chromatic
-classify
-cleam
-collatz
-colored
-colours
-comet
-commonmark
-conllu
-context_fp_gleam
-conversation
-cors_builder
-cosepo
-cosmos
-counter
-crabbucket_pgo
-crabbucket_redis
-crossbar
-css_select
-cymbal
-dahlia
-dbots
-decepticon
-decipher
-decode
-dedent
-defangle
-defer_g
-delay
-dew
-dig
-discord_gleam
-domu
-dot_env
-dotenv_gleam
-dove
-ecoji
-edit_distance
-efetch
-email
-embeds
-emel
-envoy
-esgleam
-espresso
-espresso_pgo_wrapper
-eval
-event_hub
-eventsourcing
-eventsourcing_postgres
-eventsourcing_sqlite
-exception
-exercism_test_runner
-facet
-facquest
-falala
-falcon
-feather
-fetch_event
-ffmpeg
-fibo
-file_streams
-filepath
-filespy
-finch_gleam
-first_gleam_publish_package
-flash
-fluoresce
-fmglee
-fmt
-for_the_crows
-form_coder
-formal
-fp
-fp2
-fp2_gleam
-fp_gl
-fresnel
-fswalk
-functx
-funtil
-gacache
-galant
-gap
-garnet_tool
-gary
-gbase32_clockwork
-gcalc
-gchess
-gemqtt
-gen_core_erlang
-gen_gleam
-geny
-germinal
-ggleam
-gild
-gild_frontend
-gip
-gjwt
-gl
-glacier
-glacier_gleeunit
-gladvent
-glailglind
-glam
-glame
-glaml
-glance
-glance_printer
-glanoid
-glare
-glatch
-glats
-glatus
-glcode
-gleaf
-gleam
-gleam_bbmustache
-gleam_bitwise
-gleam_bson
-gleam_community_ansi
-gleam_community_colour
-gleam_community_maths
-gleam_community_path
-gleam_cors
-gleam_cowboy
-gleam_cowboy_websockets
-gleam_crypto
-gleam_deno
-gleam_dotenv
-gleam_elli
-gleam_email
-gleam_erlang
-gleam_erlexec
-gleam_fetch
-gleam_gun
-gleam_hackney
-gleam_hexpm
-gleam_html
-gleam_http
-gleam_httpc
-gleam_javascript
-gleam_json
-gleam_module_javascript_test
-gleam_mongo
-gleam_nodejs
-gleam_os_mon
-gleam_otp
-gleam_package_interface
-gleam_pgo
-gleam_qs
-gleam_sendgrid
-gleam_stats
-gleam_stdlib
-gleam_synapses
-gleam_tailwind
-gleam_tcp
-gleam_test
-gleam_toml
-gleam_xml
-gleam_yaml
-gleam_zlists
-gleambox
-gleamix
-gleamql
-gleamsver
-gleamy_bench
-gleamy_structures
-gleamyshell
-gleanix
-glearray
-gleastsq
-gleative
-gleb128
-glector
-gledis
-gledo
-gleebor
-gleenix
-gleepl
-gleescript
-gleesend
-gleeunit
-gleez
-gleither
-glemini
-glemo
-glemplate
-glemtext
-glen
-glen_node
-glency
-glentities
-glenv
-glenvy
-glerd
-glerd_json
-glerd_valid
-glerm
-gleroglero
-glesha
-glesha2
-glevatar
-glevenshtein
-glex
-glexec
-glexer
-glexif
-glib
-gliberapay
-glibsql
-gliew
-glimiter
-glimmer
-glimt
-gling
-glint
-glisbn
-glisdigit
-glisten
-glistix_gleeunit
-glistix_nix
-glitch
-glitter
-glittr
-glitzer
-gliua
-globe
-glog
-glome
-gloml
-glomp
-gloom
-glormat
-gloss
-glotel
-glove
-glow
-glow_auth
-glubs
-glubsub
-glucose
-glue
-gluid
-gluon
-gluple
-glv8
-glx
-glychee
-glyph
-glyph_codegen
-glzoneinfo
-gmysql
-go_over
-gopenai
-gpsd_json
-gpxb
-grammy
-gramps
-graph
-grille_pain
-gripe
-gserde
-gstripe
-gsv
-gtempo
-gts
-gtui
-gu
-gwitch
-gwr
-gwt
-gxid
-gzlib
-halo
-handles
-hardcache
-hello_joe
-howdy
-howdy_authentication_cookies
-howdy_uuid
-htmb
-htmgrrrl
-html_components
-html_dsl
-html_lustre_converter
-html_parser
-htmz
-httpp
-hug
-humanise
-hyphenation
-ids
-ieee_float
-illustrious
-immutable_lru
-integer_complexity
-ior
-iox
-iso_8859
-ivy
-jackson
-jasper
-javascript_dom_parser
-jbs
-jot
-json_canvas
-juno
-justin
-keccak_gleam
-kick
-kielet
-kirala_bbmarkdown
-kirala_l4u
-kirala_markdown
-kreator
-libsql
-lite_fs
-logging
-lotta
-lumi
-lustre
-lustre_animation
-lustre_carousel
-lustre_dev_tools
-lustre_hash_state
-lustre_http
-lustre_hx
-lustre_limiter
-lustre_routed
-lustre_ssg
-lustre_transition
-lustre_ui
-lustre_virtual_list
-lustre_websocket
-lzf_gleam
-marceau
-mat
-meadow
-melon
-midas
-migrant
-mineflayer
-minigen
-mist
-mockth
-modem
-monies
-morse_code_translator
-mote
-mug
-mumu
-mungo
-nakai
-nanoworker
-nbeet
-nerf
-nessie
-nessie_cluster
-ngs
-nibble
-nimiq_gleam
-node_socket_client
-node_tags
-non_empty_list
-novdom
-novdom_dev_tools
-novdom_testing
-observatory
-open_color
-openfeature
-opt_args_with_defs_for_gleam
-oteap
-outcome
-outil
-owoify_gleam
-p5js_gleam
-palindrome
-panel
-parallel_map
-parser_gleam
-party
-parz
-pb_lite
-pears
-peggy
-phonetic_gleam
-phony
-phosphor_lustre
-pickle
-pika_id
-pine
-pink
-plex_pin_auth
-plinth
-plunk
-pngleam
-pojo
-pona
-postgresql_protocol
-pprint
-prequel
-pretty_diff
-priorityq
-prng
-process_groups
-process_waiter
-processgroups
-promgleam
-psg
-puddle
-punycode
-qcheck
-qcheck_gleeunit_utils
-qs
-queryb
-question
-rad
-rada
-radiate
-radish
-radish_fork
-ramble
-ranged_int
-ranger
-rank
-react_gleam
-reactive_signal
-ream
-recursive
-redraw
-redraw_dom
-ref
-rememo
-remote_data
-render_md
-repeatedly
-rizzo
-runetracer
-scaffold_gleam
-scriptorium
-sequin
-shakespeare
-shamir
-sheen
-shellout
-shimmer
-showtime
-signal
-signal_pgo
-simple_pubsub
-simplifile
-singularity
-sketch
-sketch_css
-sketch_lustre
-slackin
-snag
-snowgleam
-sol
-sparkle
-spinner
-sprinkle
-sprocket
-sqlight
-squirrel
-stacky
-staff_ai
-starmap
-startest
-stdin
-stego
-stoiridh_version
-storch
-stratus
-string_format
-sturnidae
-sunny
-surreal_gleam
-survey
-swen_jwt
-systemd_status
-tardis
-tcpea
-telega
-temporary
-term_size
-testbldr
-testcontainers_gleam
-the_stars
-tinyroute
-tom
-tote
-translate
-transparent_http
-trie_again
-trust
-tubes
-tulip
-tupler
-typed_headers
-valid
-validate_monadic
-varasto
-vindaloo
-vleam
-wasmify
-weapp
-webls
-webmidi
-wechat_dev_tools
-wemote
-wimp
-wink
-wisp
-wisp_flash
-wolf
-worm
-wp_tables
-xmb
-xmleam
-xmlm
-ygleam
-youid
-zeptomail
-zip_list
diff --git a/extensions/gleam/src/gleam.rs b/extensions/gleam/src/gleam.rs
deleted file mode 100644
index a40111f79341cf..00000000000000
--- a/extensions/gleam/src/gleam.rs
+++ /dev/null
@@ -1,249 +0,0 @@
-mod hexdocs;
-
-use std::fs;
-use std::sync::LazyLock;
-use zed::lsp::CompletionKind;
-use zed::{
-    CodeLabel, CodeLabelSpan, KeyValueStore, LanguageServerId, SlashCommand, SlashCommandOutput,
-    SlashCommandOutputSection,
-};
-use zed_extension_api::{self as zed, Result};
-
-struct GleamExtension {
-    cached_binary_path: Option<String>,
-}
-
-impl GleamExtension {
-    fn language_server_binary_path(
-        &mut self,
-        language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<String> {
-        if let Some(path) = worktree.which("gleam") {
-            return Ok(path);
-        }
-
-        if let Some(path) = &self.cached_binary_path {
-            if fs::metadata(path).map_or(false, |stat| stat.is_file()) {
-                return Ok(path.clone());
-            }
-        }
-
-        zed::set_language_server_installation_status(
-            language_server_id,
-            &zed::LanguageServerInstallationStatus::CheckingForUpdate,
-        );
-        let release = zed::latest_github_release(
-            "gleam-lang/gleam",
-            zed::GithubReleaseOptions {
-                require_assets: true,
-                pre_release: false,
-            },
-        )?;
-
-        let (platform, arch) = zed::current_platform();
-        let asset_name = format!(
-            "gleam-{version}-{arch}-{os}.tar.gz",
-            version = release.version,
-            arch = match arch {
-                zed::Architecture::Aarch64 => "aarch64",
-                zed::Architecture::X86 => "x86",
-                zed::Architecture::X8664 => "x86_64",
-            },
-            os = match platform {
-                zed::Os::Mac => "apple-darwin",
-                zed::Os::Linux => "unknown-linux-musl",
-                zed::Os::Windows => "pc-windows-msvc",
-            },
-        );
-
-        let asset = release
-            .assets
-            .iter()
-            .find(|asset| asset.name == asset_name)
-            .ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
-
-        let version_dir = format!("gleam-{}", release.version);
-        let binary_path = format!("{version_dir}/gleam");
-
-        if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
-            zed::set_language_server_installation_status(
-                language_server_id,
-                &zed::LanguageServerInstallationStatus::Downloading,
-            );
-
-            zed::download_file(
-                &asset.download_url,
-                &version_dir,
-                zed::DownloadedFileType::GzipTar,
-            )
-            .map_err(|e| format!("failed to download file: {e}"))?;
-
-            let entries =
-                fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
-            for entry in entries {
-                let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
-                if entry.file_name().to_str() != Some(&version_dir) {
-                    fs::remove_dir_all(entry.path()).ok();
-                }
-            }
-        }
-
-        self.cached_binary_path = Some(binary_path.clone());
-        Ok(binary_path)
-    }
-}
-
-impl zed::Extension for GleamExtension {
-    fn new() -> Self {
-        Self {
-            cached_binary_path: None,
-        }
-    }
-
-    fn language_server_command(
-        &mut self,
-        language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<zed::Command> {
-        Ok(zed::Command {
-            command: self.language_server_binary_path(language_server_id, worktree)?,
-            args: vec!["lsp".to_string()],
-            env: Default::default(),
-        })
-    }
-
-    fn label_for_completion(
-        &self,
-        _language_server_id: &LanguageServerId,
-        completion: zed::lsp::Completion,
-    ) -> Option<zed::CodeLabel> {
-        let name = &completion.label;
-        let ty = strip_newlines_from_detail(&completion.detail?);
-        let let_binding = "let a";
-        let colon = ": ";
-        let assignment = " = ";
-        let call = match completion.kind? {
-            CompletionKind::Function | CompletionKind::Constructor => "()",
-            _ => "",
-        };
-        let code = format!("{let_binding}{colon}{ty}{assignment}{name}{call}");
-
-        Some(CodeLabel {
-            spans: vec![
-                CodeLabelSpan::code_range({
-                    let start = let_binding.len() + colon.len() + ty.len() + assignment.len();
-                    start..start + name.len()
-                }),
-                CodeLabelSpan::code_range({
-                    let start = let_binding.len();
-                    start..start + colon.len()
-                }),
-                CodeLabelSpan::code_range({
-                    let start = let_binding.len() + colon.len();
-                    start..start + ty.len()
-                }),
-            ],
-            filter_range: (0..name.len()).into(),
-            code,
-        })
-    }
-
-    fn run_slash_command(
-        &self,
-        command: SlashCommand,
-        _args: Vec<String>,
-        worktree: Option<&zed::Worktree>,
-    ) -> Result<SlashCommandOutput, String> {
-        match command.name.as_str() {
-            "gleam-project" => {
-                let worktree = worktree.ok_or("no worktree")?;
-
-                let mut text = String::new();
-                text.push_str("You are in a Gleam project.\n");
-
-                if let Ok(gleam_toml) = worktree.read_text_file("gleam.toml") {
-                    text.push_str("The `gleam.toml` is as follows:\n");
-                    text.push_str(&gleam_toml);
-                }
-
-                Ok(SlashCommandOutput {
-                    sections: vec![SlashCommandOutputSection {
-                        range: (0..text.len()).into(),
-                        label: "gleam-project".to_string(),
-                    }],
-                    text,
-                })
-            }
-            command => Err(format!("unknown slash command: \"{command}\"")),
-        }
-    }
-
-    fn suggest_docs_packages(&self, provider: String) -> Result<Vec<String>, String> {
-        match provider.as_str() {
-            "gleam-hexdocs" => {
-                static GLEAM_PACKAGES: LazyLock<Vec<String>> = LazyLock::new(|| {
-                    include_str!("../packages.txt")
-                        .lines()
-                        .filter(|line| !line.starts_with('#'))
-                        .map(|line| line.trim().to_owned())
-                        .collect()
-                });
-
-                Ok(GLEAM_PACKAGES.clone())
-            }
-            _ => Ok(Vec::new()),
-        }
-    }
-
-    fn index_docs(
-        &self,
-        provider: String,
-        package: String,
-        database: &KeyValueStore,
-    ) -> Result<(), String> {
-        match provider.as_str() {
-            "gleam-hexdocs" => hexdocs::index(package, database),
-            _ => Ok(()),
-        }
-    }
-}
-
-zed::register_extension!(GleamExtension);
-
-/// Removes newlines from the completion detail.
-///
-/// The Gleam LSP can return types containing newlines, which causes formatting
-/// issues within the Zed completions menu.
-fn strip_newlines_from_detail(detail: &str) -> String {
-    let without_newlines = detail
-        .replace("->\n  ", "-> ")
-        .replace("\n  ", "")
-        .replace(",\n", "");
-
-    let comma_delimited_parts = without_newlines.split(',');
-    comma_delimited_parts
-        .map(|part| part.trim())
-        .collect::<Vec<_>>()
-        .join(", ")
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::strip_newlines_from_detail;
-
-    #[test]
-    fn test_strip_newlines_from_detail() {
-        let detail = "fn(\n  Selector(a),\n  b,\n  fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a,\n) -> Selector(a)";
-        let expected = "fn(Selector(a), b, fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a) -> Selector(a)";
-        assert_eq!(strip_newlines_from_detail(detail), expected);
-
-        let detail = "fn(Selector(a), b, fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a) ->\n  Selector(a)";
-        let expected = "fn(Selector(a), b, fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a) -> Selector(a)";
-        assert_eq!(strip_newlines_from_detail(detail), expected);
-
-        let detail = "fn(\n  Method,\n  List(#(String, String)),\n  a,\n  Scheme,\n  String,\n  Option(Int),\n  String,\n  Option(String),\n) -> Request(a)";
-        let expected = "fn(Method, List(#(String, String)), a, Scheme, String, Option(Int), String, Option(String)) -> Request(a)";
-        assert_eq!(strip_newlines_from_detail(detail), expected);
-    }
-}
diff --git a/extensions/gleam/src/hexdocs.rs b/extensions/gleam/src/hexdocs.rs
deleted file mode 100644
index 1b6b073a61b418..00000000000000
--- a/extensions/gleam/src/hexdocs.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-use std::cell::RefCell;
-use std::collections::BTreeSet;
-use std::io::{self, Read};
-use std::rc::Rc;
-
-use html_to_markdown::markdown::{
-    HeadingHandler, ListHandler, ParagraphHandler, StyledTextHandler, TableHandler,
-};
-use html_to_markdown::{
-    convert_html_to_markdown, HandleTag, HandlerOutcome, HtmlElement, MarkdownWriter,
-    StartTagOutcome, TagHandler,
-};
-use zed_extension_api::{
-    http_client::{HttpMethod, HttpRequest, RedirectPolicy},
-    KeyValueStore, Result,
-};
-
-pub fn index(package: String, database: &KeyValueStore) -> Result<()> {
-    let headers = vec![(
-        "User-Agent".to_string(),
-        "Zed (Gleam Extension)".to_string(),
-    )];
-
-    let response = HttpRequest::builder()
-        .method(HttpMethod::Get)
-        .url(format!("https://hexdocs.pm/{package}"))
-        .headers(headers.clone())
-        .redirect_policy(RedirectPolicy::FollowAll)
-        .build()?
-        .fetch()?;
-
-    let (package_root_markdown, modules) =
-        convert_hexdocs_to_markdown(&mut io::Cursor::new(&response.body))?;
-
-    database.insert(&package, &package_root_markdown)?;
-
-    for module in modules {
-        let response = HttpRequest::builder()
-            .method(HttpMethod::Get)
-            .url(format!("https://hexdocs.pm/{package}/{module}.html"))
-            .headers(headers.clone())
-            .redirect_policy(RedirectPolicy::FollowAll)
-            .build()?
-            .fetch()?;
-
-        let (markdown, _modules) =
-            convert_hexdocs_to_markdown(&mut io::Cursor::new(&response.body))?;
-
-        database.insert(&format!("{module} ({package})"), &markdown)?;
-    }
-
-    Ok(())
-}
-
-pub fn convert_hexdocs_to_markdown(html: impl Read) -> Result<(String, Vec<String>)> {
-    let module_collector = Rc::new(RefCell::new(GleamModuleCollector::new()));
-
-    let mut handlers: Vec<TagHandler> = vec![
-        module_collector.clone(),
-        Rc::new(RefCell::new(GleamChromeRemover)),
-        Rc::new(RefCell::new(NavSkipper::new(ParagraphHandler))),
-        Rc::new(RefCell::new(NavSkipper::new(HeadingHandler))),
-        Rc::new(RefCell::new(NavSkipper::new(ListHandler))),
-        Rc::new(RefCell::new(NavSkipper::new(TableHandler::new()))),
-        Rc::new(RefCell::new(NavSkipper::new(StyledTextHandler))),
-    ];
-
-    let markdown = convert_html_to_markdown(html, &mut handlers)
-        .map_err(|err| format!("failed to convert docs to Markdown {err}"))?;
-
-    let modules = module_collector
-        .borrow()
-        .modules
-        .iter()
-        .cloned()
-        .collect::<Vec<_>>();
-
-    Ok((markdown, modules))
-}
-
-/// A higher-order handler that skips all content from the `nav`.
-///
-/// We still need to traverse the `nav` for collecting information, but
-/// we don't want to include any of its content in the resulting Markdown.
-pub struct NavSkipper<T: HandleTag> {
-    handler: T,
-}
-
-impl<T: HandleTag> NavSkipper<T> {
-    pub fn new(handler: T) -> Self {
-        Self { handler }
-    }
-}
-
-impl<T: HandleTag> HandleTag for NavSkipper<T> {
-    fn should_handle(&self, tag: &str) -> bool {
-        tag == "nav" || self.handler.should_handle(tag)
-    }
-
-    fn handle_tag_start(
-        &mut self,
-        tag: &HtmlElement,
-        writer: &mut MarkdownWriter,
-    ) -> StartTagOutcome {
-        if writer.is_inside("nav") {
-            return StartTagOutcome::Continue;
-        }
-
-        self.handler.handle_tag_start(tag, writer)
-    }
-
-    fn handle_tag_end(&mut self, tag: &HtmlElement, writer: &mut MarkdownWriter) {
-        if writer.is_inside("nav") {
-            return;
-        }
-
-        self.handler.handle_tag_end(tag, writer)
-    }
-
-    fn handle_text(&mut self, text: &str, writer: &mut MarkdownWriter) -> HandlerOutcome {
-        if writer.is_inside("nav") {
-            return HandlerOutcome::Handled;
-        }
-
-        self.handler.handle_text(text, writer)
-    }
-}
-
-pub struct GleamChromeRemover;
-
-impl HandleTag for GleamChromeRemover {
-    fn should_handle(&self, tag: &str) -> bool {
-        matches!(
-            tag,
-            "head" | "script" | "style" | "svg" | "header" | "footer" | "a"
-        )
-    }
-
-    fn handle_tag_start(
-        &mut self,
-        tag: &HtmlElement,
-        _writer: &mut MarkdownWriter,
-    ) -> StartTagOutcome {
-        match tag.tag() {
-            "head" | "script" | "style" | "svg" | "header" | "footer" => {
-                return StartTagOutcome::Skip;
-            }
-            "a" => {
-                if tag.attr("onclick").is_some() {
-                    return StartTagOutcome::Skip;
-                }
-            }
-            _ => {}
-        }
-
-        StartTagOutcome::Continue
-    }
-}
-
-pub struct GleamModuleCollector {
-    modules: BTreeSet<String>,
-    has_seen_modules_header: bool,
-}
-
-impl GleamModuleCollector {
-    pub fn new() -> Self {
-        Self {
-            modules: BTreeSet::new(),
-            has_seen_modules_header: false,
-        }
-    }
-
-    fn parse_module(tag: &HtmlElement) -> Option<String> {
-        if tag.tag() != "a" {
-            return None;
-        }
-
-        let href = tag.attr("href")?;
-        if href.starts_with('#') || href.starts_with("https://") || href.starts_with("../") {
-            return None;
-        }
-
-        let module_name = href.trim_start_matches("./").trim_end_matches(".html");
-
-        Some(module_name.to_owned())
-    }
-}
-
-impl HandleTag for GleamModuleCollector {
-    fn should_handle(&self, tag: &str) -> bool {
-        matches!(tag, "h2" | "a")
-    }
-
-    fn handle_tag_start(
-        &mut self,
-        tag: &HtmlElement,
-        writer: &mut MarkdownWriter,
-    ) -> StartTagOutcome {
-        if tag.tag() == "a" && self.has_seen_modules_header && writer.is_inside("li") {
-            if let Some(module_name) = Self::parse_module(tag) {
-                self.modules.insert(module_name);
-            }
-        }
-
-        StartTagOutcome::Continue
-    }
-
-    fn handle_text(&mut self, text: &str, writer: &mut MarkdownWriter) -> HandlerOutcome {
-        if writer.is_inside("nav") && writer.is_inside("h2") && text == "Modules" {
-            self.has_seen_modules_header = true;
-        }
-
-        HandlerOutcome::NoOp
-    }
-}

From c21f26c41915402a758e6e7b8c99b3cbc2b78ba1 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Fri, 11 Oct 2024 17:11:20 +0200
Subject: [PATCH 605/762] ssh remote: Stream stderr from server via proxy to
 client (#19073)

Release Notes:

- N/A

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/remote/src/ssh_session.rs |   3 +-
 crates/remote_server/src/main.rs |  33 ++--
 crates/remote_server/src/unix.rs | 281 ++++++++++++++++++++++---------
 3 files changed, 220 insertions(+), 97 deletions(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 48b1641f3d244d..87756aeb0c6ec8 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -836,8 +836,7 @@ impl SshRemoteClient {
                                     let line_ix = start_ix + ix;
                                     let content = &stderr_buffer[start_ix..line_ix];
                                     start_ix = line_ix + 1;
-                                    if let Ok(mut record) = serde_json::from_slice::<LogRecord>(content) {
-                                        record.message = format!("(remote) {}", record.message);
+                                    if let Ok(record) = serde_json::from_slice::<LogRecord>(content) {
                                         record.log(log::logger())
                                     } else {
                                         eprintln!("(remote) {}", String::from_utf8_lossy(content));
diff --git a/crates/remote_server/src/main.rs b/crates/remote_server/src/main.rs
index 50f34fbd39f581..a37ec2864e8be4 100644
--- a/crates/remote_server/src/main.rs
+++ b/crates/remote_server/src/main.rs
@@ -22,6 +22,8 @@ enum Commands {
         stdin_socket: PathBuf,
         #[arg(long)]
         stdout_socket: PathBuf,
+        #[arg(long)]
+        stderr_socket: PathBuf,
     },
     Proxy {
         #[arg(long)]
@@ -40,7 +42,7 @@ fn main() {
 #[cfg(not(windows))]
 fn main() -> Result<()> {
     use remote::proxy::ProxyLaunchError;
-    use remote_server::unix::{execute_proxy, execute_run, init};
+    use remote_server::unix::{execute_proxy, execute_run};
 
     let cli = Cli::parse();
 
@@ -50,25 +52,26 @@ fn main() -> Result<()> {
             pid_file,
             stdin_socket,
             stdout_socket,
-        }) => {
-            init(Some(log_file))?;
-            execute_run(pid_file, stdin_socket, stdout_socket)
-        }
+            stderr_socket,
+        }) => execute_run(
+            log_file,
+            pid_file,
+            stdin_socket,
+            stdout_socket,
+            stderr_socket,
+        ),
         Some(Commands::Proxy {
             identifier,
             reconnect,
-        }) => {
-            init(None)?;
-            match execute_proxy(identifier, reconnect) {
-                Ok(_) => Ok(()),
-                Err(err) => {
-                    if let Some(err) = err.downcast_ref::<ProxyLaunchError>() {
-                        std::process::exit(err.to_exit_code());
-                    }
-                    Err(err)
+        }) => match execute_proxy(identifier, reconnect) {
+            Ok(_) => Ok(()),
+            Err(err) => {
+                if let Some(err) = err.downcast_ref::<ProxyLaunchError>() {
+                    std::process::exit(err.to_exit_code());
                 }
+                Err(err)
             }
-        }
+        },
         Some(Commands::Version) => {
             eprintln!("{}", env!("ZED_PKG_VERSION"));
             Ok(())
diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs
index 7a05268cc8efc1..2b487803fbe67e 100644
--- a/crates/remote_server/src/unix.rs
+++ b/crates/remote_server/src/unix.rs
@@ -2,7 +2,7 @@ use crate::HeadlessProject;
 use anyhow::{anyhow, Context, Result};
 use fs::RealFs;
 use futures::channel::mpsc;
-use futures::{select, select_biased, AsyncRead, AsyncWrite, FutureExt, SinkExt};
+use futures::{select, select_biased, AsyncRead, AsyncWrite, AsyncWriteExt, FutureExt, SinkExt};
 use gpui::{AppContext, Context as _};
 use remote::proxy::ProxyLaunchError;
 use remote::ssh_session::ChannelClient;
@@ -11,8 +11,10 @@ use remote::{
     protocol::{read_message, write_message},
 };
 use rpc::proto::Envelope;
+use smol::channel::{Receiver, Sender};
+use smol::io::AsyncReadExt;
 use smol::Async;
-use smol::{io::AsyncWriteExt, net::unix::UnixListener, stream::StreamExt as _};
+use smol::{net::unix::UnixListener, stream::StreamExt as _};
 use std::{
     env,
     io::Write,
@@ -21,36 +23,70 @@ use std::{
     sync::Arc,
 };
 
-pub fn init(log_file: Option<PathBuf>) -> Result<()> {
-    init_logging(log_file)?;
-    init_panic_hook();
-    Ok(())
+fn init_logging_proxy() {
+    env_logger::builder()
+        .format(|buf, record| {
+            let mut log_record = LogRecord::new(record);
+            log_record.message = format!("(remote proxy) {}", log_record.message);
+            serde_json::to_writer(&mut *buf, &log_record)?;
+            buf.write_all(b"\n")?;
+            Ok(())
+        })
+        .init();
 }
 
-fn init_logging(log_file: Option<PathBuf>) -> Result<()> {
-    if let Some(log_file) = log_file {
-        let target = Box::new(if log_file.exists() {
-            std::fs::OpenOptions::new()
-                .append(true)
-                .open(&log_file)
-                .context("Failed to open log file in append mode")?
-        } else {
-            std::fs::File::create(&log_file).context("Failed to create log file")?
-        });
+fn init_logging_server(log_file_path: PathBuf) -> Result<Receiver<Vec<u8>>> {
+    struct MultiWrite {
+        file: Box<dyn std::io::Write + Send + 'static>,
+        channel: Sender<Vec<u8>>,
+        buffer: Vec<u8>,
+    }
 
-        env_logger::Builder::from_default_env()
-            .target(env_logger::Target::Pipe(target))
-            .init();
-    } else {
-        env_logger::builder()
-            .format(|buf, record| {
-                serde_json::to_writer(&mut *buf, &LogRecord::new(record))?;
-                buf.write_all(b"\n")?;
-                Ok(())
-            })
-            .init();
+    impl std::io::Write for MultiWrite {
+        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+            let written = self.file.write(buf)?;
+            self.buffer.extend_from_slice(&buf[..written]);
+            Ok(written)
+        }
+
+        fn flush(&mut self) -> std::io::Result<()> {
+            self.channel
+                .send_blocking(self.buffer.clone())
+                .map_err(|error| std::io::Error::new(std::io::ErrorKind::Other, error))?;
+            self.buffer.clear();
+            self.file.flush()
+        }
     }
-    Ok(())
+
+    let log_file = Box::new(if log_file_path.exists() {
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(&log_file_path)
+            .context("Failed to open log file in append mode")?
+    } else {
+        std::fs::File::create(&log_file_path).context("Failed to create log file")?
+    });
+
+    let (tx, rx) = smol::channel::unbounded();
+
+    let target = Box::new(MultiWrite {
+        file: log_file,
+        channel: tx,
+        buffer: Vec::new(),
+    });
+
+    env_logger::Builder::from_default_env()
+        .target(env_logger::Target::Pipe(target))
+        .format(|buf, record| {
+            let mut log_record = LogRecord::new(record);
+            log_record.message = format!("(remote server) {}", log_record.message);
+            serde_json::to_writer(&mut *buf, &log_record)?;
+            buf.write_all(b"\n")?;
+            Ok(())
+        })
+        .init();
+
+    Ok(rx)
 }
 
 fn init_panic_hook() {
@@ -83,7 +119,7 @@ fn init_panic_hook() {
         }
 
         log::error!(
-            "server: panic occurred: {}\nBacktrace:\n{}",
+            "panic occurred: {}\nBacktrace:\n{}",
             payload,
             backtrace.join("\n")
         );
@@ -92,9 +128,25 @@ fn init_panic_hook() {
     }));
 }
 
+struct ServerListeners {
+    stdin: UnixListener,
+    stdout: UnixListener,
+    stderr: UnixListener,
+}
+
+impl ServerListeners {
+    pub fn new(stdin_path: PathBuf, stdout_path: PathBuf, stderr_path: PathBuf) -> Result<Self> {
+        Ok(Self {
+            stdin: UnixListener::bind(stdin_path).context("failed to bind stdin socket")?,
+            stdout: UnixListener::bind(stdout_path).context("failed to bind stdout socket")?,
+            stderr: UnixListener::bind(stderr_path).context("failed to bind stderr socket")?,
+        })
+    }
+}
+
 fn start_server(
-    stdin_listener: UnixListener,
-    stdout_listener: UnixListener,
+    listeners: ServerListeners,
+    mut log_rx: Receiver<Vec<u8>>,
     cx: &mut AppContext,
 ) -> Arc<ChannelClient> {
     // This is the server idle timeout. If no connection comes in in this timeout, the server will shut down.
@@ -114,22 +166,24 @@ fn start_server(
     .detach();
 
     cx.spawn(|cx| async move {
-        let mut stdin_incoming = stdin_listener.incoming();
-        let mut stdout_incoming = stdout_listener.incoming();
+        let mut stdin_incoming = listeners.stdin.incoming();
+        let mut stdout_incoming = listeners.stdout.incoming();
+        let mut stderr_incoming = listeners.stderr.incoming();
 
         loop {
-            let streams = futures::future::join(stdin_incoming.next(), stdout_incoming.next());
+            let streams = futures::future::join3(stdin_incoming.next(), stdout_incoming.next(), stderr_incoming.next());
 
-            log::info!("server: accepting new connections");
+            log::info!("accepting new connections");
             let result = select! {
                 streams = streams.fuse() => {
-                    let (Some(Ok(stdin_stream)), Some(Ok(stdout_stream))) = streams else {
+                    log::warn!("stdin {:?}, stdout: {:?}, stderr: {:?}", streams.0, streams.1, streams.2);
+                    let (Some(Ok(stdin_stream)), Some(Ok(stdout_stream)), Some(Ok(stderr_stream))) = streams else {
                         break;
                     };
-                    anyhow::Ok((stdin_stream, stdout_stream))
+                    anyhow::Ok((stdin_stream, stdout_stream, stderr_stream))
                 }
                 _ = futures::FutureExt::fuse(smol::Timer::after(IDLE_TIMEOUT)) => {
-                    log::warn!("server: timed out waiting for new connections after {:?}. exiting.", IDLE_TIMEOUT);
+                    log::warn!("timed out waiting for new connections after {:?}. exiting.", IDLE_TIMEOUT);
                     cx.update(|cx| {
                         // TODO: This is a hack, because in a headless project, shutdown isn't executed
                         // when calling quit, but it should be.
@@ -143,10 +197,12 @@ fn start_server(
                 }
             };
 
-            let Ok((mut stdin_stream, mut stdout_stream)) = result else {
+            let Ok((mut stdin_stream, mut stdout_stream, mut stderr_stream)) = result else {
                 break;
             };
 
+            log::info!("yep! we got connections");
+
             let mut input_buffer = Vec::new();
             let mut output_buffer = Vec::new();
             loop {
@@ -159,33 +215,47 @@ fn start_server(
                         let message = match stdin_message {
                             Ok(message) => message,
                             Err(error) => {
-                                log::warn!("server: error reading message on stdin: {}. exiting.", error);
+                                log::warn!("error reading message on stdin: {}. exiting.", error);
                                 break;
                             }
                         };
                         if let Err(error) = incoming_tx.unbounded_send(message) {
-                            log::error!("server: failed to send message to application: {:?}. exiting.", error);
+                            log::error!("failed to send message to application: {:?}. exiting.", error);
                             return Err(anyhow!(error));
                         }
                     }
 
                     outgoing_message  = outgoing_rx.next().fuse() => {
                         let Some(message) = outgoing_message else {
-                            log::error!("server: stdout handler, no message");
+                            log::error!("stdout handler, no message");
                             break;
                         };
 
                         if let Err(error) =
                             write_message(&mut stdout_stream, &mut output_buffer, message).await
                         {
-                            log::error!("server: failed to write stdout message: {:?}", error);
+                            log::error!("failed to write stdout message: {:?}", error);
                             break;
                         }
                         if let Err(error) = stdout_stream.flush().await {
-                            log::error!("server: failed to flush stdout message: {:?}", error);
+                            log::error!("failed to flush stdout message: {:?}", error);
                             break;
                         }
                     }
+
+                    // // TODO: How do we handle backpressure?
+                    log_message = log_rx.next().fuse() => {
+                        if let Some(log_message) = log_message {
+                            if let Err(error) = stderr_stream.write_all(&log_message).await {
+                                log::error!("failed to write log message to stderr: {:?}", error);
+                                break;
+                            }
+                            if let Err(error) = stderr_stream.flush().await {
+                                log::error!("failed to flush stderr stream: {:?}", error);
+                                break;
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -196,35 +266,44 @@ fn start_server(
     ChannelClient::new(incoming_rx, outgoing_tx, cx)
 }
 
-pub fn execute_run(pid_file: PathBuf, stdin_socket: PathBuf, stdout_socket: PathBuf) -> Result<()> {
+pub fn execute_run(
+    log_file: PathBuf,
+    pid_file: PathBuf,
+    stdin_socket: PathBuf,
+    stdout_socket: PathBuf,
+    stderr_socket: PathBuf,
+) -> Result<()> {
+    let log_rx = init_logging_server(log_file)?;
+    init_panic_hook();
+
     log::info!(
-        "server: starting up. pid_file: {:?}, stdin_socket: {:?}, stdout_socket: {:?}",
+        "starting up. pid_file: {:?}, stdin_socket: {:?}, stdout_socket: {:?}, stderr_socket: {:?}",
         pid_file,
         stdin_socket,
-        stdout_socket
+        stdout_socket,
+        stderr_socket
     );
 
     write_pid_file(&pid_file)
         .with_context(|| format!("failed to write pid file: {:?}", &pid_file))?;
 
-    let stdin_listener = UnixListener::bind(stdin_socket).context("failed to bind stdin socket")?;
-    let stdout_listener =
-        UnixListener::bind(stdout_socket).context("failed to bind stdout socket")?;
+    let listeners = ServerListeners::new(stdin_socket, stdout_socket, stderr_socket)?;
 
-    log::debug!("server: starting gpui app");
+    log::debug!("starting gpui app");
     gpui::App::headless().run(move |cx| {
         settings::init(cx);
         HeadlessProject::init(cx);
 
-        log::info!("server: gpui app started, initializing server");
-        let session = start_server(stdin_listener, stdout_listener, cx);
+        log::info!("gpui app started, initializing server");
+        let session = start_server(listeners, log_rx, cx);
+
         let project = cx.new_model(|cx| {
             HeadlessProject::new(session, Arc::new(RealFs::new(Default::default(), None)), cx)
         });
 
         mem::forget(project);
     });
-    log::info!("server: gpui app is shut down. quitting.");
+    log::info!("gpui app is shut down. quitting.");
     Ok(())
 }
 
@@ -234,6 +313,7 @@ struct ServerPaths {
     pid_file: PathBuf,
     stdin_socket: PathBuf,
     stdout_socket: PathBuf,
+    stderr_socket: PathBuf,
 }
 
 impl ServerPaths {
@@ -243,19 +323,24 @@ impl ServerPaths {
         let pid_file = project_dir.join("server.pid");
         let stdin_socket = project_dir.join("stdin.sock");
         let stdout_socket = project_dir.join("stdout.sock");
+        let stderr_socket = project_dir.join("stderr.sock");
         let log_file = project_dir.join("server.log");
 
         Ok(Self {
             pid_file,
             stdin_socket,
             stdout_socket,
+            stderr_socket,
             log_file,
         })
     }
 }
 
 pub fn execute_proxy(identifier: String, is_reconnecting: bool) -> Result<()> {
-    log::debug!("proxy: starting up. PID: {}", std::process::id());
+    init_logging_proxy();
+    init_panic_hook();
+
+    log::debug!("starting up. PID: {}", std::process::id());
 
     let server_paths = ServerPaths::new(&identifier)?;
 
@@ -263,12 +348,12 @@ pub fn execute_proxy(identifier: String, is_reconnecting: bool) -> Result<()> {
     let server_running = server_pid.is_some();
     if is_reconnecting {
         if !server_running {
-            log::error!("proxy: attempted to reconnect, but no server running");
+            log::error!("attempted to reconnect, but no server running");
             return Err(anyhow!(ProxyLaunchError::ServerNotRunning));
         }
     } else {
         if let Some(pid) = server_pid {
-            log::debug!("proxy: found server already running with PID {}. Killing process and cleaning up files...", pid);
+            log::debug!("found server already running with PID {}. Killing process and cleaning up files...", pid);
             kill_running_server(pid, &server_paths)?;
         }
 
@@ -287,11 +372,35 @@ pub fn execute_proxy(identifier: String, is_reconnecting: bool) -> Result<()> {
         handle_io(stream, stdout, "stdout").await
     });
 
-    if let Err(forwarding_result) =
-        smol::block_on(async move { smol::future::race(stdin_task, stdout_task).await })
-    {
+    let stderr_task: smol::Task<Result<()>> = smol::spawn(async move {
+        let mut stderr = Async::new(std::io::stderr())?;
+        let mut stream = smol::net::unix::UnixStream::connect(&server_paths.stderr_socket).await?;
+        let mut stderr_buffer = vec![0; 2048];
+        loop {
+            match stream.read(&mut stderr_buffer).await {
+                Ok(0) => {
+                    return anyhow::Ok(());
+                }
+                Ok(n) => {
+                    stderr.write_all(&mut stderr_buffer[..n]).await?;
+                    stderr.flush().await?;
+                }
+                Err(error) => {
+                    Err(anyhow!("error reading stderr: {error:?}"))?;
+                }
+            }
+        }
+    });
+
+    if let Err(forwarding_result) = smol::block_on(async move {
+        futures::select! {
+            result = stdin_task.fuse() => result,
+            result = stdout_task.fuse() => result,
+            result = stderr_task.fuse() => result,
+        }
+    }) {
         log::error!(
-            "proxy: failed to forward messages: {:?}, terminating...",
+            "failed to forward messages: {:?}, terminating...",
             forwarding_result
         );
         return Err(forwarding_result);
@@ -314,17 +423,19 @@ fn create_state_directory(identifier: &str) -> Result<PathBuf> {
 }
 
 fn kill_running_server(pid: u32, paths: &ServerPaths) -> Result<()> {
-    log::info!("proxy: killing existing server with PID {}", pid);
+    log::info!("killing existing server with PID {}", pid);
     std::process::Command::new("kill")
         .arg(pid.to_string())
         .output()
-        .context("proxy: failed to kill existing server")?;
-
-    for file in [&paths.pid_file, &paths.stdin_socket, &paths.stdout_socket] {
-        log::debug!(
-            "proxy: cleaning up file {:?} before starting new server",
-            file
-        );
+        .context("failed to kill existing server")?;
+
+    for file in [
+        &paths.pid_file,
+        &paths.stdin_socket,
+        &paths.stdout_socket,
+        &paths.stderr_socket,
+    ] {
+        log::debug!("cleaning up file {:?} before starting new server", file);
         std::fs::remove_file(file).ok();
     }
     Ok(())
@@ -337,6 +448,9 @@ fn spawn_server(paths: &ServerPaths) -> Result<()> {
     if paths.stdout_socket.exists() {
         std::fs::remove_file(&paths.stdout_socket)?;
     }
+    if paths.stderr_socket.exists() {
+        std::fs::remove_file(&paths.stderr_socket)?;
+    }
 
     let binary_name = std::env::current_exe()?;
     let server_process = std::process::Command::new(binary_name)
@@ -349,20 +463,25 @@ fn spawn_server(paths: &ServerPaths) -> Result<()> {
         .arg(&paths.stdin_socket)
         .arg("--stdout-socket")
         .arg(&paths.stdout_socket)
+        .arg("--stderr-socket")
+        .arg(&paths.stderr_socket)
         .spawn()?;
 
-    log::debug!("proxy: server started. PID: {:?}", server_process.id());
+    log::debug!("server started. PID: {:?}", server_process.id());
 
     let mut total_time_waited = std::time::Duration::from_secs(0);
     let wait_duration = std::time::Duration::from_millis(20);
-    while !paths.stdout_socket.exists() || !paths.stdin_socket.exists() {
-        log::debug!("proxy: waiting for server to be ready to accept connections...");
+    while !paths.stdout_socket.exists()
+        || !paths.stdin_socket.exists()
+        || !paths.stderr_socket.exists()
+    {
+        log::debug!("waiting for server to be ready to accept connections...");
         std::thread::sleep(wait_duration);
         total_time_waited += wait_duration;
     }
 
     log::info!(
-        "proxy: server ready to accept connections. total time waited: {:?}",
+        "server ready to accept connections. total time waited: {:?}",
         total_time_waited
     );
     Ok(())
@@ -376,19 +495,21 @@ fn check_pid_file(path: &Path) -> Result<Option<u32>> {
         return Ok(None);
     };
 
-    log::debug!("proxy: Checking if process with PID {} exists...", pid);
+    log::debug!("Checking if process with PID {} exists...", pid);
     match std::process::Command::new("kill")
         .arg("-0")
         .arg(pid.to_string())
         .output()
     {
         Ok(output) if output.status.success() => {
-            log::debug!("proxy: Process with PID {} exists. NOT spawning new server, but attaching to existing one.", pid);
+            log::debug!("Process with PID {} exists. NOT spawning new server, but attaching to existing one.", pid);
             Ok(Some(pid))
         }
         _ => {
-            log::debug!("proxy: Found PID file, but process with that PID does not exist. Removing PID file.");
-            std::fs::remove_file(&path).context("proxy: Failed to remove PID file")?;
+            log::debug!(
+                "Found PID file, but process with that PID does not exist. Removing PID file."
+            );
+            std::fs::remove_file(&path).context("Failed to remove PID file")?;
             Ok(None)
         }
     }
@@ -399,7 +520,7 @@ fn write_pid_file(path: &Path) -> Result<()> {
         std::fs::remove_file(path)?;
     }
     let pid = std::process::id().to_string();
-    log::debug!("server: writing PID {} to file {:?}", pid, path);
+    log::debug!("writing PID {} to file {:?}", pid, path);
     std::fs::write(path, pid).context("Failed to write PID file")
 }
 
@@ -414,11 +535,11 @@ where
     loop {
         read_message_raw(&mut reader, &mut buffer)
             .await
-            .with_context(|| format!("proxy: failed to read message from {}", socket_name))?;
+            .with_context(|| format!("failed to read message from {}", socket_name))?;
 
         write_size_prefixed_buffer(&mut writer, &mut buffer)
             .await
-            .with_context(|| format!("proxy: failed to write message to {}", socket_name))?;
+            .with_context(|| format!("failed to write message to {}", socket_name))?;
 
         writer.flush().await?;
 

From 5cf0217549747a79da0ec27d0b1125f6f9f9a7bf Mon Sep 17 00:00:00 2001
From: Shish <shish@shishnet.org>
Date: Fri, 11 Oct 2024 17:09:24 +0100
Subject: [PATCH 606/762] terminal: Improve default locale handling (#18967)

terminal: Improve default locale handling

* Use `LANG` instead of `LC_ALL` (`LC_ALL` is the highest priority which
will override any other end-user settings; when that isn't set things
fall back to separate `LC_*` variables; and when those aren't set things
fall back to `LANG`). [0]
* Only set `LANG` for our child if necessary (if it already exists in
the parent, then the child will inherit that, no need for us to do
anything)

[0]
https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html#tag_08_02

Tested cases:

- `unset LANG ; cargo run`: locale inside zed's terminal is set to
`en_US.UTF-8`
- `export LANG=en_GB.UTF-8 ; cargo run`: locale inside zed's terminal is
set to `en_GB.UTF-8`

Release Notes:

- Use the system locale in the terminal instead of forcing `en_US.UTF-8`
---
 crates/terminal/src/terminal.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs
index 092f8c63777bce..d02da38d94ee6f 100644
--- a/crates/terminal/src/terminal.rs
+++ b/crates/terminal/src/terminal.rs
@@ -332,9 +332,14 @@ impl TerminalBuilder {
         completion_tx: Sender<()>,
         cx: &AppContext,
     ) -> Result<TerminalBuilder> {
-        // TODO: Properly set the current locale,
-        env.entry("LC_ALL".to_string())
-            .or_insert_with(|| "en_US.UTF-8".to_string());
+        // If the parent environment doesn't have a locale set
+        // (As is the case when launched from a .app on MacOS),
+        // and the Project doesn't have a locale set, then
+        // set a fallback for our child environment to use.
+        if std::env::var("LANG").is_err() {
+            env.entry("LANG".to_string())
+                .or_insert_with(|| "en_US.UTF-8".to_string());
+        }
 
         env.insert("ZED_TERM".to_string(), "true".to_string());
         env.insert("TERM_PROGRAM".to_string(), "zed".to_string());

From 84b61c8b1aec84b5235b7798b83aad039d98033e Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 11 Oct 2024 13:22:45 -0400
Subject: [PATCH 607/762] assistant: Add support for displaying billing-related
 errors (#19082)

This PR adds support to the assistant for display billing-related
errors.

Pulling this out of #19081 to make it easier to cherry-pick.

Release Notes:

- N/A

Co-authored-by: Antonio <antonio@zed.dev>
Co-authored-by: Richard <richard@zed.dev>
---
 Cargo.lock                                  |   1 +
 crates/assistant/src/assistant_panel.rs     | 214 +++++++++++++++-----
 crates/assistant/src/context.rs             |  48 +++--
 crates/language_model/Cargo.toml            |   1 +
 crates/language_model/src/provider/cloud.rs | 138 +++++++++++--
 crates/language_model/src/registry.rs       |   3 +
 crates/proto/proto/zed.proto                |   5 +-
 crates/proto/src/proto.rs                   |   1 +
 crates/rpc/src/llm.rs                       |   2 +
 9 files changed, 330 insertions(+), 83 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 018e9219c5d6af..752050c99522be 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6291,6 +6291,7 @@ dependencies = [
  "strum 0.25.0",
  "text",
  "theme",
+ "thiserror",
  "tiktoken-rs",
  "ui",
  "unindent",
diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index e4d02e5bb733a7..0439122cb48a56 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -1503,6 +1503,13 @@ struct WorkflowAssist {
 
 type MessageHeader = MessageMetadata;
 
+#[derive(Clone)]
+enum AssistError {
+    PaymentRequired,
+    MaxMonthlySpendReached,
+    Message(SharedString),
+}
+
 pub struct ContextEditor {
     context: Model<Context>,
     fs: Arc<dyn Fs>,
@@ -1521,7 +1528,7 @@ pub struct ContextEditor {
     workflow_steps: HashMap<Range<language::Anchor>, WorkflowStepViewState>,
     active_workflow_step: Option<ActiveWorkflowStep>,
     assistant_panel: WeakView<AssistantPanel>,
-    error_message: Option<SharedString>,
+    last_error: Option<AssistError>,
     show_accept_terms: bool,
     pub(crate) slash_menu_handle:
         PopoverMenuHandle<Picker<slash_command_picker::SlashCommandDelegate>>,
@@ -1592,7 +1599,7 @@ impl ContextEditor {
             workflow_steps: HashMap::default(),
             active_workflow_step: None,
             assistant_panel,
-            error_message: None,
+            last_error: None,
             show_accept_terms: false,
             slash_menu_handle: Default::default(),
             dragged_file_worktrees: Vec::new(),
@@ -1636,7 +1643,7 @@ impl ContextEditor {
         }
 
         if !self.apply_active_workflow_step(cx) {
-            self.error_message = None;
+            self.last_error = None;
             self.send_to_model(cx);
             cx.notify();
         }
@@ -1786,7 +1793,7 @@ impl ContextEditor {
     }
 
     fn cancel(&mut self, _: &editor::actions::Cancel, cx: &mut ViewContext<Self>) {
-        self.error_message = None;
+        self.last_error = None;
 
         if self
             .context
@@ -2291,7 +2298,13 @@ impl ContextEditor {
             }
             ContextEvent::Operation(_) => {}
             ContextEvent::ShowAssistError(error_message) => {
-                self.error_message = Some(error_message.clone());
+                self.last_error = Some(AssistError::Message(error_message.clone()));
+            }
+            ContextEvent::ShowPaymentRequiredError => {
+                self.last_error = Some(AssistError::PaymentRequired);
+            }
+            ContextEvent::ShowMaxMonthlySpendReachedError => {
+                self.last_error = Some(AssistError::MaxMonthlySpendReached);
             }
         }
     }
@@ -4305,6 +4318,154 @@ impl ContextEditor {
                 focus_handle.dispatch_action(&Assist, cx);
             })
     }
+
+    fn render_last_error(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
+        let last_error = self.last_error.as_ref()?;
+
+        Some(
+            div()
+                .absolute()
+                .right_3()
+                .bottom_12()
+                .max_w_96()
+                .py_2()
+                .px_3()
+                .elevation_2(cx)
+                .occlude()
+                .child(match last_error {
+                    AssistError::PaymentRequired => self.render_payment_required_error(cx),
+                    AssistError::MaxMonthlySpendReached => {
+                        self.render_max_monthly_spend_reached_error(cx)
+                    }
+                    AssistError::Message(error_message) => {
+                        self.render_assist_error(error_message, cx)
+                    }
+                })
+                .into_any(),
+        )
+    }
+
+    fn render_payment_required_error(&self, cx: &mut ViewContext<Self>) -> AnyElement {
+        const ERROR_MESSAGE: &str = "Free tier exceeded. Subscribe and add payment to continue using Zed LLMs. You'll be billed at cost for tokens used.";
+        const SUBSCRIBE_URL: &str = "https://zed.dev/ai/subscribe";
+
+        v_flex()
+            .gap_0p5()
+            .child(
+                h_flex()
+                    .gap_1p5()
+                    .items_center()
+                    .child(Icon::new(IconName::XCircle).color(Color::Error))
+                    .child(Label::new("Free Usage Exceeded").weight(FontWeight::MEDIUM)),
+            )
+            .child(
+                div()
+                    .id("error-message")
+                    .max_h_24()
+                    .overflow_y_scroll()
+                    .child(Label::new(ERROR_MESSAGE)),
+            )
+            .child(
+                h_flex()
+                    .justify_end()
+                    .mt_1()
+                    .child(Button::new("subscribe", "Subscribe").on_click(cx.listener(
+                        |this, _, cx| {
+                            this.last_error = None;
+                            cx.open_url(SUBSCRIBE_URL);
+                            cx.notify();
+                        },
+                    )))
+                    .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
+                        |this, _, cx| {
+                            this.last_error = None;
+                            cx.notify();
+                        },
+                    ))),
+            )
+            .into_any()
+    }
+
+    fn render_max_monthly_spend_reached_error(&self, cx: &mut ViewContext<Self>) -> AnyElement {
+        const ERROR_MESSAGE: &str = "You have reached your maximum monthly spend. Increase your spend limit to continue using Zed LLMs.";
+        const ACCOUNT_URL: &str = "https://zed.dev/account";
+
+        v_flex()
+            .gap_0p5()
+            .child(
+                h_flex()
+                    .gap_1p5()
+                    .items_center()
+                    .child(Icon::new(IconName::XCircle).color(Color::Error))
+                    .child(Label::new("Max Monthly Spend Reached").weight(FontWeight::MEDIUM)),
+            )
+            .child(
+                div()
+                    .id("error-message")
+                    .max_h_24()
+                    .overflow_y_scroll()
+                    .child(Label::new(ERROR_MESSAGE)),
+            )
+            .child(
+                h_flex()
+                    .justify_end()
+                    .mt_1()
+                    .child(
+                        Button::new("subscribe", "Update Monthly Spend Limit").on_click(
+                            cx.listener(|this, _, cx| {
+                                this.last_error = None;
+                                cx.open_url(ACCOUNT_URL);
+                                cx.notify();
+                            }),
+                        ),
+                    )
+                    .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
+                        |this, _, cx| {
+                            this.last_error = None;
+                            cx.notify();
+                        },
+                    ))),
+            )
+            .into_any()
+    }
+
+    fn render_assist_error(
+        &self,
+        error_message: &SharedString,
+        cx: &mut ViewContext<Self>,
+    ) -> AnyElement {
+        v_flex()
+            .gap_0p5()
+            .child(
+                h_flex()
+                    .gap_1p5()
+                    .items_center()
+                    .child(Icon::new(IconName::XCircle).color(Color::Error))
+                    .child(
+                        Label::new("Error interacting with language model")
+                            .weight(FontWeight::MEDIUM),
+                    ),
+            )
+            .child(
+                div()
+                    .id("error-message")
+                    .max_h_24()
+                    .overflow_y_scroll()
+                    .child(Label::new(error_message.clone())),
+            )
+            .child(
+                h_flex()
+                    .justify_end()
+                    .mt_1()
+                    .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
+                        |this, _, cx| {
+                            this.last_error = None;
+                            cx.notify();
+                        },
+                    ))),
+            )
+            .into_any()
+    }
 }
 
 /// Returns the contents of the *outermost* fenced code block that contains the given offset.
@@ -4441,48 +4602,7 @@ impl Render for ContextEditor {
                         .child(element),
                 )
             })
-            .when_some(self.error_message.clone(), |this, error_message| {
-                this.child(
-                    div()
-                        .absolute()
-                        .right_3()
-                        .bottom_12()
-                        .max_w_96()
-                        .py_2()
-                        .px_3()
-                        .elevation_2(cx)
-                        .occlude()
-                        .child(
-                            v_flex()
-                                .gap_0p5()
-                                .child(
-                                    h_flex()
-                                        .gap_1p5()
-                                        .items_center()
-                                        .child(Icon::new(IconName::XCircle).color(Color::Error))
-                                        .child(
-                                            Label::new("Error interacting with language model")
-                                                .weight(FontWeight::MEDIUM),
-                                        ),
-                                )
-                                .child(
-                                    div()
-                                        .id("error-message")
-                                        .max_h_24()
-                                        .overflow_y_scroll()
-                                        .child(Label::new(error_message)),
-                                )
-                                .child(h_flex().justify_end().mt_1().child(
-                                    Button::new("dismiss", "Dismiss").on_click(cx.listener(
-                                        |this, _, cx| {
-                                            this.error_message = None;
-                                            cx.notify();
-                                        },
-                                    )),
-                                )),
-                        ),
-                )
-            })
+            .children(self.render_last_error(cx))
             .child(
                 h_flex().w_full().relative().child(
                     h_flex()
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index c27d17f8c5cef7..1a5a4d44f08df0 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -26,6 +26,7 @@ use gpui::{
 
 use language::{AnchorRangeExt, Bias, Buffer, LanguageRegistry, OffsetRangeExt, Point, ToOffset};
 use language_model::{
+    provider::cloud::{MaxMonthlySpendReachedError, PaymentRequiredError},
     LanguageModel, LanguageModelCacheConfiguration, LanguageModelCompletionEvent,
     LanguageModelImage, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
     LanguageModelRequestTool, LanguageModelToolResult, LanguageModelToolUse, MessageContent, Role,
@@ -294,6 +295,8 @@ impl ContextOperation {
 #[derive(Debug, Clone)]
 pub enum ContextEvent {
     ShowAssistError(SharedString),
+    ShowPaymentRequiredError,
+    ShowMaxMonthlySpendReachedError,
     MessagesEdited,
     SummaryChanged,
     StreamedCompletion,
@@ -2112,25 +2115,36 @@ impl Context {
                 let result = stream_completion.await;
 
                 this.update(&mut cx, |this, cx| {
-                    let error_message = result
-                        .as_ref()
-                        .err()
-                        .map(|error| error.to_string().trim().to_string());
-
-                    if let Some(error_message) = error_message.as_ref() {
-                        cx.emit(ContextEvent::ShowAssistError(SharedString::from(
-                            error_message.clone(),
-                        )));
-                    }
-
-                    this.update_metadata(assistant_message_id, cx, |metadata| {
-                        if let Some(error_message) = error_message.as_ref() {
-                            metadata.status =
-                                MessageStatus::Error(SharedString::from(error_message.clone()));
+                    let error_message = if let Some(error) = result.as_ref().err() {
+                        if error.is::<PaymentRequiredError>() {
+                            cx.emit(ContextEvent::ShowPaymentRequiredError);
+                            this.update_metadata(assistant_message_id, cx, |metadata| {
+                                metadata.status = MessageStatus::Canceled;
+                            });
+                            Some(error.to_string())
+                        } else if error.is::<MaxMonthlySpendReachedError>() {
+                            cx.emit(ContextEvent::ShowMaxMonthlySpendReachedError);
+                            this.update_metadata(assistant_message_id, cx, |metadata| {
+                                metadata.status = MessageStatus::Canceled;
+                            });
+                            Some(error.to_string())
                         } else {
-                            metadata.status = MessageStatus::Done;
+                            let error_message = error.to_string().trim().to_string();
+                            cx.emit(ContextEvent::ShowAssistError(SharedString::from(
+                                error_message.clone(),
+                            )));
+                            this.update_metadata(assistant_message_id, cx, |metadata| {
+                                metadata.status =
+                                    MessageStatus::Error(SharedString::from(error_message.clone()));
+                            });
+                            Some(error_message)
                         }
-                    });
+                    } else {
+                        this.update_metadata(assistant_message_id, cx, |metadata| {
+                            metadata.status = MessageStatus::Done;
+                        });
+                        None
+                    };
 
                     if let Some(telemetry) = this.telemetry.as_ref() {
                         let language_name = this
diff --git a/crates/language_model/Cargo.toml b/crates/language_model/Cargo.toml
index ef273ac44fca39..74a2ed0ed0d7e1 100644
--- a/crates/language_model/Cargo.toml
+++ b/crates/language_model/Cargo.toml
@@ -47,6 +47,7 @@ settings.workspace = true
 smol.workspace = true
 strum.workspace = true
 theme.workspace = true
+thiserror.workspace = true
 tiktoken-rs.workspace = true
 ui.workspace = true
 util.workspace = true
diff --git a/crates/language_model/src/provider/cloud.rs b/crates/language_model/src/provider/cloud.rs
index b81f6f9fba3363..eb66a22e59f7fe 100644
--- a/crates/language_model/src/provider/cloud.rs
+++ b/crates/language_model/src/provider/cloud.rs
@@ -7,7 +7,10 @@ use crate::{
 };
 use anthropic::AnthropicError;
 use anyhow::{anyhow, Result};
-use client::{Client, PerformCompletionParams, UserStore, EXPIRED_LLM_TOKEN_HEADER_NAME};
+use client::{
+    Client, PerformCompletionParams, UserStore, EXPIRED_LLM_TOKEN_HEADER_NAME,
+    MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME,
+};
 use collections::BTreeMap;
 use feature_flags::{FeatureFlagAppExt, LlmClosedBeta, ZedPro};
 use futures::{
@@ -15,10 +18,11 @@ use futures::{
     TryStreamExt as _,
 };
 use gpui::{
-    AnyElement, AnyView, AppContext, AsyncAppContext, FontWeight, Model, ModelContext,
-    Subscription, Task,
+    AnyElement, AnyView, AppContext, AsyncAppContext, EventEmitter, FontWeight, Global, Model,
+    ModelContext, ReadGlobal, Subscription, Task,
 };
-use http_client::{AsyncBody, HttpClient, HttpRequestExt, Method, Response};
+use http_client::{AsyncBody, HttpClient, HttpRequestExt, Method, Response, StatusCode};
+use proto::TypedEnvelope;
 use schemars::JsonSchema;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use serde_json::value::RawValue;
@@ -27,12 +31,14 @@ use smol::{
     io::{AsyncReadExt, BufReader},
     lock::{RwLock, RwLockUpgradableReadGuard, RwLockWriteGuard},
 };
+use std::fmt;
 use std::time::Duration;
 use std::{
     future,
     sync::{Arc, LazyLock},
 };
 use strum::IntoEnumIterator;
+use thiserror::Error;
 use ui::{prelude::*, TintColor};
 
 use crate::{LanguageModelAvailability, LanguageModelCompletionEvent, LanguageModelProvider};
@@ -90,22 +96,93 @@ pub struct AvailableModel {
     pub default_temperature: Option<f32>,
 }
 
+struct GlobalRefreshLlmTokenListener(Model<RefreshLlmTokenListener>);
+
+impl Global for GlobalRefreshLlmTokenListener {}
+
+pub struct RefreshLlmTokenEvent;
+
+pub struct RefreshLlmTokenListener {
+    _llm_token_subscription: client::Subscription,
+}
+
+impl EventEmitter<RefreshLlmTokenEvent> for RefreshLlmTokenListener {}
+
+impl RefreshLlmTokenListener {
+    pub fn register(client: Arc<Client>, cx: &mut AppContext) {
+        let listener = cx.new_model(|cx| RefreshLlmTokenListener::new(client, cx));
+        cx.set_global(GlobalRefreshLlmTokenListener(listener));
+    }
+
+    pub fn global(cx: &AppContext) -> Model<Self> {
+        GlobalRefreshLlmTokenListener::global(cx).0.clone()
+    }
+
+    fn new(client: Arc<Client>, cx: &mut ModelContext<Self>) -> Self {
+        Self {
+            _llm_token_subscription: client
+                .add_message_handler(cx.weak_model(), Self::handle_refresh_llm_token),
+        }
+    }
+
+    async fn handle_refresh_llm_token(
+        this: Model<Self>,
+        _: TypedEnvelope<proto::RefreshLlmToken>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        this.update(&mut cx, |_this, cx| cx.emit(RefreshLlmTokenEvent))
+    }
+}
+
 pub struct CloudLanguageModelProvider {
     client: Arc<Client>,
-    llm_api_token: LlmApiToken,
     state: gpui::Model<State>,
     _maintain_client_status: Task<()>,
 }
 
 pub struct State {
     client: Arc<Client>,
+    llm_api_token: LlmApiToken,
     user_store: Model<UserStore>,
     status: client::Status,
     accept_terms: Option<Task<Result<()>>>,
-    _subscription: Subscription,
+    _settings_subscription: Subscription,
+    _llm_token_subscription: Subscription,
 }
 
 impl State {
+    fn new(
+        client: Arc<Client>,
+        user_store: Model<UserStore>,
+        status: client::Status,
+        cx: &mut ModelContext<Self>,
+    ) -> Self {
+        let refresh_llm_token_listener = RefreshLlmTokenListener::global(cx);
+
+        Self {
+            client: client.clone(),
+            llm_api_token: LlmApiToken::default(),
+            user_store,
+            status,
+            accept_terms: None,
+            _settings_subscription: cx.observe_global::<SettingsStore>(|_, cx| {
+                cx.notify();
+            }),
+            _llm_token_subscription: cx.subscribe(
+                &refresh_llm_token_listener,
+                |this, _listener, _event, cx| {
+                    let client = this.client.clone();
+                    let llm_api_token = this.llm_api_token.clone();
+                    cx.spawn(|_this, _cx| async move {
+                        llm_api_token.refresh(&client).await?;
+                        anyhow::Ok(())
+                    })
+                    .detach_and_log_err(cx);
+                },
+            ),
+        }
+    }
+
     fn is_signed_out(&self) -> bool {
         self.status.is_signed_out()
     }
@@ -144,15 +221,7 @@ impl CloudLanguageModelProvider {
         let mut status_rx = client.status();
         let status = *status_rx.borrow();
 
-        let state = cx.new_model(|cx| State {
-            client: client.clone(),
-            user_store,
-            status,
-            accept_terms: None,
-            _subscription: cx.observe_global::<SettingsStore>(|_, cx| {
-                cx.notify();
-            }),
-        });
+        let state = cx.new_model(|cx| State::new(client.clone(), user_store.clone(), status, cx));
 
         let state_ref = state.downgrade();
         let maintain_client_status = cx.spawn(|mut cx| async move {
@@ -172,8 +241,7 @@ impl CloudLanguageModelProvider {
 
         Self {
             client,
-            state,
-            llm_api_token: LlmApiToken::default(),
+            state: state.clone(),
             _maintain_client_status: maintain_client_status,
         }
     }
@@ -272,13 +340,14 @@ impl LanguageModelProvider for CloudLanguageModelProvider {
             models.insert(model.id().to_string(), model.clone());
         }
 
+        let llm_api_token = self.state.read(cx).llm_api_token.clone();
         models
             .into_values()
             .map(|model| {
                 Arc::new(CloudLanguageModel {
                     id: LanguageModelId::from(model.id().to_string()),
                     model,
-                    llm_api_token: self.llm_api_token.clone(),
+                    llm_api_token: llm_api_token.clone(),
                     client: self.client.clone(),
                     request_limiter: RateLimiter::new(4),
                 }) as Arc<dyn LanguageModel>
@@ -377,6 +446,30 @@ pub struct CloudLanguageModel {
 #[derive(Clone, Default)]
 struct LlmApiToken(Arc<RwLock<Option<String>>>);
 
+#[derive(Error, Debug)]
+pub struct PaymentRequiredError;
+
+impl fmt::Display for PaymentRequiredError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Payment required to use this language model. Please upgrade your account."
+        )
+    }
+}
+
+#[derive(Error, Debug)]
+pub struct MaxMonthlySpendReachedError;
+
+impl fmt::Display for MaxMonthlySpendReachedError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Maximum spending limit reached for this month. For more usage, increase your spending limit."
+        )
+    }
+}
+
 impl CloudLanguageModel {
     async fn perform_llm_completion(
         client: Arc<Client>,
@@ -411,6 +504,15 @@ impl CloudLanguageModel {
             {
                 did_retry = true;
                 token = llm_api_token.refresh(&client).await?;
+            } else if response.status() == StatusCode::FORBIDDEN
+                && response
+                    .headers()
+                    .get(MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME)
+                    .is_some()
+            {
+                break Err(anyhow!(MaxMonthlySpendReachedError))?;
+            } else if response.status() == StatusCode::PAYMENT_REQUIRED {
+                break Err(anyhow!(PaymentRequiredError))?;
             } else {
                 let mut body = String::new();
                 response.body_mut().read_to_string(&mut body).await?;
diff --git a/crates/language_model/src/registry.rs b/crates/language_model/src/registry.rs
index e1ba1c588695c6..72dfd998d4bb2c 100644
--- a/crates/language_model/src/registry.rs
+++ b/crates/language_model/src/registry.rs
@@ -1,3 +1,4 @@
+use crate::provider::cloud::RefreshLlmTokenListener;
 use crate::{
     provider::{
         anthropic::AnthropicLanguageModelProvider, cloud::CloudLanguageModelProvider,
@@ -30,6 +31,8 @@ fn register_language_model_providers(
 ) {
     use feature_flags::FeatureFlagAppExt;
 
+    RefreshLlmTokenListener::register(client.clone(), cx);
+
     registry.register_provider(
         AnthropicLanguageModelProvider::new(client.http_client(), cx),
         cx,
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index e4e6ac42403012..f6711f8db939b6 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -269,6 +269,7 @@ message Envelope {
 
         GetLlmToken get_llm_token = 235;
         GetLlmTokenResponse get_llm_token_response = 236;
+        RefreshLlmToken refresh_llm_token = 259; // current max
 
         LspExtSwitchSourceHeader lsp_ext_switch_source_header = 241;
         LspExtSwitchSourceHeaderResponse lsp_ext_switch_source_header_response = 242;
@@ -284,7 +285,7 @@ message Envelope {
 
         ShutdownRemoteServer shutdown_remote_server = 257;
 
-        RemoveWorktree remove_worktree = 258; // current max
+        RemoveWorktree remove_worktree = 258;
     }
 
     reserved 87 to 88;
@@ -2429,6 +2430,8 @@ message GetLlmTokenResponse {
     string token = 1;
 }
 
+message RefreshLlmToken {}
+
 // Remote FS
 
 message AddWorktree {
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 93c92e9d476b38..2c038c2e1caadc 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -253,6 +253,7 @@ messages!(
     (ProjectEntryResponse, Foreground),
     (CountLanguageModelTokens, Background),
     (CountLanguageModelTokensResponse, Background),
+    (RefreshLlmToken, Background),
     (RefreshInlayHints, Foreground),
     (RejoinChannelBuffers, Foreground),
     (RejoinChannelBuffersResponse, Foreground),
diff --git a/crates/rpc/src/llm.rs b/crates/rpc/src/llm.rs
index 681f2d8db32d18..0a7510d891d352 100644
--- a/crates/rpc/src/llm.rs
+++ b/crates/rpc/src/llm.rs
@@ -3,6 +3,8 @@ use strum::{Display, EnumIter, EnumString};
 
 pub const EXPIRED_LLM_TOKEN_HEADER_NAME: &str = "x-zed-expired-token";
 
+pub const MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME: &str = "x-zed-llm-max-monthly-spend-reached";
+
 #[derive(
     Debug, PartialEq, Eq, Hash, Clone, Copy, Serialize, Deserialize, EnumString, EnumIter, Display,
 )]

From f1c45d988e227f40260e03ad2cbea0e625273d7a Mon Sep 17 00:00:00 2001
From: Shish <shish@shishnet.org>
Date: Fri, 11 Oct 2024 18:28:34 +0100
Subject: [PATCH 608/762] collab: Remove dependency on X11 (#19079)

collab: Remove dependency on X11

I'm not sure if this is the best solution (perhaps pulling
`LanguageName` into a separate `language_types` crate would be
better...?) - but it massively reduces build time / dependencies / size
and means that the collab server no longer requires X11 libraries to be
installed.

tl;dr: `telemetry_events` requires the `language` crate, and the
language crate requires a whole ton of extra stuff. Since
telemetry_events only uses `language` for a single type definition
(`LanguageName`, aka `String`), we can cut all of these out by using the
base `String` type (This doesn't seem too terrible, given that all other
telemetry fields are using basic datatypes like String as opposed to
more strongly-typed variants).


FYI the dependency tree for "why does collab need X11 libraries??" looks
like this:

```
collab
 \- telemetry_events
     \- language
         |- gpui
         |- fuzzy
         |   \- gpui
         |- git
         |   \- gpui
         |- lsp
         |   |- gpui
         |   \- release_channel
         |       \- gpui
         |- settings
         |   |- fs
         |   |   \- gpui
         |   \- gpui
         |- task
         |   \- gpui
         \- theme
             \- gpui
```

Release Notes:

- N/A
---
 Cargo.lock                                    |  1 -
 Dockerfile-collab                             | 23 +------------------
 crates/assistant/src/context.rs               |  2 +-
 crates/assistant/src/inline_assistant.rs      |  6 ++---
 crates/telemetry_events/Cargo.toml            |  1 -
 .../telemetry_events/src/telemetry_events.rs  |  3 +--
 6 files changed, 6 insertions(+), 30 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 752050c99522be..0a607155e0e223 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11346,7 +11346,6 @@ dependencies = [
 name = "telemetry_events"
 version = "0.1.0"
 dependencies = [
- "language",
  "semantic_version",
  "serde",
 ]
diff --git a/Dockerfile-collab b/Dockerfile-collab
index 7945eb426d925f..507ad3be19bc00 100644
--- a/Dockerfile-collab
+++ b/Dockerfile-collab
@@ -13,30 +13,9 @@ ARG GITHUB_SHA
 
 ENV GITHUB_SHA=$GITHUB_SHA
 
-# At some point in the past 3 weeks, additional dependencies on `xkbcommon` and
-# `xkbcommon-x11` were introduced into collab.
-#
-# A `git bisect` points to this commit as being the culprit: `b8e6098f60e5dabe98fe8281f993858dacc04a55`.
-#
-# Now when we try to build collab for the Docker image, it fails with the following
-# error:
-#
-# ```
-# 985.3   = note: /usr/bin/ld: cannot find -lxkbcommon: No such file or directory
-# 985.3           /usr/bin/ld: cannot find -lxkbcommon-x11: No such file or directory
-# 985.3           collect2: error: ld returned 1 exit status
-# ```
-#
-# The last successful deploys were at:
-# - Staging: `4f408ec65a3867278322a189b4eb20f1ab51f508`
-# - Production: `fc4c533d0a8c489e5636a4249d2b52a80039fbd7`
-#
 # Also add `cmake`, since we need it to build `wasmtime`.
-#
-# Installing these as a temporary workaround, but I think ideally we'd want to figure
-# out what caused them to be included in the first place.
 RUN apt-get update; \
-    apt-get install -y --no-install-recommends libxkbcommon-dev libxkbcommon-x11-dev cmake
+    apt-get install -y --no-install-recommends cmake
 
 RUN --mount=type=cache,target=./script/node_modules \
     --mount=type=cache,target=/usr/local/cargo/registry \
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index 1a5a4d44f08df0..610652a371442b 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -2160,7 +2160,7 @@ impl Context {
                             model_provider: model.provider_id().to_string(),
                             response_latency,
                             error_message,
-                            language_name,
+                            language_name: language_name.map(|name| name.to_proto()),
                         });
                     }
 
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index b3427271b9a4eb..4ecf8dd37e5e08 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -267,7 +267,7 @@ impl InlineAssistant {
                         model_provider: model.provider_id().to_string(),
                         response_latency: None,
                         error_message: None,
-                        language_name: buffer.language().map(|language| language.name()),
+                        language_name: buffer.language().map(|language| language.name().to_proto()),
                     });
                 }
             }
@@ -788,7 +788,7 @@ impl InlineAssistant {
                         model_provider: model.provider_id().to_string(),
                         response_latency: None,
                         error_message: None,
-                        language_name,
+                        language_name: language_name.map(|name| name.to_proto()),
                     });
                 }
             }
@@ -2954,7 +2954,7 @@ impl CodegenAlternative {
                                     model_provider: model_provider_id.to_string(),
                                     response_latency,
                                     error_message,
-                                    language_name,
+                                    language_name: language_name.map(|name| name.to_proto()),
                                 });
                             }
 
diff --git a/crates/telemetry_events/Cargo.toml b/crates/telemetry_events/Cargo.toml
index 34ccc20c3a53fb..01145549b156f7 100644
--- a/crates/telemetry_events/Cargo.toml
+++ b/crates/telemetry_events/Cargo.toml
@@ -12,6 +12,5 @@ workspace = true
 path = "src/telemetry_events.rs"
 
 [dependencies]
-language.workspace = true
 semantic_version.workspace = true
 serde.workspace = true
diff --git a/crates/telemetry_events/src/telemetry_events.rs b/crates/telemetry_events/src/telemetry_events.rs
index 14bcf985bf0da6..47e66a46a74d23 100644
--- a/crates/telemetry_events/src/telemetry_events.rs
+++ b/crates/telemetry_events/src/telemetry_events.rs
@@ -1,6 +1,5 @@
 //! See [Telemetry in Zed](https://zed.dev/docs/telemetry) for additional information.
 
-use language::LanguageName;
 use semantic_version::SemanticVersion;
 use serde::{Deserialize, Serialize};
 use std::{fmt::Display, sync::Arc, time::Duration};
@@ -150,7 +149,7 @@ pub struct AssistantEvent {
     pub model_provider: String,
     pub response_latency: Option<Duration>,
     pub error_message: Option<String>,
-    pub language_name: Option<LanguageName>,
+    pub language_name: Option<String>,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]

From 22ea7cef7a2762cb3bd55c73848a18c5f0c0128d Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 11 Oct 2024 13:36:54 -0400
Subject: [PATCH 609/762] collab: Add usage-based billing for LLM interactions
 (#19081)

This PR adds usage-based billing for LLM interactions in the Assistant.

Release Notes:

- N/A

---------

Co-authored-by: Antonio Scandurra <me@as-cii.com>
Co-authored-by: Antonio <antonio@zed.dev>
Co-authored-by: Richard <richard@zed.dev>
Co-authored-by: Richard Feldman <oss@rtfeldman.com>
---
 Cargo.lock                                    |   5 +-
 Cargo.toml                                    |   3 +-
 .../20241010151249_create_billing_events.sql  |  12 +
 crates/collab/src/api/billing.rs              | 203 ++++-----
 .../src/db/queries/billing_subscriptions.rs   |  38 +-
 crates/collab/src/lib.rs                      |  29 +-
 crates/collab/src/llm.rs                      |  65 +--
 crates/collab/src/llm/db.rs                   |   2 +-
 crates/collab/src/llm/db/ids.rs               |   1 +
 crates/collab/src/llm/db/queries.rs           |   1 +
 .../src/llm/db/queries/billing_events.rs      |  31 ++
 crates/collab/src/llm/db/queries/usages.rs    | 133 +++---
 crates/collab/src/llm/db/tables.rs            |   1 +
 .../collab/src/llm/db/tables/billing_event.rs |  37 ++
 crates/collab/src/llm/db/tables/model.rs      |   8 +
 crates/collab/src/llm/db/tests/usage_tests.rs | 192 ++++++--
 crates/collab/src/main.rs                     |   2 +-
 crates/collab/src/rpc.rs                      |   9 +
 crates/collab/src/stripe_billing.rs           | 427 ++++++++++++++++++
 crates/collab/src/tests/test_server.rs        |   3 +-
 20 files changed, 920 insertions(+), 282 deletions(-)
 create mode 100644 crates/collab/migrations_llm/20241010151249_create_billing_events.sql
 create mode 100644 crates/collab/src/llm/db/queries/billing_events.rs
 create mode 100644 crates/collab/src/llm/db/tables/billing_event.rs
 create mode 100644 crates/collab/src/stripe_billing.rs

diff --git a/Cargo.lock b/Cargo.lock
index 0a607155e0e223..5f6218cb653550 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -839,9 +839,8 @@ dependencies = [
 
 [[package]]
 name = "async-stripe"
-version = "0.39.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58d670cf4d47a1b8ffef54286a5625382e360a34ee76902fd93ad8c7032a0c30"
+version = "0.40.0"
+source = "git+https://github.com/zed-industries/async-stripe?rev=3672dd4efb7181aa597bf580bf5a2f5d23db6735#3672dd4efb7181aa597bf580bf5a2f5d23db6735"
 dependencies = [
  "chrono",
  "futures-util",
diff --git a/Cargo.toml b/Cargo.toml
index fa4289b9a2167f..42f935e66b33bc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -480,7 +480,8 @@ which = "6.0.0"
 wit-component = "0.201"
 
 [workspace.dependencies.async-stripe]
-version = "0.39"
+git = "https://github.com/zed-industries/async-stripe"
+rev = "3672dd4efb7181aa597bf580bf5a2f5d23db6735"
 default-features = false
 features = [
     "runtime-tokio-hyper-rustls",
diff --git a/crates/collab/migrations_llm/20241010151249_create_billing_events.sql b/crates/collab/migrations_llm/20241010151249_create_billing_events.sql
new file mode 100644
index 00000000000000..74a270872e5f66
--- /dev/null
+++ b/crates/collab/migrations_llm/20241010151249_create_billing_events.sql
@@ -0,0 +1,12 @@
+create table billing_events (
+    id serial primary key,
+    idempotency_key uuid not null default gen_random_uuid(),
+    user_id integer not null,
+    model_id integer not null references models (id) on delete cascade,
+    input_tokens bigint not null default 0,
+    input_cache_creation_tokens bigint not null default 0,
+    input_cache_read_tokens bigint not null default 0,
+    output_tokens bigint not null default 0
+);
+
+create index uix_billing_events_on_user_id_model_id on billing_events (user_id, model_id);
diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index 838dea19819194..c0fc33a643bf12 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -1,7 +1,3 @@
-use std::str::FromStr;
-use std::sync::Arc;
-use std::time::Duration;
-
 use anyhow::{anyhow, bail, Context};
 use axum::{
     extract::{self, Query},
@@ -9,28 +5,35 @@ use axum::{
     Extension, Json, Router,
 };
 use chrono::{DateTime, SecondsFormat, Utc};
+use collections::HashSet;
 use reqwest::StatusCode;
 use sea_orm::ActiveValue;
 use serde::{Deserialize, Serialize};
+use std::{str::FromStr, sync::Arc, time::Duration};
 use stripe::{
-    BillingPortalSession, CheckoutSession, CreateBillingPortalSession,
-    CreateBillingPortalSessionFlowData, CreateBillingPortalSessionFlowDataAfterCompletion,
+    BillingPortalSession, CreateBillingPortalSession, CreateBillingPortalSessionFlowData,
+    CreateBillingPortalSessionFlowDataAfterCompletion,
     CreateBillingPortalSessionFlowDataAfterCompletionRedirect,
-    CreateBillingPortalSessionFlowDataType, CreateCheckoutSession, CreateCheckoutSessionLineItems,
-    CreateCustomer, Customer, CustomerId, EventObject, EventType, Expandable, ListEvents,
-    Subscription, SubscriptionId, SubscriptionStatus,
+    CreateBillingPortalSessionFlowDataType, CreateCustomer, Customer, CustomerId, EventObject,
+    EventType, Expandable, ListEvents, Subscription, SubscriptionId, SubscriptionStatus,
 };
 use util::ResultExt;
 
-use crate::db::billing_subscription::{self, StripeSubscriptionStatus};
-use crate::db::{
-    billing_customer, BillingSubscriptionId, CreateBillingCustomerParams,
-    CreateBillingSubscriptionParams, CreateProcessedStripeEventParams, UpdateBillingCustomerParams,
-    UpdateBillingPreferencesParams, UpdateBillingSubscriptionParams,
-};
-use crate::llm::db::LlmDatabase;
-use crate::llm::{DEFAULT_MAX_MONTHLY_SPEND, FREE_TIER_MONTHLY_SPENDING_LIMIT};
+use crate::llm::DEFAULT_MAX_MONTHLY_SPEND;
 use crate::rpc::ResultExt as _;
+use crate::{
+    db::{
+        billing_customer, BillingSubscriptionId, CreateBillingCustomerParams,
+        CreateBillingSubscriptionParams, CreateProcessedStripeEventParams,
+        UpdateBillingCustomerParams, UpdateBillingPreferencesParams,
+        UpdateBillingSubscriptionParams,
+    },
+    stripe_billing::StripeBilling,
+};
+use crate::{
+    db::{billing_subscription::StripeSubscriptionStatus, UserId},
+    llm::db::LlmDatabase,
+};
 use crate::{AppState, Error, Result};
 
 pub fn router() -> Router {
@@ -87,6 +90,7 @@ struct UpdateBillingPreferencesBody {
 
 async fn update_billing_preferences(
     Extension(app): Extension<Arc<AppState>>,
+    Extension(rpc_server): Extension<Arc<crate::rpc::Server>>,
     extract::Json(body): extract::Json<UpdateBillingPreferencesBody>,
 ) -> Result<Json<BillingPreferencesResponse>> {
     let user = app
@@ -119,6 +123,8 @@ async fn update_billing_preferences(
                 .await?
         };
 
+    rpc_server.refresh_llm_tokens_for_user(user.id).await;
+
     Ok(Json(BillingPreferencesResponse {
         max_monthly_llm_usage_spending_in_cents: billing_preferences
             .max_monthly_llm_usage_spending_in_cents,
@@ -197,12 +203,15 @@ async fn create_billing_subscription(
         .await?
         .ok_or_else(|| anyhow!("user not found"))?;
 
-    let Some((stripe_client, stripe_access_price_id)) = app
-        .stripe_client
-        .clone()
-        .zip(app.config.stripe_llm_access_price_id.clone())
-    else {
-        log::error!("failed to retrieve Stripe client or price ID");
+    let Some(stripe_client) = app.stripe_client.clone() else {
+        log::error!("failed to retrieve Stripe client");
+        Err(Error::http(
+            StatusCode::NOT_IMPLEMENTED,
+            "not supported".into(),
+        ))?
+    };
+    let Some(llm_db) = app.llm_db.clone() else {
+        log::error!("failed to retrieve LLM database");
         Err(Error::http(
             StatusCode::NOT_IMPLEMENTED,
             "not supported".into(),
@@ -226,26 +235,15 @@ async fn create_billing_subscription(
             customer.id
         };
 
-    let checkout_session = {
-        let mut params = CreateCheckoutSession::new();
-        params.mode = Some(stripe::CheckoutSessionMode::Subscription);
-        params.customer = Some(customer_id);
-        params.client_reference_id = Some(user.github_login.as_str());
-        params.line_items = Some(vec![CreateCheckoutSessionLineItems {
-            price: Some(stripe_access_price_id.to_string()),
-            quantity: Some(1),
-            ..Default::default()
-        }]);
-        let success_url = format!("{}/account", app.config.zed_dot_dev_url());
-        params.success_url = Some(&success_url);
-
-        CheckoutSession::create(&stripe_client, params).await?
-    };
-
+    let default_model = llm_db.model(rpc::LanguageModelProvider::Anthropic, "claude-3-5-sonnet")?;
+    let mut stripe_billing = StripeBilling::new(stripe_client.clone()).await?;
+    let stripe_model = stripe_billing.register_model(default_model).await?;
+    let success_url = format!("{}/account", app.config.zed_dot_dev_url());
+    let checkout_session_url = stripe_billing
+        .checkout(customer_id, &user.github_login, &stripe_model, &success_url)
+        .await?;
     Ok(Json(CreateBillingSubscriptionResponse {
-        checkout_session_url: checkout_session
-            .url
-            .ok_or_else(|| anyhow!("no checkout session URL"))?,
+        checkout_session_url,
     }))
 }
 
@@ -715,15 +713,15 @@ async fn find_or_create_billing_customer(
     Ok(Some(billing_customer))
 }
 
-const SYNC_LLM_USAGE_WITH_STRIPE_INTERVAL: Duration = Duration::from_secs(24 * 60 * 60);
+const SYNC_LLM_USAGE_WITH_STRIPE_INTERVAL: Duration = Duration::from_secs(60);
 
-pub fn sync_llm_usage_with_stripe_periodically(app: Arc<AppState>, llm_db: LlmDatabase) {
+pub fn sync_llm_usage_with_stripe_periodically(app: Arc<AppState>) {
     let Some(stripe_client) = app.stripe_client.clone() else {
         log::warn!("failed to retrieve Stripe client");
         return;
     };
-    let Some(stripe_llm_usage_price_id) = app.config.stripe_llm_usage_price_id.clone() else {
-        log::warn!("failed to retrieve Stripe LLM usage price ID");
+    let Some(llm_db) = app.llm_db.clone() else {
+        log::warn!("failed to retrieve LLM database");
         return;
     };
 
@@ -732,15 +730,9 @@ pub fn sync_llm_usage_with_stripe_periodically(app: Arc<AppState>, llm_db: LlmDa
         let executor = executor.clone();
         async move {
             loop {
-                sync_with_stripe(
-                    &app,
-                    &llm_db,
-                    &stripe_client,
-                    stripe_llm_usage_price_id.clone(),
-                )
-                .await
-                .trace_err();
-
+                sync_with_stripe(&app, &llm_db, &stripe_client)
+                    .await
+                    .trace_err();
                 executor.sleep(SYNC_LLM_USAGE_WITH_STRIPE_INTERVAL).await;
             }
         }
@@ -749,71 +741,46 @@ pub fn sync_llm_usage_with_stripe_periodically(app: Arc<AppState>, llm_db: LlmDa
 
 async fn sync_with_stripe(
     app: &Arc<AppState>,
-    llm_db: &LlmDatabase,
-    stripe_client: &stripe::Client,
-    stripe_llm_usage_price_id: Arc<str>,
+    llm_db: &Arc<LlmDatabase>,
+    stripe_client: &Arc<stripe::Client>,
 ) -> anyhow::Result<()> {
-    let subscriptions = app.db.get_active_billing_subscriptions().await?;
-
-    for (customer, subscription) in subscriptions {
-        update_stripe_subscription(
-            llm_db,
-            stripe_client,
-            &stripe_llm_usage_price_id,
-            customer,
-            subscription,
-        )
-        .await
-        .log_err();
-    }
-
-    Ok(())
-}
-
-async fn update_stripe_subscription(
-    llm_db: &LlmDatabase,
-    stripe_client: &stripe::Client,
-    stripe_llm_usage_price_id: &Arc<str>,
-    customer: billing_customer::Model,
-    subscription: billing_subscription::Model,
-) -> Result<(), anyhow::Error> {
-    let monthly_spending = llm_db
-        .get_user_spending_for_month(customer.user_id, Utc::now())
-        .await?;
-    let subscription_id = SubscriptionId::from_str(&subscription.stripe_subscription_id)
-        .context("failed to parse subscription ID")?;
-
-    let monthly_spending_over_free_tier =
-        monthly_spending.saturating_sub(FREE_TIER_MONTHLY_SPENDING_LIMIT);
-
-    let new_quantity = (monthly_spending_over_free_tier.0 as f32 / 100.).ceil();
-    let current_subscription = Subscription::retrieve(stripe_client, &subscription_id, &[]).await?;
-
-    let mut update_params = stripe::UpdateSubscription {
-        proration_behavior: Some(
-            stripe::generated::billing::subscription::SubscriptionProrationBehavior::None,
-        ),
-        ..Default::default()
-    };
-
-    if let Some(existing_item) = current_subscription.items.data.iter().find(|item| {
-        item.price.as_ref().map_or(false, |price| {
-            price.id == stripe_llm_usage_price_id.as_ref()
-        })
-    }) {
-        update_params.items = Some(vec![stripe::UpdateSubscriptionItems {
-            id: Some(existing_item.id.to_string()),
-            quantity: Some(new_quantity as u64),
-            ..Default::default()
-        }]);
-    } else {
-        update_params.items = Some(vec![stripe::UpdateSubscriptionItems {
-            price: Some(stripe_llm_usage_price_id.to_string()),
-            quantity: Some(new_quantity as u64),
-            ..Default::default()
-        }]);
+    let mut stripe_billing = StripeBilling::new(stripe_client.clone()).await?;
+
+    let events = llm_db.get_billing_events().await?;
+    let user_ids = events
+        .iter()
+        .map(|(event, _)| event.user_id)
+        .collect::<HashSet<UserId>>();
+    let stripe_subscriptions = app.db.get_active_billing_subscriptions(user_ids).await?;
+
+    for (event, model) in events {
+        let Some((stripe_db_customer, stripe_db_subscription)) =
+            stripe_subscriptions.get(&event.user_id)
+        else {
+            tracing::warn!(
+                user_id = event.user_id.0,
+                "Registered billing event for user who is not a Stripe customer. Billing events should only be created for users who are Stripe customers, so this is a mistake on our side."
+            );
+            continue;
+        };
+        let stripe_subscription_id: stripe::SubscriptionId = stripe_db_subscription
+            .stripe_subscription_id
+            .parse()
+            .context("failed to parse stripe subscription id from db")?;
+        let stripe_customer_id: stripe::CustomerId = stripe_db_customer
+            .stripe_customer_id
+            .parse()
+            .context("failed to parse stripe customer id from db")?;
+
+        let stripe_model = stripe_billing.register_model(&model).await?;
+        stripe_billing
+            .subscribe_to_model(&stripe_subscription_id, &stripe_model)
+            .await?;
+        stripe_billing
+            .bill_model_usage(&stripe_customer_id, &stripe_model, &event)
+            .await?;
+        llm_db.consume_billing_event(event.id).await?;
     }
 
-    Subscription::update(stripe_client, &subscription_id, update_params).await?;
     Ok(())
 }
diff --git a/crates/collab/src/db/queries/billing_subscriptions.rs b/crates/collab/src/db/queries/billing_subscriptions.rs
index bcf093bebd4240..53a17f9c531abd 100644
--- a/crates/collab/src/db/queries/billing_subscriptions.rs
+++ b/crates/collab/src/db/queries/billing_subscriptions.rs
@@ -114,23 +114,31 @@ impl Database {
 
     pub async fn get_active_billing_subscriptions(
         &self,
-    ) -> Result<Vec<(billing_customer::Model, billing_subscription::Model)>> {
-        self.transaction(|tx| async move {
-            let mut result = Vec::new();
-            let mut rows = billing_subscription::Entity::find()
-                .inner_join(billing_customer::Entity)
-                .select_also(billing_customer::Entity)
-                .order_by_asc(billing_subscription::Column::Id)
-                .stream(&*tx)
-                .await?;
-
-            while let Some(row) = rows.next().await {
-                if let (subscription, Some(customer)) = row? {
-                    result.push((customer, subscription));
+        user_ids: HashSet<UserId>,
+    ) -> Result<HashMap<UserId, (billing_customer::Model, billing_subscription::Model)>> {
+        self.transaction(|tx| {
+            let user_ids = user_ids.clone();
+            async move {
+                let mut rows = billing_subscription::Entity::find()
+                    .inner_join(billing_customer::Entity)
+                    .select_also(billing_customer::Entity)
+                    .filter(billing_customer::Column::UserId.is_in(user_ids))
+                    .filter(
+                        billing_subscription::Column::StripeSubscriptionStatus
+                            .eq(StripeSubscriptionStatus::Active),
+                    )
+                    .order_by_asc(billing_subscription::Column::Id)
+                    .stream(&*tx)
+                    .await?;
+
+                let mut subscriptions = HashMap::default();
+                while let Some(row) = rows.next().await {
+                    if let (subscription, Some(customer)) = row? {
+                        subscriptions.insert(customer.user_id, (customer, subscription));
+                    }
                 }
+                Ok(subscriptions)
             }
-
-            Ok(result)
         })
         .await
     }
diff --git a/crates/collab/src/lib.rs b/crates/collab/src/lib.rs
index 3896926f4372fe..0cc50f68f311a9 100644
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -10,6 +10,7 @@ pub mod migrations;
 mod rate_limiter;
 pub mod rpc;
 pub mod seed;
+pub mod stripe_billing;
 pub mod user_backfiller;
 
 #[cfg(test)]
@@ -24,6 +25,7 @@ use axum::{
 pub use cents::*;
 use db::{ChannelId, Database};
 use executor::Executor;
+use llm::db::LlmDatabase;
 pub use rate_limiter::*;
 use serde::Deserialize;
 use std::{path::PathBuf, sync::Arc};
@@ -176,8 +178,6 @@ pub struct Config {
     pub slack_panics_webhook: Option<String>,
     pub auto_join_channel_id: Option<ChannelId>,
     pub stripe_api_key: Option<String>,
-    pub stripe_llm_access_price_id: Option<Arc<str>>,
-    pub stripe_llm_usage_price_id: Option<Arc<str>>,
     pub supermaven_admin_api_key: Option<Arc<str>>,
     pub user_backfiller_github_access_token: Option<Arc<str>>,
 }
@@ -197,7 +197,7 @@ impl Config {
     }
 
     pub fn is_llm_billing_enabled(&self) -> bool {
-        self.stripe_llm_usage_price_id.is_some()
+        self.stripe_api_key.is_some()
     }
 
     #[cfg(test)]
@@ -238,8 +238,6 @@ impl Config {
             migrations_path: None,
             seed_path: None,
             stripe_api_key: None,
-            stripe_llm_access_price_id: None,
-            stripe_llm_usage_price_id: None,
             supermaven_admin_api_key: None,
             user_backfiller_github_access_token: None,
         }
@@ -272,6 +270,7 @@ impl ServiceMode {
 
 pub struct AppState {
     pub db: Arc<Database>,
+    pub llm_db: Option<Arc<LlmDatabase>>,
     pub live_kit_client: Option<Arc<dyn live_kit_server::api::Client>>,
     pub blob_store_client: Option<aws_sdk_s3::Client>,
     pub stripe_client: Option<Arc<stripe::Client>>,
@@ -288,6 +287,20 @@ impl AppState {
         let mut db = Database::new(db_options, Executor::Production).await?;
         db.initialize_notification_kinds().await?;
 
+        let llm_db = if let Some((llm_database_url, llm_database_max_connections)) = config
+            .llm_database_url
+            .clone()
+            .zip(config.llm_database_max_connections)
+        {
+            let mut llm_db_options = db::ConnectOptions::new(llm_database_url);
+            llm_db_options.max_connections(llm_database_max_connections);
+            let mut llm_db = LlmDatabase::new(llm_db_options, executor.clone()).await?;
+            llm_db.initialize().await?;
+            Some(Arc::new(llm_db))
+        } else {
+            None
+        };
+
         let live_kit_client = if let Some(((server, key), secret)) = config
             .live_kit_server
             .as_ref()
@@ -306,9 +319,10 @@ impl AppState {
         let db = Arc::new(db);
         let this = Self {
             db: db.clone(),
+            llm_db,
             live_kit_client,
             blob_store_client: build_blob_store_client(&config).await.log_err(),
-            stripe_client: build_stripe_client(&config).await.map(Arc::new).log_err(),
+            stripe_client: build_stripe_client(&config).map(Arc::new).log_err(),
             rate_limiter: Arc::new(RateLimiter::new(db)),
             executor,
             clickhouse_client: config
@@ -321,12 +335,11 @@ impl AppState {
     }
 }
 
-async fn build_stripe_client(config: &Config) -> anyhow::Result<stripe::Client> {
+fn build_stripe_client(config: &Config) -> anyhow::Result<stripe::Client> {
     let api_key = config
         .stripe_api_key
         .as_ref()
         .ok_or_else(|| anyhow!("missing stripe_api_key"))?;
-
     Ok(stripe::Client::new(api_key))
 }
 
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index c389a4de62fed0..70a309367c5385 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -20,13 +20,14 @@ use axum::{
 };
 use chrono::{DateTime, Duration, Utc};
 use collections::HashMap;
+use db::TokenUsage;
 use db::{usage_measure::UsageMeasure, ActiveUserCount, LlmDatabase};
 use futures::{Stream, StreamExt as _};
 use isahc_http_client::IsahcHttpClient;
-use rpc::ListModelsResponse;
 use rpc::{
     proto::Plan, LanguageModelProvider, PerformCompletionParams, EXPIRED_LLM_TOKEN_HEADER_NAME,
 };
+use rpc::{ListModelsResponse, MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME};
 use std::{
     pin::Pin,
     sync::Arc,
@@ -418,10 +419,7 @@ async fn perform_completion(
         claims,
         provider: params.provider,
         model,
-        input_tokens: 0,
-        output_tokens: 0,
-        cache_creation_input_tokens: 0,
-        cache_read_input_tokens: 0,
+        tokens: TokenUsage::default(),
         inner_stream: stream,
     })))
 }
@@ -476,6 +474,19 @@ async fn check_usage_limit(
                     "Maximum spending limit reached for this month.".to_string(),
                 ));
             }
+
+            if usage.spending_this_month >= Cents(claims.max_monthly_spend_in_cents) {
+                return Err(Error::Http(
+                    StatusCode::FORBIDDEN,
+                    "Maximum spending limit reached for this month.".to_string(),
+                    [(
+                        HeaderName::from_static(MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME),
+                        HeaderValue::from_static("true"),
+                    )]
+                    .into_iter()
+                    .collect(),
+                ));
+            }
         }
     }
 
@@ -598,10 +609,7 @@ struct TokenCountingStream<S> {
     claims: LlmTokenClaims,
     provider: LanguageModelProvider,
     model: String,
-    input_tokens: usize,
-    output_tokens: usize,
-    cache_creation_input_tokens: usize,
-    cache_read_input_tokens: usize,
+    tokens: TokenUsage,
     inner_stream: S,
 }
 
@@ -615,10 +623,10 @@ where
         match Pin::new(&mut self.inner_stream).poll_next(cx) {
             Poll::Ready(Some(Ok(mut chunk))) => {
                 chunk.bytes.push(b'\n');
-                self.input_tokens += chunk.input_tokens;
-                self.output_tokens += chunk.output_tokens;
-                self.cache_creation_input_tokens += chunk.cache_creation_input_tokens;
-                self.cache_read_input_tokens += chunk.cache_read_input_tokens;
+                self.tokens.input += chunk.input_tokens;
+                self.tokens.output += chunk.output_tokens;
+                self.tokens.input_cache_creation += chunk.cache_creation_input_tokens;
+                self.tokens.input_cache_read += chunk.cache_read_input_tokens;
                 Poll::Ready(Some(Ok(chunk.bytes)))
             }
             Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(e))),
@@ -634,10 +642,7 @@ impl<S> Drop for TokenCountingStream<S> {
         let claims = self.claims.clone();
         let provider = self.provider;
         let model = std::mem::take(&mut self.model);
-        let input_token_count = self.input_tokens;
-        let output_token_count = self.output_tokens;
-        let cache_creation_input_token_count = self.cache_creation_input_tokens;
-        let cache_read_input_token_count = self.cache_read_input_tokens;
+        let tokens = self.tokens;
         self.state.executor.spawn_detached(async move {
             let usage = state
                 .db
@@ -646,10 +651,9 @@ impl<S> Drop for TokenCountingStream<S> {
                     claims.is_staff,
                     provider,
                     &model,
-                    input_token_count,
-                    cache_creation_input_token_count,
-                    cache_read_input_token_count,
-                    output_token_count,
+                    tokens,
+                    claims.has_llm_subscription,
+                    Cents(claims.max_monthly_spend_in_cents),
                     Utc::now(),
                 )
                 .await
@@ -679,22 +683,23 @@ impl<S> Drop for TokenCountingStream<S> {
                             },
                             model,
                             provider: provider.to_string(),
-                            input_token_count: input_token_count as u64,
-                            cache_creation_input_token_count: cache_creation_input_token_count
-                                as u64,
-                            cache_read_input_token_count: cache_read_input_token_count as u64,
-                            output_token_count: output_token_count as u64,
+                            input_token_count: tokens.input as u64,
+                            cache_creation_input_token_count: tokens.input_cache_creation as u64,
+                            cache_read_input_token_count: tokens.input_cache_read as u64,
+                            output_token_count: tokens.output as u64,
                             requests_this_minute: usage.requests_this_minute as u64,
                             tokens_this_minute: usage.tokens_this_minute as u64,
                             tokens_this_day: usage.tokens_this_day as u64,
-                            input_tokens_this_month: usage.input_tokens_this_month as u64,
+                            input_tokens_this_month: usage.tokens_this_month.input as u64,
                             cache_creation_input_tokens_this_month: usage
-                                .cache_creation_input_tokens_this_month
+                                .tokens_this_month
+                                .input_cache_creation
                                 as u64,
                             cache_read_input_tokens_this_month: usage
-                                .cache_read_input_tokens_this_month
+                                .tokens_this_month
+                                .input_cache_read
                                 as u64,
-                            output_tokens_this_month: usage.output_tokens_this_month as u64,
+                            output_tokens_this_month: usage.tokens_this_month.output as u64,
                             spending_this_month: usage.spending_this_month.0 as u64,
                             lifetime_spending: usage.lifetime_spending.0 as u64,
                         },
diff --git a/crates/collab/src/llm/db.rs b/crates/collab/src/llm/db.rs
index 996837116b190d..4374214c1b52fe 100644
--- a/crates/collab/src/llm/db.rs
+++ b/crates/collab/src/llm/db.rs
@@ -20,7 +20,7 @@ use std::future::Future;
 use std::sync::Arc;
 
 use anyhow::anyhow;
-pub use queries::usages::ActiveUserCount;
+pub use queries::usages::{ActiveUserCount, TokenUsage};
 use sea_orm::prelude::*;
 pub use sea_orm::ConnectOptions;
 use sea_orm::{
diff --git a/crates/collab/src/llm/db/ids.rs b/crates/collab/src/llm/db/ids.rs
index 8cc8a0f9746ef7..80da32fbf49f19 100644
--- a/crates/collab/src/llm/db/ids.rs
+++ b/crates/collab/src/llm/db/ids.rs
@@ -8,3 +8,4 @@ id_type!(ProviderId);
 id_type!(UsageId);
 id_type!(UsageMeasureId);
 id_type!(RevokedAccessTokenId);
+id_type!(BillingEventId);
diff --git a/crates/collab/src/llm/db/queries.rs b/crates/collab/src/llm/db/queries.rs
index 907d0589f34334..79a17999b79476 100644
--- a/crates/collab/src/llm/db/queries.rs
+++ b/crates/collab/src/llm/db/queries.rs
@@ -1,5 +1,6 @@
 use super::*;
 
+pub mod billing_events;
 pub mod providers;
 pub mod revoked_access_tokens;
 pub mod usages;
diff --git a/crates/collab/src/llm/db/queries/billing_events.rs b/crates/collab/src/llm/db/queries/billing_events.rs
new file mode 100644
index 00000000000000..400477f2340e86
--- /dev/null
+++ b/crates/collab/src/llm/db/queries/billing_events.rs
@@ -0,0 +1,31 @@
+use super::*;
+use crate::Result;
+use anyhow::Context as _;
+
+impl LlmDatabase {
+    pub async fn get_billing_events(&self) -> Result<Vec<(billing_event::Model, model::Model)>> {
+        self.transaction(|tx| async move {
+            let events_with_models = billing_event::Entity::find()
+                .find_also_related(model::Entity)
+                .all(&*tx)
+                .await?;
+            events_with_models
+                .into_iter()
+                .map(|(event, model)| {
+                    let model =
+                        model.context("could not find model associated with billing event")?;
+                    Ok((event, model))
+                })
+                .collect()
+        })
+        .await
+    }
+
+    pub async fn consume_billing_event(&self, id: BillingEventId) -> Result<()> {
+        self.transaction(|tx| async move {
+            billing_event::Entity::delete_by_id(id).exec(&*tx).await?;
+            Ok(())
+        })
+        .await
+    }
+}
diff --git a/crates/collab/src/llm/db/queries/usages.rs b/crates/collab/src/llm/db/queries/usages.rs
index 3d6ab184153c4b..c7f8fd163a4272 100644
--- a/crates/collab/src/llm/db/queries/usages.rs
+++ b/crates/collab/src/llm/db/queries/usages.rs
@@ -1,5 +1,5 @@
-use crate::db::UserId;
 use crate::llm::Cents;
+use crate::{db::UserId, llm::FREE_TIER_MONTHLY_SPENDING_LIMIT};
 use chrono::{Datelike, Duration};
 use futures::StreamExt as _;
 use rpc::LanguageModelProvider;
@@ -9,15 +9,26 @@ use strum::IntoEnumIterator as _;
 
 use super::*;
 
+#[derive(Debug, PartialEq, Clone, Copy, Default)]
+pub struct TokenUsage {
+    pub input: usize,
+    pub input_cache_creation: usize,
+    pub input_cache_read: usize,
+    pub output: usize,
+}
+
+impl TokenUsage {
+    pub fn total(&self) -> usize {
+        self.input + self.input_cache_creation + self.input_cache_read + self.output
+    }
+}
+
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub struct Usage {
     pub requests_this_minute: usize,
     pub tokens_this_minute: usize,
     pub tokens_this_day: usize,
-    pub input_tokens_this_month: usize,
-    pub cache_creation_input_tokens_this_month: usize,
-    pub cache_read_input_tokens_this_month: usize,
-    pub output_tokens_this_month: usize,
+    pub tokens_this_month: TokenUsage,
     pub spending_this_month: Cents,
     pub lifetime_spending: Cents,
 }
@@ -257,18 +268,20 @@ impl LlmDatabase {
                 requests_this_minute,
                 tokens_this_minute,
                 tokens_this_day,
-                input_tokens_this_month: monthly_usage
-                    .as_ref()
-                    .map_or(0, |usage| usage.input_tokens as usize),
-                cache_creation_input_tokens_this_month: monthly_usage
-                    .as_ref()
-                    .map_or(0, |usage| usage.cache_creation_input_tokens as usize),
-                cache_read_input_tokens_this_month: monthly_usage
-                    .as_ref()
-                    .map_or(0, |usage| usage.cache_read_input_tokens as usize),
-                output_tokens_this_month: monthly_usage
-                    .as_ref()
-                    .map_or(0, |usage| usage.output_tokens as usize),
+                tokens_this_month: TokenUsage {
+                    input: monthly_usage
+                        .as_ref()
+                        .map_or(0, |usage| usage.input_tokens as usize),
+                    input_cache_creation: monthly_usage
+                        .as_ref()
+                        .map_or(0, |usage| usage.cache_creation_input_tokens as usize),
+                    input_cache_read: monthly_usage
+                        .as_ref()
+                        .map_or(0, |usage| usage.cache_read_input_tokens as usize),
+                    output: monthly_usage
+                        .as_ref()
+                        .map_or(0, |usage| usage.output_tokens as usize),
+                },
                 spending_this_month,
                 lifetime_spending,
             })
@@ -283,10 +296,9 @@ impl LlmDatabase {
         is_staff: bool,
         provider: LanguageModelProvider,
         model_name: &str,
-        input_token_count: usize,
-        cache_creation_input_tokens: usize,
-        cache_read_input_tokens: usize,
-        output_token_count: usize,
+        tokens: TokenUsage,
+        has_llm_subscription: bool,
+        max_monthly_spend: Cents,
         now: DateTimeUtc,
     ) -> Result<Usage> {
         self.transaction(|tx| async move {
@@ -313,10 +325,6 @@ impl LlmDatabase {
                     &tx,
                 )
                 .await?;
-            let total_token_count = input_token_count
-                + cache_read_input_tokens
-                + cache_creation_input_tokens
-                + output_token_count;
             let tokens_this_minute = self
                 .update_usage_for_measure(
                     user_id,
@@ -325,7 +333,7 @@ impl LlmDatabase {
                     &usages,
                     UsageMeasure::TokensPerMinute,
                     now,
-                    total_token_count,
+                    tokens.total(),
                     &tx,
                 )
                 .await?;
@@ -337,7 +345,7 @@ impl LlmDatabase {
                     &usages,
                     UsageMeasure::TokensPerDay,
                     now,
-                    total_token_count,
+                    tokens.total(),
                     &tx,
                 )
                 .await?;
@@ -361,18 +369,14 @@ impl LlmDatabase {
                 Some(usage) => {
                     monthly_usage::Entity::update(monthly_usage::ActiveModel {
                         id: ActiveValue::unchanged(usage.id),
-                        input_tokens: ActiveValue::set(
-                            usage.input_tokens + input_token_count as i64,
-                        ),
+                        input_tokens: ActiveValue::set(usage.input_tokens + tokens.input as i64),
                         cache_creation_input_tokens: ActiveValue::set(
-                            usage.cache_creation_input_tokens + cache_creation_input_tokens as i64,
+                            usage.cache_creation_input_tokens + tokens.input_cache_creation as i64,
                         ),
                         cache_read_input_tokens: ActiveValue::set(
-                            usage.cache_read_input_tokens + cache_read_input_tokens as i64,
-                        ),
-                        output_tokens: ActiveValue::set(
-                            usage.output_tokens + output_token_count as i64,
+                            usage.cache_read_input_tokens + tokens.input_cache_read as i64,
                         ),
+                        output_tokens: ActiveValue::set(usage.output_tokens + tokens.output as i64),
                         ..Default::default()
                     })
                     .exec(&*tx)
@@ -384,12 +388,12 @@ impl LlmDatabase {
                         model_id: ActiveValue::set(model.id),
                         month: ActiveValue::set(month),
                         year: ActiveValue::set(year),
-                        input_tokens: ActiveValue::set(input_token_count as i64),
+                        input_tokens: ActiveValue::set(tokens.input as i64),
                         cache_creation_input_tokens: ActiveValue::set(
-                            cache_creation_input_tokens as i64,
+                            tokens.input_cache_creation as i64,
                         ),
-                        cache_read_input_tokens: ActiveValue::set(cache_read_input_tokens as i64),
-                        output_tokens: ActiveValue::set(output_token_count as i64),
+                        cache_read_input_tokens: ActiveValue::set(tokens.input_cache_read as i64),
+                        output_tokens: ActiveValue::set(tokens.output as i64),
                         ..Default::default()
                     }
                     .insert(&*tx)
@@ -405,6 +409,26 @@ impl LlmDatabase {
                 monthly_usage.output_tokens as usize,
             );
 
+            if spending_this_month > FREE_TIER_MONTHLY_SPENDING_LIMIT
+                && has_llm_subscription
+                && spending_this_month <= max_monthly_spend
+            {
+                billing_event::ActiveModel {
+                    id: ActiveValue::not_set(),
+                    idempotency_key: ActiveValue::not_set(),
+                    user_id: ActiveValue::set(user_id),
+                    model_id: ActiveValue::set(model.id),
+                    input_tokens: ActiveValue::set(tokens.input as i64),
+                    input_cache_creation_tokens: ActiveValue::set(
+                        tokens.input_cache_creation as i64,
+                    ),
+                    input_cache_read_tokens: ActiveValue::set(tokens.input_cache_read as i64),
+                    output_tokens: ActiveValue::set(tokens.output as i64),
+                }
+                .insert(&*tx)
+                .await?;
+            }
+
             // Update lifetime usage
             let lifetime_usage = lifetime_usage::Entity::find()
                 .filter(
@@ -419,18 +443,14 @@ impl LlmDatabase {
                 Some(usage) => {
                     lifetime_usage::Entity::update(lifetime_usage::ActiveModel {
                         id: ActiveValue::unchanged(usage.id),
-                        input_tokens: ActiveValue::set(
-                            usage.input_tokens + input_token_count as i64,
-                        ),
+                        input_tokens: ActiveValue::set(usage.input_tokens + tokens.input as i64),
                         cache_creation_input_tokens: ActiveValue::set(
-                            usage.cache_creation_input_tokens + cache_creation_input_tokens as i64,
+                            usage.cache_creation_input_tokens + tokens.input_cache_creation as i64,
                         ),
                         cache_read_input_tokens: ActiveValue::set(
-                            usage.cache_read_input_tokens + cache_read_input_tokens as i64,
-                        ),
-                        output_tokens: ActiveValue::set(
-                            usage.output_tokens + output_token_count as i64,
+                            usage.cache_read_input_tokens + tokens.input_cache_read as i64,
                         ),
+                        output_tokens: ActiveValue::set(usage.output_tokens + tokens.output as i64),
                         ..Default::default()
                     })
                     .exec(&*tx)
@@ -440,12 +460,12 @@ impl LlmDatabase {
                     lifetime_usage::ActiveModel {
                         user_id: ActiveValue::set(user_id),
                         model_id: ActiveValue::set(model.id),
-                        input_tokens: ActiveValue::set(input_token_count as i64),
+                        input_tokens: ActiveValue::set(tokens.input as i64),
                         cache_creation_input_tokens: ActiveValue::set(
-                            cache_creation_input_tokens as i64,
+                            tokens.input_cache_creation as i64,
                         ),
-                        cache_read_input_tokens: ActiveValue::set(cache_read_input_tokens as i64),
-                        output_tokens: ActiveValue::set(output_token_count as i64),
+                        cache_read_input_tokens: ActiveValue::set(tokens.input_cache_read as i64),
+                        output_tokens: ActiveValue::set(tokens.output as i64),
                         ..Default::default()
                     }
                     .insert(&*tx)
@@ -465,11 +485,12 @@ impl LlmDatabase {
                 requests_this_minute,
                 tokens_this_minute,
                 tokens_this_day,
-                input_tokens_this_month: monthly_usage.input_tokens as usize,
-                cache_creation_input_tokens_this_month: monthly_usage.cache_creation_input_tokens
-                    as usize,
-                cache_read_input_tokens_this_month: monthly_usage.cache_read_input_tokens as usize,
-                output_tokens_this_month: monthly_usage.output_tokens as usize,
+                tokens_this_month: TokenUsage {
+                    input: monthly_usage.input_tokens as usize,
+                    input_cache_creation: monthly_usage.cache_creation_input_tokens as usize,
+                    input_cache_read: monthly_usage.cache_read_input_tokens as usize,
+                    output: monthly_usage.output_tokens as usize,
+                },
                 spending_this_month,
                 lifetime_spending,
             })
diff --git a/crates/collab/src/llm/db/tables.rs b/crates/collab/src/llm/db/tables.rs
index 57aded70e91d29..407c5c8fd040db 100644
--- a/crates/collab/src/llm/db/tables.rs
+++ b/crates/collab/src/llm/db/tables.rs
@@ -1,3 +1,4 @@
+pub mod billing_event;
 pub mod lifetime_usage;
 pub mod model;
 pub mod monthly_usage;
diff --git a/crates/collab/src/llm/db/tables/billing_event.rs b/crates/collab/src/llm/db/tables/billing_event.rs
new file mode 100644
index 00000000000000..93987bc71e5aaa
--- /dev/null
+++ b/crates/collab/src/llm/db/tables/billing_event.rs
@@ -0,0 +1,37 @@
+use crate::{
+    db::UserId,
+    llm::db::{BillingEventId, ModelId},
+};
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "billing_events")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: BillingEventId,
+    pub idempotency_key: Uuid,
+    pub user_id: UserId,
+    pub model_id: ModelId,
+    pub input_tokens: i64,
+    pub input_cache_creation_tokens: i64,
+    pub input_cache_read_tokens: i64,
+    pub output_tokens: i64,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::model::Entity",
+        from = "Column::ModelId",
+        to = "super::model::Column::Id"
+    )]
+    Model,
+}
+
+impl Related<super::model::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Model.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}
diff --git a/crates/collab/src/llm/db/tables/model.rs b/crates/collab/src/llm/db/tables/model.rs
index 4d7d2d8da9bce3..6c521841854908 100644
--- a/crates/collab/src/llm/db/tables/model.rs
+++ b/crates/collab/src/llm/db/tables/model.rs
@@ -29,6 +29,8 @@ pub enum Relation {
     Provider,
     #[sea_orm(has_many = "super::usage::Entity")]
     Usages,
+    #[sea_orm(has_many = "super::billing_event::Entity")]
+    BillingEvents,
 }
 
 impl Related<super::provider::Entity> for Entity {
@@ -43,4 +45,10 @@ impl Related<super::usage::Entity> for Entity {
     }
 }
 
+impl Related<super::billing_event::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::BillingEvents.def()
+    }
+}
+
 impl ActiveModelBehavior for ActiveModel {}
diff --git a/crates/collab/src/llm/db/tests/usage_tests.rs b/crates/collab/src/llm/db/tests/usage_tests.rs
index 2730a030466cad..8e96ac4f54082c 100644
--- a/crates/collab/src/llm/db/tests/usage_tests.rs
+++ b/crates/collab/src/llm/db/tests/usage_tests.rs
@@ -2,7 +2,7 @@ use crate::{
     db::UserId,
     llm::db::{
         queries::{providers::ModelParams, usages::Usage},
-        LlmDatabase,
+        LlmDatabase, TokenUsage,
     },
     test_llm_db, Cents,
 };
@@ -36,14 +36,42 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
     let user_id = UserId::from_proto(123);
 
     let now = t0;
-    db.record_usage(user_id, false, provider, model, 1000, 0, 0, 0, now)
-        .await
-        .unwrap();
+    db.record_usage(
+        user_id,
+        false,
+        provider,
+        model,
+        TokenUsage {
+            input: 1000,
+            input_cache_creation: 0,
+            input_cache_read: 0,
+            output: 0,
+        },
+        false,
+        Cents::ZERO,
+        now,
+    )
+    .await
+    .unwrap();
 
     let now = t0 + Duration::seconds(10);
-    db.record_usage(user_id, false, provider, model, 2000, 0, 0, 0, now)
-        .await
-        .unwrap();
+    db.record_usage(
+        user_id,
+        false,
+        provider,
+        model,
+        TokenUsage {
+            input: 2000,
+            input_cache_creation: 0,
+            input_cache_read: 0,
+            output: 0,
+        },
+        false,
+        Cents::ZERO,
+        now,
+    )
+    .await
+    .unwrap();
 
     let usage = db.get_usage(user_id, provider, model, now).await.unwrap();
     assert_eq!(
@@ -52,10 +80,12 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             requests_this_minute: 2,
             tokens_this_minute: 3000,
             tokens_this_day: 3000,
-            input_tokens_this_month: 3000,
-            cache_creation_input_tokens_this_month: 0,
-            cache_read_input_tokens_this_month: 0,
-            output_tokens_this_month: 0,
+            tokens_this_month: TokenUsage {
+                input: 3000,
+                input_cache_creation: 0,
+                input_cache_read: 0,
+                output: 0,
+            },
             spending_this_month: Cents::ZERO,
             lifetime_spending: Cents::ZERO,
         }
@@ -69,19 +99,35 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             requests_this_minute: 1,
             tokens_this_minute: 2000,
             tokens_this_day: 3000,
-            input_tokens_this_month: 3000,
-            cache_creation_input_tokens_this_month: 0,
-            cache_read_input_tokens_this_month: 0,
-            output_tokens_this_month: 0,
+            tokens_this_month: TokenUsage {
+                input: 3000,
+                input_cache_creation: 0,
+                input_cache_read: 0,
+                output: 0,
+            },
             spending_this_month: Cents::ZERO,
             lifetime_spending: Cents::ZERO,
         }
     );
 
     let now = t0 + Duration::seconds(60);
-    db.record_usage(user_id, false, provider, model, 3000, 0, 0, 0, now)
-        .await
-        .unwrap();
+    db.record_usage(
+        user_id,
+        false,
+        provider,
+        model,
+        TokenUsage {
+            input: 3000,
+            input_cache_creation: 0,
+            input_cache_read: 0,
+            output: 0,
+        },
+        false,
+        Cents::ZERO,
+        now,
+    )
+    .await
+    .unwrap();
 
     let usage = db.get_usage(user_id, provider, model, now).await.unwrap();
     assert_eq!(
@@ -90,10 +136,12 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             requests_this_minute: 2,
             tokens_this_minute: 5000,
             tokens_this_day: 6000,
-            input_tokens_this_month: 6000,
-            cache_creation_input_tokens_this_month: 0,
-            cache_read_input_tokens_this_month: 0,
-            output_tokens_this_month: 0,
+            tokens_this_month: TokenUsage {
+                input: 6000,
+                input_cache_creation: 0,
+                input_cache_read: 0,
+                output: 0,
+            },
             spending_this_month: Cents::ZERO,
             lifetime_spending: Cents::ZERO,
         }
@@ -108,18 +156,34 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             requests_this_minute: 0,
             tokens_this_minute: 0,
             tokens_this_day: 5000,
-            input_tokens_this_month: 6000,
-            cache_creation_input_tokens_this_month: 0,
-            cache_read_input_tokens_this_month: 0,
-            output_tokens_this_month: 0,
+            tokens_this_month: TokenUsage {
+                input: 6000,
+                input_cache_creation: 0,
+                input_cache_read: 0,
+                output: 0,
+            },
             spending_this_month: Cents::ZERO,
             lifetime_spending: Cents::ZERO,
         }
     );
 
-    db.record_usage(user_id, false, provider, model, 4000, 0, 0, 0, now)
-        .await
-        .unwrap();
+    db.record_usage(
+        user_id,
+        false,
+        provider,
+        model,
+        TokenUsage {
+            input: 4000,
+            input_cache_creation: 0,
+            input_cache_read: 0,
+            output: 0,
+        },
+        false,
+        Cents::ZERO,
+        now,
+    )
+    .await
+    .unwrap();
 
     let usage = db.get_usage(user_id, provider, model, now).await.unwrap();
     assert_eq!(
@@ -128,10 +192,12 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             requests_this_minute: 1,
             tokens_this_minute: 4000,
             tokens_this_day: 9000,
-            input_tokens_this_month: 10000,
-            cache_creation_input_tokens_this_month: 0,
-            cache_read_input_tokens_this_month: 0,
-            output_tokens_this_month: 0,
+            tokens_this_month: TokenUsage {
+                input: 10000,
+                input_cache_creation: 0,
+                input_cache_read: 0,
+                output: 0,
+            },
             spending_this_month: Cents::ZERO,
             lifetime_spending: Cents::ZERO,
         }
@@ -143,9 +209,23 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
         .with_timezone(&Utc);
 
     // Test cache creation input tokens
-    db.record_usage(user_id, false, provider, model, 1000, 500, 0, 0, now)
-        .await
-        .unwrap();
+    db.record_usage(
+        user_id,
+        false,
+        provider,
+        model,
+        TokenUsage {
+            input: 1000,
+            input_cache_creation: 500,
+            input_cache_read: 0,
+            output: 0,
+        },
+        false,
+        Cents::ZERO,
+        now,
+    )
+    .await
+    .unwrap();
 
     let usage = db.get_usage(user_id, provider, model, now).await.unwrap();
     assert_eq!(
@@ -154,19 +234,35 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             requests_this_minute: 1,
             tokens_this_minute: 1500,
             tokens_this_day: 1500,
-            input_tokens_this_month: 1000,
-            cache_creation_input_tokens_this_month: 500,
-            cache_read_input_tokens_this_month: 0,
-            output_tokens_this_month: 0,
+            tokens_this_month: TokenUsage {
+                input: 1000,
+                input_cache_creation: 500,
+                input_cache_read: 0,
+                output: 0,
+            },
             spending_this_month: Cents::ZERO,
             lifetime_spending: Cents::ZERO,
         }
     );
 
     // Test cache read input tokens
-    db.record_usage(user_id, false, provider, model, 1000, 0, 300, 0, now)
-        .await
-        .unwrap();
+    db.record_usage(
+        user_id,
+        false,
+        provider,
+        model,
+        TokenUsage {
+            input: 1000,
+            input_cache_creation: 0,
+            input_cache_read: 300,
+            output: 0,
+        },
+        false,
+        Cents::ZERO,
+        now,
+    )
+    .await
+    .unwrap();
 
     let usage = db.get_usage(user_id, provider, model, now).await.unwrap();
     assert_eq!(
@@ -175,10 +271,12 @@ async fn test_tracking_usage(db: &mut LlmDatabase) {
             requests_this_minute: 2,
             tokens_this_minute: 2800,
             tokens_this_day: 2800,
-            input_tokens_this_month: 2000,
-            cache_creation_input_tokens_this_month: 500,
-            cache_read_input_tokens_this_month: 300,
-            output_tokens_this_month: 0,
+            tokens_this_month: TokenUsage {
+                input: 2000,
+                input_cache_creation: 500,
+                input_cache_read: 300,
+                output: 0,
+            },
             spending_this_month: Cents::ZERO,
             lifetime_spending: Cents::ZERO,
         }
diff --git a/crates/collab/src/main.rs b/crates/collab/src/main.rs
index bd227f17c70404..02c0baf9dec0db 100644
--- a/crates/collab/src/main.rs
+++ b/crates/collab/src/main.rs
@@ -157,7 +157,7 @@ async fn main() -> Result<()> {
 
                     if let Some(mut llm_db) = llm_db {
                         llm_db.initialize().await?;
-                        sync_llm_usage_with_stripe_periodically(state.clone(), llm_db);
+                        sync_llm_usage_with_stripe_periodically(state.clone());
                     }
 
                     app = app
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index 2b861dd403120d..e5dafe80d8dc02 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -1218,6 +1218,15 @@ impl Server {
         Ok(())
     }
 
+    pub async fn refresh_llm_tokens_for_user(self: &Arc<Self>, user_id: UserId) {
+        let pool = self.connection_pool.lock();
+        for connection_id in pool.user_connection_ids(user_id) {
+            self.peer
+                .send(connection_id, proto::RefreshLlmToken {})
+                .trace_err();
+        }
+    }
+
     pub async fn snapshot<'a>(self: &'a Arc<Self>) -> ServerSnapshot<'a> {
         ServerSnapshot {
             connection_pool: ConnectionPoolGuard {
diff --git a/crates/collab/src/stripe_billing.rs b/crates/collab/src/stripe_billing.rs
new file mode 100644
index 00000000000000..878d16066661f8
--- /dev/null
+++ b/crates/collab/src/stripe_billing.rs
@@ -0,0 +1,427 @@
+use std::sync::Arc;
+
+use crate::{llm, Cents, Result};
+use anyhow::Context;
+use chrono::Utc;
+use collections::HashMap;
+use serde::{Deserialize, Serialize};
+
+pub struct StripeBilling {
+    meters_by_event_name: HashMap<String, StripeMeter>,
+    price_ids_by_meter_id: HashMap<String, stripe::PriceId>,
+    client: Arc<stripe::Client>,
+}
+
+pub struct StripeModel {
+    input_tokens_price: StripeBillingPrice,
+    input_cache_creation_tokens_price: StripeBillingPrice,
+    input_cache_read_tokens_price: StripeBillingPrice,
+    output_tokens_price: StripeBillingPrice,
+}
+
+struct StripeBillingPrice {
+    id: stripe::PriceId,
+    meter_event_name: String,
+}
+
+impl StripeBilling {
+    pub async fn new(client: Arc<stripe::Client>) -> Result<Self> {
+        let mut meters_by_event_name = HashMap::default();
+        for meter in StripeMeter::list(&client).await?.data {
+            meters_by_event_name.insert(meter.event_name.clone(), meter);
+        }
+
+        let mut price_ids_by_meter_id = HashMap::default();
+        for price in stripe::Price::list(&client, &stripe::ListPrices::default())
+            .await?
+            .data
+        {
+            if let Some(recurring) = price.recurring {
+                if let Some(meter) = recurring.meter {
+                    price_ids_by_meter_id.insert(meter, price.id);
+                }
+            }
+        }
+
+        Ok(Self {
+            meters_by_event_name,
+            price_ids_by_meter_id,
+            client,
+        })
+    }
+
+    pub async fn register_model(&mut self, model: &llm::db::model::Model) -> Result<StripeModel> {
+        let input_tokens_price = self
+            .get_or_insert_price(
+                &format!("model_{}/input_tokens", model.id),
+                &format!("{} (Input Tokens)", model.name),
+                Cents::new(model.price_per_million_input_tokens as u32),
+            )
+            .await?;
+        let input_cache_creation_tokens_price = self
+            .get_or_insert_price(
+                &format!("model_{}/input_cache_creation_tokens", model.id),
+                &format!("{} (Input Cache Creation Tokens)", model.name),
+                Cents::new(model.price_per_million_cache_creation_input_tokens as u32),
+            )
+            .await?;
+        let input_cache_read_tokens_price = self
+            .get_or_insert_price(
+                &format!("model_{}/input_cache_read_tokens", model.id),
+                &format!("{} (Input Cache Read Tokens)", model.name),
+                Cents::new(model.price_per_million_cache_read_input_tokens as u32),
+            )
+            .await?;
+        let output_tokens_price = self
+            .get_or_insert_price(
+                &format!("model_{}/output_tokens", model.id),
+                &format!("{} (Output Tokens)", model.name),
+                Cents::new(model.price_per_million_output_tokens as u32),
+            )
+            .await?;
+        Ok(StripeModel {
+            input_tokens_price,
+            input_cache_creation_tokens_price,
+            input_cache_read_tokens_price,
+            output_tokens_price,
+        })
+    }
+
+    async fn get_or_insert_price(
+        &mut self,
+        meter_event_name: &str,
+        price_description: &str,
+        price_per_million_tokens: Cents,
+    ) -> Result<StripeBillingPrice> {
+        let meter = if let Some(meter) = self.meters_by_event_name.get(meter_event_name) {
+            meter.clone()
+        } else {
+            let meter = StripeMeter::create(
+                &self.client,
+                StripeCreateMeterParams {
+                    default_aggregation: DefaultAggregation { formula: "sum" },
+                    display_name: price_description.to_string(),
+                    event_name: meter_event_name,
+                },
+            )
+            .await?;
+            self.meters_by_event_name
+                .insert(meter_event_name.to_string(), meter.clone());
+            meter
+        };
+
+        let price_id = if let Some(price_id) = self.price_ids_by_meter_id.get(&meter.id) {
+            price_id.clone()
+        } else {
+            let price = stripe::Price::create(
+                &self.client,
+                stripe::CreatePrice {
+                    active: Some(true),
+                    billing_scheme: Some(stripe::PriceBillingScheme::PerUnit),
+                    currency: stripe::Currency::USD,
+                    currency_options: None,
+                    custom_unit_amount: None,
+                    expand: &[],
+                    lookup_key: None,
+                    metadata: None,
+                    nickname: None,
+                    product: None,
+                    product_data: Some(stripe::CreatePriceProductData {
+                        id: None,
+                        active: Some(true),
+                        metadata: None,
+                        name: price_description.to_string(),
+                        statement_descriptor: None,
+                        tax_code: None,
+                        unit_label: None,
+                    }),
+                    recurring: Some(stripe::CreatePriceRecurring {
+                        aggregate_usage: None,
+                        interval: stripe::CreatePriceRecurringInterval::Month,
+                        interval_count: None,
+                        trial_period_days: None,
+                        usage_type: Some(stripe::CreatePriceRecurringUsageType::Metered),
+                        meter: Some(meter.id.clone()),
+                    }),
+                    tax_behavior: None,
+                    tiers: None,
+                    tiers_mode: None,
+                    transfer_lookup_key: None,
+                    transform_quantity: None,
+                    unit_amount: None,
+                    unit_amount_decimal: Some(&format!(
+                        "{:.12}",
+                        price_per_million_tokens.0 as f64 / 1_000_000f64
+                    )),
+                },
+            )
+            .await?;
+            self.price_ids_by_meter_id
+                .insert(meter.id, price.id.clone());
+            price.id
+        };
+
+        Ok(StripeBillingPrice {
+            id: price_id,
+            meter_event_name: meter_event_name.to_string(),
+        })
+    }
+
+    pub async fn subscribe_to_model(
+        &self,
+        subscription_id: &stripe::SubscriptionId,
+        model: &StripeModel,
+    ) -> Result<()> {
+        let subscription =
+            stripe::Subscription::retrieve(&self.client, &subscription_id, &[]).await?;
+
+        let mut items = Vec::new();
+
+        if !subscription_contains_price(&subscription, &model.input_tokens_price.id) {
+            items.push(stripe::UpdateSubscriptionItems {
+                price: Some(model.input_tokens_price.id.to_string()),
+                ..Default::default()
+            });
+        }
+
+        if !subscription_contains_price(&subscription, &model.input_cache_creation_tokens_price.id)
+        {
+            items.push(stripe::UpdateSubscriptionItems {
+                price: Some(model.input_cache_creation_tokens_price.id.to_string()),
+                ..Default::default()
+            });
+        }
+
+        if !subscription_contains_price(&subscription, &model.input_cache_read_tokens_price.id) {
+            items.push(stripe::UpdateSubscriptionItems {
+                price: Some(model.input_cache_read_tokens_price.id.to_string()),
+                ..Default::default()
+            });
+        }
+
+        if !subscription_contains_price(&subscription, &model.output_tokens_price.id) {
+            items.push(stripe::UpdateSubscriptionItems {
+                price: Some(model.output_tokens_price.id.to_string()),
+                ..Default::default()
+            });
+        }
+
+        if !items.is_empty() {
+            items.extend(subscription.items.data.iter().map(|item| {
+                stripe::UpdateSubscriptionItems {
+                    id: Some(item.id.to_string()),
+                    ..Default::default()
+                }
+            }));
+
+            stripe::Subscription::update(
+                &self.client,
+                subscription_id,
+                stripe::UpdateSubscription {
+                    items: Some(items),
+                    ..Default::default()
+                },
+            )
+            .await?;
+        }
+
+        Ok(())
+    }
+
+    pub async fn bill_model_usage(
+        &self,
+        customer_id: &stripe::CustomerId,
+        model: &StripeModel,
+        event: &llm::db::billing_event::Model,
+    ) -> Result<()> {
+        let timestamp = Utc::now().timestamp();
+
+        if event.input_tokens > 0 {
+            StripeMeterEvent::create(
+                &self.client,
+                StripeCreateMeterEventParams {
+                    identifier: &format!("input_tokens/{}", event.idempotency_key),
+                    event_name: &model.input_tokens_price.meter_event_name,
+                    payload: StripeCreateMeterEventPayload {
+                        value: event.input_tokens as u64,
+                        stripe_customer_id: customer_id,
+                    },
+                    timestamp: Some(timestamp),
+                },
+            )
+            .await?;
+        }
+
+        if event.input_cache_creation_tokens > 0 {
+            StripeMeterEvent::create(
+                &self.client,
+                StripeCreateMeterEventParams {
+                    identifier: &format!("input_cache_creation_tokens/{}", event.idempotency_key),
+                    event_name: &model.input_cache_creation_tokens_price.meter_event_name,
+                    payload: StripeCreateMeterEventPayload {
+                        value: event.input_cache_creation_tokens as u64,
+                        stripe_customer_id: customer_id,
+                    },
+                    timestamp: Some(timestamp),
+                },
+            )
+            .await?;
+        }
+
+        if event.input_cache_read_tokens > 0 {
+            StripeMeterEvent::create(
+                &self.client,
+                StripeCreateMeterEventParams {
+                    identifier: &format!("input_cache_read_tokens/{}", event.idempotency_key),
+                    event_name: &model.input_cache_read_tokens_price.meter_event_name,
+                    payload: StripeCreateMeterEventPayload {
+                        value: event.input_cache_read_tokens as u64,
+                        stripe_customer_id: customer_id,
+                    },
+                    timestamp: Some(timestamp),
+                },
+            )
+            .await?;
+        }
+
+        if event.output_tokens > 0 {
+            StripeMeterEvent::create(
+                &self.client,
+                StripeCreateMeterEventParams {
+                    identifier: &format!("output_tokens/{}", event.idempotency_key),
+                    event_name: &model.output_tokens_price.meter_event_name,
+                    payload: StripeCreateMeterEventPayload {
+                        value: event.output_tokens as u64,
+                        stripe_customer_id: customer_id,
+                    },
+                    timestamp: Some(timestamp),
+                },
+            )
+            .await?;
+        }
+
+        Ok(())
+    }
+
+    pub async fn checkout(
+        &self,
+        customer_id: stripe::CustomerId,
+        github_login: &str,
+        model: &StripeModel,
+        success_url: &str,
+    ) -> Result<String> {
+        let mut params = stripe::CreateCheckoutSession::new();
+        params.mode = Some(stripe::CheckoutSessionMode::Subscription);
+        params.customer = Some(customer_id);
+        params.client_reference_id = Some(github_login);
+        params.line_items = Some(
+            [
+                &model.input_tokens_price.id,
+                &model.input_cache_creation_tokens_price.id,
+                &model.input_cache_read_tokens_price.id,
+                &model.output_tokens_price.id,
+            ]
+            .into_iter()
+            .map(|price_id| stripe::CreateCheckoutSessionLineItems {
+                price: Some(price_id.to_string()),
+                ..Default::default()
+            })
+            .collect(),
+        );
+        params.success_url = Some(success_url);
+
+        let session = stripe::CheckoutSession::create(&self.client, params).await?;
+        Ok(session.url.context("no checkout session URL")?)
+    }
+}
+
+#[derive(Serialize)]
+struct DefaultAggregation {
+    formula: &'static str,
+}
+
+#[derive(Serialize)]
+struct StripeCreateMeterParams<'a> {
+    default_aggregation: DefaultAggregation,
+    display_name: String,
+    event_name: &'a str,
+}
+
+#[derive(Clone, Deserialize)]
+struct StripeMeter {
+    id: String,
+    event_name: String,
+}
+
+impl StripeMeter {
+    pub fn create(
+        client: &stripe::Client,
+        params: StripeCreateMeterParams,
+    ) -> stripe::Response<Self> {
+        client.post_form("/billing/meters", params)
+    }
+
+    pub fn list(client: &stripe::Client) -> stripe::Response<stripe::List<Self>> {
+        #[derive(Serialize)]
+        struct Params {}
+
+        client.get_query("/billing/meters", Params {})
+    }
+}
+
+#[derive(Deserialize)]
+struct StripeMeterEvent {
+    identifier: String,
+}
+
+impl StripeMeterEvent {
+    pub async fn create(
+        client: &stripe::Client,
+        params: StripeCreateMeterEventParams<'_>,
+    ) -> Result<Self, stripe::StripeError> {
+        let identifier = params.identifier;
+        match client.post_form("/billing/meter_events", params).await {
+            Ok(event) => Ok(event),
+            Err(stripe::StripeError::Stripe(error)) => {
+                if error.http_status == 400
+                    && error
+                        .message
+                        .as_ref()
+                        .map_or(false, |message| message.contains(identifier))
+                {
+                    Ok(Self {
+                        identifier: identifier.to_string(),
+                    })
+                } else {
+                    Err(stripe::StripeError::Stripe(error))
+                }
+            }
+            Err(error) => Err(error),
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct StripeCreateMeterEventParams<'a> {
+    identifier: &'a str,
+    event_name: &'a str,
+    payload: StripeCreateMeterEventPayload<'a>,
+    timestamp: Option<i64>,
+}
+
+#[derive(Serialize)]
+struct StripeCreateMeterEventPayload<'a> {
+    value: u64,
+    stripe_customer_id: &'a stripe::CustomerId,
+}
+
+fn subscription_contains_price(
+    subscription: &stripe::Subscription,
+    price_id: &stripe::PriceId,
+) -> bool {
+    subscription.items.data.iter().any(|item| {
+        item.price
+            .as_ref()
+            .map_or(false, |price| price.id == *price_id)
+    })
+}
diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs
index 683a53a2f56618..484940c527bd0d 100644
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -635,6 +635,7 @@ impl TestServer {
     ) -> Arc<AppState> {
         Arc::new(AppState {
             db: test_db.db().clone(),
+            llm_db: None,
             live_kit_client: Some(Arc::new(live_kit_test_server.create_api_client())),
             blob_store_client: None,
             stripe_client: None,
@@ -677,8 +678,6 @@ impl TestServer {
                 migrations_path: None,
                 seed_path: None,
                 stripe_api_key: None,
-                stripe_llm_access_price_id: None,
-                stripe_llm_usage_price_id: None,
                 supermaven_admin_api_key: None,
                 user_backfiller_github_access_token: None,
             },

From f33b8abc7249fd10a4cfb08377fce2518af5bb94 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 11 Oct 2024 13:57:48 -0400
Subject: [PATCH 610/762] collab: Sort LLM database ID types (#19083)

This PR sorts the order of the LLM database ID type declarations.

Release Notes:

- N/A
---
 crates/collab/src/llm/db/ids.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/collab/src/llm/db/ids.rs b/crates/collab/src/llm/db/ids.rs
index 80da32fbf49f19..67f2a49380796c 100644
--- a/crates/collab/src/llm/db/ids.rs
+++ b/crates/collab/src/llm/db/ids.rs
@@ -3,9 +3,9 @@ use serde::{Deserialize, Serialize};
 
 use crate::id_type;
 
+id_type!(BillingEventId);
 id_type!(ModelId);
 id_type!(ProviderId);
+id_type!(RevokedAccessTokenId);
 id_type!(UsageId);
 id_type!(UsageMeasureId);
-id_type!(RevokedAccessTokenId);
-id_type!(BillingEventId);

From 550064f80faecbe1951b249c913a7158c32ff53b Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Fri, 11 Oct 2024 21:53:37 +0300
Subject: [PATCH 611/762] Fix ~ expansion in ssh projects' terminals (#19078)

When setting a remote ssh project path starting with ~, Zed would fail
to cd into such project's directory when opening a new terminal.

Release Notes:

- N/A

---------

Co-authored-by: Thorsten Ball <mrnugget@gmail.com>
---
 crates/project/src/terminals.rs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs
index ecac58fb858666..11b3152f0cf660 100644
--- a/crates/project/src/terminals.rs
+++ b/crates/project/src/terminals.rs
@@ -362,7 +362,16 @@ pub fn wrap_for_ssh(
     }
 
     let commands = if let Some(path) = path {
-        format!("cd {:?}; {} {}", path, env_changes, to_run)
+        let path_string = path.to_string_lossy().to_string();
+        // shlex will wrap the command in single quotes (''), disabling ~ expansion,
+        // replace ith with something that works
+        let tilde_prefix = "~/";
+        if path.starts_with(tilde_prefix) {
+            let trimmed_path = &path_string[tilde_prefix.len()..];
+            format!("cd \"$HOME/{trimmed_path}\"; {env_changes} {to_run}")
+        } else {
+            format!("cd {path:?}; {env_changes} {to_run}")
+        }
     } else {
         format!("cd; {env_changes} {to_run}")
     };

From f280b298594a3c20cfa0a3d473d6d499cf59a60c Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 11 Oct 2024 15:15:08 -0400
Subject: [PATCH 612/762] collab: Make the `StripeBilling` object long-lived
 (#19090)

This PR makes the `StripeBilling` object long-lived so that we can make
better use of the cached data on it.

We now hold it on the `AppState` and spawn a background task to
initialize the cache on startup.

Release Notes:

- N/A

Co-authored-by: Richard <richard@zed.dev>
---
 crates/collab/src/api/billing.rs       |  18 ++-
 crates/collab/src/lib.rs               |   9 +-
 crates/collab/src/main.rs              |   7 +
 crates/collab/src/stripe_billing.rs    | 188 ++++++++++++++-----------
 crates/collab/src/tests/test_server.rs |   1 +
 5 files changed, 130 insertions(+), 93 deletions(-)

diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index c0fc33a643bf12..0e46e8453d95f0 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -210,6 +210,13 @@ async fn create_billing_subscription(
             "not supported".into(),
         ))?
     };
+    let Some(stripe_billing) = app.stripe_billing.clone() else {
+        log::error!("failed to retrieve Stripe billing object");
+        Err(Error::http(
+            StatusCode::NOT_IMPLEMENTED,
+            "not supported".into(),
+        ))?
+    };
     let Some(llm_db) = app.llm_db.clone() else {
         log::error!("failed to retrieve LLM database");
         Err(Error::http(
@@ -236,7 +243,6 @@ async fn create_billing_subscription(
         };
 
     let default_model = llm_db.model(rpc::LanguageModelProvider::Anthropic, "claude-3-5-sonnet")?;
-    let mut stripe_billing = StripeBilling::new(stripe_client.clone()).await?;
     let stripe_model = stripe_billing.register_model(default_model).await?;
     let success_url = format!("{}/account", app.config.zed_dot_dev_url());
     let checkout_session_url = stripe_billing
@@ -716,8 +722,8 @@ async fn find_or_create_billing_customer(
 const SYNC_LLM_USAGE_WITH_STRIPE_INTERVAL: Duration = Duration::from_secs(60);
 
 pub fn sync_llm_usage_with_stripe_periodically(app: Arc<AppState>) {
-    let Some(stripe_client) = app.stripe_client.clone() else {
-        log::warn!("failed to retrieve Stripe client");
+    let Some(stripe_billing) = app.stripe_billing.clone() else {
+        log::warn!("failed to retrieve Stripe billing object");
         return;
     };
     let Some(llm_db) = app.llm_db.clone() else {
@@ -730,7 +736,7 @@ pub fn sync_llm_usage_with_stripe_periodically(app: Arc<AppState>) {
         let executor = executor.clone();
         async move {
             loop {
-                sync_with_stripe(&app, &llm_db, &stripe_client)
+                sync_with_stripe(&app, &llm_db, &stripe_billing)
                     .await
                     .trace_err();
                 executor.sleep(SYNC_LLM_USAGE_WITH_STRIPE_INTERVAL).await;
@@ -742,10 +748,8 @@ pub fn sync_llm_usage_with_stripe_periodically(app: Arc<AppState>) {
 async fn sync_with_stripe(
     app: &Arc<AppState>,
     llm_db: &Arc<LlmDatabase>,
-    stripe_client: &Arc<stripe::Client>,
+    stripe_billing: &Arc<StripeBilling>,
 ) -> anyhow::Result<()> {
-    let mut stripe_billing = StripeBilling::new(stripe_client.clone()).await?;
-
     let events = llm_db.get_billing_events().await?;
     let user_ids = events
         .iter()
diff --git a/crates/collab/src/lib.rs b/crates/collab/src/lib.rs
index 0cc50f68f311a9..c82968efecd9c1 100644
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -31,6 +31,8 @@ use serde::Deserialize;
 use std::{path::PathBuf, sync::Arc};
 use util::ResultExt;
 
+use crate::stripe_billing::StripeBilling;
+
 pub type Result<T, E = Error> = std::result::Result<T, E>;
 
 pub enum Error {
@@ -274,6 +276,7 @@ pub struct AppState {
     pub live_kit_client: Option<Arc<dyn live_kit_server::api::Client>>,
     pub blob_store_client: Option<aws_sdk_s3::Client>,
     pub stripe_client: Option<Arc<stripe::Client>>,
+    pub stripe_billing: Option<Arc<StripeBilling>>,
     pub rate_limiter: Arc<RateLimiter>,
     pub executor: Executor,
     pub clickhouse_client: Option<::clickhouse::Client>,
@@ -317,12 +320,16 @@ impl AppState {
         };
 
         let db = Arc::new(db);
+        let stripe_client = build_stripe_client(&config).map(Arc::new).log_err();
         let this = Self {
             db: db.clone(),
             llm_db,
             live_kit_client,
             blob_store_client: build_blob_store_client(&config).await.log_err(),
-            stripe_client: build_stripe_client(&config).map(Arc::new).log_err(),
+            stripe_billing: stripe_client
+                .clone()
+                .map(|stripe_client| Arc::new(StripeBilling::new(stripe_client))),
+            stripe_client,
             rate_limiter: Arc::new(RateLimiter::new(db)),
             executor,
             clickhouse_client: config
diff --git a/crates/collab/src/main.rs b/crates/collab/src/main.rs
index 02c0baf9dec0db..de77be21eb4e01 100644
--- a/crates/collab/src/main.rs
+++ b/crates/collab/src/main.rs
@@ -111,6 +111,13 @@ async fn main() -> Result<()> {
 
                 let state = AppState::new(config, Executor::Production).await?;
 
+                if let Some(stripe_billing) = state.stripe_billing.clone() {
+                    let executor = state.executor.clone();
+                    executor.spawn_detached(async move {
+                        stripe_billing.initialize().await.trace_err();
+                    });
+                }
+
                 if mode.is_collab() {
                     state.db.purge_old_embeddings().await.trace_err();
                     RateLimiter::save_periodically(
diff --git a/crates/collab/src/stripe_billing.rs b/crates/collab/src/stripe_billing.rs
index 878d16066661f8..ee7d93979dafe6 100644
--- a/crates/collab/src/stripe_billing.rs
+++ b/crates/collab/src/stripe_billing.rs
@@ -5,10 +5,11 @@ use anyhow::Context;
 use chrono::Utc;
 use collections::HashMap;
 use serde::{Deserialize, Serialize};
+use tokio::sync::RwLock;
 
 pub struct StripeBilling {
-    meters_by_event_name: HashMap<String, StripeMeter>,
-    price_ids_by_meter_id: HashMap<String, stripe::PriceId>,
+    meters_by_event_name: RwLock<HashMap<String, StripeMeter>>,
+    price_ids_by_meter_id: RwLock<HashMap<String, stripe::PriceId>>,
     client: Arc<stripe::Client>,
 }
 
@@ -25,32 +26,43 @@ struct StripeBillingPrice {
 }
 
 impl StripeBilling {
-    pub async fn new(client: Arc<stripe::Client>) -> Result<Self> {
-        let mut meters_by_event_name = HashMap::default();
-        for meter in StripeMeter::list(&client).await?.data {
-            meters_by_event_name.insert(meter.event_name.clone(), meter);
+    pub fn new(client: Arc<stripe::Client>) -> Self {
+        Self {
+            client,
+            meters_by_event_name: RwLock::new(HashMap::default()),
+            price_ids_by_meter_id: RwLock::new(HashMap::default()),
         }
+    }
+
+    pub async fn initialize(&self) -> Result<()> {
+        log::info!("initializing StripeBilling");
 
-        let mut price_ids_by_meter_id = HashMap::default();
-        for price in stripe::Price::list(&client, &stripe::ListPrices::default())
-            .await?
-            .data
         {
-            if let Some(recurring) = price.recurring {
-                if let Some(meter) = recurring.meter {
-                    price_ids_by_meter_id.insert(meter, price.id);
+            let meters = StripeMeter::list(&self.client).await?.data;
+            let mut meters_by_event_name = self.meters_by_event_name.write().await;
+            for meter in meters {
+                meters_by_event_name.insert(meter.event_name.clone(), meter);
+            }
+        }
+
+        {
+            let prices = stripe::Price::list(&self.client, &stripe::ListPrices::default())
+                .await?
+                .data;
+            let mut price_ids_by_meter_id = self.price_ids_by_meter_id.write().await;
+            for price in prices {
+                if let Some(recurring) = price.recurring {
+                    if let Some(meter) = recurring.meter {
+                        price_ids_by_meter_id.insert(meter, price.id);
+                    }
                 }
             }
         }
 
-        Ok(Self {
-            meters_by_event_name,
-            price_ids_by_meter_id,
-            client,
-        })
+        Ok(())
     }
 
-    pub async fn register_model(&mut self, model: &llm::db::model::Model) -> Result<StripeModel> {
+    pub async fn register_model(&self, model: &llm::db::model::Model) -> Result<StripeModel> {
         let input_tokens_price = self
             .get_or_insert_price(
                 &format!("model_{}/input_tokens", model.id),
@@ -88,78 +100,84 @@ impl StripeBilling {
     }
 
     async fn get_or_insert_price(
-        &mut self,
+        &self,
         meter_event_name: &str,
         price_description: &str,
         price_per_million_tokens: Cents,
     ) -> Result<StripeBillingPrice> {
-        let meter = if let Some(meter) = self.meters_by_event_name.get(meter_event_name) {
-            meter.clone()
-        } else {
-            let meter = StripeMeter::create(
-                &self.client,
-                StripeCreateMeterParams {
-                    default_aggregation: DefaultAggregation { formula: "sum" },
-                    display_name: price_description.to_string(),
-                    event_name: meter_event_name,
-                },
-            )
-            .await?;
-            self.meters_by_event_name
-                .insert(meter_event_name.to_string(), meter.clone());
-            meter
-        };
-
-        let price_id = if let Some(price_id) = self.price_ids_by_meter_id.get(&meter.id) {
-            price_id.clone()
-        } else {
-            let price = stripe::Price::create(
-                &self.client,
-                stripe::CreatePrice {
-                    active: Some(true),
-                    billing_scheme: Some(stripe::PriceBillingScheme::PerUnit),
-                    currency: stripe::Currency::USD,
-                    currency_options: None,
-                    custom_unit_amount: None,
-                    expand: &[],
-                    lookup_key: None,
-                    metadata: None,
-                    nickname: None,
-                    product: None,
-                    product_data: Some(stripe::CreatePriceProductData {
-                        id: None,
+        let meter =
+            if let Some(meter) = self.meters_by_event_name.read().await.get(meter_event_name) {
+                meter.clone()
+            } else {
+                let meter = StripeMeter::create(
+                    &self.client,
+                    StripeCreateMeterParams {
+                        default_aggregation: DefaultAggregation { formula: "sum" },
+                        display_name: price_description.to_string(),
+                        event_name: meter_event_name,
+                    },
+                )
+                .await?;
+                self.meters_by_event_name
+                    .write()
+                    .await
+                    .insert(meter_event_name.to_string(), meter.clone());
+                meter
+            };
+
+        let price_id =
+            if let Some(price_id) = self.price_ids_by_meter_id.read().await.get(&meter.id) {
+                price_id.clone()
+            } else {
+                let price = stripe::Price::create(
+                    &self.client,
+                    stripe::CreatePrice {
                         active: Some(true),
+                        billing_scheme: Some(stripe::PriceBillingScheme::PerUnit),
+                        currency: stripe::Currency::USD,
+                        currency_options: None,
+                        custom_unit_amount: None,
+                        expand: &[],
+                        lookup_key: None,
                         metadata: None,
-                        name: price_description.to_string(),
-                        statement_descriptor: None,
-                        tax_code: None,
-                        unit_label: None,
-                    }),
-                    recurring: Some(stripe::CreatePriceRecurring {
-                        aggregate_usage: None,
-                        interval: stripe::CreatePriceRecurringInterval::Month,
-                        interval_count: None,
-                        trial_period_days: None,
-                        usage_type: Some(stripe::CreatePriceRecurringUsageType::Metered),
-                        meter: Some(meter.id.clone()),
-                    }),
-                    tax_behavior: None,
-                    tiers: None,
-                    tiers_mode: None,
-                    transfer_lookup_key: None,
-                    transform_quantity: None,
-                    unit_amount: None,
-                    unit_amount_decimal: Some(&format!(
-                        "{:.12}",
-                        price_per_million_tokens.0 as f64 / 1_000_000f64
-                    )),
-                },
-            )
-            .await?;
-            self.price_ids_by_meter_id
-                .insert(meter.id, price.id.clone());
-            price.id
-        };
+                        nickname: None,
+                        product: None,
+                        product_data: Some(stripe::CreatePriceProductData {
+                            id: None,
+                            active: Some(true),
+                            metadata: None,
+                            name: price_description.to_string(),
+                            statement_descriptor: None,
+                            tax_code: None,
+                            unit_label: None,
+                        }),
+                        recurring: Some(stripe::CreatePriceRecurring {
+                            aggregate_usage: None,
+                            interval: stripe::CreatePriceRecurringInterval::Month,
+                            interval_count: None,
+                            trial_period_days: None,
+                            usage_type: Some(stripe::CreatePriceRecurringUsageType::Metered),
+                            meter: Some(meter.id.clone()),
+                        }),
+                        tax_behavior: None,
+                        tiers: None,
+                        tiers_mode: None,
+                        transfer_lookup_key: None,
+                        transform_quantity: None,
+                        unit_amount: None,
+                        unit_amount_decimal: Some(&format!(
+                            "{:.12}",
+                            price_per_million_tokens.0 as f64 / 1_000_000f64
+                        )),
+                    },
+                )
+                .await?;
+                self.price_ids_by_meter_id
+                    .write()
+                    .await
+                    .insert(meter.id, price.id.clone());
+                price.id
+            };
 
         Ok(StripeBillingPrice {
             id: price_id,
diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs
index 484940c527bd0d..210a049e0bcb30 100644
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -639,6 +639,7 @@ impl TestServer {
             live_kit_client: Some(Arc::new(live_kit_test_server.create_api_client())),
             blob_store_client: None,
             stripe_client: None,
+            stripe_billing: None,
             rate_limiter: Arc::new(RateLimiter::new(test_db.db().clone())),
             executor,
             clickhouse_client: None,

From 12c9f0f723c63236c3293e340c27b5667fe51627 Mon Sep 17 00:00:00 2001
From: Richard Feldman <oss@rtfeldman.com>
Date: Fri, 11 Oct 2024 16:21:21 -0400
Subject: [PATCH 613/762] Test some billing events logic (#19094)

Release Notes:

- N/A

Co-authored-by: Marshall <marshall@zed.dev>
---
 crates/collab/src/llm/db/tests.rs             |   1 +
 .../collab/src/llm/db/tests/billing_tests.rs  | 165 ++++++++++++++++++
 2 files changed, 166 insertions(+)
 create mode 100644 crates/collab/src/llm/db/tests/billing_tests.rs

diff --git a/crates/collab/src/llm/db/tests.rs b/crates/collab/src/llm/db/tests.rs
index 5fba2a24fd157d..963e5bcb0a30a7 100644
--- a/crates/collab/src/llm/db/tests.rs
+++ b/crates/collab/src/llm/db/tests.rs
@@ -1,3 +1,4 @@
+mod billing_tests;
 mod provider_tests;
 mod usage_tests;
 
diff --git a/crates/collab/src/llm/db/tests/billing_tests.rs b/crates/collab/src/llm/db/tests/billing_tests.rs
new file mode 100644
index 00000000000000..241a705db4b6a1
--- /dev/null
+++ b/crates/collab/src/llm/db/tests/billing_tests.rs
@@ -0,0 +1,165 @@
+use crate::{
+    db::UserId,
+    llm::{
+        db::{
+            queries::{providers::ModelParams, usages::Usage},
+            LlmDatabase, TokenUsage,
+        },
+        FREE_TIER_MONTHLY_SPENDING_LIMIT,
+    },
+    test_llm_db, Cents,
+};
+use chrono::{DateTime, Utc};
+use pretty_assertions::assert_eq;
+use rpc::LanguageModelProvider;
+
+test_llm_db!(
+    test_billing_limit_exceeded,
+    test_billing_limit_exceeded_postgres
+);
+
+async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
+    let provider = LanguageModelProvider::Anthropic;
+    let model = "fake-claude-limerick";
+    const PRICE_PER_MILLION_INPUT_TOKENS: i32 = 5;
+    const PRICE_PER_MILLION_OUTPUT_TOKENS: i32 = 5;
+
+    // Initialize the database and insert the model
+    db.initialize().await.unwrap();
+    db.insert_models(&[ModelParams {
+        provider,
+        name: model.to_string(),
+        max_requests_per_minute: 5,
+        max_tokens_per_minute: 10_000,
+        max_tokens_per_day: 50_000,
+        price_per_million_input_tokens: PRICE_PER_MILLION_INPUT_TOKENS,
+        price_per_million_output_tokens: PRICE_PER_MILLION_OUTPUT_TOKENS,
+    }])
+    .await
+    .unwrap();
+
+    // Set a fixed datetime for consistent testing
+    let now = DateTime::parse_from_rfc3339("2024-08-08T22:46:33Z")
+        .unwrap()
+        .with_timezone(&Utc);
+
+    let user_id = UserId::from_proto(123);
+
+    let max_monthly_spend = Cents::from_dollars(10);
+
+    // Record usage that brings us close to the limit but doesn't exceed it
+    // Let's say we use $9.50 worth of tokens
+    let tokens_to_use = 190_000_000; // This will cost $9.50 at $0.05 per 1 million tokens
+    let usage = TokenUsage {
+        input: tokens_to_use,
+        input_cache_creation: 0,
+        input_cache_read: 0,
+        output: 0,
+    };
+    let cost = Cents::new(tokens_to_use as u32 / 1_000_000 * PRICE_PER_MILLION_INPUT_TOKENS as u32);
+
+    assert_eq!(
+        cost,
+        Cents::new(950),
+        "expected the cost to be $9.50, based on the inputs, but it wasn't"
+    );
+
+    // Verify that before we record any usage, there are 0 billing events
+    let billing_events = db.get_billing_events().await.unwrap();
+    assert_eq!(billing_events.len(), 0);
+
+    db.record_usage(
+        user_id,
+        false,
+        provider,
+        model,
+        usage,
+        true,
+        max_monthly_spend,
+        now,
+    )
+    .await
+    .unwrap();
+
+    // Verify the recorded usage and spending
+    let recorded_usage = db.get_usage(user_id, provider, model, now).await.unwrap();
+
+    // Verify that we exceeded the free tier usage
+    assert!(
+        recorded_usage.spending_this_month > FREE_TIER_MONTHLY_SPENDING_LIMIT,
+        "Expected spending to exceed free tier limit"
+    );
+
+    assert_eq!(
+        recorded_usage,
+        Usage {
+            requests_this_minute: 1,
+            tokens_this_minute: tokens_to_use,
+            tokens_this_day: tokens_to_use,
+            tokens_this_month: TokenUsage {
+                input: tokens_to_use,
+                input_cache_creation: 0,
+                input_cache_read: 0,
+                output: 0,
+            },
+            spending_this_month: Cents::new(950),
+            lifetime_spending: Cents::new(950),
+        }
+    );
+
+    // Verify that there is one `billing_event` record
+    let billing_events = db.get_billing_events().await.unwrap();
+    assert_eq!(billing_events.len(), 1);
+
+    let (billing_event, _model) = &billing_events[0];
+    assert_eq!(billing_event.user_id, user_id);
+    assert_eq!(billing_event.input_tokens, tokens_to_use as i64);
+    assert_eq!(billing_event.input_cache_creation_tokens, 0);
+    assert_eq!(billing_event.input_cache_read_tokens, 0);
+    assert_eq!(billing_event.output_tokens, 0);
+
+    let tokens_to_exceed = 20_000_000; // This will cost $1.00 more, pushing us from $9.50 to $10.50, which is over the $10 monthly maximum limit
+    let usage_exceeding = TokenUsage {
+        input: tokens_to_exceed,
+        input_cache_creation: 0,
+        input_cache_read: 0,
+        output: 0,
+    };
+
+    // This should still create a billing event as it's the first request that exceeds the limit
+    db.record_usage(
+        user_id,
+        false,
+        provider,
+        model,
+        usage_exceeding,
+        true,
+        max_monthly_spend,
+        now,
+    )
+    .await
+    .unwrap();
+
+    // Verify that there is still one billing record
+    let billing_events = db.get_billing_events().await.unwrap();
+    assert_eq!(billing_events.len(), 1);
+
+    // Verify the updated usage and spending
+    let updated_usage = db.get_usage(user_id, provider, model, now).await.unwrap();
+    assert_eq!(
+        updated_usage,
+        Usage {
+            requests_this_minute: 2,
+            tokens_this_minute: tokens_to_use + tokens_to_exceed,
+            tokens_this_day: tokens_to_use + tokens_to_exceed,
+            tokens_this_month: TokenUsage {
+                input: tokens_to_use + tokens_to_exceed,
+                input_cache_creation: 0,
+                input_cache_read: 0,
+                output: 0,
+            },
+            spending_this_month: Cents::new(1050),
+            lifetime_spending: Cents::new(1050),
+        }
+    );
+}

From 3cbaa08d89ce6f04ed9354acd02c3c2dfae6c5e9 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 11 Oct 2024 16:29:35 -0400
Subject: [PATCH 614/762] Fix script/linux for Linux Mint (#19096)

- Closes: https://github.com/zed-industries/zed/issues/18827

Release Notes:

- N/A
---
 script/linux | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/script/linux b/script/linux
index c69cd5a842eb85..87841f80f192ae 100755
--- a/script/linux
+++ b/script/linux
@@ -43,11 +43,11 @@ if [[ -n $apt ]]; then
     elfutils
     libsqlite3-dev
   )
-  if (grep -qP 'PRETTY_NAME="(.+24\.04)' /etc/os-release); then
+  if (grep -qP 'PRETTY_NAME="(Linux Mint 22|.+24\.04)' /etc/os-release); then
     deps+=( mold libstdc++-14-dev )
-  elif (grep -qP 'PRETTY_NAME="((Debian|Raspbian).+12|.+22\.04)' /etc/os-release); then
+  elif (grep -qP 'PRETTY_NAME="((Debian|Raspbian).+12|Linux Mint 21|.+22\.04)' /etc/os-release); then
     deps+=( mold libstdc++-12-dev )
-  elif (grep -qP 'PRETTY_NAME="((Debian|Raspbian).+11|.+20\.04)' /etc/os-release); then
+  elif (grep -qP 'PRETTY_NAME="((Debian|Raspbian).+11|Linux Mint 20|.+20\.04)' /etc/os-release); then
     deps+=( libstdc++-10-dev )
   fi
 

From 0fc3072362775edd8bf10f0ed46ea8a4fbbed0e4 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 11 Oct 2024 16:33:40 -0400
Subject: [PATCH 615/762] Document extension extraction process (#19085)

Release Notes:

- N/A
---
 extensions/EXTRACTION.md | 88 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 extensions/EXTRACTION.md

diff --git a/extensions/EXTRACTION.md b/extensions/EXTRACTION.md
new file mode 100644
index 00000000000000..fe112e5b41d0fa
--- /dev/null
+++ b/extensions/EXTRACTION.md
@@ -0,0 +1,88 @@
+# Extracting an extension to dedicated repo
+
+These are some notes of how to extract an extension from the main zed repository and generate a new repository which preserves the history as best as possible.  In the this example we will be extracting the `ruby` extension, substitute as appropriate.
+
+## Pre-requisites
+
+Install [git-filter-repo](https://github.com/newren/git-filter-repo/blob/main/INSTALL.md):
+
+```
+brew install git-filter-repo
+```
+
+## Process
+
+1. Create an expressions.txt file somewhere (e.g. `~/projects/expressions.txt`)
+
+```
+ruby: ==>
+extension: ==>
+chore: ==>
+zed_extension_api: ==>
+regex:(?<![\[a-zA-Z0-9])(#[0-9]{3,5})==>zed-industries/zed\1
+```
+
+This file takes the form of `patern==>replacement`, where the replacement is optional.
+Note whitespace matters so `ruby: ==>` is removing the `ruby:` prefix from a commit messages and adding a space after `==> ` means the replacement begins with a space.  Regex capture groups are numbered `\1`, `\2`, etc.
+
+See: [Git Filter Repo Docs](https://htmlpreview.github.io/?https://github.com/newren/git-filter-repo/blob/docs/html/git-filter-repo.html) for more.
+
+2. Create a clean clone the zed repository, delete tags, delete branches and do the work.
+
+> **Note**
+> If you get `zsh: command not found: #` errors, run:
+> `setopt interactive_comments && echo "setopt interactive_comments" >> ~/.zshrc`
+
+```sh
+rm -rf zed3
+git clone --single-branch --no-tags git@github.com:zed-industries/zed.git zed3
+cd zed3
+
+# This removes the LICENSE symlink
+git filter-repo --invert-paths --path extensions/ruby/LICENSE-APACHE
+
+git filter-repo \
+    --use-mailmap \
+    --subdirectory-filter extensions/ruby/ \
+    --path LICENSE-APACHE \
+    --replace-message ~/projects/expressions.txt
+```
+
+3. Review the commits.
+
+This is your last chance to make any modifications.
+If you don't fix it now, it'll be wrong forever.
+
+For example, a previous commit message was `php/ruby: bump version to 0.0.5`
+which was replaced with `php/bump version to 0.0.5`
+so I added a new line to expressions.txt with `php/==>`
+and next run it became `bump version to 0.0.5`.
+
+4. [Optional] Generate tags
+
+You can always add tags later, but it's a nice touch.
+
+Show you all commits that mention a version number:
+
+```sh
+git log --grep="(\d+\.\d+\.\d+\.)" --perl-regexp --oneline --reverse
+```
+
+Then just:
+```
+git tag v0.0.2 abcd1234
+git tag v0.0.3 deadbeef
+```
+
+Usually the initial extraction didn't mention a version number so you can just do that one manually.
+
+4. Push to the new repo
+
+Create a new empty repo on github under the [zed-extensions](https://github.com/zed-extensions) organization.
+
+```
+git remote add origin git@github.com:zed-extensions/ruby
+git push origin main --tags
+```
+
+5. [Optional]

From b739cfa73fe0a682240d01a3bf5ee76ac0862a0d Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 11 Oct 2024 17:24:56 -0400
Subject: [PATCH 616/762] docs: Link environment.md (#19101)

---
 docs/src/SUMMARY.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
index 8d82dad8c9e2e1..4f5491b7bd4a37 100644
--- a/docs/src/SUMMARY.md
+++ b/docs/src/SUMMARY.md
@@ -29,6 +29,7 @@
 - [Git](./git.md)
 - [Tasks](./tasks.md)
 - [Remote Development](./remote-development.md)
+- [Environment Variables](./environment.md)
 - [REPL](./repl.md)
 
 # Assistant

From c709b66f35d7e6d07b2754933bf962aa7d01ecef Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 11 Oct 2024 17:54:10 -0400
Subject: [PATCH 617/762] collab: Don't record billing events if billing is not
 enabled (#19102)

This PR adjusts the billing logic to not write any records to
`billing_events` if:

- The user is staff, as we don't want to bill staff members
- Billing is disabled (we currently enable billing based on the presence
of the Stripe API key)

Release Notes:

- N/A
---
 crates/collab/src/llm.rs                   | 10 +++++++++-
 crates/collab/src/llm/db/queries/usages.rs |  3 ++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index 70a309367c5385..583cfdb7b82ea0 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -639,6 +639,7 @@ where
 impl<S> Drop for TokenCountingStream<S> {
     fn drop(&mut self) {
         let state = self.state.clone();
+        let is_llm_billing_enabled = state.config.is_llm_billing_enabled();
         let claims = self.claims.clone();
         let provider = self.provider;
         let model = std::mem::take(&mut self.model);
@@ -652,7 +653,14 @@ impl<S> Drop for TokenCountingStream<S> {
                     provider,
                     &model,
                     tokens,
-                    claims.has_llm_subscription,
+                    // We're passing `false` here if LLM billing is not enabled
+                    // so that we don't write any records to the
+                    // `billing_events` table until we're ready to bill users.
+                    if is_llm_billing_enabled {
+                        claims.has_llm_subscription
+                    } else {
+                        false
+                    },
                     Cents(claims.max_monthly_spend_in_cents),
                     Utc::now(),
                 )
diff --git a/crates/collab/src/llm/db/queries/usages.rs b/crates/collab/src/llm/db/queries/usages.rs
index c7f8fd163a4272..1e9204b02b21c8 100644
--- a/crates/collab/src/llm/db/queries/usages.rs
+++ b/crates/collab/src/llm/db/queries/usages.rs
@@ -409,7 +409,8 @@ impl LlmDatabase {
                 monthly_usage.output_tokens as usize,
             );
 
-            if spending_this_month > FREE_TIER_MONTHLY_SPENDING_LIMIT
+            if !is_staff
+                && spending_this_month > FREE_TIER_MONTHLY_SPENDING_LIMIT
                 && has_llm_subscription
                 && spending_this_month <= max_monthly_spend
             {

From 22ac178f9d1b8a62b71353bc39b805efb45ac9ee Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Fri, 11 Oct 2024 14:58:58 -0700
Subject: [PATCH 618/762] Restore HTTP client transition, but use reqwest
 everywhere (#19055)

Release Notes:

- N/A
---
 Cargo.lock                                    | 577 ++++++++++++------
 Cargo.toml                                    |  16 +-
 crates/anthropic/Cargo.toml                   |   3 -
 crates/client/Cargo.toml                      |   3 +-
 crates/client/src/client.rs                   |  27 +-
 crates/collab/Cargo.toml                      |   4 +-
 crates/collab/src/llm.rs                      |  11 +-
 crates/collab/src/rpc.rs                      |   6 +-
 crates/evals/Cargo.toml                       |   2 +-
 crates/evals/src/eval.rs                      |   3 +-
 crates/extension/Cargo.toml                   |   3 +-
 crates/extension/src/extension_store_test.rs  |   5 +-
 crates/extension_cli/Cargo.toml               |   4 +-
 crates/extension_cli/src/main.rs              |   9 +-
 crates/gpui/src/app.rs                        |   4 +
 crates/gpui/src/app/test_context.rs           |   2 +-
 crates/http_client/Cargo.toml                 |   4 +-
 crates/http_client/src/http_client.rs         |  56 +-
 crates/isahc_http_client/Cargo.toml           |  22 -
 crates/isahc_http_client/LICENSE-APACHE       |   1 -
 .../src/isahc_http_client.rs                  | 105 ----
 crates/live_kit_server/Cargo.toml             |   2 +-
 crates/reqwest_client/Cargo.toml              |  34 ++
 crates/reqwest_client/LICENSE-GPL             |   1 +
 crates/reqwest_client/examples/client.rs      |  41 ++
 crates/reqwest_client/src/reqwest_client.rs   | 261 ++++++++
 crates/semantic_index/Cargo.toml              |   2 +-
 crates/semantic_index/examples/index.rs       |   5 +-
 crates/sqlez/src/util.rs                      |   6 +-
 crates/storybook/Cargo.toml                   |   2 +-
 crates/storybook/src/storybook.rs             |   8 +-
 crates/util/src/util.rs                       |   2 +-
 crates/vim/Cargo.toml                         |   4 +-
 crates/zed/Cargo.toml                         |   2 +-
 crates/zed/src/main.rs                        |  11 +-
 35 files changed, 834 insertions(+), 414 deletions(-)
 delete mode 100644 crates/isahc_http_client/Cargo.toml
 delete mode 120000 crates/isahc_http_client/LICENSE-APACHE
 delete mode 100644 crates/isahc_http_client/src/isahc_http_client.rs
 create mode 100644 crates/reqwest_client/Cargo.toml
 create mode 120000 crates/reqwest_client/LICENSE-GPL
 create mode 100644 crates/reqwest_client/examples/client.rs
 create mode 100644 crates/reqwest_client/src/reqwest_client.rs

diff --git a/Cargo.lock b/Cargo.lock
index 5f6218cb653550..d9eb21ee26b2f7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -250,7 +250,6 @@ dependencies = [
  "serde_json",
  "strum 0.25.0",
  "thiserror",
- "tokio",
  "util",
 ]
 
@@ -845,8 +844,8 @@ dependencies = [
  "chrono",
  "futures-util",
  "http-types",
- "hyper",
- "hyper-rustls",
+ "hyper 0.14.30",
+ "hyper-rustls 0.24.2",
  "serde",
  "serde_json",
  "serde_path_to_error",
@@ -879,15 +878,14 @@ checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
 
 [[package]]
 name = "async-tls"
-version = "0.12.0"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfeefd0ca297cbbb3bd34fd6b228401c2a5177038257afd751bc29f0a2da4795"
+checksum = "b2ae3c9eba89d472a0e4fe1dea433df78fbbe63d2b764addaf2ba3a6bde89a5e"
 dependencies = [
  "futures-core",
  "futures-io",
- "rustls 0.20.9",
+ "rustls 0.21.12",
  "rustls-pemfile 1.0.4",
- "webpki",
  "webpki-roots 0.22.6",
 ]
 
@@ -904,9 +902,9 @@ dependencies = [
 
 [[package]]
 name = "async-tungstenite"
-version = "0.23.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1e9efbe14612da0a19fb983059a0b621e9cf6225d7018ecab4f9988215540dc"
+checksum = "90e661b6cb0a6eb34d02c520b052daa3aa9ac0cc02495c9d066bbce13ead132b"
 dependencies = [
  "async-std",
  "async-tls",
@@ -914,7 +912,7 @@ dependencies = [
  "futures-util",
  "log",
  "pin-project-lite",
- "tungstenite 0.20.1",
+ "tungstenite 0.24.0",
 ]
 
 [[package]]
@@ -1063,7 +1061,7 @@ dependencies = [
  "fastrand 2.1.1",
  "hex",
  "http 0.2.12",
- "ring 0.17.8",
+ "ring",
  "time",
  "tokio",
  "tracing",
@@ -1232,7 +1230,7 @@ dependencies = [
  "once_cell",
  "p256",
  "percent-encoding",
- "ring 0.17.8",
+ "ring",
  "sha2",
  "subtle",
  "time",
@@ -1335,13 +1333,13 @@ dependencies = [
  "aws-smithy-types",
  "bytes 1.7.1",
  "fastrand 2.1.1",
- "h2",
+ "h2 0.3.26",
  "http 0.2.12",
  "http-body 0.4.6",
  "http-body 1.0.1",
  "httparse",
- "hyper",
- "hyper-rustls",
+ "hyper 0.14.30",
+ "hyper-rustls 0.24.2",
  "once_cell",
  "pin-project-lite",
  "pin-utils",
@@ -1431,7 +1429,7 @@ dependencies = [
  "headers",
  "http 0.2.12",
  "http-body 0.4.6",
- "hyper",
+ "hyper 0.14.30",
  "itoa",
  "matchit",
  "memchr",
@@ -1444,7 +1442,7 @@ dependencies = [
  "serde_path_to_error",
  "serde_urlencoded",
  "sha1",
- "sync_wrapper",
+ "sync_wrapper 0.1.2",
  "tokio",
  "tokio-tungstenite 0.20.1",
  "tower",
@@ -1583,7 +1581,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "shlex",
  "syn 2.0.76",
 ]
@@ -1603,7 +1601,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "shlex",
  "syn 2.0.76",
 ]
@@ -2099,12 +2097,6 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
-[[package]]
-name = "castaway"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2698f953def977c68f935bb0dfa959375ad4638570e969e2f1e9f433cbf1af6"
-
 [[package]]
 name = "cbc"
 version = "0.1.2"
@@ -2362,8 +2354,8 @@ dependencies = [
  "clickhouse-derive",
  "clickhouse-rs-cityhash-sys",
  "futures 0.3.30",
- "hyper",
- "hyper-tls",
+ "hyper 0.14.30",
+ "hyper-tls 0.5.0",
  "lz4",
  "sealed",
  "serde",
@@ -2401,6 +2393,7 @@ dependencies = [
  "anyhow",
  "async-native-tls",
  "async-recursion 0.3.2",
+ "async-tls",
  "async-tungstenite",
  "chrono",
  "clock",
@@ -2418,8 +2411,6 @@ dependencies = [
  "rand 0.8.5",
  "release_channel",
  "rpc",
- "rustls 0.20.9",
- "rustls-native-certs 0.8.0",
  "schemars",
  "serde",
  "serde_json",
@@ -2567,9 +2558,8 @@ dependencies = [
  "headless",
  "hex",
  "http_client",
- "hyper",
+ "hyper 0.14.30",
  "indoc",
- "isahc_http_client",
  "jsonwebtoken",
  "language",
  "language_model",
@@ -2593,7 +2583,8 @@ dependencies = [
  "release_channel",
  "remote",
  "remote_server",
- "reqwest",
+ "reqwest 0.11.27",
+ "reqwest_client",
  "rpc",
  "rustc-demangle",
  "scrypt",
@@ -2677,7 +2668,7 @@ dependencies = [
 name = "collections"
 version = "0.1.0"
 dependencies = [
- "rustc-hash",
+ "rustc-hash 1.1.0",
 ]
 
 [[package]]
@@ -2995,7 +2986,7 @@ dependencies = [
  "log",
  "rangemap",
  "rayon",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "rustybuzz",
  "self_cell",
  "swash",
@@ -3085,7 +3076,7 @@ dependencies = [
  "hashbrown 0.14.5",
  "log",
  "regalloc2",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "smallvec",
  "target-lexicon",
 ]
@@ -3341,36 +3332,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "curl"
-version = "0.4.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e2161dd6eba090ff1594084e95fd67aeccf04382ffea77999ea94ed42ec67b6"
-dependencies = [
- "curl-sys",
- "libc",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "socket2 0.5.7",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "curl-sys"
-version = "0.4.74+curl-8.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8af10b986114528fcdc4b63b6f5f021b7057618411046a4de2ba0f0149a097bf"
-dependencies = [
- "cc",
- "libc",
- "libz-sys",
- "openssl-sys",
- "pkg-config",
- "vcpkg",
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "cursor-icon"
 version = "1.1.0"
@@ -4032,12 +3993,12 @@ dependencies = [
  "git",
  "gpui",
  "http_client",
- "isahc_http_client",
  "language",
  "languages",
  "node_runtime",
  "open_ai",
  "project",
+ "reqwest_client",
  "semantic_index",
  "serde",
  "serde_json",
@@ -4127,7 +4088,6 @@ dependencies = [
  "gpui",
  "http_client",
  "indexed_docs",
- "isahc_http_client",
  "language",
  "log",
  "lsp",
@@ -4136,6 +4096,7 @@ dependencies = [
  "paths",
  "project",
  "release_channel",
+ "reqwest_client",
  "schemars",
  "semantic_version",
  "serde",
@@ -4145,7 +4106,6 @@ dependencies = [
  "snippet_provider",
  "task",
  "theme",
- "tokio",
  "toml 0.8.19",
  "ui",
  "url",
@@ -4167,9 +4127,9 @@ dependencies = [
  "env_logger",
  "extension",
  "fs",
- "isahc_http_client",
  "language",
  "log",
+ "reqwest_client",
  "rpc",
  "serde",
  "serde_json",
@@ -4416,7 +4376,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "nanorand",
- "spin 0.9.8",
+ "spin",
 ]
 
 [[package]]
@@ -5182,6 +5142,25 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "h2"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524e8ac6999421f49a846c2d4411f337e53497d8ec55d67753beffa43c5d9205"
+dependencies = [
+ "atomic-waker",
+ "bytes 1.7.1",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http 1.1.0",
+ "indexmap 2.4.0",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
 [[package]]
 name = "half"
 version = "2.4.1"
@@ -5550,8 +5529,10 @@ dependencies = [
  "anyhow",
  "derive_more",
  "futures 0.3.30",
- "http 0.2.12",
+ "http 1.1.0",
  "log",
+ "rustls 0.21.12",
+ "rustls-native-certs 0.8.0",
  "serde",
  "serde_json",
  "smol",
@@ -5592,7 +5573,7 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2",
+ "h2 0.3.26",
  "http 0.2.12",
  "http-body 0.4.6",
  "httparse",
@@ -5606,6 +5587,26 @@ dependencies = [
  "want",
 ]
 
+[[package]]
+name = "hyper"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50dfd22e0e76d0f662d429a5f80fcaf3855009297eab6a0a9f8543834744ba05"
+dependencies = [
+ "bytes 1.7.1",
+ "futures-channel",
+ "futures-util",
+ "h2 0.4.6",
+ "http 1.1.0",
+ "http-body 1.0.1",
+ "httparse",
+ "itoa",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
 [[package]]
 name = "hyper-rustls"
 version = "0.24.2"
@@ -5614,12 +5615,29 @@ checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
  "futures-util",
  "http 0.2.12",
- "hyper",
+ "hyper 0.14.30",
  "log",
  "rustls 0.21.12",
  "rustls-native-certs 0.6.3",
  "tokio",
- "tokio-rustls",
+ "tokio-rustls 0.24.1",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.27.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08afdbb5c31130e3034af566421053ab03787c640246a446327f550d11bcb333"
+dependencies = [
+ "futures-util",
+ "http 1.1.0",
+ "hyper 1.4.1",
+ "hyper-util",
+ "rustls 0.23.13",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls 0.26.0",
+ "tower-service",
 ]
 
 [[package]]
@@ -5629,12 +5647,47 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
 dependencies = [
  "bytes 1.7.1",
- "hyper",
+ "hyper 0.14.30",
  "native-tls",
  "tokio",
  "tokio-native-tls",
 ]
 
+[[package]]
+name = "hyper-tls"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
+dependencies = [
+ "bytes 1.7.1",
+ "http-body-util",
+ "hyper 1.4.1",
+ "hyper-util",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+ "tower-service",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41296eb09f183ac68eec06e03cdbea2e759633d4067b2f6552fc2e009bcad08b"
+dependencies = [
+ "bytes 1.7.1",
+ "futures-channel",
+ "futures-util",
+ "http 1.1.0",
+ "http-body 1.0.1",
+ "hyper 1.4.1",
+ "pin-project-lite",
+ "socket2 0.5.7",
+ "tokio",
+ "tower-service",
+ "tracing",
+]
+
 [[package]]
 name = "iana-time-zone"
 version = "0.1.60"
@@ -6002,44 +6055,6 @@ version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 
-[[package]]
-name = "isahc"
-version = "1.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "334e04b4d781f436dc315cb1e7515bd96826426345d498149e4bde36b67f8ee9"
-dependencies = [
- "async-channel 1.9.0",
- "castaway",
- "crossbeam-utils",
- "curl",
- "curl-sys",
- "encoding_rs",
- "event-listener 2.5.3",
- "futures-lite 1.13.0",
- "http 0.2.12",
- "log",
- "mime",
- "once_cell",
- "polling 2.8.0",
- "slab",
- "sluice",
- "tracing",
- "tracing-futures",
- "url",
- "waker-fn",
-]
-
-[[package]]
-name = "isahc_http_client"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "futures 0.3.30",
- "http_client",
- "isahc",
- "util",
-]
-
 [[package]]
 name = "itertools"
 version = "0.10.5"
@@ -6144,7 +6159,7 @@ dependencies = [
  "base64 0.21.7",
  "js-sys",
  "pem",
- "ring 0.17.8",
+ "ring",
  "serde",
  "serde_json",
  "simple_asn1",
@@ -6395,7 +6410,7 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 dependencies = [
- "spin 0.9.8",
+ "spin",
 ]
 
 [[package]]
@@ -6590,7 +6605,7 @@ dependencies = [
  "prost",
  "prost-build",
  "prost-types",
- "reqwest",
+ "reqwest 0.12.8",
  "serde",
 ]
 
@@ -7074,7 +7089,7 @@ dependencies = [
  "hexf-parse",
  "indexmap 2.4.0",
  "log",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "spirv",
  "termcolor",
  "thiserror",
@@ -8722,6 +8737,54 @@ dependencies = [
  "zed_actions",
 ]
 
+[[package]]
+name = "quinn"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c7c5fdde3cdae7203427dc4f0a68fe0ed09833edc525a03456b153b79828684"
+dependencies = [
+ "bytes 1.7.1",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash 2.0.0",
+ "rustls 0.23.13",
+ "socket2 0.5.7",
+ "thiserror",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fadfaed2cd7f389d0161bb73eeb07b7b78f8691047a6f3e73caaeae55310a4a6"
+dependencies = [
+ "bytes 1.7.1",
+ "rand 0.8.5",
+ "ring",
+ "rustc-hash 2.0.0",
+ "rustls 0.23.13",
+ "slab",
+ "thiserror",
+ "tinyvec",
+ "tracing",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fe68c2e9e1a1234e218683dbdf9f9dfcb094113c5ac2b938dfcb9bab4c4140b"
+dependencies = [
+ "libc",
+ "once_cell",
+ "socket2 0.5.7",
+ "tracing",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.37"
@@ -8998,7 +9061,7 @@ checksum = "ad156d539c879b7a24a363a2016d77961786e71f48f2e2fc8302a92abd2429a6"
 dependencies = [
  "hashbrown 0.13.2",
  "log",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "slice-group-by",
  "smallvec",
 ]
@@ -9178,11 +9241,11 @@ dependencies = [
  "encoding_rs",
  "futures-core",
  "futures-util",
- "h2",
+ "h2 0.3.26",
  "http 0.2.12",
  "http-body 0.4.6",
- "hyper",
- "hyper-tls",
+ "hyper 0.14.30",
+ "hyper-tls 0.5.0",
  "ipnet",
  "js-sys",
  "log",
@@ -9195,8 +9258,8 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_urlencoded",
- "sync_wrapper",
- "system-configuration",
+ "sync_wrapper 0.1.2",
+ "system-configuration 0.5.1",
  "tokio",
  "tokio-native-tls",
  "tower-service",
@@ -9207,6 +9270,70 @@ dependencies = [
  "winreg 0.50.0",
 ]
 
+[[package]]
+name = "reqwest"
+version = "0.12.8"
+source = "git+https://github.com/zed-industries/reqwest.git?rev=fd110f6998da16bbca97b6dddda9be7827c50e29#fd110f6998da16bbca97b6dddda9be7827c50e29"
+dependencies = [
+ "base64 0.22.1",
+ "bytes 1.7.1",
+ "encoding_rs",
+ "futures-core",
+ "futures-util",
+ "h2 0.4.6",
+ "http 1.1.0",
+ "http-body 1.0.1",
+ "http-body-util",
+ "hyper 1.4.1",
+ "hyper-rustls 0.27.3",
+ "hyper-tls 0.6.0",
+ "hyper-util",
+ "ipnet",
+ "js-sys",
+ "log",
+ "mime",
+ "native-tls",
+ "once_cell",
+ "percent-encoding",
+ "pin-project-lite",
+ "quinn",
+ "rustls 0.23.13",
+ "rustls-pemfile 2.1.3",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper 1.0.1",
+ "system-configuration 0.6.1",
+ "tokio",
+ "tokio-native-tls",
+ "tokio-rustls 0.26.0",
+ "tokio-util",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams",
+ "web-sys",
+ "windows-registry",
+]
+
+[[package]]
+name = "reqwest_client"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "bytes 1.7.1",
+ "futures 0.3.30",
+ "gpui",
+ "http_client",
+ "log",
+ "reqwest 0.12.8",
+ "serde",
+ "smol",
+ "tokio",
+]
+
 [[package]]
 name = "resvg"
 version = "0.41.0"
@@ -9255,21 +9382,6 @@ dependencies = [
  "util",
 ]
 
-[[package]]
-name = "ring"
-version = "0.16.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
-dependencies = [
- "cc",
- "libc",
- "once_cell",
- "spin 0.5.2",
- "untrusted 0.7.1",
- "web-sys",
- "winapi",
-]
-
 [[package]]
 name = "ring"
 version = "0.17.8"
@@ -9280,8 +9392,8 @@ dependencies = [
  "cfg-if",
  "getrandom 0.2.15",
  "libc",
- "spin 0.9.8",
- "untrusted 0.9.0",
+ "spin",
+ "untrusted",
  "windows-sys 0.52.0",
 ]
 
@@ -9437,7 +9549,7 @@ dependencies = [
  "futures 0.3.30",
  "glob",
  "rand 0.8.5",
- "ring 0.17.8",
+ "ring",
  "serde",
  "serde_json",
  "shellexpand 3.1.0",
@@ -9509,6 +9621,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc-hash"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152"
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -9560,26 +9678,28 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.20.9"
+version = "0.21.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b80e3dec595989ea8510028f30c408a4630db12c9cbb8de34203b89d6577e99"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 dependencies = [
  "log",
- "ring 0.16.20",
+ "ring",
+ "rustls-webpki 0.101.7",
  "sct",
- "webpki",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.21.12"
+version = "0.23.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
+checksum = "f2dabaac7466917e566adb06783a81ca48944c6898a1b08b9374106dd671f4c8"
 dependencies = [
- "log",
- "ring 0.17.8",
- "rustls-webpki",
- "sct",
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki 0.102.8",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
@@ -9638,8 +9758,19 @@ version = "0.101.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 dependencies = [
- "ring 0.17.8",
- "untrusted 0.9.0",
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.102.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
 ]
 
 [[package]]
@@ -9753,8 +9884,8 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "ring 0.17.8",
- "untrusted 0.9.0",
+ "ring",
+ "untrusted",
 ]
 
 [[package]]
@@ -9950,7 +10081,6 @@ dependencies = [
  "gpui",
  "heed",
  "http_client",
- "isahc_http_client",
  "language",
  "language_model",
  "languages",
@@ -9958,6 +10088,7 @@ dependencies = [
  "open_ai",
  "parking_lot",
  "project",
+ "reqwest_client",
  "serde",
  "serde_json",
  "settings",
@@ -10400,17 +10531,6 @@ dependencies = [
  "version_check",
 ]
 
-[[package]]
-name = "sluice"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d7400c0eff44aa2fcb5e31a5f24ba9716ed90138769e4977a2ba6014ae63eb5"
-dependencies = [
- "async-channel 1.9.0",
- "futures-core",
- "futures-io",
-]
-
 [[package]]
 name = "smallvec"
 version = "1.13.2"
@@ -10525,12 +10645,6 @@ dependencies = [
  "smallvec",
 ]
 
-[[package]]
-name = "spin"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
-
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -10861,12 +10975,12 @@ dependencies = [
  "fuzzy",
  "gpui",
  "indoc",
- "isahc_http_client",
  "language",
  "log",
  "menu",
  "picker",
  "project",
+ "reqwest_client",
  "rust-embed",
  "settings",
  "simplelog",
@@ -11162,6 +11276,15 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
 
+[[package]]
+name = "sync_wrapper"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394"
+dependencies = [
+ "futures-core",
+]
+
 [[package]]
 name = "synchronoise"
 version = "1.0.1"
@@ -11202,7 +11325,18 @@ checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
 dependencies = [
  "bitflags 1.3.2",
  "core-foundation 0.9.4",
- "system-configuration-sys",
+ "system-configuration-sys 0.5.0",
+]
+
+[[package]]
+name = "system-configuration"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
+dependencies = [
+ "bitflags 2.6.0",
+ "core-foundation 0.9.4",
+ "system-configuration-sys 0.6.0",
 ]
 
 [[package]]
@@ -11215,6 +11349,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "system-configuration-sys"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "system-deps"
 version = "6.2.2"
@@ -11592,7 +11736,7 @@ dependencies = [
  "fancy-regex",
  "lazy_static",
  "parking_lot",
- "rustc-hash",
+ "rustc-hash 1.1.0",
 ]
 
 [[package]]
@@ -11808,6 +11952,17 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "tokio-rustls"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4"
+dependencies = [
+ "rustls 0.23.13",
+ "rustls-pki-types",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-socks"
 version = "0.5.2"
@@ -11857,9 +12012,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.11"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1"
+checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a"
 dependencies = [
  "bytes 1.7.1",
  "futures-core",
@@ -12041,16 +12196,6 @@ dependencies = [
  "valuable",
 ]
 
-[[package]]
-name = "tracing-futures"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
-dependencies = [
- "pin-project",
- "tracing",
-]
-
 [[package]]
 name = "tracing-log"
 version = "0.2.0"
@@ -12357,6 +12502,24 @@ dependencies = [
  "utf-8",
 ]
 
+[[package]]
+name = "tungstenite"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
+dependencies = [
+ "byteorder",
+ "bytes 1.7.1",
+ "data-encoding",
+ "http 1.1.0",
+ "httparse",
+ "log",
+ "rand 0.8.5",
+ "sha1",
+ "thiserror",
+ "utf-8",
+]
+
 [[package]]
 name = "typeid"
 version = "1.0.2"
@@ -12515,12 +12678,6 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
 
-[[package]]
-name = "untrusted"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
-
 [[package]]
 name = "untrusted"
 version = "0.9.0"
@@ -12830,7 +12987,7 @@ dependencies = [
  "futures-util",
  "headers",
  "http 0.2.12",
- "hyper",
+ "hyper 0.14.30",
  "log",
  "mime",
  "mime_guess",
@@ -12966,6 +13123,19 @@ dependencies = [
  "wasmparser 0.201.0",
 ]
 
+[[package]]
+name = "wasm-streams"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b65dc4c90b63b118468cf747d8bf3566c1913ef60be765b5730ead9e0a3ba129"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "wasmparser"
 version = "0.201.0"
@@ -13381,8 +13551,8 @@ version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53"
 dependencies = [
- "ring 0.17.8",
- "untrusted 0.9.0",
+ "ring",
+ "untrusted",
 ]
 
 [[package]]
@@ -13630,6 +13800,17 @@ dependencies = [
  "syn 2.0.76",
 ]
 
+[[package]]
+name = "windows-registry"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e400001bb720a623c1c69032f8e3e4cf09984deec740f007dd2b03ec864804b0"
+dependencies = [
+ "windows-result 0.2.0",
+ "windows-strings",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-result"
 version = "0.1.2"
@@ -14421,7 +14602,6 @@ dependencies = [
  "image_viewer",
  "inline_completion_button",
  "install_cli",
- "isahc_http_client",
  "journal",
  "language",
  "language_model",
@@ -14449,6 +14629,7 @@ dependencies = [
  "release_channel",
  "remote",
  "repl",
+ "reqwest_client",
  "rope",
  "search",
  "serde",
diff --git a/Cargo.toml b/Cargo.toml
index 42f935e66b33bc..f29d8041cc82e6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,7 +52,6 @@ members = [
     "crates/indexed_docs",
     "crates/inline_completion_button",
     "crates/install_cli",
-    "crates/isahc_http_client",
     "crates/journal",
     "crates/language",
     "crates/language_model",
@@ -88,6 +87,7 @@ members = [
     "crates/remote",
     "crates/remote_server",
     "crates/repl",
+    "crates/reqwest_client",
     "crates/rich_text",
     "crates/rope",
     "crates/rpc",
@@ -122,6 +122,7 @@ members = [
     "crates/ui",
     "crates/ui_input",
     "crates/ui_macros",
+    "crates/reqwest_client",
     "crates/util",
     "crates/vcs_menu",
     "crates/vim",
@@ -228,7 +229,6 @@ image_viewer = { path = "crates/image_viewer" }
 indexed_docs = { path = "crates/indexed_docs" }
 inline_completion_button = { path = "crates/inline_completion_button" }
 install_cli = { path = "crates/install_cli" }
-isahc_http_client = { path = "crates/isahc_http_client" }
 journal = { path = "crates/journal" }
 language = { path = "crates/language" }
 language_model = { path = "crates/language_model" }
@@ -265,6 +265,7 @@ release_channel = { path = "crates/release_channel" }
 remote = { path = "crates/remote" }
 remote_server = { path = "crates/remote_server" }
 repl = { path = "crates/repl" }
+reqwest_client = { path = "crates/reqwest_client" }
 rich_text = { path = "crates/rich_text" }
 rope = { path = "crates/rope" }
 rpc = { path = "crates/rpc" }
@@ -326,7 +327,7 @@ async-pipe = { git = "https://github.com/zed-industries/async-pipe-rs", rev = "8
 async-recursion = "1.0.0"
 async-tar = "0.5.0"
 async-trait = "0.1"
-async-tungstenite = "0.23"
+async-tungstenite = "0.28"
 async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
 base64 = "0.22"
@@ -366,10 +367,6 @@ ignore = "0.4.22"
 image = "0.25.1"
 indexmap = { version = "1.6.2", features = ["serde"] }
 indoc = "2"
-# We explicitly disable http2 support in isahc.
-isahc = { version = "1.7.2", default-features = false, features = [
-    "text-decoding",
-] }
 itertools = "0.13.0"
 jsonwebtoken = "9.3"
 libc = "0.2"
@@ -394,13 +391,14 @@ pulldown-cmark = { version = "0.12.0", default-features = false }
 rand = "0.8.5"
 regex = "1.5"
 repair_json = "0.1.0"
+reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29" }
 rsa = "0.9.6"
 runtimelib = { version = "0.15", default-features = false, features = [
     "async-dispatcher-runtime",
 ] }
 rustc-demangle = "0.1.23"
 rust-embed = { version = "8.4", features = ["include-exclude"] }
-rustls = "0.20.3"
+rustls = "0.21.12"
 rustls-native-certs = "0.8.0"
 schemars = { version = "0.8", features = ["impl_json_schema"] }
 semver = "1.0"
@@ -438,7 +436,7 @@ time = { version = "0.3", features = [
 ] }
 tiny_http = "0.8"
 toml = "0.8"
-tokio = { version = "1", features = ["full"] }
+tokio = { version = "1" }
 tower-http = "0.4.4"
 tree-sitter = { version = "0.23", features = ["wasm"] }
 tree-sitter-bash = "0.23"
diff --git a/crates/anthropic/Cargo.toml b/crates/anthropic/Cargo.toml
index ec12932fb74f1e..32ac0fd9884034 100644
--- a/crates/anthropic/Cargo.toml
+++ b/crates/anthropic/Cargo.toml
@@ -26,6 +26,3 @@ serde_json.workspace = true
 strum.workspace = true
 thiserror.workspace = true
 util.workspace = true
-
-[dev-dependencies]
-tokio.workspace = true
diff --git a/crates/client/Cargo.toml b/crates/client/Cargo.toml
index dd420bbbe63184..c3fbea1f98a882 100644
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -18,6 +18,7 @@ test-support = ["clock/test-support", "collections/test-support", "gpui/test-sup
 [dependencies]
 anyhow.workspace = true
 async-recursion = "0.3"
+async-tls = "0.13"
 async-tungstenite = { workspace = true, features = ["async-std", "async-tls"] }
 chrono = { workspace = true, features = ["serde"] }
 clock.workspace = true
@@ -34,8 +35,6 @@ postage.workspace = true
 rand.workspace = true
 release_channel.workspace = true
 rpc = { workspace = true, features = ["gpui"] }
-rustls.workspace = true
-rustls-native-certs.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 7a37b1b40556b8..03d81b117f37e6 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -1023,7 +1023,7 @@ impl Client {
         &self,
         http: Arc<HttpClientWithUrl>,
         release_channel: Option<ReleaseChannel>,
-    ) -> impl Future<Output = Result<Url>> {
+    ) -> impl Future<Output = Result<url::Url>> {
         #[cfg(any(test, feature = "test-support"))]
         let url_override = self.rpc_url.read().clone();
 
@@ -1117,7 +1117,7 @@ impl Client {
             // for us from the RPC URL.
             //
             // Among other things, it will generate and set a `Sec-WebSocket-Key` header for us.
-            let mut request = rpc_url.into_client_request()?;
+            let mut request = IntoClientRequest::into_client_request(rpc_url.as_str())?;
 
             // We then modify the request to add our desired headers.
             let request_headers = request.headers_mut();
@@ -1137,30 +1137,13 @@ impl Client {
 
             match url_scheme {
                 Https => {
-                    let client_config = {
-                        let mut root_store = rustls::RootCertStore::empty();
-
-                        let root_certs = rustls_native_certs::load_native_certs();
-                        for error in root_certs.errors {
-                            log::warn!("error loading native certs: {:?}", error);
-                        }
-                        root_store.add_parsable_certificates(
-                            &root_certs
-                                .certs
-                                .into_iter()
-                                .map(|cert| cert.as_ref().to_owned())
-                                .collect::<Vec<_>>(),
-                        );
-                        rustls::ClientConfig::builder()
-                            .with_safe_defaults()
-                            .with_root_certificates(root_store)
-                            .with_no_client_auth()
-                    };
                     let (stream, _) =
                         async_tungstenite::async_tls::client_async_tls_with_connector(
                             request,
                             stream,
-                            Some(client_config.into()),
+                            Some(async_tls::TlsConnector::from(
+                                http_client::TLS_CONFIG.clone(),
+                            )),
                         )
                         .await?;
                     Ok(Connection::new(
diff --git a/crates/collab/Cargo.toml b/crates/collab/Cargo.toml
index 4513e02af30e18..ad2c0136681936 100644
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -38,7 +38,6 @@ futures.workspace = true
 google_ai.workspace = true
 hex.workspace = true
 http_client.workspace = true
-isahc_http_client.workspace = true
 jsonwebtoken.workspace = true
 live_kit_server.workspace = true
 log.workspace = true
@@ -49,6 +48,7 @@ prometheus = "0.13"
 prost.workspace = true
 rand.workspace = true
 reqwest = { version = "0.11", features = ["json"] }
+reqwest_client.workspace = true
 rpc.workspace = true
 rustc-demangle.workspace = true
 scrypt = "0.11"
@@ -67,7 +67,7 @@ telemetry_events.workspace = true
 text.workspace = true
 thiserror.workspace = true
 time.workspace = true
-tokio.workspace = true
+tokio = { workspace = true, features = ["full"] }
 toml.workspace = true
 tower = "0.4"
 tower-http = { workspace = true, features = ["trace"] }
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index 583cfdb7b82ea0..a94aa5afe94af9 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -23,7 +23,7 @@ use collections::HashMap;
 use db::TokenUsage;
 use db::{usage_measure::UsageMeasure, ActiveUserCount, LlmDatabase};
 use futures::{Stream, StreamExt as _};
-use isahc_http_client::IsahcHttpClient;
+use reqwest_client::ReqwestClient;
 use rpc::{
     proto::Plan, LanguageModelProvider, PerformCompletionParams, EXPIRED_LLM_TOKEN_HEADER_NAME,
 };
@@ -44,7 +44,7 @@ pub struct LlmState {
     pub config: Config,
     pub executor: Executor,
     pub db: Arc<LlmDatabase>,
-    pub http_client: IsahcHttpClient,
+    pub http_client: ReqwestClient,
     pub clickhouse_client: Option<clickhouse::Client>,
     active_user_count_by_model:
         RwLock<HashMap<(LanguageModelProvider, String), (DateTime<Utc>, ActiveUserCount)>>,
@@ -70,11 +70,8 @@ impl LlmState {
         let db = Arc::new(db);
 
         let user_agent = format!("Zed Server/{}", env!("CARGO_PKG_VERSION"));
-        let http_client = IsahcHttpClient::builder()
-            .default_header("User-Agent", user_agent)
-            .build()
-            .map(IsahcHttpClient::from)
-            .context("failed to construct http client")?;
+        let http_client =
+            ReqwestClient::user_agent(&user_agent).context("failed to construct http client")?;
 
         let this = Self {
             executor,
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index e5dafe80d8dc02..05d7726069959f 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -36,8 +36,8 @@ use collections::{HashMap, HashSet};
 pub use connection_pool::{ConnectionPool, ZedVersion};
 use core::fmt::{self, Debug, Formatter};
 use http_client::HttpClient;
-use isahc_http_client::IsahcHttpClient;
 use open_ai::{OpenAiEmbeddingModel, OPEN_AI_API_URL};
+use reqwest_client::ReqwestClient;
 use sha2::Digest;
 use supermaven_api::{CreateExternalUserRequest, SupermavenAdminApi};
 
@@ -961,8 +961,8 @@ impl Server {
             tracing::info!("connection opened");
 
             let user_agent = format!("Zed Server/{}", env!("CARGO_PKG_VERSION"));
-            let http_client = match IsahcHttpClient::builder().default_header("User-Agent", user_agent).build() {
-                Ok(http_client) => Arc::new(IsahcHttpClient::from(http_client)),
+            let http_client = match ReqwestClient::user_agent(&user_agent) {
+                Ok(http_client) => Arc::new(http_client),
                 Err(error) => {
                     tracing::error!(?error, "failed to create HTTP client");
                     return;
diff --git a/crates/evals/Cargo.toml b/crates/evals/Cargo.toml
index b3b3a2f2a80109..3057edcd1a2588 100644
--- a/crates/evals/Cargo.toml
+++ b/crates/evals/Cargo.toml
@@ -25,7 +25,6 @@ fs.workspace = true
 git.workspace = true
 gpui.workspace = true
 http_client.workspace = true
-isahc_http_client.workspace = true
 language.workspace = true
 languages.workspace = true
 node_runtime.workspace = true
@@ -36,3 +35,4 @@ serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
 smol.workspace = true
+reqwest_client.workspace = true
diff --git a/crates/evals/src/eval.rs b/crates/evals/src/eval.rs
index 899d8210537111..2db13ff392a267 100644
--- a/crates/evals/src/eval.rs
+++ b/crates/evals/src/eval.rs
@@ -12,6 +12,7 @@ use language::LanguageRegistry;
 use node_runtime::NodeRuntime;
 use open_ai::OpenAiEmbeddingModel;
 use project::Project;
+use reqwest_client::ReqwestClient;
 use semantic_index::{
     EmbeddingProvider, OpenAiEmbeddingProvider, ProjectIndex, SemanticDb, Status,
 };
@@ -100,7 +101,7 @@ fn main() -> Result<()> {
 
     gpui::App::headless().run(move |cx| {
         let executor = cx.background_executor().clone();
-        let client = isahc_http_client::IsahcHttpClient::new(None, None);
+        let client = Arc::new(ReqwestClient::user_agent("Zed LLM evals").unwrap());
         cx.set_http_client(client.clone());
         match cli.command {
             Commands::Fetch {} => {
diff --git a/crates/extension/Cargo.toml b/crates/extension/Cargo.toml
index f495ef7cdc9920..26b8610e767143 100644
--- a/crates/extension/Cargo.toml
+++ b/crates/extension/Cargo.toml
@@ -56,7 +56,6 @@ wit-component.workspace = true
 workspace.workspace = true
 
 [dev-dependencies]
-isahc_http_client.workspace = true
 ctor.workspace = true
 env_logger.workspace = true
 fs = { workspace = true, features = ["test-support"] }
@@ -64,5 +63,5 @@ gpui = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }
 parking_lot.workspace = true
 project = { workspace = true, features = ["test-support"] }
-tokio.workspace = true
+reqwest_client.workspace = true
 workspace = { workspace = true, features = ["test-support"] }
diff --git a/crates/extension/src/extension_store_test.rs b/crates/extension/src/extension_store_test.rs
index 126e6b2cfbdad0..1274fafc3c9325 100644
--- a/crates/extension/src/extension_store_test.rs
+++ b/crates/extension/src/extension_store_test.rs
@@ -13,12 +13,12 @@ use futures::{io::BufReader, AsyncReadExt, StreamExt};
 use gpui::{Context, SemanticVersion, TestAppContext};
 use http_client::{FakeHttpClient, Response};
 use indexed_docs::IndexedDocsRegistry;
-use isahc_http_client::IsahcHttpClient;
 use language::{LanguageMatcher, LanguageRegistry, LanguageServerBinaryStatus, LanguageServerName};
 use node_runtime::NodeRuntime;
 use parking_lot::Mutex;
 use project::{Project, DEFAULT_COMPLETION_CONTEXT};
 use release_channel::AppVersion;
+use reqwest_client::ReqwestClient;
 use serde_json::json;
 use settings::{Settings as _, SettingsStore};
 use snippet_provider::SnippetRegistry;
@@ -576,7 +576,8 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
             std::env::consts::ARCH
         )
     });
-    let builder_client = IsahcHttpClient::new(None, Some(user_agent));
+    let builder_client =
+        Arc::new(ReqwestClient::user_agent(&user_agent).expect("Could not create HTTP client"));
 
     let extension_store = cx.new_model(|cx| {
         ExtensionStore::new(
diff --git a/crates/extension_cli/Cargo.toml b/crates/extension_cli/Cargo.toml
index bc649d8e04989f..6c7e3bdc62724d 100644
--- a/crates/extension_cli/Cargo.toml
+++ b/crates/extension_cli/Cargo.toml
@@ -18,14 +18,14 @@ clap = { workspace = true, features = ["derive"] }
 env_logger.workspace = true
 extension = { workspace = true, features = ["no-webrtc"] }
 fs.workspace = true
-isahc_http_client.workspace = true
 language.workspace = true
 log.workspace = true
+reqwest_client.workspace = true
 rpc.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 theme.workspace = true
-tokio.workspace = true
+tokio = { workspace = true, features = ["full"] }
 toml.workspace = true
 tree-sitter.workspace = true
 wasmtime.workspace = true
diff --git a/crates/extension_cli/src/main.rs b/crates/extension_cli/src/main.rs
index 6eaebca2f0e9bf..dd6f2213781197 100644
--- a/crates/extension_cli/src/main.rs
+++ b/crates/extension_cli/src/main.rs
@@ -13,8 +13,8 @@ use extension::{
     extension_builder::{CompileExtensionOptions, ExtensionBuilder},
     ExtensionManifest,
 };
-use isahc_http_client::IsahcHttpClient;
 use language::LanguageConfig;
+use reqwest_client::ReqwestClient;
 use theme::ThemeRegistry;
 use tree_sitter::{Language, Query, WasmStore};
 
@@ -66,12 +66,7 @@ async fn main() -> Result<()> {
         std::env::consts::OS,
         std::env::consts::ARCH
     );
-    let http_client = Arc::new(
-        IsahcHttpClient::builder()
-            .default_header("User-Agent", user_agent)
-            .build()
-            .map(IsahcHttpClient::from)?,
-    );
+    let http_client = Arc::new(ReqwestClient::user_agent(&user_agent)?);
 
     let builder = ExtensionBuilder::new(http_client, scratch_dir);
     builder
diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index bba5f857b4f52c..f81a2092d56af6 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -1533,4 +1533,8 @@ impl HttpClient for NullHttpClient {
     fn proxy(&self) -> Option<&http_client::Uri> {
         None
     }
+
+    fn type_name(&self) -> &'static str {
+        type_name::<Self>()
+    }
 }
diff --git a/crates/gpui/src/app/test_context.rs b/crates/gpui/src/app/test_context.rs
index 95f0698855e126..f46cdc8e34b1a6 100644
--- a/crates/gpui/src/app/test_context.rs
+++ b/crates/gpui/src/app/test_context.rs
@@ -431,7 +431,7 @@ impl TestAppContext {
         rx
     }
 
-    /// Retuens a stream of events emitted by the given Model.
+    /// Returns a stream of events emitted by the given Model.
     pub fn events<Evt, T: 'static + EventEmitter<Evt>>(
         &mut self,
         entity: &Model<T>,
diff --git a/crates/http_client/Cargo.toml b/crates/http_client/Cargo.toml
index 0244ac41042b6f..e8585cff9820fd 100644
--- a/crates/http_client/Cargo.toml
+++ b/crates/http_client/Cargo.toml
@@ -16,11 +16,13 @@ path = "src/http_client.rs"
 doctest = true
 
 [dependencies]
-http = "0.2"
 anyhow.workspace = true
 derive_more.workspace = true
 futures.workspace = true
+http = "1.1"
 log.workspace = true
+rustls-native-certs.workspace = true
+rustls.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 smol.workspace = true
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index 2f029a1d236bba..bf1046d88ee820 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -11,13 +11,22 @@ use http::request::Builder;
 #[cfg(feature = "test-support")]
 use std::fmt;
 use std::{
-    sync::{Arc, Mutex},
+    any::type_name,
+    sync::{Arc, LazyLock, Mutex},
     time::Duration,
 };
 pub use url::Url;
 
+#[derive(Clone)]
 pub struct ReadTimeout(pub Duration);
-#[derive(Default, Debug, Clone)]
+impl Default for ReadTimeout {
+    fn default() -> Self {
+        Self(Duration::from_secs(5))
+    }
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Hash)]
+
 pub enum RedirectPolicy {
     #[default]
     NoFollow,
@@ -26,6 +35,23 @@ pub enum RedirectPolicy {
 }
 pub struct FollowRedirects(pub bool);
 
+pub static TLS_CONFIG: LazyLock<Arc<rustls::ClientConfig>> = LazyLock::new(|| {
+    let mut root_store = rustls::RootCertStore::empty();
+
+    let root_certs = rustls_native_certs::load_native_certs();
+    for error in root_certs.errors {
+        log::warn!("error loading native certs: {:?}", error);
+    }
+    root_store.add_parsable_certificates(&root_certs.certs);
+
+    Arc::new(
+        rustls::ClientConfig::builder()
+            .with_safe_defaults()
+            .with_root_certificates(root_store)
+            .with_no_client_auth(),
+    )
+});
+
 pub trait HttpRequestExt {
     /// Set a read timeout on the request.
     /// For isahc, this is the low_speed_timeout.
@@ -47,6 +73,8 @@ impl HttpRequestExt for http::request::Builder {
 }
 
 pub trait HttpClient: 'static + Send + Sync {
+    fn type_name(&self) -> &'static str;
+
     fn send(
         &self,
         req: http::Request<AsyncBody>,
@@ -129,6 +157,10 @@ impl HttpClient for HttpClientWithProxy {
     fn proxy(&self) -> Option<&Uri> {
         self.proxy.as_ref()
     }
+
+    fn type_name(&self) -> &'static str {
+        self.client.type_name()
+    }
 }
 
 impl HttpClient for Arc<HttpClientWithProxy> {
@@ -142,6 +174,10 @@ impl HttpClient for Arc<HttpClientWithProxy> {
     fn proxy(&self) -> Option<&Uri> {
         self.proxy.as_ref()
     }
+
+    fn type_name(&self) -> &'static str {
+        self.client.type_name()
+    }
 }
 
 /// An [`HttpClient`] that has a base URL.
@@ -253,6 +289,10 @@ impl HttpClient for Arc<HttpClientWithUrl> {
     fn proxy(&self) -> Option<&Uri> {
         self.client.proxy.as_ref()
     }
+
+    fn type_name(&self) -> &'static str {
+        self.client.type_name()
+    }
 }
 
 impl HttpClient for HttpClientWithUrl {
@@ -266,6 +306,10 @@ impl HttpClient for HttpClientWithUrl {
     fn proxy(&self) -> Option<&Uri> {
         self.client.proxy.as_ref()
     }
+
+    fn type_name(&self) -> &'static str {
+        self.client.type_name()
+    }
 }
 
 pub fn read_proxy_from_env() -> Option<Uri> {
@@ -306,6 +350,10 @@ impl HttpClient for BlockedHttpClient {
     fn proxy(&self) -> Option<&Uri> {
         None
     }
+
+    fn type_name(&self) -> &'static str {
+        type_name::<Self>()
+    }
 }
 
 #[cfg(feature = "test-support")]
@@ -378,4 +426,8 @@ impl HttpClient for FakeHttpClient {
     fn proxy(&self) -> Option<&Uri> {
         None
     }
+
+    fn type_name(&self) -> &'static str {
+        type_name::<Self>()
+    }
 }
diff --git a/crates/isahc_http_client/Cargo.toml b/crates/isahc_http_client/Cargo.toml
deleted file mode 100644
index 82f7621bf8cace..00000000000000
--- a/crates/isahc_http_client/Cargo.toml
+++ /dev/null
@@ -1,22 +0,0 @@
-[package]
-name = "isahc_http_client"
-version = "0.1.0"
-edition = "2021"
-publish = false
-license = "Apache-2.0"
-
-[lints]
-workspace = true
-
-[features]
-test-support = []
-
-[lib]
-path = "src/isahc_http_client.rs"
-
-[dependencies]
-anyhow.workspace = true
-futures.workspace = true
-http_client.workspace = true
-isahc.workspace = true
-util.workspace = true
diff --git a/crates/isahc_http_client/LICENSE-APACHE b/crates/isahc_http_client/LICENSE-APACHE
deleted file mode 120000
index 1cd601d0a3affa..00000000000000
--- a/crates/isahc_http_client/LICENSE-APACHE
+++ /dev/null
@@ -1 +0,0 @@
-../../LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/isahc_http_client/src/isahc_http_client.rs b/crates/isahc_http_client/src/isahc_http_client.rs
deleted file mode 100644
index 778f6a04598909..00000000000000
--- a/crates/isahc_http_client/src/isahc_http_client.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use std::{mem, sync::Arc, time::Duration};
-
-use futures::future::BoxFuture;
-use util::maybe;
-
-pub use isahc::config::Configurable;
-pub struct IsahcHttpClient(isahc::HttpClient);
-
-pub use http_client::*;
-
-impl IsahcHttpClient {
-    pub fn new(proxy: Option<Uri>, user_agent: Option<String>) -> Arc<IsahcHttpClient> {
-        let mut builder = isahc::HttpClient::builder()
-            .connect_timeout(Duration::from_secs(5))
-            .low_speed_timeout(100, Duration::from_secs(5))
-            .proxy(proxy.clone());
-        if let Some(agent) = user_agent {
-            builder = builder.default_header("User-Agent", agent);
-        }
-        Arc::new(IsahcHttpClient(builder.build().unwrap()))
-    }
-    pub fn builder() -> isahc::HttpClientBuilder {
-        isahc::HttpClientBuilder::new()
-    }
-}
-
-impl From<isahc::HttpClient> for IsahcHttpClient {
-    fn from(client: isahc::HttpClient) -> Self {
-        Self(client)
-    }
-}
-
-impl HttpClient for IsahcHttpClient {
-    fn proxy(&self) -> Option<&Uri> {
-        None
-    }
-
-    fn send(
-        &self,
-        req: http_client::http::Request<http_client::AsyncBody>,
-    ) -> BoxFuture<'static, Result<http_client::Response<http_client::AsyncBody>, anyhow::Error>>
-    {
-        let redirect_policy = req
-            .extensions()
-            .get::<http_client::RedirectPolicy>()
-            .cloned()
-            .unwrap_or_default();
-        let read_timeout = req
-            .extensions()
-            .get::<http_client::ReadTimeout>()
-            .map(|t| t.0);
-        let req = maybe!({
-            let (mut parts, body) = req.into_parts();
-            let mut builder = isahc::Request::builder()
-                .method(parts.method)
-                .uri(parts.uri)
-                .version(parts.version);
-            if let Some(read_timeout) = read_timeout {
-                builder = builder.low_speed_timeout(100, read_timeout);
-            }
-
-            let headers = builder.headers_mut()?;
-            mem::swap(headers, &mut parts.headers);
-
-            let extensions = builder.extensions_mut()?;
-            mem::swap(extensions, &mut parts.extensions);
-
-            let isahc_body = match body.0 {
-                http_client::Inner::Empty => isahc::AsyncBody::empty(),
-                http_client::Inner::AsyncReader(reader) => isahc::AsyncBody::from_reader(reader),
-                http_client::Inner::SyncReader(reader) => {
-                    isahc::AsyncBody::from_bytes_static(reader.into_inner())
-                }
-            };
-
-            builder
-                .redirect_policy(match redirect_policy {
-                    http_client::RedirectPolicy::FollowAll => isahc::config::RedirectPolicy::Follow,
-                    http_client::RedirectPolicy::FollowLimit(limit) => {
-                        isahc::config::RedirectPolicy::Limit(limit)
-                    }
-                    http_client::RedirectPolicy::NoFollow => isahc::config::RedirectPolicy::None,
-                })
-                .body(isahc_body)
-                .ok()
-        });
-
-        let client = self.0.clone();
-
-        Box::pin(async move {
-            match req {
-                Some(req) => client
-                    .send_async(req)
-                    .await
-                    .map_err(Into::into)
-                    .map(|response| {
-                        let (parts, body) = response.into_parts();
-                        let body = http_client::AsyncBody::from_reader(body);
-                        http_client::Response::from_parts(parts, body)
-                    }),
-                None => Err(anyhow::anyhow!("Request was malformed")),
-            }
-        })
-    }
-}
diff --git a/crates/live_kit_server/Cargo.toml b/crates/live_kit_server/Cargo.toml
index bad4c5a05f4754..4b4b5e13dad43b 100644
--- a/crates/live_kit_server/Cargo.toml
+++ b/crates/live_kit_server/Cargo.toml
@@ -20,7 +20,7 @@ jsonwebtoken.workspace = true
 log.workspace = true
 prost.workspace = true
 prost-types.workspace = true
-reqwest = "0.11"
+reqwest.workspace = true
 serde.workspace = true
 
 [build-dependencies]
diff --git a/crates/reqwest_client/Cargo.toml b/crates/reqwest_client/Cargo.toml
new file mode 100644
index 00000000000000..1246aa4eef9540
--- /dev/null
+++ b/crates/reqwest_client/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+name = "reqwest_client"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "Apache-2.0"
+
+[lints]
+workspace = true
+
+[features]
+test-support = []
+
+[lib]
+path = "src/reqwest_client.rs"
+doctest = true
+
+[[example]]
+name = "client"
+path = "examples/client.rs"
+
+[dependencies]
+anyhow.workspace = true
+bytes = "1.0"
+futures.workspace = true
+http_client.workspace = true
+serde.workspace = true
+smol.workspace = true
+log.workspace = true
+tokio = { workspace = true, features = ["rt", "rt-multi-thread"] }
+reqwest = { workspace = true, features = ["rustls-tls-manual-roots", "stream"] }
+
+[dev-dependencies]
+gpui.workspace = true
diff --git a/crates/reqwest_client/LICENSE-GPL b/crates/reqwest_client/LICENSE-GPL
new file mode 120000
index 00000000000000..89e542f750cd38
--- /dev/null
+++ b/crates/reqwest_client/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
\ No newline at end of file
diff --git a/crates/reqwest_client/examples/client.rs b/crates/reqwest_client/examples/client.rs
new file mode 100644
index 00000000000000..d94c4cec5ffaa9
--- /dev/null
+++ b/crates/reqwest_client/examples/client.rs
@@ -0,0 +1,41 @@
+use std::time::Instant;
+
+use futures::stream::FuturesUnordered;
+use futures::AsyncReadExt as _;
+use http_client::AsyncBody;
+use http_client::HttpClient;
+use reqwest_client::ReqwestClient;
+use smol::stream::StreamExt;
+
+fn main() {
+    let app = gpui::App::new();
+    app.run(|cx| {
+        cx.spawn(|cx| async move {
+            let client = ReqwestClient::new();
+            let start = Instant::now();
+            let requests = [
+                client.get("https://www.google.com/", AsyncBody::empty(), true),
+                client.get("https://zed.dev/", AsyncBody::empty(), true),
+                client.get("https://docs.rs/", AsyncBody::empty(), true),
+            ];
+            let mut requests = requests.into_iter().collect::<FuturesUnordered<_>>();
+            while let Some(response) = requests.next().await {
+                let mut body = String::new();
+                response
+                    .unwrap()
+                    .into_body()
+                    .read_to_string(&mut body)
+                    .await
+                    .unwrap();
+                println!("{}", &body.len());
+            }
+            println!("{:?}", start.elapsed());
+
+            cx.update(|cx| {
+                cx.quit();
+            })
+            .ok();
+        })
+        .detach();
+    })
+}
diff --git a/crates/reqwest_client/src/reqwest_client.rs b/crates/reqwest_client/src/reqwest_client.rs
new file mode 100644
index 00000000000000..7b0e66f2a59100
--- /dev/null
+++ b/crates/reqwest_client/src/reqwest_client.rs
@@ -0,0 +1,261 @@
+use std::{any::type_name, borrow::Cow, io::Read, mem, pin::Pin, sync::OnceLock, task::Poll};
+
+use anyhow::anyhow;
+use bytes::{BufMut, Bytes, BytesMut};
+use futures::{AsyncRead, TryStreamExt};
+use http_client::{http, ReadTimeout, RedirectPolicy};
+use reqwest::{
+    header::{HeaderMap, HeaderValue},
+    redirect,
+};
+use smol::future::FutureExt;
+
+const DEFAULT_CAPACITY: usize = 4096;
+
+pub struct ReqwestClient {
+    client: reqwest::Client,
+    proxy: Option<http::Uri>,
+    handle: tokio::runtime::Handle,
+}
+
+impl ReqwestClient {
+    pub fn new() -> Self {
+        reqwest::Client::new().into()
+    }
+
+    pub fn user_agent(agent: &str) -> anyhow::Result<Self> {
+        let mut map = HeaderMap::new();
+        map.insert(http::header::USER_AGENT, HeaderValue::from_str(agent)?);
+        let client = reqwest::Client::builder().default_headers(map).build()?;
+        Ok(client.into())
+    }
+
+    pub fn proxy_and_user_agent(proxy: Option<http::Uri>, agent: &str) -> anyhow::Result<Self> {
+        let mut map = HeaderMap::new();
+        map.insert(http::header::USER_AGENT, HeaderValue::from_str(agent)?);
+        let mut client = reqwest::Client::builder().default_headers(map);
+        if let Some(proxy) = proxy.clone() {
+            client = client.proxy(reqwest::Proxy::all(proxy.to_string())?);
+        }
+        let client = client.build()?;
+        let mut client: ReqwestClient = client.into();
+        client.proxy = proxy;
+        Ok(client)
+    }
+}
+
+static RUNTIME: OnceLock<tokio::runtime::Runtime> = OnceLock::new();
+
+impl From<reqwest::Client> for ReqwestClient {
+    fn from(client: reqwest::Client) -> Self {
+        let handle = tokio::runtime::Handle::try_current().unwrap_or_else(|_| {
+            log::info!("no tokio runtime found, creating one for Reqwest...");
+            let runtime = RUNTIME.get_or_init(|| {
+                tokio::runtime::Builder::new_multi_thread()
+                    // Since we now have two executors, let's try to keep our footprint small
+                    .worker_threads(1)
+                    .enable_all()
+                    .build()
+                    .expect("Failed to initialize HTTP client")
+            });
+
+            runtime.handle().clone()
+        });
+        Self {
+            client,
+            handle,
+            proxy: None,
+        }
+    }
+}
+
+// This struct is essentially a re-implementation of
+// https://docs.rs/tokio-util/0.7.12/tokio_util/io/struct.ReaderStream.html
+// except outside of Tokio's aegis
+struct StreamReader {
+    reader: Option<Pin<Box<dyn futures::AsyncRead + Send + Sync>>>,
+    buf: BytesMut,
+    capacity: usize,
+}
+
+impl StreamReader {
+    fn new(reader: Pin<Box<dyn futures::AsyncRead + Send + Sync>>) -> Self {
+        Self {
+            reader: Some(reader),
+            buf: BytesMut::new(),
+            capacity: DEFAULT_CAPACITY,
+        }
+    }
+}
+
+impl futures::Stream for StreamReader {
+    type Item = std::io::Result<Bytes>;
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        let mut this = self.as_mut();
+
+        let mut reader = match this.reader.take() {
+            Some(r) => r,
+            None => return Poll::Ready(None),
+        };
+
+        if this.buf.capacity() == 0 {
+            let capacity = this.capacity;
+            this.buf.reserve(capacity);
+        }
+
+        match poll_read_buf(&mut reader, cx, &mut this.buf) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(Err(err)) => {
+                self.reader = None;
+
+                Poll::Ready(Some(Err(err)))
+            }
+            Poll::Ready(Ok(0)) => {
+                self.reader = None;
+                Poll::Ready(None)
+            }
+            Poll::Ready(Ok(_)) => {
+                let chunk = this.buf.split();
+                self.reader = Some(reader);
+                Poll::Ready(Some(Ok(chunk.freeze())))
+            }
+        }
+    }
+}
+
+/// Implementation from https://docs.rs/tokio-util/0.7.12/src/tokio_util/util/poll_buf.rs.html
+/// Specialized for this use case
+pub fn poll_read_buf(
+    io: &mut Pin<Box<dyn futures::AsyncRead + Send + Sync>>,
+    cx: &mut std::task::Context<'_>,
+    buf: &mut BytesMut,
+) -> Poll<std::io::Result<usize>> {
+    if !buf.has_remaining_mut() {
+        return Poll::Ready(Ok(0));
+    }
+
+    let n = {
+        let dst = buf.chunk_mut();
+
+        // Safety: `chunk_mut()` returns a `&mut UninitSlice`, and `UninitSlice` is a
+        // transparent wrapper around `[MaybeUninit<u8>]`.
+        let dst = unsafe { &mut *(dst as *mut _ as *mut [std::mem::MaybeUninit<u8>]) };
+        let mut buf = tokio::io::ReadBuf::uninit(dst);
+        let ptr = buf.filled().as_ptr();
+        let unfilled_portion = buf.initialize_unfilled();
+        // SAFETY: Pin projection
+        let io_pin = unsafe { Pin::new_unchecked(io) };
+        std::task::ready!(io_pin.poll_read(cx, unfilled_portion)?);
+
+        // Ensure the pointer does not change from under us
+        assert_eq!(ptr, buf.filled().as_ptr());
+        buf.filled().len()
+    };
+
+    // Safety: This is guaranteed to be the number of initialized (and read)
+    // bytes due to the invariants provided by `ReadBuf::filled`.
+    unsafe {
+        buf.advance_mut(n);
+    }
+
+    Poll::Ready(Ok(n))
+}
+
+struct SyncReader {
+    cursor: Option<std::io::Cursor<Cow<'static, [u8]>>>,
+}
+
+impl SyncReader {
+    fn new(cursor: std::io::Cursor<Cow<'static, [u8]>>) -> Self {
+        Self {
+            cursor: Some(cursor),
+        }
+    }
+}
+
+impl futures::stream::Stream for SyncReader {
+    type Item = Result<Bytes, std::io::Error>;
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        let Some(mut cursor) = self.cursor.take() else {
+            return Poll::Ready(None);
+        };
+
+        let mut buf = Vec::new();
+        match cursor.read_to_end(&mut buf) {
+            Ok(_) => {
+                return Poll::Ready(Some(Ok(Bytes::from(buf))));
+            }
+            Err(e) => return Poll::Ready(Some(Err(e))),
+        }
+    }
+}
+
+impl http_client::HttpClient for ReqwestClient {
+    fn proxy(&self) -> Option<&http::Uri> {
+        self.proxy.as_ref()
+    }
+
+    fn type_name(&self) -> &'static str {
+        type_name::<Self>()
+    }
+
+    fn send(
+        &self,
+        req: http::Request<http_client::AsyncBody>,
+    ) -> futures::future::BoxFuture<
+        'static,
+        Result<http_client::Response<http_client::AsyncBody>, anyhow::Error>,
+    > {
+        let (parts, body) = req.into_parts();
+
+        let mut request = self.client.request(parts.method, parts.uri.to_string());
+        request = request.headers(parts.headers);
+        if let Some(redirect_policy) = parts.extensions.get::<RedirectPolicy>() {
+            request = request.redirect_policy(match redirect_policy {
+                RedirectPolicy::NoFollow => redirect::Policy::none(),
+                RedirectPolicy::FollowLimit(limit) => redirect::Policy::limited(*limit as usize),
+                RedirectPolicy::FollowAll => redirect::Policy::limited(100),
+            });
+        }
+        if let Some(ReadTimeout(timeout)) = parts.extensions.get::<ReadTimeout>() {
+            request = request.timeout(*timeout);
+        }
+        let request = request.body(match body.0 {
+            http_client::Inner::Empty => reqwest::Body::default(),
+            http_client::Inner::SyncReader(cursor) => {
+                reqwest::Body::wrap_stream(SyncReader::new(cursor))
+            }
+            http_client::Inner::AsyncReader(stream) => {
+                reqwest::Body::wrap_stream(StreamReader::new(stream))
+            }
+        });
+
+        let handle = self.handle.clone();
+        async move {
+            let mut response = handle.spawn(async { request.send().await }).await??;
+
+            let headers = mem::take(response.headers_mut());
+            let mut builder = http::Response::builder()
+                .status(response.status().as_u16())
+                .version(response.version());
+            *builder.headers_mut().unwrap() = headers;
+
+            let bytes = response
+                .bytes_stream()
+                .map_err(|e| futures::io::Error::new(futures::io::ErrorKind::Other, e))
+                .into_async_read();
+            let body = http_client::AsyncBody::from_reader(bytes);
+
+            builder.body(body).map_err(|e| anyhow!(e))
+        }
+        .boxed()
+    }
+}
diff --git a/crates/semantic_index/Cargo.toml b/crates/semantic_index/Cargo.toml
index f157cc9b3fc8ef..d6d43f491694f2 100644
--- a/crates/semantic_index/Cargo.toml
+++ b/crates/semantic_index/Cargo.toml
@@ -51,7 +51,6 @@ workspace.workspace = true
 worktree.workspace = true
 
 [dev-dependencies]
-isahc_http_client.workspace = true
 client = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
 fs = { workspace = true, features = ["test-support"] }
@@ -62,6 +61,7 @@ language = { workspace = true, features = ["test-support"] }
 languages.workspace = true
 project = { workspace = true, features = ["test-support"] }
 tempfile.workspace = true
+reqwest_client.workspace = true
 util = { workspace = true, features = ["test-support"] }
 workspace = { workspace = true, features = ["test-support"] }
 worktree = { workspace = true, features = ["test-support"] }
diff --git a/crates/semantic_index/examples/index.rs b/crates/semantic_index/examples/index.rs
index c5c2c633a10603..2efd94cb57e48e 100644
--- a/crates/semantic_index/examples/index.rs
+++ b/crates/semantic_index/examples/index.rs
@@ -2,7 +2,6 @@ use client::Client;
 use futures::channel::oneshot;
 use gpui::App;
 use http_client::HttpClientWithUrl;
-use isahc_http_client::IsahcHttpClient;
 use language::language_settings::AllLanguageSettings;
 use project::Project;
 use semantic_index::{OpenAiEmbeddingModel, OpenAiEmbeddingProvider, SemanticDb};
@@ -29,7 +28,9 @@ fn main() {
         let clock = Arc::new(FakeSystemClock::default());
 
         let http = Arc::new(HttpClientWithUrl::new(
-            IsahcHttpClient::new(None, None),
+            Arc::new(
+                reqwest_client::ReqwestClient::user_agent("Zed semantic index example").unwrap(),
+            ),
             "http://localhost:11434",
             None,
         ));
diff --git a/crates/sqlez/src/util.rs b/crates/sqlez/src/util.rs
index ce0353b15e09f3..8be6d3f4e08e88 100644
--- a/crates/sqlez/src/util.rs
+++ b/crates/sqlez/src/util.rs
@@ -9,14 +9,14 @@ use thread_local::ThreadLocal;
 /// Note: this locks on the cloneable sender, but its done once per thread, so it
 /// shouldn't result in too much contention
 pub struct UnboundedSyncSender<T: Send> {
-    clonable_sender: Mutex<Sender<T>>,
+    cloneable_sender: Mutex<Sender<T>>,
     local_senders: ThreadLocal<Sender<T>>,
 }
 
 impl<T: Send> UnboundedSyncSender<T> {
     pub fn new(sender: Sender<T>) -> Self {
         Self {
-            clonable_sender: Mutex::new(sender),
+            cloneable_sender: Mutex::new(sender),
             local_senders: ThreadLocal::new(),
         }
     }
@@ -27,6 +27,6 @@ impl<T: Send> Deref for UnboundedSyncSender<T> {
 
     fn deref(&self) -> &Self::Target {
         self.local_senders
-            .get_or(|| self.clonable_sender.lock().clone())
+            .get_or(|| self.cloneable_sender.lock().clone())
     }
 }
diff --git a/crates/storybook/Cargo.toml b/crates/storybook/Cargo.toml
index f8e78acad336b0..a27079489bb943 100644
--- a/crates/storybook/Cargo.toml
+++ b/crates/storybook/Cargo.toml
@@ -22,7 +22,6 @@ editor.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
 indoc.workspace = true
-isahc_http_client.workspace = true
 language.workspace = true
 log.workspace = true
 menu.workspace = true
@@ -36,6 +35,7 @@ strum = { workspace = true, features = ["derive"] }
 theme.workspace = true
 title_bar = { workspace = true, features = ["stories"] }
 ui = { workspace = true, features = ["stories"] }
+reqwest_client.workspace = true
 
 [dev-dependencies]
 gpui = { workspace = true, features = ["test-support"] }
diff --git a/crates/storybook/src/storybook.rs b/crates/storybook/src/storybook.rs
index 73b1396da51662..9fe61a70c4d818 100644
--- a/crates/storybook/src/storybook.rs
+++ b/crates/storybook/src/storybook.rs
@@ -4,15 +4,17 @@ mod assets;
 mod stories;
 mod story_selector;
 
+use std::sync::Arc;
+
 use clap::Parser;
 use dialoguer::FuzzySelect;
 use gpui::{
     div, px, size, AnyView, AppContext, Bounds, Render, ViewContext, VisualContext, WindowBounds,
     WindowOptions,
 };
-use isahc_http_client::IsahcHttpClient;
 use log::LevelFilter;
 use project::Project;
+use reqwest_client::ReqwestClient;
 use settings::{KeymapFile, Settings};
 use simplelog::SimpleLogger;
 use strum::IntoEnumIterator;
@@ -66,8 +68,8 @@ fn main() {
     gpui::App::new().with_assets(Assets).run(move |cx| {
         load_embedded_fonts(cx).unwrap();
 
-        let http_client = IsahcHttpClient::new(None, Some("zed_storybook".to_string()));
-        cx.set_http_client(http_client);
+        let http_client = ReqwestClient::user_agent("zed_storybook").unwrap();
+        cx.set_http_client(Arc::new(http_client));
 
         settings::init(cx);
         theme::init(theme::LoadThemes::All(Box::new(Assets)), cx);
diff --git a/crates/util/src/util.rs b/crates/util/src/util.rs
index 50fc070009ebf6..1330c3f749d251 100644
--- a/crates/util/src/util.rs
+++ b/crates/util/src/util.rs
@@ -729,7 +729,7 @@ mod tests {
     }
 
     #[test]
-    fn test_trancate_and_trailoff() {
+    fn test_truncate_and_trailoff() {
         assert_eq!(truncate_and_trailoff("", 5), "");
         assert_eq!(truncate_and_trailoff("èèèèèè", 7), "èèèèèè");
         assert_eq!(truncate_and_trailoff("èèèèèè", 6), "èèèèèè");
diff --git a/crates/vim/Cargo.toml b/crates/vim/Cargo.toml
index 410371cb0c554b..fddb607c1fb73d 100644
--- a/crates/vim/Cargo.toml
+++ b/crates/vim/Cargo.toml
@@ -17,7 +17,7 @@ neovim = ["nvim-rs", "async-compat", "async-trait", "tokio"]
 
 [dependencies]
 anyhow.workspace = true
-async-compat = { version = "0.2.1", "optional" = true }
+async-compat = { workspace = true, "optional" = true }
 async-trait = { workspace = true, "optional" = true }
 collections.workspace = true
 command_palette.workspace = true
@@ -36,7 +36,7 @@ serde.workspace = true
 serde_derive.workspace = true
 serde_json.workspace = true
 settings.workspace = true
-tokio = { version = "1.15", "optional" = true }
+tokio = { version = "1.15", features = ["full"], optional = true }
 ui.workspace = true
 util.workspace = true
 workspace.workspace = true
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index 0ec26ea7cd9fe2..a271019573ca7c 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -57,7 +57,6 @@ http_client.workspace = true
 image_viewer.workspace = true
 inline_completion_button.workspace = true
 install_cli.workspace = true
-isahc_http_client.workspace = true
 journal.workspace = true
 language.workspace = true
 language_model.workspace = true
@@ -108,6 +107,7 @@ theme.workspace = true
 theme_selector.workspace = true
 time.workspace = true
 ui.workspace = true
+reqwest_client.workspace = true
 url.workspace = true
 urlencoding = "2.1.2"
 util.workspace = true
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index cd245dc12c5b4f..6652e235042a0c 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -24,9 +24,9 @@ use gpui::{
     UpdateGlobal as _, VisualContext,
 };
 use http_client::{read_proxy_from_env, Uri};
-use isahc_http_client::IsahcHttpClient;
 use language::LanguageRegistry;
 use log::LevelFilter;
+use reqwest_client::ReqwestClient;
 
 use assets::Assets;
 use node_runtime::{NodeBinaryOptions, NodeRuntime};
@@ -335,9 +335,7 @@ fn main() {
 
     log::info!("========== starting zed ==========");
 
-    let app = App::new()
-        .with_assets(Assets)
-        .with_http_client(IsahcHttpClient::new(None, None));
+    let app = App::new().with_assets(Assets);
 
     let system_id = app.background_executor().block(system_id()).ok();
     let installation_id = app.background_executor().block(installation_id()).ok();
@@ -471,8 +469,9 @@ fn main() {
                     .ok()
             })
             .or_else(read_proxy_from_env);
-        let http = IsahcHttpClient::new(proxy_url, Some(user_agent));
-        cx.set_http_client(http);
+        let http = ReqwestClient::proxy_and_user_agent(proxy_url, &user_agent)
+            .expect("could not start HTTP client");
+        cx.set_http_client(Arc::new(http));
 
         <dyn Fs>::set_global(fs.clone(), cx);
 

From c85a3cc117db760586c2f830e9e8b8a7a7f03a48 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Fri, 11 Oct 2024 18:18:09 -0700
Subject: [PATCH 619/762] Switch from OpenSSL to Rustls (#19104)

This PR also includes a downgrade of our async_tungstenite version to
0.24

Release Notes:

- N/A
---
 Cargo.lock                                  | 148 ++++++++++----------
 Cargo.toml                                  |   6 +-
 crates/client/Cargo.toml                    |   3 +-
 crates/client/src/client.rs                 |  24 +++-
 crates/http_client/Cargo.toml               |   2 -
 crates/http_client/src/http_client.rs       |  19 +--
 crates/reqwest_client/Cargo.toml            |   2 +-
 crates/reqwest_client/src/reqwest_client.rs |  20 ++-
 8 files changed, 118 insertions(+), 106 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d9eb21ee26b2f7..28f38a0d1e22db 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -878,14 +878,15 @@ checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
 
 [[package]]
 name = "async-tls"
-version = "0.13.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ae3c9eba89d472a0e4fe1dea433df78fbbe63d2b764addaf2ba3a6bde89a5e"
+checksum = "cfeefd0ca297cbbb3bd34fd6b228401c2a5177038257afd751bc29f0a2da4795"
 dependencies = [
  "futures-core",
  "futures-io",
- "rustls 0.21.12",
+ "rustls 0.20.9",
  "rustls-pemfile 1.0.4",
+ "webpki",
  "webpki-roots 0.22.6",
 ]
 
@@ -902,9 +903,9 @@ dependencies = [
 
 [[package]]
 name = "async-tungstenite"
-version = "0.28.0"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90e661b6cb0a6eb34d02c520b052daa3aa9ac0cc02495c9d066bbce13ead132b"
+checksum = "3609af4bbf701ddaf1f6bb4e6257dff4ff8932327d0e685d3f653724c258b1ac"
 dependencies = [
  "async-std",
  "async-tls",
@@ -912,7 +913,7 @@ dependencies = [
  "futures-util",
  "log",
  "pin-project-lite",
- "tungstenite 0.24.0",
+ "tungstenite 0.21.0",
 ]
 
 [[package]]
@@ -1061,7 +1062,7 @@ dependencies = [
  "fastrand 2.1.1",
  "hex",
  "http 0.2.12",
- "ring",
+ "ring 0.17.8",
  "time",
  "tokio",
  "tracing",
@@ -1230,7 +1231,7 @@ dependencies = [
  "once_cell",
  "p256",
  "percent-encoding",
- "ring",
+ "ring 0.17.8",
  "sha2",
  "subtle",
  "time",
@@ -1575,7 +1576,7 @@ dependencies = [
  "bitflags 2.6.0",
  "cexpr",
  "clang-sys",
- "itertools 0.10.5",
+ "itertools 0.12.1",
  "lazy_static",
  "lazycell",
  "proc-macro2",
@@ -2355,7 +2356,7 @@ dependencies = [
  "clickhouse-rs-cityhash-sys",
  "futures 0.3.30",
  "hyper 0.14.30",
- "hyper-tls 0.5.0",
+ "hyper-tls",
  "lz4",
  "sealed",
  "serde",
@@ -2393,7 +2394,6 @@ dependencies = [
  "anyhow",
  "async-native-tls",
  "async-recursion 0.3.2",
- "async-tls",
  "async-tungstenite",
  "chrono",
  "clock",
@@ -2411,6 +2411,8 @@ dependencies = [
  "rand 0.8.5",
  "release_channel",
  "rpc",
+ "rustls 0.20.9",
+ "rustls-native-certs 0.8.0",
  "schemars",
  "serde",
  "serde_json",
@@ -4376,7 +4378,7 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "nanorand",
- "spin",
+ "spin 0.9.8",
 ]
 
 [[package]]
@@ -5531,8 +5533,6 @@ dependencies = [
  "futures 0.3.30",
  "http 1.1.0",
  "log",
- "rustls 0.21.12",
- "rustls-native-certs 0.8.0",
  "serde",
  "serde_json",
  "smol",
@@ -5634,6 +5634,7 @@ dependencies = [
  "hyper 1.4.1",
  "hyper-util",
  "rustls 0.23.13",
+ "rustls-native-certs 0.8.0",
  "rustls-pki-types",
  "tokio",
  "tokio-rustls 0.26.0",
@@ -5653,22 +5654,6 @@ dependencies = [
  "tokio-native-tls",
 ]
 
-[[package]]
-name = "hyper-tls"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
-dependencies = [
- "bytes 1.7.1",
- "http-body-util",
- "hyper 1.4.1",
- "hyper-util",
- "native-tls",
- "tokio",
- "tokio-native-tls",
- "tower-service",
-]
-
 [[package]]
 name = "hyper-util"
 version = "0.1.9"
@@ -6159,7 +6144,7 @@ dependencies = [
  "base64 0.21.7",
  "js-sys",
  "pem",
- "ring",
+ "ring 0.17.8",
  "serde",
  "serde_json",
  "simple_asn1",
@@ -6410,7 +6395,7 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 dependencies = [
- "spin",
+ "spin 0.9.8",
 ]
 
 [[package]]
@@ -6477,7 +6462,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
  "cfg-if",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -8763,7 +8748,7 @@ checksum = "fadfaed2cd7f389d0161bb73eeb07b7b78f8691047a6f3e73caaeae55310a4a6"
 dependencies = [
  "bytes 1.7.1",
  "rand 0.8.5",
- "ring",
+ "ring 0.17.8",
  "rustc-hash 2.0.0",
  "rustls 0.23.13",
  "slab",
@@ -9245,7 +9230,7 @@ dependencies = [
  "http 0.2.12",
  "http-body 0.4.6",
  "hyper 0.14.30",
- "hyper-tls 0.5.0",
+ "hyper-tls",
  "ipnet",
  "js-sys",
  "log",
@@ -9286,18 +9271,17 @@ dependencies = [
  "http-body-util",
  "hyper 1.4.1",
  "hyper-rustls 0.27.3",
- "hyper-tls 0.6.0",
  "hyper-util",
  "ipnet",
  "js-sys",
  "log",
  "mime",
- "native-tls",
  "once_cell",
  "percent-encoding",
  "pin-project-lite",
  "quinn",
  "rustls 0.23.13",
+ "rustls-native-certs 0.8.0",
  "rustls-pemfile 2.1.3",
  "rustls-pki-types",
  "serde",
@@ -9306,7 +9290,6 @@ dependencies = [
  "sync_wrapper 1.0.1",
  "system-configuration 0.6.1",
  "tokio",
- "tokio-native-tls",
  "tokio-rustls 0.26.0",
  "tokio-util",
  "tower-service",
@@ -9382,6 +9365,21 @@ dependencies = [
  "util",
 ]
 
+[[package]]
+name = "ring"
+version = "0.16.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+dependencies = [
+ "cc",
+ "libc",
+ "once_cell",
+ "spin 0.5.2",
+ "untrusted 0.7.1",
+ "web-sys",
+ "winapi",
+]
+
 [[package]]
 name = "ring"
 version = "0.17.8"
@@ -9392,8 +9390,8 @@ dependencies = [
  "cfg-if",
  "getrandom 0.2.15",
  "libc",
- "spin",
- "untrusted",
+ "spin 0.9.8",
+ "untrusted 0.9.0",
  "windows-sys 0.52.0",
 ]
 
@@ -9549,7 +9547,7 @@ dependencies = [
  "futures 0.3.30",
  "glob",
  "rand 0.8.5",
- "ring",
+ "ring 0.17.8",
  "serde",
  "serde_json",
  "shellexpand 3.1.0",
@@ -9676,6 +9674,18 @@ dependencies = [
  "rustix 0.38.35",
 ]
 
+[[package]]
+name = "rustls"
+version = "0.20.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b80e3dec595989ea8510028f30c408a4630db12c9cbb8de34203b89d6577e99"
+dependencies = [
+ "log",
+ "ring 0.16.20",
+ "sct",
+ "webpki",
+]
+
 [[package]]
 name = "rustls"
 version = "0.21.12"
@@ -9683,7 +9693,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
 dependencies = [
  "log",
- "ring",
+ "ring 0.17.8",
  "rustls-webpki 0.101.7",
  "sct",
 ]
@@ -9695,7 +9705,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2dabaac7466917e566adb06783a81ca48944c6898a1b08b9374106dd671f4c8"
 dependencies = [
  "once_cell",
- "ring",
+ "ring 0.17.8",
  "rustls-pki-types",
  "rustls-webpki 0.102.8",
  "subtle",
@@ -9758,8 +9768,8 @@ version = "0.101.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.8",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -9768,9 +9778,9 @@ version = "0.102.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
 dependencies = [
- "ring",
+ "ring 0.17.8",
  "rustls-pki-types",
- "untrusted",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -9884,8 +9894,8 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.8",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -10645,6 +10655,12 @@ dependencies = [
  "smallvec",
 ]
 
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -12502,24 +12518,6 @@ dependencies = [
  "utf-8",
 ]
 
-[[package]]
-name = "tungstenite"
-version = "0.24.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
-dependencies = [
- "byteorder",
- "bytes 1.7.1",
- "data-encoding",
- "http 1.1.0",
- "httparse",
- "log",
- "rand 0.8.5",
- "sha1",
- "thiserror",
- "utf-8",
-]
-
 [[package]]
 name = "typeid"
 version = "1.0.2"
@@ -12678,6 +12676,12 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
 
+[[package]]
+name = "untrusted"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+
 [[package]]
 name = "untrusted"
 version = "0.9.0"
@@ -13125,9 +13129,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-streams"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b65dc4c90b63b118468cf747d8bf3566c1913ef60be765b5730ead9e0a3ba129"
+checksum = "4e072d4e72f700fb3443d8fe94a39315df013eef1104903cdb0a2abd322bbecd"
 dependencies = [
  "futures-util",
  "js-sys",
@@ -13551,8 +13555,8 @@ version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.8",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -13700,7 +13704,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index f29d8041cc82e6..ac66fe369fa5c3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -327,7 +327,7 @@ async-pipe = { git = "https://github.com/zed-industries/async-pipe-rs", rev = "8
 async-recursion = "1.0.0"
 async-tar = "0.5.0"
 async-trait = "0.1"
-async-tungstenite = "0.28"
+async-tungstenite = "0.24"
 async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
 base64 = "0.22"
@@ -391,14 +391,14 @@ pulldown-cmark = { version = "0.12.0", default-features = false }
 rand = "0.8.5"
 regex = "1.5"
 repair_json = "0.1.0"
-reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29" }
+reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29", default-features = false, features = ["charset", "http2", "macos-system-configuration", "rustls-tls-native-roots", "stream"]}
 rsa = "0.9.6"
 runtimelib = { version = "0.15", default-features = false, features = [
     "async-dispatcher-runtime",
 ] }
 rustc-demangle = "0.1.23"
 rust-embed = { version = "8.4", features = ["include-exclude"] }
-rustls = "0.21.12"
+rustls = "0.20.3"
 rustls-native-certs = "0.8.0"
 schemars = { version = "0.8", features = ["impl_json_schema"] }
 semver = "1.0"
diff --git a/crates/client/Cargo.toml b/crates/client/Cargo.toml
index c3fbea1f98a882..80e9a17ba8e421 100644
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -18,7 +18,6 @@ test-support = ["clock/test-support", "collections/test-support", "gpui/test-sup
 [dependencies]
 anyhow.workspace = true
 async-recursion = "0.3"
-async-tls = "0.13"
 async-tungstenite = { workspace = true, features = ["async-std", "async-tls"] }
 chrono = { workspace = true, features = ["serde"] }
 clock.workspace = true
@@ -35,6 +34,8 @@ postage.workspace = true
 rand.workspace = true
 release_channel.workspace = true
 rpc = { workspace = true, features = ["gpui"] }
+rustls-native-certs.workspace = true
+rustls.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 03d81b117f37e6..49f3ff4b146f4b 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -1137,13 +1137,31 @@ impl Client {
 
             match url_scheme {
                 Https => {
+                    let client_config = {
+                        let mut root_store = rustls::RootCertStore::empty();
+
+                        let root_certs = rustls_native_certs::load_native_certs();
+                        for error in root_certs.errors {
+                            log::warn!("error loading native certs: {:?}", error);
+                        }
+                        root_store.add_parsable_certificates(
+                            &root_certs
+                                .certs
+                                .into_iter()
+                                .map(|cert| cert.as_ref().to_owned())
+                                .collect::<Vec<_>>(),
+                        );
+                        rustls::ClientConfig::builder()
+                            .with_safe_defaults()
+                            .with_root_certificates(root_store)
+                            .with_no_client_auth()
+                    };
+
                     let (stream, _) =
                         async_tungstenite::async_tls::client_async_tls_with_connector(
                             request,
                             stream,
-                            Some(async_tls::TlsConnector::from(
-                                http_client::TLS_CONFIG.clone(),
-                            )),
+                            Some(client_config.into()),
                         )
                         .await?;
                     Ok(Connection::new(
diff --git a/crates/http_client/Cargo.toml b/crates/http_client/Cargo.toml
index e8585cff9820fd..2156f4d37a9d08 100644
--- a/crates/http_client/Cargo.toml
+++ b/crates/http_client/Cargo.toml
@@ -21,8 +21,6 @@ derive_more.workspace = true
 futures.workspace = true
 http = "1.1"
 log.workspace = true
-rustls-native-certs.workspace = true
-rustls.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 smol.workspace = true
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index bf1046d88ee820..fb2a2a3cf9a9d0 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -12,7 +12,7 @@ use http::request::Builder;
 use std::fmt;
 use std::{
     any::type_name,
-    sync::{Arc, LazyLock, Mutex},
+    sync::{Arc, Mutex},
     time::Duration,
 };
 pub use url::Url;
@@ -35,23 +35,6 @@ pub enum RedirectPolicy {
 }
 pub struct FollowRedirects(pub bool);
 
-pub static TLS_CONFIG: LazyLock<Arc<rustls::ClientConfig>> = LazyLock::new(|| {
-    let mut root_store = rustls::RootCertStore::empty();
-
-    let root_certs = rustls_native_certs::load_native_certs();
-    for error in root_certs.errors {
-        log::warn!("error loading native certs: {:?}", error);
-    }
-    root_store.add_parsable_certificates(&root_certs.certs);
-
-    Arc::new(
-        rustls::ClientConfig::builder()
-            .with_safe_defaults()
-            .with_root_certificates(root_store)
-            .with_no_client_auth(),
-    )
-});
-
 pub trait HttpRequestExt {
     /// Set a read timeout on the request.
     /// For isahc, this is the low_speed_timeout.
diff --git a/crates/reqwest_client/Cargo.toml b/crates/reqwest_client/Cargo.toml
index 1246aa4eef9540..08a57ff4d7d937 100644
--- a/crates/reqwest_client/Cargo.toml
+++ b/crates/reqwest_client/Cargo.toml
@@ -28,7 +28,7 @@ serde.workspace = true
 smol.workspace = true
 log.workspace = true
 tokio = { workspace = true, features = ["rt", "rt-multi-thread"] }
-reqwest = { workspace = true, features = ["rustls-tls-manual-roots", "stream"] }
+reqwest.workspace = true
 
 [dev-dependencies]
 gpui.workspace = true
diff --git a/crates/reqwest_client/src/reqwest_client.rs b/crates/reqwest_client/src/reqwest_client.rs
index 7b0e66f2a59100..67df21be3c3ba1 100644
--- a/crates/reqwest_client/src/reqwest_client.rs
+++ b/crates/reqwest_client/src/reqwest_client.rs
@@ -2,7 +2,7 @@ use std::{any::type_name, borrow::Cow, io::Read, mem, pin::Pin, sync::OnceLock,
 
 use anyhow::anyhow;
 use bytes::{BufMut, Bytes, BytesMut};
-use futures::{AsyncRead, TryStreamExt};
+use futures::{AsyncRead, TryStreamExt as _};
 use http_client::{http, ReadTimeout, RedirectPolicy};
 use reqwest::{
     header::{HeaderMap, HeaderValue},
@@ -11,6 +11,7 @@ use reqwest::{
 use smol::future::FutureExt;
 
 const DEFAULT_CAPACITY: usize = 4096;
+static RUNTIME: OnceLock<tokio::runtime::Runtime> = OnceLock::new();
 
 pub struct ReqwestClient {
     client: reqwest::Client,
@@ -20,20 +21,29 @@ pub struct ReqwestClient {
 
 impl ReqwestClient {
     pub fn new() -> Self {
-        reqwest::Client::new().into()
+        reqwest::Client::builder()
+            .use_rustls_tls()
+            .build()
+            .expect("Failed to initialize HTTP client")
+            .into()
     }
 
     pub fn user_agent(agent: &str) -> anyhow::Result<Self> {
         let mut map = HeaderMap::new();
         map.insert(http::header::USER_AGENT, HeaderValue::from_str(agent)?);
-        let client = reqwest::Client::builder().default_headers(map).build()?;
+        let client = reqwest::Client::builder()
+            .default_headers(map)
+            .use_rustls_tls()
+            .build()?;
         Ok(client.into())
     }
 
     pub fn proxy_and_user_agent(proxy: Option<http::Uri>, agent: &str) -> anyhow::Result<Self> {
         let mut map = HeaderMap::new();
         map.insert(http::header::USER_AGENT, HeaderValue::from_str(agent)?);
-        let mut client = reqwest::Client::builder().default_headers(map);
+        let mut client = reqwest::Client::builder()
+            .use_rustls_tls()
+            .default_headers(map);
         if let Some(proxy) = proxy.clone() {
             client = client.proxy(reqwest::Proxy::all(proxy.to_string())?);
         }
@@ -44,8 +54,6 @@ impl ReqwestClient {
     }
 }
 
-static RUNTIME: OnceLock<tokio::runtime::Runtime> = OnceLock::new();
-
 impl From<reqwest::Client> for ReqwestClient {
     fn from(client: reqwest::Client) -> Self {
         let handle = tokio::runtime::Handle::try_current().unwrap_or_else(|_| {

From 9e14fd915f0c1ce7901e8d4db09afa1020395637 Mon Sep 17 00:00:00 2001
From: Lorenzo Cinque <lore.cinque@gmail.com>
Date: Sat, 12 Oct 2024 18:18:33 +0100
Subject: [PATCH 620/762] docs: Fix missing parenthesis in the Terminal: Detect
 Virtual Environments section of configuring-zed.md (#19127)

Release Notes:

- N/A
---
 docs/src/configuring-zed.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index ce5a6a97aca35e..1dca3bb4978660 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -1763,7 +1763,7 @@ See Buffer Font Features
 
 ```json
 {
-  "terminal":
+  "terminal": {
     "detect_venv": {
       "on": {
         // Default directories to search for virtual environments, relative
@@ -1782,7 +1782,7 @@ Disable with:
 
 ```json
 {
-  "terminal":
+  "terminal": {
     "detect_venv": "off"
   }
 }

From b2e844f2ecd66efbf54e1b899d6e8647b8d5795a Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Sat, 12 Oct 2024 13:32:08 -0700
Subject: [PATCH 621/762] Fix an issue with using non-reusable body types with
 redirects (#19134)

Closes #19131
Closes #19039

fixes the broken auto-updater.

I had the bright idea of using streams as the most common unit of data
transfer. Unfortunately, streams are not re-usable. So HTTP redirects
that have a stream body (like our remote server and auto update
downloads), don't redirect, as they can't reuse the stream. This PR
fixes the problem and simplifies the AsyncBody implementation now that
we're not using Isahc.

Release Notes:

- N/A
---
 Cargo.lock                                    |  2 +-
 Cargo.toml                                    |  1 +
 crates/http_client/Cargo.toml                 |  2 +-
 crates/http_client/src/async_body.rs          | 57 +++++++++++--------
 crates/http_client/src/http_client.rs         |  3 +-
 crates/project/src/worktree_store.rs          |  3 +
 crates/recent_projects/src/ssh_connections.rs | 17 +++++-
 crates/reqwest_client/Cargo.toml              |  2 +-
 crates/reqwest_client/src/reqwest_client.rs   | 39 +------------
 9 files changed, 59 insertions(+), 67 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 28f38a0d1e22db..0055b1133f0232 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5529,13 +5529,13 @@ name = "http_client"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "bytes 1.7.1",
  "derive_more",
  "futures 0.3.30",
  "http 1.1.0",
  "log",
  "serde",
  "serde_json",
- "smol",
  "url",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index ac66fe369fa5c3..c6f7f95cc4ed7c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -336,6 +336,7 @@ blade-graphics = { git = "https://github.com/kvark/blade", rev = "e142a3a5e678eb
 blade-macros = { git = "https://github.com/kvark/blade", rev = "e142a3a5e678eb6a13e642ad8401b1f3aa38e969" }
 blade-util = { git = "https://github.com/kvark/blade", rev = "e142a3a5e678eb6a13e642ad8401b1f3aa38e969" }
 blake3 = "1.5.3"
+bytes = "1.0"
 cargo_metadata = "0.18"
 cargo_toml = "0.20"
 chrono = { version = "0.4", features = ["serde"] }
diff --git a/crates/http_client/Cargo.toml b/crates/http_client/Cargo.toml
index 2156f4d37a9d08..ac8e254b84f60d 100644
--- a/crates/http_client/Cargo.toml
+++ b/crates/http_client/Cargo.toml
@@ -16,6 +16,7 @@ path = "src/http_client.rs"
 doctest = true
 
 [dependencies]
+bytes.workspace = true
 anyhow.workspace = true
 derive_more.workspace = true
 futures.workspace = true
@@ -23,5 +24,4 @@ http = "1.1"
 log.workspace = true
 serde.workspace = true
 serde_json.workspace = true
-smol.workspace = true
 url.workspace = true
diff --git a/crates/http_client/src/async_body.rs b/crates/http_client/src/async_body.rs
index e2544f60fe5404..6e3bfe4d3cb5ca 100644
--- a/crates/http_client/src/async_body.rs
+++ b/crates/http_client/src/async_body.rs
@@ -1,6 +1,11 @@
-use std::{borrow::Cow, io::Read, pin::Pin, task::Poll};
+use std::{
+    io::{Cursor, Read},
+    pin::Pin,
+    task::Poll,
+};
 
-use futures::{AsyncRead, AsyncReadExt};
+use bytes::Bytes;
+use futures::AsyncRead;
 
 /// Based on the implementation of AsyncBody in
 /// https://github.com/sagebind/isahc/blob/5c533f1ef4d6bdf1fd291b5103c22110f41d0bf0/src/body/mod.rs
@@ -11,7 +16,7 @@ pub enum Inner {
     Empty,
 
     /// A body stored in memory.
-    SyncReader(std::io::Cursor<Cow<'static, [u8]>>),
+    Bytes(std::io::Cursor<Bytes>),
 
     /// An asynchronous reader.
     AsyncReader(Pin<Box<dyn futures::AsyncRead + Send + Sync>>),
@@ -32,6 +37,10 @@ impl AsyncBody {
     {
         Self(Inner::AsyncReader(Box::pin(read)))
     }
+
+    pub fn from_bytes(bytes: Bytes) -> Self {
+        Self(Inner::Bytes(Cursor::new(bytes.clone())))
+    }
 }
 
 impl Default for AsyncBody {
@@ -46,27 +55,35 @@ impl From<()> for AsyncBody {
     }
 }
 
-impl From<Vec<u8>> for AsyncBody {
-    fn from(body: Vec<u8>) -> Self {
-        Self(Inner::SyncReader(std::io::Cursor::new(Cow::Owned(body))))
+impl From<Bytes> for AsyncBody {
+    fn from(bytes: Bytes) -> Self {
+        Self::from_bytes(bytes)
     }
 }
 
-impl From<&'_ [u8]> for AsyncBody {
-    fn from(body: &[u8]) -> Self {
-        body.to_vec().into()
+impl From<Vec<u8>> for AsyncBody {
+    fn from(body: Vec<u8>) -> Self {
+        Self::from_bytes(body.into())
     }
 }
 
 impl From<String> for AsyncBody {
     fn from(body: String) -> Self {
-        body.into_bytes().into()
+        Self::from_bytes(body.into())
     }
 }
 
-impl From<&'_ str> for AsyncBody {
-    fn from(body: &str) -> Self {
-        body.as_bytes().into()
+impl From<&'static [u8]> for AsyncBody {
+    #[inline]
+    fn from(s: &'static [u8]) -> Self {
+        Self::from_bytes(Bytes::from_static(s))
+    }
+}
+
+impl From<&'static str> for AsyncBody {
+    #[inline]
+    fn from(s: &'static str) -> Self {
+        Self::from_bytes(Bytes::from_static(s.as_bytes()))
     }
 }
 
@@ -74,17 +91,7 @@ impl<T: Into<Self>> From<Option<T>> for AsyncBody {
     fn from(body: Option<T>) -> Self {
         match body {
             Some(body) => body.into(),
-            None => Self(Inner::Empty),
-        }
-    }
-}
-
-impl std::io::Read for AsyncBody {
-    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-        match &mut self.0 {
-            Inner::Empty => Ok(0),
-            Inner::SyncReader(cursor) => cursor.read(buf),
-            Inner::AsyncReader(async_reader) => smol::block_on(async_reader.read(buf)),
+            None => Self::empty(),
         }
     }
 }
@@ -100,7 +107,7 @@ impl futures::AsyncRead for AsyncBody {
         match inner {
             Inner::Empty => Poll::Ready(Ok(0)),
             // Blocking call is over an in-memory buffer
-            Inner::SyncReader(cursor) => Poll::Ready(cursor.read(buf)),
+            Inner::Bytes(cursor) => Poll::Ready(cursor.read(buf)),
             Inner::AsyncReader(async_reader) => {
                 AsyncRead::poll_read(async_reader.as_mut(), cx, buf)
             }
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index fb2a2a3cf9a9d0..3d4a41f4a61df1 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -17,8 +17,9 @@ use std::{
 };
 pub use url::Url;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct ReadTimeout(pub Duration);
+
 impl Default for ReadTimeout {
     fn default() -> Self {
         Self(Duration::from_secs(5))
diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 66fe14969676eb..6e04a884b91877 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -231,6 +231,9 @@ impl WorktreeStore {
         if abs_path.starts_with("/~") {
             abs_path = abs_path[1..].to_string();
         }
+        if abs_path.is_empty() {
+            abs_path = "~/".to_string();
+        }
         let root_name = PathBuf::from(abs_path.clone())
             .file_name()
             .unwrap()
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index af651333398099..0e33c6d36a73c9 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -515,9 +515,24 @@ pub async fn open_ssh_project(
 
     let did_open_ssh_project = cx
         .update(|cx| {
-            workspace::open_ssh_project(window, connection_options, delegate, app_state, paths, cx)
+            workspace::open_ssh_project(
+                window,
+                connection_options,
+                delegate.clone(),
+                app_state,
+                paths,
+                cx,
+            )
         })?
         .await;
 
+    let did_open_ssh_project = match did_open_ssh_project {
+        Ok(ok) => Ok(ok),
+        Err(e) => {
+            delegate.update_error(e.to_string(), cx);
+            Err(e)
+        }
+    };
+
     did_open_ssh_project
 }
diff --git a/crates/reqwest_client/Cargo.toml b/crates/reqwest_client/Cargo.toml
index 08a57ff4d7d937..ccf7dc35e23d14 100644
--- a/crates/reqwest_client/Cargo.toml
+++ b/crates/reqwest_client/Cargo.toml
@@ -21,7 +21,7 @@ path = "examples/client.rs"
 
 [dependencies]
 anyhow.workspace = true
-bytes = "1.0"
+bytes.workspace = true
 futures.workspace = true
 http_client.workspace = true
 serde.workspace = true
diff --git a/crates/reqwest_client/src/reqwest_client.rs b/crates/reqwest_client/src/reqwest_client.rs
index 67df21be3c3ba1..ade115bcd0a596 100644
--- a/crates/reqwest_client/src/reqwest_client.rs
+++ b/crates/reqwest_client/src/reqwest_client.rs
@@ -1,4 +1,4 @@
-use std::{any::type_name, borrow::Cow, io::Read, mem, pin::Pin, sync::OnceLock, task::Poll};
+use std::{any::type_name, mem, pin::Pin, sync::OnceLock, task::Poll};
 
 use anyhow::anyhow;
 use bytes::{BufMut, Bytes, BytesMut};
@@ -173,39 +173,6 @@ pub fn poll_read_buf(
     Poll::Ready(Ok(n))
 }
 
-struct SyncReader {
-    cursor: Option<std::io::Cursor<Cow<'static, [u8]>>>,
-}
-
-impl SyncReader {
-    fn new(cursor: std::io::Cursor<Cow<'static, [u8]>>) -> Self {
-        Self {
-            cursor: Some(cursor),
-        }
-    }
-}
-
-impl futures::stream::Stream for SyncReader {
-    type Item = Result<Bytes, std::io::Error>;
-
-    fn poll_next(
-        mut self: std::pin::Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Option<Self::Item>> {
-        let Some(mut cursor) = self.cursor.take() else {
-            return Poll::Ready(None);
-        };
-
-        let mut buf = Vec::new();
-        match cursor.read_to_end(&mut buf) {
-            Ok(_) => {
-                return Poll::Ready(Some(Ok(Bytes::from(buf))));
-            }
-            Err(e) => return Poll::Ready(Some(Err(e))),
-        }
-    }
-}
-
 impl http_client::HttpClient for ReqwestClient {
     fn proxy(&self) -> Option<&http::Uri> {
         self.proxy.as_ref()
@@ -238,9 +205,7 @@ impl http_client::HttpClient for ReqwestClient {
         }
         let request = request.body(match body.0 {
             http_client::Inner::Empty => reqwest::Body::default(),
-            http_client::Inner::SyncReader(cursor) => {
-                reqwest::Body::wrap_stream(SyncReader::new(cursor))
-            }
+            http_client::Inner::Bytes(cursor) => cursor.into_inner().into(),
             http_client::Inner::AsyncReader(stream) => {
                 reqwest::Body::wrap_stream(StreamReader::new(stream))
             }

From f73a076a636972a3b12802378642860b74b08a89 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Sat, 12 Oct 2024 14:54:06 -0700
Subject: [PATCH 622/762] Update Rust crate bytes to v1.7.2 (#18656)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [bytes](https://redirect.github.com/tokio-rs/bytes) |
workspace.dependencies | patch | `1.7.1` -> `1.7.2` |

---

### Release Notes

<details>
<summary>tokio-rs/bytes (bytes)</summary>

###
[`v1.7.2`](https://redirect.github.com/tokio-rs/bytes/blob/HEAD/CHANGELOG.md#172-September-17-2024)

[Compare
Source](https://redirect.github.com/tokio-rs/bytes/compare/v1.7.1...v1.7.2)

##### Fixed

- Fix default impl of `Buf::{get_int, get_int_le}`
([#&#8203;732](https://redirect.github.com/tokio-rs/bytes/issues/732))

##### Documented

- Fix double spaces in comments and doc comments
([#&#8203;731](https://redirect.github.com/tokio-rs/bytes/issues/731))

##### Internal changes

- Ensure BytesMut::advance reduces capacity
([#&#8203;728](https://redirect.github.com/tokio-rs/bytes/issues/728))

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC45Ny4wIiwidXBkYXRlZEluVmVyIjoiMzguMTE1LjEiLCJ0YXJnZXRCcmFuY2giOiJtYWluIiwibGFiZWxzIjpbXX0=-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 110 ++++++++++++++++++++++++++---------------------------
 1 file changed, 55 insertions(+), 55 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0055b1133f0232..9f8a1615aa5362 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -944,7 +944,7 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a860072022177f903e59730004fb5dc13db9275b79bb2aef7ba8ce831956c233"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-sink",
  "futures-util",
  "memchr",
@@ -1058,7 +1058,7 @@ dependencies = [
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "aws-types",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "fastrand 2.1.1",
  "hex",
  "http 0.2.12",
@@ -1097,7 +1097,7 @@ dependencies = [
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "aws-types",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "fastrand 2.1.1",
  "http 0.2.12",
  "http-body 0.4.6",
@@ -1128,7 +1128,7 @@ dependencies = [
  "aws-smithy-types",
  "aws-smithy-xml",
  "aws-types",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "fastrand 2.1.1",
  "hex",
  "hmac",
@@ -1158,7 +1158,7 @@ dependencies = [
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "aws-types",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "http 0.2.12",
  "once_cell",
  "regex-lite",
@@ -1180,7 +1180,7 @@ dependencies = [
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "aws-types",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "http 0.2.12",
  "once_cell",
  "regex-lite",
@@ -1221,7 +1221,7 @@ dependencies = [
  "aws-smithy-http",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "crypto-bigint 0.5.5",
  "form_urlencoded",
  "hex",
@@ -1258,7 +1258,7 @@ checksum = "598b1689d001c4d4dc3cb386adb07d37786783aee3ac4b324bcadac116bf3d23"
 dependencies = [
  "aws-smithy-http",
  "aws-smithy-types",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "crc32c",
  "crc32fast",
  "hex",
@@ -1278,7 +1278,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6363078f927f612b970edf9d1903ef5cef9a64d1e8423525ebb1f0a1633c858"
 dependencies = [
  "aws-smithy-types",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "crc32fast",
 ]
 
@@ -1291,7 +1291,7 @@ dependencies = [
  "aws-smithy-eventstream",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "bytes-utils",
  "futures-core",
  "http 0.2.12",
@@ -1332,7 +1332,7 @@ dependencies = [
  "aws-smithy-http",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "fastrand 2.1.1",
  "h2 0.3.26",
  "http 0.2.12",
@@ -1357,7 +1357,7 @@ checksum = "e086682a53d3aa241192aa110fa8dfce98f2f5ac2ead0de84d41582c7e8fdb96"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-types",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "http 0.2.12",
  "http 1.1.0",
  "pin-project-lite",
@@ -1373,7 +1373,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "273dcdfd762fae3e1650b8024624e7cd50e484e37abdab73a7a706188ad34543"
 dependencies = [
  "base64-simd",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "bytes-utils",
  "futures-core",
  "http 0.2.12",
@@ -1425,7 +1425,7 @@ dependencies = [
  "axum-core",
  "base64 0.21.7",
  "bitflags 1.3.2",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-util",
  "headers",
  "http 0.2.12",
@@ -1458,7 +1458,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "759fa577a247914fd3f7f76d62972792636412fbfd634cd452f6a385a74d2d2c"
 dependencies = [
  "async-trait",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-util",
  "http 0.2.12",
  "http-body 0.4.6",
@@ -1475,7 +1475,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9a320103719de37b7b4da4c8eb629d4573f6bcfd3dfe80d3208806895ccf81d"
 dependencies = [
  "axum",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-util",
  "http 0.2.12",
  "mime",
@@ -1909,9 +1909,9 @@ dependencies = [
 
 [[package]]
 name = "bytes"
-version = "1.7.1"
+version = "1.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50"
+checksum = "428d9aa8fbc0670b7b8d6030a7fadd0f86151cae55e4dbbece15f3780a3dfaf3"
 
 [[package]]
 name = "bytes-utils"
@@ -1919,7 +1919,7 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7dafe3a8757b027e2be6e4e5601ed563c55989fcf1546e933c66c8eb3a058d35"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "either",
 ]
 
@@ -2351,7 +2351,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0875e527e299fc5f4faba42870bf199a39ab0bb2dbba1b8aef0a2151451130f"
 dependencies = [
  "bstr",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "clickhouse-derive",
  "clickhouse-rs-cityhash-sys",
  "futures 0.3.30",
@@ -2691,7 +2691,7 @@ version = "4.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "memchr",
 ]
 
@@ -5131,7 +5131,7 @@ version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "fnv",
  "futures-core",
  "futures-sink",
@@ -5151,7 +5151,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "524e8ac6999421f49a846c2d4411f337e53497d8ec55d67753beffa43c5d9205"
 dependencies = [
  "atomic-waker",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "fnv",
  "futures-core",
  "futures-sink",
@@ -5246,7 +5246,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06683b93020a07e3dbcf5f8c0f6d40080d725bea7936fc01ad345c01b97dc270"
 dependencies = [
  "base64 0.21.7",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "headers-core",
  "http 0.2.12",
  "httpdate",
@@ -5447,7 +5447,7 @@ version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "fnv",
  "itoa",
 ]
@@ -5458,7 +5458,7 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "fnv",
  "itoa",
 ]
@@ -5469,7 +5469,7 @@ version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "http 0.2.12",
  "pin-project-lite",
 ]
@@ -5480,7 +5480,7 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "http 1.1.0",
 ]
 
@@ -5490,7 +5490,7 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-util",
  "http 1.1.0",
  "http-body 1.0.1",
@@ -5569,7 +5569,7 @@ version = "0.14.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a152ddd61dfaec7273fe8419ab357f33aee0d914c5f4efbf0d96fa749eea5ec9"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-channel",
  "futures-core",
  "futures-util",
@@ -5593,7 +5593,7 @@ version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "50dfd22e0e76d0f662d429a5f80fcaf3855009297eab6a0a9f8543834744ba05"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-channel",
  "futures-util",
  "h2 0.4.6",
@@ -5647,7 +5647,7 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "hyper 0.14.30",
  "native-tls",
  "tokio",
@@ -5660,7 +5660,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41296eb09f183ac68eec06e03cdbea2e759633d4067b2f6552fc2e009bcad08b"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-channel",
  "futures-util",
  "http 1.1.0",
@@ -8550,7 +8550,7 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "444879275cb4fd84958b1a1d5420d15e6fcf7c235fe47f053c9c2a80aceb6001"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "prost-derive",
 ]
 
@@ -8560,7 +8560,7 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "62941722fb675d463659e49c4f3fe1fe792ff24fe5bbaa9c08cd3b98a1c354f5"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "heck 0.3.3",
  "itertools 0.10.5",
  "lazy_static",
@@ -8593,7 +8593,7 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "534b7a0e836e3c482d2693070f982e39e7611da9695d4d1f5a4b186b51faef0a"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "prost",
 ]
 
@@ -8728,7 +8728,7 @@ version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8c7c5fdde3cdae7203427dc4f0a68fe0ed09833edc525a03456b153b79828684"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "pin-project-lite",
  "quinn-proto",
  "quinn-udp",
@@ -8746,7 +8746,7 @@ version = "0.11.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fadfaed2cd7f389d0161bb73eeb07b7b78f8691047a6f3e73caaeae55310a4a6"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "rand 0.8.5",
  "ring 0.17.8",
  "rustc-hash 2.0.0",
@@ -9222,7 +9222,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
 dependencies = [
  "base64 0.21.7",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "encoding_rs",
  "futures-core",
  "futures-util",
@@ -9261,7 +9261,7 @@ version = "0.12.8"
 source = "git+https://github.com/zed-industries/reqwest.git?rev=fd110f6998da16bbca97b6dddda9be7827c50e29#fd110f6998da16bbca97b6dddda9be7827c50e29"
 dependencies = [
  "base64 0.22.1",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "encoding_rs",
  "futures-core",
  "futures-util",
@@ -9306,7 +9306,7 @@ name = "reqwest_client"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures 0.3.30",
  "gpui",
  "http_client",
@@ -9403,7 +9403,7 @@ checksum = "9008cd6385b9e161d8229e1f6549dd23c3d022f132a2ea37ac3a10ac4935779b"
 dependencies = [
  "bitvec",
  "bytecheck",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "hashbrown 0.12.3",
  "ptr_meta",
  "rend",
@@ -9540,7 +9540,7 @@ dependencies = [
  "async-dispatcher",
  "async-std",
  "base64 0.22.1",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "chrono",
  "data-encoding",
  "dirs 5.0.1",
@@ -9599,7 +9599,7 @@ checksum = "b082d80e3e3cc52b2ed634388d436fe1f4de6af5786cc2de9ba9737527bdf555"
 dependencies = [
  "arrayvec",
  "borsh",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "num-traits",
  "rand 0.8.5",
  "rkyv",
@@ -10763,7 +10763,7 @@ dependencies = [
  "atoi",
  "bigdecimal",
  "byteorder",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "chrono",
  "crc",
  "crossbeam-queue",
@@ -10851,7 +10851,7 @@ dependencies = [
  "bigdecimal",
  "bitflags 2.6.0",
  "byteorder",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "chrono",
  "crc",
  "digest",
@@ -11915,7 +11915,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2b070231665d27ad9ec9b8df639893f46727666c6767db40317fbe920a5d998"
 dependencies = [
  "backtrace",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "libc",
  "mio 1.0.2",
  "parking_lot",
@@ -12032,7 +12032,7 @@ version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-core",
  "futures-io",
  "futures-sink",
@@ -12137,7 +12137,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f873044bf02dd1e8239e9c1293ea39dad76dc594ec16185d0a1bf31d8dc8d858"
 dependencies = [
  "bitflags 1.3.2",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-core",
  "futures-util",
  "http 0.2.12",
@@ -12155,7 +12155,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61c5bb1d698276a2443e5ecfabc1008bf15a36c12e6a7176e7bf089ea9131140"
 dependencies = [
  "bitflags 2.6.0",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-core",
  "futures-util",
  "http 0.2.12",
@@ -12487,7 +12487,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e3dac10fd62eaf6617d3a904ae222845979aec67c615d1c842b4002c7666fb9"
 dependencies = [
  "byteorder",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "data-encoding",
  "http 0.2.12",
  "httparse",
@@ -12506,7 +12506,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1"
 dependencies = [
  "byteorder",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "data-encoding",
  "http 1.1.0",
  "httparse",
@@ -12986,7 +12986,7 @@ version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4378d202ff965b011c64817db11d5829506d3404edeadb61f190d111da3f231c"
 dependencies = [
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "futures-channel",
  "futures-util",
  "headers",
@@ -13394,7 +13394,7 @@ dependencies = [
  "anyhow",
  "async-trait",
  "bitflags 2.6.0",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "cap-fs-ext",
  "cap-net-ext",
  "cap-rand",
@@ -14955,7 +14955,7 @@ dependencies = [
  "async-std",
  "async-trait",
  "asynchronous-codec",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "crossbeam-queue",
  "dashmap 5.5.3",
  "futures-channel",

From bebe24ea77eda338eb0f73b4eca9dcc3a047d2bd Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Sat, 12 Oct 2024 23:23:56 -0700
Subject: [PATCH 623/762] Add remote server cross compilation (#19136)

This will allow us to compile debug builds of the remote-server for a
different architecture than the one we are developing on.

This also adds a CI step for building our remote server with minimal
dependencies.

Release Notes:

- N/A
---
 .github/workflows/ci.yml                      |  31 +++-
 Cargo.lock                                    |   1 +
 Cargo.toml                                    |   3 +-
 Cross.toml                                    |   2 +
 Dockerfile-cross                              |  17 ++
 Dockerfile-cross.dockerignore                 |  16 ++
 crates/auto_update/src/auto_update.rs         |   1 +
 crates/gpui/Cargo.toml                        | 109 +++++++++----
 crates/gpui/src/platform.rs                   |  93 ++++++++++-
 .../gpui/src/platform/blade/blade_renderer.rs |   2 +-
 crates/gpui/src/platform/linux.rs             |   8 +
 crates/gpui/src/platform/linux/platform.rs    | 150 +++++++++---------
 crates/gpui/src/platform/linux/wayland.rs     |  32 ++++
 crates/gpui/src/platform/linux/x11/client.rs  |   2 +
 .../src/platform/linux/xdg_desktop_portal.rs  |   2 +
 crates/gpui/src/platform/mac.rs               |  11 +-
 crates/gpui/src/platform/mac/platform.rs      |  19 ++-
 crates/gpui/src/scene.rs                      |  20 +++
 crates/recent_projects/src/ssh_connections.rs | 138 ++++++++++++----
 crates/remote/src/ssh_session.rs              |  14 ++
 crates/rpc/Cargo.toml                         |   5 +-
 crates/zed/Cargo.toml                         |   6 +-
 script/remote-server                          |  17 ++
 23 files changed, 540 insertions(+), 159 deletions(-)
 create mode 100644 Cross.toml
 create mode 100644 Dockerfile-cross
 create mode 100644 Dockerfile-cross.dockerignore
 create mode 100755 script/remote-server

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f322d44cca9685..4222d64437d3ef 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -99,7 +99,10 @@ jobs:
         run: cargo build -p collab
 
       - name: Build other binaries and features
-        run: cargo build --workspace --bins --all-features; cargo check -p gpui --features "macos-blade"
+        run: |
+          cargo build --workspace --bins --all-features
+          cargo check -p gpui --features "macos-blade"
+          cargo build -p remote_server
 
   linux_tests:
     timeout-minutes: 60
@@ -133,6 +136,32 @@ jobs:
       - name: Build Zed
         run: cargo build -p zed
 
+  build_remote_server:
+    timeout-minutes: 60
+    name: (Linux) Build Remote Server
+    runs-on:
+      - buildjet-16vcpu-ubuntu-2204
+    steps:
+      - name: Add Rust to the PATH
+        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+
+      - name: Checkout repo
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
+        with:
+          clean: false
+
+      - name: Cache dependencies
+        uses: swatinem/rust-cache@23bce251a8cd2ffc3c1075eaa2367cf899916d84 # v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-provider: "buildjet"
+
+      - name: Install Clang & Mold
+        run: ./script/remote-server && ./script/install-mold 2.34.0
+
+      - name: Build Remote Server
+        run: cargo build -p remote_server
+
   # todo(windows): Actually run the tests
   windows_tests:
     timeout-minutes: 60
diff --git a/Cargo.lock b/Cargo.lock
index 9f8a1615aa5362..93ba1988fca3fe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14669,6 +14669,7 @@ dependencies = [
  "winresource",
  "workspace",
  "zed_actions",
+ "zstd",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index c6f7f95cc4ed7c..47cd3f915f69ad 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -220,7 +220,7 @@ git = { path = "crates/git" }
 git_hosting_providers = { path = "crates/git_hosting_providers" }
 go_to_line = { path = "crates/go_to_line" }
 google_ai = { path = "crates/google_ai" }
-gpui = { path = "crates/gpui" }
+gpui = { path = "crates/gpui", default-features = false, features = ["http_client"]}
 gpui_macros = { path = "crates/gpui_macros" }
 headless = { path = "crates/headless" }
 html_to_markdown = { path = "crates/html_to_markdown" }
@@ -477,6 +477,7 @@ wasmtime = { version = "24", default-features = false, features = [
 wasmtime-wasi = "24"
 which = "6.0.0"
 wit-component = "0.201"
+zstd = "0.11"
 
 [workspace.dependencies.async-stripe]
 git = "https://github.com/zed-industries/async-stripe"
diff --git a/Cross.toml b/Cross.toml
new file mode 100644
index 00000000000000..b5f0f1103af2ba
--- /dev/null
+++ b/Cross.toml
@@ -0,0 +1,2 @@
+[build]
+dockerfile = "Dockerfile-cross"
diff --git a/Dockerfile-cross b/Dockerfile-cross
new file mode 100644
index 00000000000000..488309641caed5
--- /dev/null
+++ b/Dockerfile-cross
@@ -0,0 +1,17 @@
+# syntax=docker/dockerfile:1
+
+ARG CROSS_BASE_IMAGE
+FROM ${CROSS_BASE_IMAGE}
+WORKDIR /app
+ARG TZ=Etc/UTC \
+    LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    DEBIAN_FRONTEND=noninteractive
+ENV CARGO_TERM_COLOR=always
+
+COPY script/install-mold script/
+RUN ./script/install-mold "2.34.0"
+COPY script/remote-server script/
+RUN ./script/remote-server
+
+COPY . .
diff --git a/Dockerfile-cross.dockerignore b/Dockerfile-cross.dockerignore
new file mode 100644
index 00000000000000..337b4d42623c48
--- /dev/null
+++ b/Dockerfile-cross.dockerignore
@@ -0,0 +1,16 @@
+.git
+.github
+**/.gitignore
+**/.gitkeep
+.gitattributes
+.mailmap
+**/target
+zed.xcworkspace
+.DS_Store
+compose.yml
+plugins/bin
+script/node_modules
+styles/node_modules
+crates/collab/static/styles.css
+vendor/bin
+assets/themes/
diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index 2c93ee4171c8b8..bb952990fccc87 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -464,6 +464,7 @@ impl AutoUpdater {
         smol::fs::create_dir_all(&platform_dir).await.ok();
 
         let client = this.read_with(cx, |this, _| this.http_client.clone())?;
+
         if smol::fs::metadata(&version_path).await.is_err() {
             log::info!("downloading zed-remote-server {os} {arch}");
             download_remote_server_binary(&version_path, release, client, cx).await?;
diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml
index 56a419d2de6419..8e982da85598b9 100644
--- a/crates/gpui/Cargo.toml
+++ b/crates/gpui/Cargo.toml
@@ -11,16 +11,53 @@ license = "Apache-2.0"
 workspace = true
 
 [features]
-default = ["http_client"]
+default = ["http_client", "font-kit", "wayland", "x11"]
 test-support = [
     "backtrace",
     "collections/test-support",
     "rand",
     "util/test-support",
     "http_client?/test-support",
+    "wayland",
+    "x11",
 ]
 runtime_shaders = []
 macos-blade = ["blade-graphics", "blade-macros", "blade-util", "bytemuck"]
+wayland = [
+    "blade-graphics",
+    "blade-macros",
+    "blade-util",
+    "bytemuck",
+    "ashpd",
+    "cosmic-text",
+    "font-kit",
+    "calloop-wayland-source",
+    "wayland-backend",
+    "wayland-client",
+    "wayland-cursor",
+    "wayland-protocols",
+    "wayland-protocols-plasma",
+    "filedescriptor",
+    "xkbcommon",
+    "open",
+]
+x11 = [
+    "blade-graphics",
+    "blade-macros",
+    "blade-util",
+    "bytemuck",
+    "ashpd",
+    "cosmic-text",
+    "font-kit",
+    "as-raw-xcb-connection",
+    "x11rb",
+    "xkbcommon",
+    "xim",
+    "x11-clipboard",
+    "filedescriptor",
+    "open",
+]
+
 
 [lib]
 path = "src/gpui.rs"
@@ -95,7 +132,7 @@ core-foundation.workspace = true
 core-foundation-sys = "0.8"
 core-graphics = "0.23"
 core-text = "20.1"
-font-kit = { git = "https://github.com/zed-industries/font-kit", rev = "40391b7" }
+font-kit = { git = "https://github.com/zed-industries/font-kit", rev = "40391b7", optional = true}
 foreign-types = "0.5"
 log.workspace = true
 media.workspace = true
@@ -105,31 +142,45 @@ objc = "0.2"
 [target.'cfg(any(target_os = "linux", target_os = "macos"))'.dependencies]
 pathfinder_geometry = "0.5"
 
-[target.'cfg(any(target_os = "linux", target_os = "windows"))'.dependencies]
-blade-graphics.workspace = true
-blade-macros.workspace = true
-blade-util.workspace = true
-bytemuck = "1"
+[target.'cfg(target_os = "linux")'.dependencies]
+# Always used
 flume = "0.11"
+oo7 = "0.3.0"
 
-[target.'cfg(target_os = "linux")'.dependencies]
-as-raw-xcb-connection = "1"
-ashpd.workspace = true
-calloop = "0.13.0"
-calloop-wayland-source = "0.3.0"
-cosmic-text = { git = "https://github.com/pop-os/cosmic-text", rev = "542b20c" }
-wayland-backend = { version = "0.3.3", features = ["client_system", "dlopen"] }
-wayland-client = { version = "0.31.2" }
-wayland-cursor = "0.31.1"
+# Used in both windowing options
+ashpd = { workspace = true, optional = true }
+blade-graphics = { workspace = true, optional = true }
+blade-macros = { workspace = true, optional = true }
+blade-util = { workspace = true, optional = true }
+bytemuck = { version = "1", optional = true }
+cosmic-text = { git = "https://github.com/pop-os/cosmic-text", rev = "542b20c", optional = true }
+font-kit = { git = "https://github.com/zed-industries/font-kit", rev = "40391b7", features = [
+    "source-fontconfig-dlopen",
+], optional = true }
+calloop = { version = "0.13.0" }
+filedescriptor = { version = "0.8.2", optional = true }
+open = { version = "5.2.0", optional = true }
+
+# Wayland
+calloop-wayland-source = { version = "0.3.0", optional = true }
+wayland-backend = { version = "0.3.3", features = [
+    "client_system",
+    "dlopen",
+], optional = true }
+wayland-client = { version = "0.31.2", optional = true }
+wayland-cursor = { version = "0.31.1", optional = true }
 wayland-protocols = { version = "0.31.2", features = [
     "client",
     "staging",
     "unstable",
-] }
-wayland-protocols-plasma = { version = "0.2.0", features = ["client"] }
-oo7 = "0.3.0"
-open = "5.2.0"
-filedescriptor = "0.8.2"
+], optional = true }
+wayland-protocols-plasma = { version = "0.2.0", features = [
+    "client",
+], optional = true }
+
+
+# X11
+as-raw-xcb-connection = { version = "1", optional = true }
 x11rb = { version = "0.13.0", features = [
     "allow-unsafe-code",
     "xkb",
@@ -138,21 +189,23 @@ x11rb = { version = "0.13.0", features = [
     "cursor",
     "resource_manager",
     "sync",
-] }
+], optional = true }
 xkbcommon = { git = "https://github.com/ConradIrwin/xkbcommon-rs", rev = "fcbb4612185cc129ceeff51d22f7fb51810a03b2", features = [
     "wayland",
     "x11",
-] }
+], optional = true }
 xim = { git = "https://github.com/XDeme1/xim-rs", rev = "d50d461764c2213655cd9cf65a0ea94c70d3c4fd", features = [
     "x11rb-xcb",
     "x11rb-client",
-] }
-font-kit = { git = "https://github.com/zed-industries/font-kit", rev = "40391b7", features = [
-    "source-fontconfig-dlopen",
-] }
-x11-clipboard = "0.9.2"
+], optional = true }
+x11-clipboard = { version = "0.9.2", optional = true }
 
 [target.'cfg(windows)'.dependencies]
+blade-util.workspace = true
+bytemuck = "1"
+blade-graphics.workspace = true
+blade-macros.workspace = true
+flume = "0.11"
 rand.workspace = true
 windows.workspace = true
 windows-core = "0.58"
diff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rs
index b5d6ae312783fe..42441c029e7f8e 100644
--- a/crates/gpui/src/platform.rs
+++ b/crates/gpui/src/platform.rs
@@ -10,7 +10,11 @@ mod linux;
 #[cfg(target_os = "macos")]
 mod mac;
 
-#[cfg(any(target_os = "linux", target_os = "windows", feature = "macos-blade"))]
+#[cfg(any(
+    all(target_os = "linux", any(feature = "x11", feature = "wayland")),
+    target_os = "windows",
+    feature = "macos-blade"
+))]
 mod blade;
 
 #[cfg(any(test, feature = "test-support"))]
@@ -26,7 +30,7 @@ use crate::{
     RenderGlyphParams, RenderImage, RenderImageParams, RenderSvgParams, ScaledPixels, Scene,
     SharedString, Size, SvgSize, Task, TaskLabel, WindowContext, DEFAULT_WINDOW_SIZE,
 };
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use async_task::Runnable;
 use futures::channel::oneshot;
 use image::codecs::gif::GifDecoder;
@@ -75,8 +79,12 @@ pub(crate) fn current_platform(headless: bool) -> Rc<dyn Platform> {
     }
 
     match guess_compositor() {
+        #[cfg(feature = "wayland")]
         "Wayland" => Rc::new(WaylandClient::new()),
+
+        #[cfg(feature = "x11")]
         "X11" => Rc::new(X11Client::new()),
+
         "Headless" => Rc::new(HeadlessClient::new()),
         _ => unreachable!(),
     }
@@ -90,8 +98,16 @@ pub fn guess_compositor() -> &'static str {
     if std::env::var_os("ZED_HEADLESS").is_some() {
         return "Headless";
     }
+
+    #[cfg(feature = "wayland")]
     let wayland_display = std::env::var_os("WAYLAND_DISPLAY");
+    #[cfg(not(feature = "wayland"))]
+    let wayland_display: Option<std::ffi::OsString> = None;
+
+    #[cfg(feature = "x11")]
     let x11_display = std::env::var_os("DISPLAY");
+    #[cfg(not(feature = "x11"))]
+    let x11_display: Option<std::ffi::OsString> = None;
 
     let use_wayland = wayland_display.is_some_and(|display| !display.is_empty());
     let use_x11 = x11_display.is_some_and(|display| !display.is_empty());
@@ -426,6 +442,61 @@ pub(crate) trait PlatformTextSystem: Send + Sync {
     fn layout_line(&self, text: &str, font_size: Pixels, runs: &[FontRun]) -> LineLayout;
 }
 
+pub(crate) struct NoopTextSystem;
+
+impl NoopTextSystem {
+    #[allow(dead_code)]
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl PlatformTextSystem for NoopTextSystem {
+    fn add_fonts(&self, _fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
+        Ok(())
+    }
+
+    fn all_font_names(&self) -> Vec<String> {
+        Vec::new()
+    }
+
+    fn font_id(&self, descriptor: &Font) -> Result<FontId> {
+        Err(anyhow!("No font found for {:?}", descriptor))
+    }
+
+    fn font_metrics(&self, _font_id: FontId) -> FontMetrics {
+        unimplemented!()
+    }
+
+    fn typographic_bounds(&self, font_id: FontId, _glyph_id: GlyphId) -> Result<Bounds<f32>> {
+        Err(anyhow!("No font found for {:?}", font_id))
+    }
+
+    fn advance(&self, font_id: FontId, _glyph_id: GlyphId) -> Result<Size<f32>> {
+        Err(anyhow!("No font found for {:?}", font_id))
+    }
+
+    fn glyph_for_char(&self, _font_id: FontId, _ch: char) -> Option<GlyphId> {
+        None
+    }
+
+    fn glyph_raster_bounds(&self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
+        Err(anyhow!("No font found for {:?}", params))
+    }
+
+    fn rasterize_glyph(
+        &self,
+        params: &RenderGlyphParams,
+        _raster_bounds: Bounds<DevicePixels>,
+    ) -> Result<(Size<DevicePixels>, Vec<u8>)> {
+        Err(anyhow!("No font found for {:?}", params))
+    }
+
+    fn layout_line(&self, _text: &str, _font_size: Pixels, _runs: &[FontRun]) -> LineLayout {
+        unimplemented!()
+    }
+}
+
 #[derive(PartialEq, Eq, Hash, Clone)]
 pub(crate) enum AtlasKey {
     Glyph(RenderGlyphParams),
@@ -434,6 +505,10 @@ pub(crate) enum AtlasKey {
 }
 
 impl AtlasKey {
+    #[cfg_attr(
+        all(target_os = "linux", not(any(feature = "x11", feature = "wayland"))),
+        allow(dead_code)
+    )]
     pub(crate) fn texture_kind(&self) -> AtlasTextureKind {
         match self {
             AtlasKey::Glyph(params) => {
@@ -494,6 +569,10 @@ pub(crate) struct AtlasTextureId {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 #[repr(C)]
+#[cfg_attr(
+    all(target_os = "linux", not(any(feature = "x11", feature = "wayland"))),
+    allow(dead_code)
+)]
 pub(crate) enum AtlasTextureKind {
     Monochrome = 0,
     Polychrome = 1,
@@ -521,6 +600,10 @@ pub(crate) struct PlatformInputHandler {
     handler: Box<dyn InputHandler>,
 }
 
+#[cfg_attr(
+    all(target_os = "linux", not(any(feature = "x11", feature = "wayland"))),
+    allow(dead_code)
+)]
 impl PlatformInputHandler {
     pub fn new(cx: AsyncWindowContext, handler: Box<dyn InputHandler>) -> Self {
         Self { cx, handler }
@@ -728,10 +811,15 @@ pub struct WindowOptions {
 
 /// The variables that can be configured when creating a new window
 #[derive(Debug)]
+#[cfg_attr(
+    all(target_os = "linux", not(any(feature = "x11", feature = "wayland"))),
+    allow(dead_code)
+)]
 pub(crate) struct WindowParams {
     pub bounds: Bounds<Pixels>,
 
     /// The titlebar configuration of the window
+    #[cfg_attr(feature = "wayland", allow(dead_code))]
     pub titlebar: Option<TitlebarOptions>,
 
     /// The kind of window to create
@@ -748,6 +836,7 @@ pub(crate) struct WindowParams {
     #[cfg_attr(target_os = "linux", allow(dead_code))]
     pub show: bool,
 
+    #[cfg_attr(feature = "wayland", allow(dead_code))]
     pub display_id: Option<DisplayId>,
 
     pub window_min_size: Option<Size<Pixels>>,
diff --git a/crates/gpui/src/platform/blade/blade_renderer.rs b/crates/gpui/src/platform/blade/blade_renderer.rs
index 65ccfcdd4db442..5c37caf2cbab02 100644
--- a/crates/gpui/src/platform/blade/blade_renderer.rs
+++ b/crates/gpui/src/platform/blade/blade_renderer.rs
@@ -455,7 +455,7 @@ impl BladeRenderer {
         }
     }
 
-    #[cfg_attr(target_os = "macos", allow(dead_code))]
+    #[cfg_attr(any(target_os = "macos", feature = "wayland"), allow(dead_code))]
     pub fn viewport_size(&self) -> gpu::Extent {
         self.surface_config.size
     }
diff --git a/crates/gpui/src/platform/linux.rs b/crates/gpui/src/platform/linux.rs
index cfba4b4907a918..04998693616fd1 100644
--- a/crates/gpui/src/platform/linux.rs
+++ b/crates/gpui/src/platform/linux.rs
@@ -1,14 +1,22 @@
 mod dispatcher;
 mod headless;
 mod platform;
+#[cfg(any(feature = "wayland", feature = "x11"))]
 mod text_system;
+#[cfg(feature = "wayland")]
 mod wayland;
+#[cfg(feature = "x11")]
 mod x11;
+
+#[cfg(any(feature = "wayland", feature = "x11"))]
 mod xdg_desktop_portal;
 
 pub(crate) use dispatcher::*;
 pub(crate) use headless::*;
 pub(crate) use platform::*;
+#[cfg(any(feature = "wayland", feature = "x11"))]
 pub(crate) use text_system::*;
+#[cfg(feature = "wayland")]
 pub(crate) use wayland::*;
+#[cfg(feature = "x11")]
 pub(crate) use x11::*;
diff --git a/crates/gpui/src/platform/linux/platform.rs b/crates/gpui/src/platform/linux/platform.rs
index 6e09badb493a64..c18478aead7d57 100644
--- a/crates/gpui/src/platform/linux/platform.rs
+++ b/crates/gpui/src/platform/linux/platform.rs
@@ -19,32 +19,26 @@ use std::{
 };
 
 use anyhow::anyhow;
-use ashpd::desktop::file_chooser::{OpenFileRequest, SaveFileRequest};
-use ashpd::desktop::open_uri::{OpenDirectoryRequest, OpenFileRequest as OpenUriRequest};
-use ashpd::{url, ActivationToken};
 use async_task::Runnable;
 use calloop::channel::Channel;
 use calloop::{EventLoop, LoopHandle, LoopSignal};
-use filedescriptor::FileDescriptor;
 use flume::{Receiver, Sender};
 use futures::channel::oneshot;
 use parking_lot::Mutex;
 use util::ResultExt;
-use wayland_client::Connection;
-use wayland_protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::Shape;
+
+#[cfg(any(feature = "wayland", feature = "x11"))]
 use xkbcommon::xkb::{self, Keycode, Keysym, State};
 
-use crate::platform::linux::wayland::WaylandClient;
+use crate::platform::NoopTextSystem;
 use crate::{
-    px, Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CosmicTextSystem, CursorStyle,
-    DisplayId, ForegroundExecutor, Keymap, Keystroke, LinuxDispatcher, Menu, MenuItem, Modifiers,
-    OwnedMenu, PathPromptOptions, Pixels, Platform, PlatformDisplay, PlatformInputHandler,
-    PlatformTextSystem, PlatformWindow, Point, PromptLevel, Result, SemanticVersion, SharedString,
-    Size, Task, WindowAppearance, WindowOptions, WindowParams,
+    px, Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DisplayId,
+    ForegroundExecutor, Keymap, Keystroke, LinuxDispatcher, Menu, MenuItem, Modifiers, OwnedMenu,
+    PathPromptOptions, Pixels, Platform, PlatformDisplay, PlatformInputHandler, PlatformTextSystem,
+    PlatformWindow, Point, PromptLevel, Result, SemanticVersion, SharedString, Size, Task,
+    WindowAppearance, WindowOptions, WindowParams,
 };
 
-use super::x11::X11Client;
-
 pub(crate) const SCROLL_LINES: f32 = 3.0;
 
 // Values match the defaults on GTK.
@@ -93,7 +87,7 @@ pub(crate) struct PlatformHandlers {
 pub(crate) struct LinuxCommon {
     pub(crate) background_executor: BackgroundExecutor,
     pub(crate) foreground_executor: ForegroundExecutor,
-    pub(crate) text_system: Arc<CosmicTextSystem>,
+    pub(crate) text_system: Arc<dyn PlatformTextSystem>,
     pub(crate) appearance: WindowAppearance,
     pub(crate) auto_hide_scrollbars: bool,
     pub(crate) callbacks: PlatformHandlers,
@@ -104,7 +98,12 @@ pub(crate) struct LinuxCommon {
 impl LinuxCommon {
     pub fn new(signal: LoopSignal) -> (Self, Channel<Runnable>) {
         let (main_sender, main_receiver) = calloop::channel::channel::<Runnable>();
-        let text_system = Arc::new(CosmicTextSystem::new());
+        #[cfg(any(feature = "wayland", feature = "x11"))]
+        let text_system = Arc::new(crate::CosmicTextSystem::new());
+
+        #[cfg(not(any(feature = "wayland", feature = "x11")))]
+        let text_system = Arc::new(crate::NoopTextSystem::new());
+
         let callbacks = PlatformHandlers::default();
 
         let dispatcher = Arc::new(LinuxDispatcher::new(main_sender.clone()));
@@ -264,6 +263,11 @@ impl<P: LinuxClient + 'static> Platform for P {
         options: PathPromptOptions,
     ) -> oneshot::Receiver<Result<Option<Vec<PathBuf>>>> {
         let (done_tx, done_rx) = oneshot::channel();
+
+        #[cfg(not(any(feature = "wayland", feature = "x11")))]
+        done_tx.send(Ok(None));
+
+        #[cfg(any(feature = "wayland", feature = "x11"))]
         self.foreground_executor()
             .spawn(async move {
                 let title = if options.directories {
@@ -272,7 +276,7 @@ impl<P: LinuxClient + 'static> Platform for P {
                     "Open File"
                 };
 
-                let request = match OpenFileRequest::default()
+                let request = match ashpd::desktop::file_chooser::OpenFileRequest::default()
                     .modal(true)
                     .title(title)
                     .multiple(options.multiple)
@@ -310,37 +314,47 @@ impl<P: LinuxClient + 'static> Platform for P {
 
     fn prompt_for_new_path(&self, directory: &Path) -> oneshot::Receiver<Result<Option<PathBuf>>> {
         let (done_tx, done_rx) = oneshot::channel();
-        let directory = directory.to_owned();
+
+        #[cfg(not(any(feature = "wayland", feature = "x11")))]
+        done_tx.send(Ok(None));
+
+        #[cfg(any(feature = "wayland", feature = "x11"))]
         self.foreground_executor()
-            .spawn(async move {
-                let request = match SaveFileRequest::default()
-                    .modal(true)
-                    .title("Save File")
-                    .current_folder(directory)
-                    .expect("pathbuf should not be nul terminated")
-                    .send()
-                    .await
-                {
-                    Ok(request) => request,
-                    Err(err) => {
-                        let result = match err {
-                            ashpd::Error::PortalNotFound(_) => anyhow!(FILE_PICKER_PORTAL_MISSING),
-                            err => err.into(),
-                        };
-                        done_tx.send(Err(result));
-                        return;
-                    }
-                };
+            .spawn({
+                let directory = directory.to_owned();
+
+                async move {
+                    let request = match ashpd::desktop::file_chooser::SaveFileRequest::default()
+                        .modal(true)
+                        .title("Save File")
+                        .current_folder(directory)
+                        .expect("pathbuf should not be nul terminated")
+                        .send()
+                        .await
+                    {
+                        Ok(request) => request,
+                        Err(err) => {
+                            let result = match err {
+                                ashpd::Error::PortalNotFound(_) => {
+                                    anyhow!(FILE_PICKER_PORTAL_MISSING)
+                                }
+                                err => err.into(),
+                            };
+                            done_tx.send(Err(result));
+                            return;
+                        }
+                    };
 
-                let result = match request.response() {
-                    Ok(response) => Ok(response
-                        .uris()
-                        .first()
-                        .and_then(|uri| uri.to_file_path().ok())),
-                    Err(ashpd::Error::Response(_)) => Ok(None),
-                    Err(e) => Err(e.into()),
-                };
-                done_tx.send(result);
+                    let result = match request.response() {
+                        Ok(response) => Ok(response
+                            .uris()
+                            .first()
+                            .and_then(|uri| uri.to_file_path().ok())),
+                        Err(ashpd::Error::Response(_)) => Ok(None),
+                        Err(e) => Err(e.into()),
+                    };
+                    done_tx.send(result);
+                }
             })
             .detach();
 
@@ -518,16 +532,17 @@ impl<P: LinuxClient + 'static> Platform for P {
     fn add_recent_document(&self, _path: &Path) {}
 }
 
+#[cfg(any(feature = "wayland", feature = "x11"))]
 pub(super) fn open_uri_internal(
     executor: BackgroundExecutor,
     uri: &str,
     activation_token: Option<String>,
 ) {
-    if let Some(uri) = url::Url::parse(uri).log_err() {
+    if let Some(uri) = ashpd::url::Url::parse(uri).log_err() {
         executor
             .spawn(async move {
-                match OpenUriRequest::default()
-                    .activation_token(activation_token.clone().map(ActivationToken::from))
+                match ashpd::desktop::open_uri::OpenFileRequest::default()
+                    .activation_token(activation_token.clone().map(ashpd::ActivationToken::from))
                     .send_uri(&uri)
                     .await
                 {
@@ -551,6 +566,7 @@ pub(super) fn open_uri_internal(
     }
 }
 
+#[cfg(any(feature = "x11", feature = "wayland"))]
 pub(super) fn reveal_path_internal(
     executor: BackgroundExecutor,
     path: PathBuf,
@@ -559,8 +575,8 @@ pub(super) fn reveal_path_internal(
     executor
         .spawn(async move {
             if let Some(dir) = File::open(path.clone()).log_err() {
-                match OpenDirectoryRequest::default()
-                    .activation_token(activation_token.map(ActivationToken::from))
+                match ashpd::desktop::open_uri::OpenDirectoryRequest::default()
+                    .activation_token(activation_token.map(ashpd::ActivationToken::from))
                     .send(&dir.as_fd())
                     .await
                 {
@@ -582,6 +598,7 @@ pub(super) fn is_within_click_distance(a: Point<Pixels>, b: Point<Pixels>) -> bo
     diff.x.abs() <= DOUBLE_CLICK_DISTANCE && diff.y.abs() <= DOUBLE_CLICK_DISTANCE
 }
 
+#[cfg(any(feature = "wayland", feature = "x11"))]
 pub(super) fn get_xkb_compose_state(cx: &xkb::Context) -> Option<xkb::compose::State> {
     let mut locales = Vec::default();
     if let Some(locale) = std::env::var_os("LC_CTYPE") {
@@ -603,7 +620,8 @@ pub(super) fn get_xkb_compose_state(cx: &xkb::Context) -> Option<xkb::compose::S
     state
 }
 
-pub(super) unsafe fn read_fd(mut fd: FileDescriptor) -> Result<Vec<u8>> {
+#[cfg(any(feature = "wayland", feature = "x11"))]
+pub(super) unsafe fn read_fd(mut fd: filedescriptor::FileDescriptor) -> Result<Vec<u8>> {
     let mut file = File::from_raw_fd(fd.as_raw_fd());
     let mut buffer = Vec::new();
     file.read_to_end(&mut buffer)?;
@@ -611,32 +629,6 @@ pub(super) unsafe fn read_fd(mut fd: FileDescriptor) -> Result<Vec<u8>> {
 }
 
 impl CursorStyle {
-    pub(super) fn to_shape(&self) -> Shape {
-        match self {
-            CursorStyle::Arrow => Shape::Default,
-            CursorStyle::IBeam => Shape::Text,
-            CursorStyle::Crosshair => Shape::Crosshair,
-            CursorStyle::ClosedHand => Shape::Grabbing,
-            CursorStyle::OpenHand => Shape::Grab,
-            CursorStyle::PointingHand => Shape::Pointer,
-            CursorStyle::ResizeLeft => Shape::WResize,
-            CursorStyle::ResizeRight => Shape::EResize,
-            CursorStyle::ResizeLeftRight => Shape::EwResize,
-            CursorStyle::ResizeUp => Shape::NResize,
-            CursorStyle::ResizeDown => Shape::SResize,
-            CursorStyle::ResizeUpDown => Shape::NsResize,
-            CursorStyle::ResizeUpLeftDownRight => Shape::NwseResize,
-            CursorStyle::ResizeUpRightDownLeft => Shape::NeswResize,
-            CursorStyle::ResizeColumn => Shape::ColResize,
-            CursorStyle::ResizeRow => Shape::RowResize,
-            CursorStyle::IBeamCursorForVerticalLayout => Shape::VerticalText,
-            CursorStyle::OperationNotAllowed => Shape::NotAllowed,
-            CursorStyle::DragLink => Shape::Alias,
-            CursorStyle::DragCopy => Shape::Copy,
-            CursorStyle::ContextualMenu => Shape::ContextMenu,
-        }
-    }
-
     pub(super) fn to_icon_name(&self) -> String {
         // Based on cursor names from https://gitlab.gnome.org/GNOME/adwaita-icon-theme (GNOME)
         // and https://github.com/KDE/breeze (KDE). Both of them seem to be also derived from
@@ -668,6 +660,7 @@ impl CursorStyle {
     }
 }
 
+#[cfg(any(feature = "wayland", feature = "x11"))]
 impl Keystroke {
     pub(super) fn from_xkb(state: &State, modifiers: Modifiers, keycode: Keycode) -> Self {
         let mut modifiers = modifiers;
@@ -813,6 +806,7 @@ impl Keystroke {
     }
 }
 
+#[cfg(any(feature = "wayland", feature = "x11"))]
 impl Modifiers {
     pub(super) fn from_xkb(keymap_state: &State) -> Self {
         let shift = keymap_state.mod_name_is_active(xkb::MOD_NAME_SHIFT, xkb::STATE_MODS_EFFECTIVE);
diff --git a/crates/gpui/src/platform/linux/wayland.rs b/crates/gpui/src/platform/linux/wayland.rs
index e8594426fae97f..f178e4b643f18d 100644
--- a/crates/gpui/src/platform/linux/wayland.rs
+++ b/crates/gpui/src/platform/linux/wayland.rs
@@ -6,3 +6,35 @@ mod serial;
 mod window;
 
 pub(crate) use client::*;
+
+use wayland_protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::Shape;
+
+use crate::CursorStyle;
+
+impl CursorStyle {
+    pub(super) fn to_shape(&self) -> Shape {
+        match self {
+            CursorStyle::Arrow => Shape::Default,
+            CursorStyle::IBeam => Shape::Text,
+            CursorStyle::Crosshair => Shape::Crosshair,
+            CursorStyle::ClosedHand => Shape::Grabbing,
+            CursorStyle::OpenHand => Shape::Grab,
+            CursorStyle::PointingHand => Shape::Pointer,
+            CursorStyle::ResizeLeft => Shape::WResize,
+            CursorStyle::ResizeRight => Shape::EResize,
+            CursorStyle::ResizeLeftRight => Shape::EwResize,
+            CursorStyle::ResizeUp => Shape::NResize,
+            CursorStyle::ResizeDown => Shape::SResize,
+            CursorStyle::ResizeUpDown => Shape::NsResize,
+            CursorStyle::ResizeUpLeftDownRight => Shape::NwseResize,
+            CursorStyle::ResizeUpRightDownLeft => Shape::NeswResize,
+            CursorStyle::ResizeColumn => Shape::ColResize,
+            CursorStyle::ResizeRow => Shape::RowResize,
+            CursorStyle::IBeamCursorForVerticalLayout => Shape::VerticalText,
+            CursorStyle::OperationNotAllowed => Shape::NotAllowed,
+            CursorStyle::DragLink => Shape::Alias,
+            CursorStyle::DragCopy => Shape::Copy,
+            CursorStyle::ContextualMenu => Shape::ContextMenu,
+        }
+    }
+}
diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs
index 459f2045bb732a..b5a5a00910b8a7 100644
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -1421,10 +1421,12 @@ impl LinuxClient for X11Client {
     }
 
     fn open_uri(&self, uri: &str) {
+        #[cfg(any(feature = "wayland", feature = "x11"))]
         open_uri_internal(self.background_executor(), uri, None);
     }
 
     fn reveal_path(&self, path: PathBuf) {
+        #[cfg(any(feature = "x11", feature = "wayland"))]
         reveal_path_internal(self.background_executor(), path, None);
     }
 
diff --git a/crates/gpui/src/platform/linux/xdg_desktop_portal.rs b/crates/gpui/src/platform/linux/xdg_desktop_portal.rs
index b36e4826396ae2..ade7833eab254d 100644
--- a/crates/gpui/src/platform/linux/xdg_desktop_portal.rs
+++ b/crates/gpui/src/platform/linux/xdg_desktop_portal.rs
@@ -11,7 +11,9 @@ use crate::{BackgroundExecutor, WindowAppearance};
 
 pub enum Event {
     WindowAppearance(WindowAppearance),
+    #[cfg_attr(feature = "x11", allow(dead_code))]
     CursorTheme(String),
+    #[cfg_attr(feature = "x11", allow(dead_code))]
     CursorSize(u32),
 }
 
diff --git a/crates/gpui/src/platform/mac.rs b/crates/gpui/src/platform/mac.rs
index 2223dd91b473a3..396fd49d048961 100644
--- a/crates/gpui/src/platform/mac.rs
+++ b/crates/gpui/src/platform/mac.rs
@@ -17,9 +17,14 @@ use metal_renderer as renderer;
 use crate::platform::blade as renderer;
 
 mod attributed_string;
+
+#[cfg(feature = "font-kit")]
 mod open_type;
-mod platform;
+
+#[cfg(feature = "font-kit")]
 mod text_system;
+
+mod platform;
 mod window;
 mod window_appearance;
 
@@ -39,9 +44,11 @@ pub(crate) use dispatcher::*;
 pub(crate) use display::*;
 pub(crate) use display_link::*;
 pub(crate) use platform::*;
-pub(crate) use text_system::*;
 pub(crate) use window::*;
 
+#[cfg(feature = "font-kit")]
+pub(crate) use text_system::*;
+
 trait BoolExt {
     fn to_objc(self) -> BOOL;
 }
diff --git a/crates/gpui/src/platform/mac/platform.rs b/crates/gpui/src/platform/mac/platform.rs
index 78465e8f8d696d..b8b9d17be7b50f 100644
--- a/crates/gpui/src/platform/mac/platform.rs
+++ b/crates/gpui/src/platform/mac/platform.rs
@@ -6,9 +6,9 @@ use super::{
 use crate::{
     hash, Action, AnyWindowHandle, BackgroundExecutor, ClipboardEntry, ClipboardItem,
     ClipboardString, CursorStyle, ForegroundExecutor, Image, ImageFormat, Keymap, MacDispatcher,
-    MacDisplay, MacTextSystem, MacWindow, Menu, MenuItem, PathPromptOptions, Platform,
-    PlatformDisplay, PlatformTextSystem, PlatformWindow, Result, SemanticVersion, Task,
-    WindowAppearance, WindowParams,
+    MacDisplay, MacWindow, Menu, MenuItem, PathPromptOptions, Platform, PlatformDisplay,
+    PlatformTextSystem, PlatformWindow, Result, SemanticVersion, Task, WindowAppearance,
+    WindowParams,
 };
 use anyhow::anyhow;
 use block::ConcreteBlock;
@@ -145,7 +145,7 @@ pub(crate) struct MacPlatform(Mutex<MacPlatformState>);
 pub(crate) struct MacPlatformState {
     background_executor: BackgroundExecutor,
     foreground_executor: ForegroundExecutor,
-    text_system: Arc<MacTextSystem>,
+    text_system: Arc<dyn PlatformTextSystem>,
     renderer_context: renderer::Context,
     headless: bool,
     pasteboard: id,
@@ -171,11 +171,18 @@ impl Default for MacPlatform {
 impl MacPlatform {
     pub(crate) fn new(headless: bool) -> Self {
         let dispatcher = Arc::new(MacDispatcher::new());
+
+        #[cfg(feature = "font-kit")]
+        let text_system = Arc::new(crate::MacTextSystem::new());
+
+        #[cfg(not(feature = "font-kit"))]
+        let text_system = Arc::new(crate::NoopTextSystem::new());
+
         Self(Mutex::new(MacPlatformState {
-            background_executor: BackgroundExecutor::new(dispatcher.clone()),
             headless,
+            text_system,
+            background_executor: BackgroundExecutor::new(dispatcher.clone()),
             foreground_executor: ForegroundExecutor::new(dispatcher),
-            text_system: Arc::new(MacTextSystem::new()),
             renderer_context: renderer::Context::default(),
             pasteboard: unsafe { NSPasteboard::generalPasteboard(nil) },
             text_hash_pasteboard_type: unsafe { ns_string("zed-text-hash") },
diff --git a/crates/gpui/src/scene.rs b/crates/gpui/src/scene.rs
index 2b0d17a51ec966..d3eee39aa77bf3 100644
--- a/crates/gpui/src/scene.rs
+++ b/crates/gpui/src/scene.rs
@@ -40,6 +40,10 @@ impl Scene {
         self.surfaces.clear();
     }
 
+    #[cfg_attr(
+        all(target_os = "linux", not(any(feature = "x11", feature = "wayland"))),
+        allow(dead_code)
+    )]
     pub fn paths(&self) -> &[Path<ScaledPixels>] {
         &self.paths
     }
@@ -130,6 +134,10 @@ impl Scene {
         self.surfaces.sort();
     }
 
+    #[cfg_attr(
+        all(target_os = "linux", not(any(feature = "x11", feature = "wayland"))),
+        allow(dead_code)
+    )]
     pub(crate) fn batches(&self) -> impl Iterator<Item = PrimitiveBatch> {
         BatchIterator {
             shadows: &self.shadows,
@@ -158,6 +166,10 @@ impl Scene {
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Default)]
+#[cfg_attr(
+    all(target_os = "linux", not(any(feature = "x11", feature = "wayland"))),
+    allow(dead_code)
+)]
 pub(crate) enum PrimitiveKind {
     Shadow,
     #[default]
@@ -212,6 +224,10 @@ impl Primitive {
     }
 }
 
+#[cfg_attr(
+    all(target_os = "linux", not(any(feature = "x11", feature = "wayland"))),
+    allow(dead_code)
+)]
 struct BatchIterator<'a> {
     shadows: &'a [Shadow],
     shadows_start: usize,
@@ -398,6 +414,10 @@ impl<'a> Iterator for BatchIterator<'a> {
 }
 
 #[derive(Debug)]
+#[cfg_attr(
+    all(target_os = "linux", not(any(feature = "x11", feature = "wayland"))),
+    allow(dead_code)
+)]
 pub(crate) enum PrimitiveBatch<'a> {
     Shadows(&'a [Shadow]),
     Quads(&'a [Quad]),
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 0e33c6d36a73c9..318c2aec6a9196 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -390,40 +390,11 @@ impl SshClientDelegate {
 
         // In dev mode, build the remote server binary from source
         #[cfg(debug_assertions)]
-        if release_channel == ReleaseChannel::Dev
-            && platform.arch == std::env::consts::ARCH
-            && platform.os == std::env::consts::OS
-        {
-            use smol::process::{Command, Stdio};
-
-            self.update_status(Some("building remote server binary from source"), cx);
-            log::info!("building remote server binary from source");
-            run_cmd(Command::new("cargo").args([
-                "build",
-                "--package",
-                "remote_server",
-                "--target-dir",
-                "target/remote_server",
-            ]))
-            .await?;
-            // run_cmd(Command::new("strip").args(["target/remote_server/debug/remote_server"]))
-            // .await?;
-            run_cmd(Command::new("gzip").args([
-                "-9",
-                "-f",
-                "target/remote_server/debug/remote_server",
-            ]))
-            .await?;
-
-            let path = std::env::current_dir()?.join("target/remote_server/debug/remote_server.gz");
-            return Ok((path, version));
-
-            async fn run_cmd(command: &mut Command) -> Result<()> {
-                let output = command.stderr(Stdio::inherit()).output().await?;
-                if !output.status.success() {
-                    Err(anyhow::anyhow!("failed to run command: {:?}", command))?;
-                }
-                Ok(())
+        if release_channel == ReleaseChannel::Dev {
+            let result = self.build_local(cx, platform, version).await?;
+            // Fall through to a remote binary if we're not able to compile a local binary
+            if let Some(result) = result {
+                return Ok(result);
             }
         }
 
@@ -446,6 +417,105 @@ impl SshClientDelegate {
 
         Ok((binary_path, version))
     }
+
+    #[cfg(debug_assertions)]
+    async fn build_local(
+        &self,
+        cx: &mut AsyncAppContext,
+        platform: SshPlatform,
+        version: SemanticVersion,
+    ) -> Result<Option<(PathBuf, SemanticVersion)>> {
+        use smol::process::{Command, Stdio};
+
+        async fn run_cmd(command: &mut Command) -> Result<()> {
+            let output = command.stderr(Stdio::inherit()).output().await?;
+            if !output.status.success() {
+                Err(anyhow::anyhow!("failed to run command: {:?}", command))?;
+            }
+            Ok(())
+        }
+
+        if platform.arch == std::env::consts::ARCH && platform.os == std::env::consts::OS {
+            self.update_status(Some("Building remote server binary from source"), cx);
+            log::info!("building remote server binary from source");
+            run_cmd(Command::new("cargo").args([
+                "build",
+                "--package",
+                "remote_server",
+                "--target-dir",
+                "target/remote_server",
+            ]))
+            .await?;
+
+            self.update_status(Some("Compressing binary"), cx);
+
+            run_cmd(Command::new("gzip").args([
+                "-9",
+                "-f",
+                "target/remote_server/debug/remote_server",
+            ]))
+            .await?;
+
+            let path = std::env::current_dir()?.join("target/remote_server/debug/remote_server.gz");
+            return Ok(Some((path, version)));
+        } else if let Some(triple) = platform.triple() {
+            smol::fs::create_dir_all("target/remote-server").await?;
+
+            self.update_status(Some("Installing cross.rs"), cx);
+            log::info!("installing cross");
+            run_cmd(Command::new("cargo").args([
+                "install",
+                "cross",
+                "--git",
+                "https://github.com/cross-rs/cross",
+            ]))
+            .await?;
+
+            self.update_status(
+                Some(&format!(
+                    "Building remote server binary from source for {}",
+                    &triple
+                )),
+                cx,
+            );
+            log::info!("building remote server binary from source for {}", &triple);
+            run_cmd(
+                Command::new("cross")
+                    .args([
+                        "build",
+                        "--package",
+                        "remote_server",
+                        "--target-dir",
+                        "target/remote_server",
+                        "--target",
+                        &triple,
+                    ])
+                    .env(
+                        "CROSS_CONTAINER_OPTS",
+                        "--mount type=bind,src=./target,dst=/app/target",
+                    ),
+            )
+            .await?;
+
+            self.update_status(Some("Compressing binary"), cx);
+
+            run_cmd(Command::new("gzip").args([
+                "-9",
+                "-f",
+                &format!("target/remote_server/{}/debug/remote_server", triple),
+            ]))
+            .await?;
+
+            let path = std::env::current_dir()?.join(format!(
+                "target/remote_server/{}/debug/remote_server.gz",
+                triple
+            ));
+
+            return Ok(Some((path, version)));
+        } else {
+            return Ok(None);
+        }
+    }
 }
 
 pub fn connect_over_ssh(
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 87756aeb0c6ec8..564b94070f2ffc 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -118,6 +118,20 @@ pub struct SshPlatform {
     pub arch: &'static str,
 }
 
+impl SshPlatform {
+    pub fn triple(&self) -> Option<String> {
+        Some(format!(
+            "{}-{}",
+            self.arch,
+            match self.os {
+                "linux" => "unknown-linux-gnu",
+                "macos" => "apple-darwin",
+                _ => return None,
+            }
+        ))
+    }
+}
+
 pub trait SshClientDelegate: Send + Sync {
     fn ask_password(
         &self,
diff --git a/crates/rpc/Cargo.toml b/crates/rpc/Cargo.toml
index f664085f04c239..ce665a111aa92a 100644
--- a/crates/rpc/Cargo.toml
+++ b/crates/rpc/Cargo.toml
@@ -35,10 +35,7 @@ sha2.workspace = true
 strum.workspace = true
 tracing = { version = "0.1.34", features = ["log"] }
 util.workspace = true
-zstd = "0.11"
-
-[target.'cfg(target_os = "linux")'.dependencies]
-zstd = { version = "0.11", features = [ "pkg-config" ] }
+zstd.workspace = true
 
 [dev-dependencies]
 collections = { workspace = true, features = ["test-support"] }
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index a271019573ca7c..69ca3aa98d2662 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -51,7 +51,7 @@ futures.workspace = true
 git.workspace = true
 git_hosting_providers.workspace = true
 go_to_line.workspace = true
-gpui.workspace = true
+gpui = { workspace = true, features = ["wayland", "x11", "font-kit"] }
 headless.workspace = true
 http_client.workspace = true
 image_viewer.workspace = true
@@ -125,6 +125,8 @@ winresource = "0.1"
 
 [target.'cfg(target_os = "linux")'.dependencies]
 ashpd.workspace = true
+# We don't use zstd in the zed crate, but we want to add this feature when compiling a desktop build of Zed
+zstd = { workspace = true, features = [ "pkg-config" ] }
 
 [dev-dependencies]
 call = { workspace = true, features = ["test-support"] }
@@ -169,4 +171,4 @@ osx_info_plist_exts = ["resources/info/*"]
 osx_url_schemes = ["zed"]
 
 [package.metadata.cargo-machete]
-ignored = ["profiling"]
+ignored = ["profiling", "zstd"]
diff --git a/script/remote-server b/script/remote-server
new file mode 100755
index 00000000000000..1ab2d943e16bbf
--- /dev/null
+++ b/script/remote-server
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+set -xeuo pipefail
+
+# if root or if sudo/unavailable, define an empty variable
+if [ "$(id -u)" -eq 0 ]
+then maysudo=''
+else maysudo="$(command -v sudo || command -v doas || true)"
+fi
+
+deps=(
+  clang
+)
+
+$maysudo apt-get update
+$maysudo apt-get install -y "${deps[@]}"
+exit 0

From aefc559f43700f69e37592fb9898bfab1bc9f4bc Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Sun, 13 Oct 2024 02:35:46 -0400
Subject: [PATCH 624/762] Improve auto-detection via shebang of TypeScript,
 JavaScript and Shell Script (#19114)

---
 crates/languages/src/bash/config.toml       | 2 +-
 crates/languages/src/javascript/config.toml | 3 ++-
 crates/languages/src/typescript/config.toml | 1 +
 typos.toml                                  | 1 -
 4 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/languages/src/bash/config.toml b/crates/languages/src/bash/config.toml
index 1deb800219a3b7..0a1deb3e692042 100644
--- a/crates/languages/src/bash/config.toml
+++ b/crates/languages/src/bash/config.toml
@@ -3,7 +3,7 @@ code_fence_block_name = "bash"
 grammar = "bash"
 path_suffixes = ["sh", "bash", "bashrc", "bash_profile", "bash_aliases", "bash_logout", "profile", "zsh", "zshrc", "zshenv", "zsh_profile", "zsh_aliases", "zsh_histfile", "zlogin", "zprofile", ".env", "PKGBUILD"]
 line_comments = ["# "]
-first_line_pattern = "^#!.*\\b(?:ba|z)?sh\\b"
+first_line_pattern = '^#!.*\b(?:ash|bash|dash|sh|zsh)\b'
 brackets = [
     { start = "[", end = "]", close = true, newline = false },
     { start = "(", end = ")", close = true, newline = false },
diff --git a/crates/languages/src/javascript/config.toml b/crates/languages/src/javascript/config.toml
index 460ee0e0fdae37..b770a2807106dc 100644
--- a/crates/languages/src/javascript/config.toml
+++ b/crates/languages/src/javascript/config.toml
@@ -1,7 +1,8 @@
 name = "JavaScript"
 grammar = "tsx"
 path_suffixes = ["js", "jsx", "mjs", "cjs"]
-first_line_pattern = '^#!.*\bnode\b'
+# [/ ] is so we match "env node" or "/node" but not "ts-node"
+first_line_pattern = '^#!.*\b(?:[/ ]node|deno run.*--ext[= ]js)\b'
 line_comments = ["// "]
 autoclose_before = ";:.,=}])>"
 brackets = [
diff --git a/crates/languages/src/typescript/config.toml b/crates/languages/src/typescript/config.toml
index ca115622c6c4bf..a34704b8305d4c 100644
--- a/crates/languages/src/typescript/config.toml
+++ b/crates/languages/src/typescript/config.toml
@@ -1,6 +1,7 @@
 name = "TypeScript"
 grammar = "typescript"
 path_suffixes = ["ts", "cts", "d.cts", "d.mts", "mts"]
+first_line_pattern = '^#!.*\b(?:deno run|ts-node|bun|tsx)\b'
 line_comments = ["// "]
 autoclose_before = ";:.,=}])>"
 brackets = [
diff --git a/typos.toml b/typos.toml
index 113fb728d1d2e3..2760af0b7d54e9 100644
--- a/typos.toml
+++ b/typos.toml
@@ -48,7 +48,6 @@ extend-ignore-re = [
     'cl\[ist]',
     '\[lan\]guage',
     '"ba"',
-    ":ba\\|z",
     # :/ crates/collab/migrations/20231009181554_add_release_channel_to_rooms.sql
     "COLUMN enviroment",
     # Typo in ClickHouse column name.

From 875c0cb09f5b8c4ffdbadc4c88c7858fbd1174e8 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Sun, 13 Oct 2024 02:56:12 -0400
Subject: [PATCH 625/762] Bytes 1.7.2 merge fix (#19145)

---
 Cargo.lock | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.lock b/Cargo.lock
index 93ba1988fca3fe..14b9f254037a61 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5529,7 +5529,7 @@ name = "http_client"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "bytes 1.7.1",
+ "bytes 1.7.2",
  "derive_more",
  "futures 0.3.30",
  "http 1.1.0",

From 74cc90887acb605c5e88fa42bc59a343e41ec561 Mon Sep 17 00:00:00 2001
From: Shish <shish@shishnet.org>
Date: Sun, 13 Oct 2024 08:01:56 +0100
Subject: [PATCH 626/762] ci: Give names to all github actions (#19080)

---
 .github/workflows/release_actions.yml                  | 2 ++
 .github/workflows/update_all_top_ranking_issues.yml    | 2 ++
 .github/workflows/update_weekly_top_ranking_issues.yml | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/.github/workflows/release_actions.yml b/.github/workflows/release_actions.yml
index fed1d728721e89..48b33c5ec6dc9c 100644
--- a/.github/workflows/release_actions.yml
+++ b/.github/workflows/release_actions.yml
@@ -1,3 +1,5 @@
+name: Release Actions
+
 on:
   release:
     types: [published]
diff --git a/.github/workflows/update_all_top_ranking_issues.yml b/.github/workflows/update_all_top_ranking_issues.yml
index 8cc0c39fc80256..72b21748715e20 100644
--- a/.github/workflows/update_all_top_ranking_issues.yml
+++ b/.github/workflows/update_all_top_ranking_issues.yml
@@ -1,3 +1,5 @@
+name: Update All Top Ranking Issues
+
 on:
   schedule:
     - cron: "0 */12 * * *"
diff --git a/.github/workflows/update_weekly_top_ranking_issues.yml b/.github/workflows/update_weekly_top_ranking_issues.yml
index 14c15c530e42f2..e6639bf05e5638 100644
--- a/.github/workflows/update_weekly_top_ranking_issues.yml
+++ b/.github/workflows/update_weekly_top_ranking_issues.yml
@@ -1,3 +1,5 @@
+name: Update Weekly Top Ranking Issues
+
 on:
   schedule:
     - cron: "0 15 * * *"

From 0b10fd5098b8c62c391132834d45828ae9e4d1a4 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Sun, 13 Oct 2024 04:09:27 -0400
Subject: [PATCH 627/762] cpp: Better icon support (#19146)

---
 assets/icons/file_icons/file_types.json | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/assets/icons/file_icons/file_types.json b/assets/icons/file_icons/file_types.json
index fd0dc448c4e54f..fee76aa0440721 100644
--- a/assets/icons/file_icons/file_types.json
+++ b/assets/icons/file_icons/file_types.json
@@ -20,6 +20,7 @@
     "bashrc": "terminal",
     "bmp": "image",
     "c": "c",
+    "c++": "cpp",
     "cc": "cpp",
     "cjs": "javascript",
     "coffee": "coffeescript",
@@ -27,6 +28,7 @@
     "cpp": "cpp",
     "css": "css",
     "csv": "storage",
+    "cxx": "cpp",
     "cts": "typescript",
     "dart": "dart",
     "dat": "storage",
@@ -66,11 +68,13 @@
     "heex": "elixir",
     "heic": "image",
     "heif": "image",
+    "hh": "cpp",
     "hpp": "cpp",
     "hrl": "erlang",
     "hs": "haskell",
     "htm": "template",
     "html": "template",
+    "hxx": "cpp",
     "ib": "storage",
     "ico": "image",
     "ini": "settings",

From 64911481966c80ab1d986a43ca34a70f47c81b9a Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Sun, 13 Oct 2024 13:39:15 +0300
Subject: [PATCH 628/762] Fail on warnings during CI builds (#19149)

Forbid things like
https://github.com/zed-industries/zed/pull/19144#issuecomment-2408871788

Release Notes:

- N/A
---
 .github/workflows/ci.yml | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4222d64437d3ef..eadd738fa5ab32 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -96,13 +96,13 @@ jobs:
         uses: ./.github/actions/run_tests
 
       - name: Build collab
-        run: cargo build -p collab
+        run: RUSTFLAGS="-D warnings" cargo build -p collab
 
       - name: Build other binaries and features
         run: |
-          cargo build --workspace --bins --all-features
+          RUSTFLAGS="-D warnings" cargo build --workspace --bins --all-features
           cargo check -p gpui --features "macos-blade"
-          cargo build -p remote_server
+          RUSTFLAGS="-D warnings" cargo build -p remote_server
 
   linux_tests:
     timeout-minutes: 60
@@ -134,7 +134,7 @@ jobs:
         uses: ./.github/actions/run_tests
 
       - name: Build Zed
-        run: cargo build -p zed
+        run: RUSTFLAGS="-D warnings" cargo build -p zed
 
   build_remote_server:
     timeout-minutes: 60
@@ -160,7 +160,7 @@ jobs:
         run: ./script/remote-server && ./script/install-mold 2.34.0
 
       - name: Build Remote Server
-        run: cargo build -p remote_server
+        run: RUSTFLAGS="-D warnings" cargo build -p remote_server
 
   # todo(windows): Actually run the tests
   windows_tests:
@@ -184,7 +184,7 @@ jobs:
         run: cargo xtask clippy
 
       - name: Build Zed
-        run: cargo build -p zed
+        run: $env:RUSTFLAGS="-D warnings"; cargo build
 
   bundle-mac:
     timeout-minutes: 60

From 39468de8c6a4d90855cb1c7138d315b6248dabf3 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Sun, 13 Oct 2024 14:35:06 +0300
Subject: [PATCH 629/762] Return back to history-based tabs activation on close
 (#19150)

Closes https://github.com/zed-industries/zed/issues/19036

Alters https://github.com/zed-industries/zed/pull/18168 and moves its
change behind a settings flag, restoring the previous behavior.

Release Notes:

- Fixed tab closing not respecting history. Use `tabs.activate_on_close
= neighbour` settings to activate near tabs instead.
---
 assets/settings/default.json |  9 +++-
 crates/workspace/src/item.rs | 18 ++++---
 crates/workspace/src/pane.rs | 93 ++++++++++++++++++++++++++++++++----
 docs/src/configuring-zed.md  | 27 ++++++++++-
 4 files changed, 129 insertions(+), 18 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 1aef3af63b3fab..d299f05766b5ca 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -494,7 +494,14 @@
     // Position of the close button on the editor tabs.
     "close_position": "right",
     // Whether to show the file icon for a tab.
-    "file_icons": false
+    "file_icons": false,
+    // What to do after closing the current tab.
+    //
+    // 1. Activate the tab that was open previously (default)
+    //     "History"
+    // 2. Activate the neighbour tab (prefers the right one, if present)
+    //     "Neighbour"
+    "activate_on_close": "history"
   },
   // Settings related to preview tabs.
   "preview_tabs": {
diff --git a/crates/workspace/src/item.rs b/crates/workspace/src/item.rs
index 935f0268b62ffe..9dc0b957f86de9 100644
--- a/crates/workspace/src/item.rs
+++ b/crates/workspace/src/item.rs
@@ -40,6 +40,7 @@ pub const LEADER_UPDATE_THROTTLE: Duration = Duration::from_millis(200);
 pub struct ItemSettings {
     pub git_status: bool,
     pub close_position: ClosePosition,
+    pub activate_on_close: ActivateOnClose,
     pub file_icons: bool,
 }
 
@@ -58,13 +59,12 @@ pub enum ClosePosition {
     Right,
 }
 
-impl ClosePosition {
-    pub fn right(&self) -> bool {
-        match self {
-            ClosePosition::Left => false,
-            ClosePosition::Right => true,
-        }
-    }
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "lowercase")]
+pub enum ActivateOnClose {
+    #[default]
+    History,
+    Neighbour,
 }
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
@@ -81,6 +81,10 @@ pub struct ItemSettingsContent {
     ///
     /// Default: false
     file_icons: Option<bool>,
+    /// What to do after closing the current tab.
+    ///
+    /// Default: history
+    pub activate_on_close: Option<ActivateOnClose>,
 }
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index 3e228b7b1602b3..9333afa42a7412 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -1,7 +1,7 @@
 use crate::{
     item::{
-        ClosePosition, Item, ItemHandle, ItemSettings, PreviewTabsSettings, TabContentParams,
-        WeakItemHandle,
+        ActivateOnClose, ClosePosition, Item, ItemHandle, ItemSettings, PreviewTabsSettings,
+        TabContentParams, WeakItemHandle,
     },
     move_item,
     notifications::NotifyResultExt,
@@ -1400,6 +1400,7 @@ impl Pane {
         focus_on_pane_if_closed: Option<View<Pane>>,
         cx: &mut ViewContext<Self>,
     ) {
+        let activate_on_close = &ItemSettings::get_global(cx).activate_on_close;
         self.activation_history
             .retain(|entry| entry.entity_id != self.items[item_index].item_id());
 
@@ -1407,12 +1408,26 @@ impl Pane {
             self.pinned_tab_count -= 1;
         }
         if item_index == self.active_item_index {
-            self.activation_history.pop();
-
-            let index_to_activate = if item_index + 1 < self.items.len() {
-                item_index + 1
-            } else {
-                item_index.saturating_sub(1)
+            let index_to_activate = match activate_on_close {
+                ActivateOnClose::History => self
+                    .activation_history
+                    .pop()
+                    .and_then(|last_activated_item| {
+                        self.items.iter().enumerate().find_map(|(index, item)| {
+                            (item.item_id() == last_activated_item.entity_id).then_some(index)
+                        })
+                    })
+                    // We didn't have a valid activation history entry, so fallback
+                    // to activating the item to the left
+                    .unwrap_or_else(|| item_index.min(self.items.len()).saturating_sub(1)),
+                ActivateOnClose::Neighbour => {
+                    self.activation_history.pop();
+                    if item_index + 1 < self.items.len() {
+                        item_index + 1
+                    } else {
+                        item_index.saturating_sub(1)
+                    }
+                }
             };
 
             let should_activate = activate_pane || self.has_focus(cx);
@@ -3292,7 +3307,7 @@ mod tests {
     }
 
     #[gpui::test]
-    async fn test_remove_item_ordering(cx: &mut TestAppContext) {
+    async fn test_remove_item_ordering_history(cx: &mut TestAppContext) {
         init_test(cx);
         let fs = FakeFs::new(cx.executor());
 
@@ -3310,6 +3325,66 @@ mod tests {
         add_labeled_item(&pane, "1", false, cx);
         assert_item_labels(&pane, ["A", "B", "1*", "C", "D"], cx);
 
+        pane.update(cx, |pane, cx| {
+            pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
+        })
+        .unwrap()
+        .await
+        .unwrap();
+        assert_item_labels(&pane, ["A", "B*", "C", "D"], cx);
+
+        pane.update(cx, |pane, cx| pane.activate_item(3, false, false, cx));
+        assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
+
+        pane.update(cx, |pane, cx| {
+            pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
+        })
+        .unwrap()
+        .await
+        .unwrap();
+        assert_item_labels(&pane, ["A", "B*", "C"], cx);
+
+        pane.update(cx, |pane, cx| {
+            pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
+        })
+        .unwrap()
+        .await
+        .unwrap();
+        assert_item_labels(&pane, ["A", "C*"], cx);
+
+        pane.update(cx, |pane, cx| {
+            pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
+        })
+        .unwrap()
+        .await
+        .unwrap();
+        assert_item_labels(&pane, ["A*"], cx);
+    }
+
+    #[gpui::test]
+    async fn test_remove_item_ordering_neighbour(cx: &mut TestAppContext) {
+        init_test(cx);
+        cx.update_global::<SettingsStore, ()>(|s, cx| {
+            s.update_user_settings::<ItemSettings>(cx, |s| {
+                s.activate_on_close = Some(ActivateOnClose::Neighbour);
+            });
+        });
+        let fs = FakeFs::new(cx.executor());
+
+        let project = Project::test(fs, None, cx).await;
+        let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
+        let pane = workspace.update(cx, |workspace, _| workspace.active_pane().clone());
+
+        add_labeled_item(&pane, "A", false, cx);
+        add_labeled_item(&pane, "B", false, cx);
+        add_labeled_item(&pane, "C", false, cx);
+        add_labeled_item(&pane, "D", false, cx);
+        assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
+
+        pane.update(cx, |pane, cx| pane.activate_item(1, false, false, cx));
+        add_labeled_item(&pane, "1", false, cx);
+        assert_item_labels(&pane, ["A", "B", "1*", "C", "D"], cx);
+
         pane.update(cx, |pane, cx| {
             pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
         })
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 1dca3bb4978660..5343c069042e67 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -539,7 +539,8 @@ List of `string` values
 "tabs": {
   "close_position": "right",
   "file_icons": false,
-  "git_status": false
+  "git_status": false,
+  "activate_on_close": "history"
 },
 ```
 
@@ -579,6 +580,30 @@ List of `string` values
 - Setting: `git_status`
 - Default: `false`
 
+### Activate on close
+
+- Description: What to do after closing the current tab.
+- Setting: `activate_on_close`
+- Default: `history`
+
+**Options**
+
+1.  Activate the tab that was open previously:
+
+```json
+{
+  "activate_on_close": "history"
+}
+```
+
+2. Activate the neighbour tab (prefers the right one, if present):
+
+```json
+{
+  "activate_on_close": "neighbour"
+}
+```
+
 ## Editor Toolbar
 
 - Description: Whether or not to show various elements in the editor toolbar.

From cdead5760a2c200179e6a51d5a396c33a3e06e3d Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Sun, 13 Oct 2024 10:25:08 -0400
Subject: [PATCH 630/762] docs: Formatter arguments, document `{buffer_path}`
 usage (#19156)

---
 docs/src/configuring-zed.md | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 5343c069042e67..121e63c233e508 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -739,7 +739,18 @@ While other options may be changed at a runtime and should be placed under `sett
 }
 ```
 
-3. Or to use code actions provided by the connected language servers, use `"code_actions"`:
+3. External formatters may optionally include a `{buffer_path}` placeholder which at runtime will include the path of the buffer being formatted. Formatters operate by receiving file content via standard input, reformatting it and then outputting it to standard output and so normally don't know the filename of what they are formatting. Tools like prettier support receiving the file path via a command line argument which can then used to impact formatting decisions.
+
+```json
+  "formatter": {
+    "external": {
+      "command": "prettier",
+      "arguments": ["--stdin-filepath", "{buffer_path}"]
+    }
+  }
+```
+
+4. Or to use code actions provided by the connected language servers, use `"code_actions"`:
 
 ```json
 {
@@ -754,7 +765,7 @@ While other options may be changed at a runtime and should be placed under `sett
 }
 ```
 
-4. Or to use multiple formatters consecutively, use an array of formatters:
+5. Or to use multiple formatters consecutively, use an array of formatters:
 
 ```json
 {

From 54683ff2b9dfcb0c8085aeac021439cafb69a1bf Mon Sep 17 00:00:00 2001
From: Bolaji Olajide <25608335+BolajiOlajide@users.noreply.github.com>
Date: Sun, 13 Oct 2024 16:47:09 -0400
Subject: [PATCH 631/762] docs: Fix typo in environment documentation (#19164)

Update incorrect spelling of Raycast in environment.md
---
 docs/src/environment.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/src/environment.md b/docs/src/environment.md
index 783311cace7e8a..41980b2d96f510 100644
--- a/docs/src/environment.md
+++ b/docs/src/environment.md
@@ -32,7 +32,7 @@ Starting with Zed 0.152.0, the CLI `zed` will _always_ pass along its environmen
 
 ### Launched via window manager, Dock, or launcher
 
-When Zed has been launched via the macOS Dock, or a GNOME or KDE icon on Linux, or an application launcher like Alfred or Raycats, it has no surrounding shell environment from which to inherit its environment variables.
+When Zed has been launched via the macOS Dock, or a GNOME or KDE icon on Linux, or an application launcher like Alfred or Raycast, it has no surrounding shell environment from which to inherit its environment variables.
 
 In order to still have a useful environment, Zed spawns a login shell in the user's home directory and gets its environment. This environment is then set on the Zed _process_. That means all Zed windows and projects will inherit that home directory environment.
 

From ec5d6e96bb304886f49680b54e58c9b0e7221cd6 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Mon, 14 Oct 2024 01:50:46 +0300
Subject: [PATCH 632/762] Make `danger` to output less false-positives (#19151)

---
 script/danger/dangerfile.ts |  5 +++--
 typos.toml                  | 18 ++++++++++--------
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/script/danger/dangerfile.ts b/script/danger/dangerfile.ts
index be014dbe1d4099..4ffe1459df1891 100644
--- a/script/danger/dangerfile.ts
+++ b/script/danger/dangerfile.ts
@@ -37,10 +37,11 @@ if (!hasReleaseNotes) {
 }
 
 const ISSUE_LINK_PATTERN = new RegExp(
-  "https://github\\.com/[\\w-]+/[\\w-]+/issues/\\d+",
-  "g",
+  "(?<!(?:Close[sd]?|Fixe[sd]|Resolve[sd]|Implement[sed])\\s+)https://github\\.com/[\\w-]+/[\\w-]+/issues/\\d+",
+  "gi"
 );
 
+
 const includesIssueUrl = ISSUE_LINK_PATTERN.test(body);
 
 if (includesIssueUrl) {
diff --git a/typos.toml b/typos.toml
index 2760af0b7d54e9..0682d0a3a9e182 100644
--- a/typos.toml
+++ b/typos.toml
@@ -7,7 +7,7 @@ extend-exclude = [
     # Contributor names aren't typos.
     ".mailmap",
 
-    # File suffixes aren't typos
+    # File suffixes aren't typos.
     "assets/icons/file_icons/file_types.json",
     "crates/extensions_ui/src/extension_suggest.rs",
 
@@ -21,26 +21,28 @@ extend-exclude = [
 
     # Stripe IDs are flagged as typos.
     "crates/collab/src/db/tests/processed_stripe_event_tests.rs",
-    # Not our typos
+    # Not our typos.
     "crates/live_kit_server/",
-    # Vim makes heavy use of partial typing tables
+    # Vim makes heavy use of partial typing tables.
     "crates/vim/",
-    # Editor and file finder rely on partial typing and custom in-string syntax
+    # Editor and file finder rely on partial typing and custom in-string syntax.
     "crates/file_finder/src/file_finder_tests.rs",
     "crates/editor/src/editor_tests.rs",
-    # Clojure uses .edn filename extension, which is not a misspelling of "end"
+    # Clojure uses .edn filename extension, which is not a misspelling of "end".
     "extensions/clojure/languages/clojure/config.toml",
     # There are some names in the test data that are incorrectly flagged as typos.
     "crates/git/test_data/blame_incremental_complex",
     "crates/git/test_data/golden/blame_incremental_complex.json",
     # We have some base64-encoded data that is incorrectly being flagged.
     "crates/rpc/src/auth.rs",
-    # glsl isn't recognized by this tool
+    # glsl isn't recognized by this tool.
     "extensions/glsl/languages/glsl/",
-    # Windows likes its abbreviations
+    # Windows likes its abbreviations.
     "crates/gpui/src/platform/windows/",
     # Some typos in the base mdBook CSS.
-    "docs/theme/css/"
+    "docs/theme/css/",
+    # Spellcheck triggers on `|Fixe[sd]|` regex part.
+    "script/danger/dangerfile.ts",
 ]
 
 [default]

From 325f106c8b34ce972bc953f6d104fd051a818477 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=96mer=20Sinan=20A=C4=9Facan?= <omeragacan@gmail.com>
Date: Mon, 14 Oct 2024 09:59:29 +0200
Subject: [PATCH 633/762] Add vim::Search command option for non-regex search
 (#19177)

Similar to e2647025ac833856961a1234ed2bd0202f9c4746, this adds a `regex`
option to `vim::Search` command to allow disabling regex search.

Release Notes:

- Added `regex` option to `vim::Search` command to allow disabling regex
search by default in the keymap. Example usage:
  ```yaml
  {
    "context": "VimControl && !menu",
    "bindings": {
      "/": ["vim::Search", { "regex": false }],
    }
  }
  ```
---
 crates/vim/src/normal/search.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/crates/vim/src/normal/search.rs b/crates/vim/src/normal/search.rs
index 364e29242b3f3b..507d21429b8529 100644
--- a/crates/vim/src/normal/search.rs
+++ b/crates/vim/src/normal/search.rs
@@ -41,6 +41,8 @@ pub(crate) struct MoveToPrev {
 pub(crate) struct Search {
     #[serde(default)]
     backwards: bool,
+    #[serde(default = "default_true")]
+    regex: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Deserialize)]
@@ -130,7 +132,11 @@ impl Vim {
                     cx.focus_self();
 
                     search_bar.set_replacement(None, cx);
-                    search_bar.set_search_options(SearchOptions::NONE | SearchOptions::REGEX, cx);
+                    let mut options = SearchOptions::NONE;
+                    if action.regex {
+                        options |= SearchOptions::REGEX;
+                    }
+                    search_bar.set_search_options(options, cx);
 
                     self.search = SearchState {
                         direction,

From 5b207ba2385e1daf25c711486a2fac4d2e2b308f Mon Sep 17 00:00:00 2001
From: Frank Sheiness <syndesis@gmail.com>
Date: Mon, 14 Oct 2024 02:00:37 -0600
Subject: [PATCH 634/762] vim: Add some "z" keybindings for scrolling (#18928)

Release Notes:

- vim: Added a few "z" keybindings for scrolling
---
 assets/keymaps/vim.json | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index f3a088f11e5d27..fc3adcc95e24ca 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -128,6 +128,10 @@
       "shift-m": "vim::WindowMiddle",
       "shift-l": "vim::WindowBottom",
       // z commands
+      "z enter": ["workspace::SendKeystrokes", "z t ^"],
+      "z -": ["workspace::SendKeystrokes", "z b ^"],
+      "z ^": ["workspace::SendKeystrokes", "shift-h k z b ^"],
+      "z +": ["workspace::SendKeystrokes", "shift-l j z t ^"],
       "z t": "editor::ScrollCursorTop",
       "z z": "editor::ScrollCursorCenter",
       "z .": ["workspace::SendKeystrokes", "z z ^"],

From 7dc069100d44e009083247ba6662a44380c6701e Mon Sep 17 00:00:00 2001
From: Xavier Lau <x@acg.box>
Date: Mon, 14 Oct 2024 16:20:36 +0800
Subject: [PATCH 635/762] Improve macOS build guide (#19172)

- `mold` moved to `sold` long time ago.
  And https://github.com/bluewhalesystems/sold/issues/43...
- And add a step for accepting xcodebuild license

Signed-off-by: Xavier Lau <x@acg.box>
---
 docs/src/development/macos.md | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/docs/src/development/macos.md b/docs/src/development/macos.md
index c5cbf56e15f1a3..2fd076b0fad71c 100644
--- a/docs/src/development/macos.md
+++ b/docs/src/development/macos.md
@@ -21,6 +21,7 @@ Clone down the [Zed repository](https://github.com/zed-industries/zed).
 
   ```sh
   sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer
+  sudo xcodebuild -license accept
   ```
 
 - Install the Rust wasm toolchain:
@@ -35,12 +36,6 @@ Clone down the [Zed repository](https://github.com/zed-industries/zed).
   brew install cmake
   ```
 
-- (Optional) Install `mold` to speed up link times
-
-  ```sh
-  brew install mold
-  ```
-
 ## Backend Dependencies
 
 If you are developing collaborative features of Zed, you'll need to install the dependencies of zed's `collab` server:

From fcf9e546da8727c515ac05ab3ba4d808d93dfa39 Mon Sep 17 00:00:00 2001
From: Lilith Iris <83819417+Irilith@users.noreply.github.com>
Date: Mon, 14 Oct 2024 16:13:53 +0700
Subject: [PATCH 636/762] project: Fix content not displaying when selecting a
 folder in Windows (#18946)

- Closes #16998

This PR resolves issues with the /file and /diagnostics commands in the
assistant panel, which previously failed to display the contents of a
directory when searching for a folder instead of using the arrow button.

- Changed the format in `project.rs` (located at
`crates/project/src/project.rs`) to use `std::path::MAIN_SEPARATOR` for
cross-platform compatibility, which resolves errors encountered on
Windows that originally used the format `format!("{}/", ...)`.


Release Notes:

- N/A
---
 crates/project/src/project.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index f4d02f47f3e8da..68f07f1ca9191e 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -3969,7 +3969,7 @@ impl<'a> fuzzy::PathMatchCandidateSet<'a> for PathMatchCandidateSet {
         if self.snapshot.root_entry().map_or(false, |e| e.is_file()) {
             self.snapshot.root_name().into()
         } else if self.include_root_name {
-            format!("{}/", self.snapshot.root_name()).into()
+            format!("{}{}", self.snapshot.root_name(), std::path::MAIN_SEPARATOR).into()
         } else {
             Arc::default()
         }

From f2337bbed1d0ef6909ab8c8b8287ccdb27389063 Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Mon, 14 Oct 2024 12:39:20 +0200
Subject: [PATCH 637/762] Redirect to checkout page when payment is required
 (#19179)

Previously, we were redirecting to a non-existant page.

Release Notes:

- N/A
---
 crates/assistant/src/assistant_panel.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 0439122cb48a56..943cbbb29ff015 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -4347,7 +4347,7 @@ impl ContextEditor {
 
     fn render_payment_required_error(&self, cx: &mut ViewContext<Self>) -> AnyElement {
         const ERROR_MESSAGE: &str = "Free tier exceeded. Subscribe and add payment to continue using Zed LLMs. You'll be billed at cost for tokens used.";
-        const SUBSCRIBE_URL: &str = "https://zed.dev/ai/subscribe";
+        const SUBSCRIBE_URL: &str = "https://zed.dev/api/billing/initiate_checkout";
 
         v_flex()
             .gap_0p5()

From 71a878aa399877268c6aa50ff2e8527f16cbf9c8 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Mon, 14 Oct 2024 14:13:06 +0200
Subject: [PATCH 638/762] remote ssh: Fix asset embedding in cross-compilation
 (#19180)

This fixes the panic from the settings file not being embedded.


Release Notes:

- N/A

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 Cargo.lock                                    | 1 +
 crates/recent_projects/src/ssh_connections.rs | 4 +++-
 crates/remote_server/Cargo.toml               | 5 +++++
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/Cargo.lock b/Cargo.lock
index 14b9f254037a61..a76e7e5a6d745b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9153,6 +9153,7 @@ dependencies = [
  "project",
  "remote",
  "rpc",
+ "rust-embed",
  "serde",
  "serde_json",
  "settings",
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 318c2aec6a9196..a78a1dbcdf84f4 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -461,7 +461,7 @@ impl SshClientDelegate {
         } else if let Some(triple) = platform.triple() {
             smol::fs::create_dir_all("target/remote-server").await?;
 
-            self.update_status(Some("Installing cross.rs"), cx);
+            self.update_status(Some("Installing cross.rs for cross-compilation"), cx);
             log::info!("installing cross");
             run_cmd(Command::new("cargo").args([
                 "install",
@@ -485,6 +485,8 @@ impl SshClientDelegate {
                         "build",
                         "--package",
                         "remote_server",
+                        "--features",
+                        "debug-embed",
                         "--target-dir",
                         "target/remote_server",
                         "--target",
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index bd619191514c52..25c5860a00900e 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -18,6 +18,7 @@ name = "remote_server"
 
 [features]
 default = []
+debug-embed = ["dep:rust-embed"]
 test-support = ["fs/test-support"]
 
 [dependencies]
@@ -36,6 +37,7 @@ node_runtime.workspace = true
 project.workspace = true
 remote.workspace = true
 rpc.workspace = true
+rust-embed = { workspace = true, optional = true, features = ["debug-embed"] }
 serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
@@ -61,3 +63,6 @@ serde_json.workspace = true
 [build-dependencies]
 cargo_toml.workspace = true
 toml.workspace = true
+
+[package.metadata.cargo-machete]
+ignored = ["rust-embed"]

From 6ec00cdb06659ac2f209a43d71e77f1e4085ba06 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Mon, 14 Oct 2024 14:56:25 +0200
Subject: [PATCH 639/762] ssh remoting: Restore SSH projects when reopening Zed
 (#19188)

Release Notes:

- N/A

---------

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/workspace/src/persistence.rs       | 163 +++++++++++++++++++---
 crates/workspace/src/persistence/model.rs |  11 +-
 crates/workspace/src/workspace.rs         |   4 +-
 crates/zed/src/main.rs                    |  51 +++++--
 crates/zed/src/zed/open_listener.rs       |  91 +++++++-----
 5 files changed, 249 insertions(+), 71 deletions(-)

diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs
index 3a0b8eabb90e6b..69217fcc457968 100644
--- a/crates/workspace/src/persistence.rs
+++ b/crates/workspace/src/persistence.rs
@@ -732,9 +732,11 @@ impl WorkspaceDb {
                                 bottom_dock_visible,
                                 bottom_dock_active_panel,
                                 bottom_dock_zoom,
+                                session_id,
+                                window_id,
                                 timestamp
                             )
-                            VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, CURRENT_TIMESTAMP)
+                            VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, CURRENT_TIMESTAMP)
                             ON CONFLICT DO
                             UPDATE SET
                                 ssh_project_id = ?2,
@@ -747,11 +749,15 @@ impl WorkspaceDb {
                                 bottom_dock_visible = ?9,
                                 bottom_dock_active_panel = ?10,
                                 bottom_dock_zoom = ?11,
+                                session_id = ?12,
+                                window_id = ?13,
                                 timestamp = CURRENT_TIMESTAMP
                         ))?((
                             workspace.id,
                             ssh_project.id.0,
                             workspace.docks,
+                            workspace.session_id,
+                            workspace.window_id
                         ))
                         .context("Updating workspace")?;
                     }
@@ -827,8 +833,8 @@ impl WorkspaceDb {
     }
 
     query! {
-        fn session_workspaces(session_id: String) -> Result<Vec<(LocalPaths, Option<u64>)>> {
-            SELECT local_paths, window_id
+        fn session_workspaces(session_id: String) -> Result<Vec<(LocalPaths, Option<u64>, Option<u64>)>> {
+            SELECT local_paths, window_id, ssh_project_id
             FROM workspaces
             WHERE session_id = ?1 AND dev_server_project_id IS NULL
             ORDER BY timestamp DESC
@@ -849,6 +855,14 @@ impl WorkspaceDb {
         }
     }
 
+    query! {
+        fn ssh_project(id: u64) -> Result<SerializedSshProject> {
+            SELECT id, host, port, paths, user
+            FROM ssh_projects
+            WHERE id = ?
+        }
+    }
+
     pub(crate) fn last_window(
         &self,
     ) -> anyhow::Result<(Option<Uuid>, Option<SerializedWindowBounds>)> {
@@ -937,18 +951,13 @@ impl WorkspaceDb {
         Ok(result)
     }
 
-    pub async fn last_workspace(&self) -> Result<Option<LocalPaths>> {
+    pub async fn last_workspace(&self) -> Result<Option<SerializedWorkspaceLocation>> {
         Ok(self
             .recent_workspaces_on_disk()
             .await?
             .into_iter()
-            .filter_map(|(_, location)| match location {
-                SerializedWorkspaceLocation::Local(local_paths, _) => Some(local_paths),
-                // Do not automatically reopen Dev Server and SSH workspaces
-                SerializedWorkspaceLocation::DevServer(_) => None,
-                SerializedWorkspaceLocation::Ssh(_) => None,
-            })
-            .next())
+            .next()
+            .map(|(_, location)| location))
     }
 
     // Returns the locations of the workspaces that were still opened when the last
@@ -959,13 +968,20 @@ impl WorkspaceDb {
         &self,
         last_session_id: &str,
         last_session_window_stack: Option<Vec<WindowId>>,
-    ) -> Result<Vec<LocalPaths>> {
+    ) -> Result<Vec<SerializedWorkspaceLocation>> {
         let mut workspaces = Vec::new();
 
-        for (location, window_id) in self.session_workspaces(last_session_id.to_owned())? {
-            if location.paths().iter().all(|path| path.exists())
+        for (location, window_id, ssh_project_id) in
+            self.session_workspaces(last_session_id.to_owned())?
+        {
+            if let Some(ssh_project_id) = ssh_project_id {
+                let location = SerializedWorkspaceLocation::Ssh(self.ssh_project(ssh_project_id)?);
+                workspaces.push((location, window_id.map(WindowId::from)));
+            } else if location.paths().iter().all(|path| path.exists())
                 && location.paths().iter().any(|path| path.is_dir())
             {
+                let location =
+                    SerializedWorkspaceLocation::from_local_paths(location.paths().iter());
                 workspaces.push((location, window_id.map(WindowId::from)));
             }
         }
@@ -1570,10 +1586,28 @@ mod tests {
             window_id: None,
         };
 
+        let ssh_project = db
+            .get_or_create_ssh_project("my-host".to_string(), Some(1234), vec![], None)
+            .await
+            .unwrap();
+
+        let workspace_5 = SerializedWorkspace {
+            id: WorkspaceId(5),
+            location: SerializedWorkspaceLocation::Ssh(ssh_project.clone()),
+            center_group: Default::default(),
+            window_bounds: Default::default(),
+            display: Default::default(),
+            docks: Default::default(),
+            centered_layout: false,
+            session_id: Some("session-id-2".to_owned()),
+            window_id: Some(50),
+        };
+
         db.save_workspace(workspace_1.clone()).await;
         db.save_workspace(workspace_2.clone()).await;
         db.save_workspace(workspace_3.clone()).await;
         db.save_workspace(workspace_4.clone()).await;
+        db.save_workspace(workspace_5.clone()).await;
 
         let locations = db.session_workspaces("session-id-1".to_owned()).unwrap();
         assert_eq!(locations.len(), 2);
@@ -1583,9 +1617,13 @@ mod tests {
         assert_eq!(locations[1].1, Some(20));
 
         let locations = db.session_workspaces("session-id-2".to_owned()).unwrap();
-        assert_eq!(locations.len(), 1);
+        assert_eq!(locations.len(), 2);
         assert_eq!(locations[0].0, LocalPaths::new(["/tmp3"]));
         assert_eq!(locations[0].1, Some(30));
+        let empty_paths: Vec<&str> = Vec::new();
+        assert_eq!(locations[1].0, LocalPaths::new(empty_paths.iter()));
+        assert_eq!(locations[1].1, Some(50));
+        assert_eq!(locations[1].2, Some(ssh_project.id.0));
     }
 
     fn default_workspace<P: AsRef<Path>>(
@@ -1650,10 +1688,97 @@ mod tests {
             .last_session_workspace_locations("one-session", stack)
             .unwrap();
         assert_eq!(have.len(), 4);
-        assert_eq!(have[0], LocalPaths::new([dir4.path().to_str().unwrap()]));
-        assert_eq!(have[1], LocalPaths::new([dir3.path().to_str().unwrap()]));
-        assert_eq!(have[2], LocalPaths::new([dir2.path().to_str().unwrap()]));
-        assert_eq!(have[3], LocalPaths::new([dir1.path().to_str().unwrap()]));
+        assert_eq!(
+            have[0],
+            SerializedWorkspaceLocation::from_local_paths(&[dir4.path().to_str().unwrap()])
+        );
+        assert_eq!(
+            have[1],
+            SerializedWorkspaceLocation::from_local_paths([dir3.path().to_str().unwrap()])
+        );
+        assert_eq!(
+            have[2],
+            SerializedWorkspaceLocation::from_local_paths([dir2.path().to_str().unwrap()])
+        );
+        assert_eq!(
+            have[3],
+            SerializedWorkspaceLocation::from_local_paths([dir1.path().to_str().unwrap()])
+        );
+    }
+
+    #[gpui::test]
+    async fn test_last_session_workspace_locations_ssh_projects() {
+        let db = WorkspaceDb(
+            open_test_db("test_serializing_workspaces_last_session_workspaces_ssh_projects").await,
+        );
+
+        let ssh_projects = [
+            ("host-1", "my-user-1"),
+            ("host-2", "my-user-2"),
+            ("host-3", "my-user-3"),
+            ("host-4", "my-user-4"),
+        ]
+        .into_iter()
+        .map(|(host, user)| async {
+            db.get_or_create_ssh_project(host.to_string(), None, vec![], Some(user.to_string()))
+                .await
+                .unwrap()
+        })
+        .collect::<Vec<_>>();
+
+        let ssh_projects = futures::future::join_all(ssh_projects).await;
+
+        let workspaces = [
+            (1, ssh_projects[0].clone(), 9),
+            (2, ssh_projects[1].clone(), 5),
+            (3, ssh_projects[2].clone(), 8),
+            (4, ssh_projects[3].clone(), 2),
+        ]
+        .into_iter()
+        .map(|(id, ssh_project, window_id)| SerializedWorkspace {
+            id: WorkspaceId(id),
+            location: SerializedWorkspaceLocation::Ssh(ssh_project),
+            center_group: Default::default(),
+            window_bounds: Default::default(),
+            display: Default::default(),
+            docks: Default::default(),
+            centered_layout: false,
+            session_id: Some("one-session".to_owned()),
+            window_id: Some(window_id),
+        })
+        .collect::<Vec<_>>();
+
+        for workspace in workspaces.iter() {
+            db.save_workspace(workspace.clone()).await;
+        }
+
+        let stack = Some(Vec::from([
+            WindowId::from(2), // Top
+            WindowId::from(8),
+            WindowId::from(5),
+            WindowId::from(9), // Bottom
+        ]));
+
+        let have = db
+            .last_session_workspace_locations("one-session", stack)
+            .unwrap();
+        assert_eq!(have.len(), 4);
+        assert_eq!(
+            have[0],
+            SerializedWorkspaceLocation::Ssh(ssh_projects[3].clone())
+        );
+        assert_eq!(
+            have[1],
+            SerializedWorkspaceLocation::Ssh(ssh_projects[2].clone())
+        );
+        assert_eq!(
+            have[2],
+            SerializedWorkspaceLocation::Ssh(ssh_projects[1].clone())
+        );
+        assert_eq!(
+            have[3],
+            SerializedWorkspaceLocation::Ssh(ssh_projects[0].clone())
+        );
     }
 
     #[gpui::test]
diff --git a/crates/workspace/src/persistence/model.rs b/crates/workspace/src/persistence/model.rs
index 7528e4c3934c57..5efc77205c3469 100644
--- a/crates/workspace/src/persistence/model.rs
+++ b/crates/workspace/src/persistence/model.rs
@@ -11,7 +11,7 @@ use db::sqlez::{
 };
 use gpui::{AsyncWindowContext, Model, View, WeakView};
 use project::Project;
-use remote::ssh_session::SshProjectId;
+use remote::{ssh_session::SshProjectId, SshConnectionOptions};
 use serde::{Deserialize, Serialize};
 use std::{
     path::{Path, PathBuf},
@@ -50,6 +50,15 @@ impl SerializedSshProject {
             })
             .collect()
     }
+
+    pub fn connection_options(&self) -> SshConnectionOptions {
+        SshConnectionOptions {
+            host: self.host.clone(),
+            username: self.user.clone(),
+            port: self.port,
+            password: None,
+        }
+    }
 }
 
 impl StaticColumnCount for SerializedSshProject {
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 11acee84939eb4..3c3b26b4c137d2 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -5046,14 +5046,14 @@ pub fn activate_workspace_for_project(
     None
 }
 
-pub async fn last_opened_workspace_paths() -> Option<LocalPaths> {
+pub async fn last_opened_workspace_location() -> Option<SerializedWorkspaceLocation> {
     DB.last_workspace().await.log_err().flatten()
 }
 
 pub fn last_session_workspace_locations(
     last_session_id: &str,
     last_session_window_stack: Option<Vec<WindowId>>,
-) -> Option<Vec<LocalPaths>> {
+) -> Option<Vec<SerializedWorkspaceLocation>> {
     DB.last_session_workspace_locations(last_session_id, last_session_window_stack)
         .log_err()
 }
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 6652e235042a0c..25baf74c68d894 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -26,6 +26,7 @@ use gpui::{
 use http_client::{read_proxy_from_env, Uri};
 use language::LanguageRegistry;
 use log::LevelFilter;
+use remote::SshConnectionOptions;
 use reqwest_client::ReqwestClient;
 
 use assets::Assets;
@@ -55,7 +56,7 @@ use uuid::Uuid;
 use welcome::{show_welcome_view, BaseKeymap, FIRST_OPEN};
 use workspace::{
     notifications::{simple_message_notification::MessageNotification, NotificationId},
-    AppState, WorkspaceSettings, WorkspaceStore,
+    AppState, SerializedWorkspaceLocation, WorkspaceSettings, WorkspaceStore,
 };
 use zed::{
     app_menus, build_window_options, derive_paths_with_position, handle_cli_connection,
@@ -868,15 +869,41 @@ async fn restore_or_create_workspace(
 ) -> Result<()> {
     if let Some(locations) = restorable_workspace_locations(cx, &app_state).await {
         for location in locations {
-            cx.update(|cx| {
-                workspace::open_paths(
-                    location.paths().as_ref(),
-                    app_state.clone(),
-                    workspace::OpenOptions::default(),
-                    cx,
-                )
-            })?
-            .await?;
+            match location {
+                SerializedWorkspaceLocation::Local(location, _) => {
+                    let task = cx.update(|cx| {
+                        workspace::open_paths(
+                            location.paths().as_ref(),
+                            app_state.clone(),
+                            workspace::OpenOptions::default(),
+                            cx,
+                        )
+                    })?;
+                    task.await?;
+                }
+                SerializedWorkspaceLocation::Ssh(ssh_project) => {
+                    let connection_options = SshConnectionOptions {
+                        host: ssh_project.host.clone(),
+                        username: ssh_project.user.clone(),
+                        port: ssh_project.port,
+                        password: None,
+                    };
+                    let app_state = app_state.clone();
+                    cx.spawn(move |mut cx| async move {
+                        recent_projects::open_ssh_project(
+                            connection_options,
+                            ssh_project.paths.into_iter().map(PathBuf::from).collect(),
+                            app_state,
+                            workspace::OpenOptions::default(),
+                            &mut cx,
+                        )
+                        .await
+                        .log_err();
+                    })
+                    .detach();
+                }
+                SerializedWorkspaceLocation::DevServer(_) => {}
+            }
         }
     } else if matches!(KEY_VALUE_STORE.read_kvp(FIRST_OPEN), Ok(None)) {
         cx.update(|cx| show_welcome_view(app_state, cx))?.await?;
@@ -895,7 +922,7 @@ async fn restore_or_create_workspace(
 pub(crate) async fn restorable_workspace_locations(
     cx: &mut AsyncAppContext,
     app_state: &Arc<AppState>,
-) -> Option<Vec<workspace::LocalPaths>> {
+) -> Option<Vec<SerializedWorkspaceLocation>> {
     let mut restore_behavior = cx
         .update(|cx| WorkspaceSettings::get(None, cx).restore_on_startup)
         .ok()?;
@@ -923,7 +950,7 @@ pub(crate) async fn restorable_workspace_locations(
 
     match restore_behavior {
         workspace::RestoreOnStartupBehavior::LastWorkspace => {
-            workspace::last_opened_workspace_paths()
+            workspace::last_opened_workspace_location()
                 .await
                 .map(|location| vec![location])
         }
diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs
index c40876ad7a9f31..66d27888214ff0 100644
--- a/crates/zed/src/zed/open_listener.rs
+++ b/crates/zed/src/zed/open_listener.rs
@@ -16,8 +16,9 @@ use futures::future::join_all;
 use futures::{FutureExt, SinkExt, StreamExt};
 use gpui::{AppContext, AsyncAppContext, Global, WindowHandle};
 use language::{Bias, Point};
+use recent_projects::open_ssh_project;
 use remote::SshConnectionOptions;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
 use std::{process, thread};
@@ -25,7 +26,7 @@ use util::paths::PathWithPosition;
 use util::ResultExt;
 use welcome::{show_welcome_view, FIRST_OPEN};
 use workspace::item::ItemHandle;
-use workspace::{AppState, OpenOptions, Workspace};
+use workspace::{AppState, OpenOptions, SerializedWorkspaceLocation, Workspace};
 
 #[derive(Default, Debug)]
 pub struct OpenRequest {
@@ -356,33 +357,21 @@ async fn open_workspaces(
     env: Option<collections::HashMap<String, String>>,
     cx: &mut AsyncAppContext,
 ) -> Result<()> {
-    let grouped_paths = if paths.is_empty() {
+    let grouped_locations = if paths.is_empty() {
         // If no paths are provided, restore from previous workspaces unless a new workspace is requested with -n
         if open_new_workspace == Some(true) {
             Vec::new()
         } else {
             let locations = restorable_workspace_locations(cx, &app_state).await;
-            locations
-                .into_iter()
-                .flat_map(|locations| {
-                    locations
-                        .into_iter()
-                        .map(|location| {
-                            location
-                                .paths()
-                                .iter()
-                                .map(|path| path.to_string_lossy().to_string())
-                                .collect()
-                        })
-                        .collect::<Vec<_>>()
-                })
-                .collect()
+            locations.unwrap_or_default()
         }
     } else {
-        vec![paths]
+        vec![SerializedWorkspaceLocation::from_local_paths(
+            paths.into_iter().map(PathBuf::from),
+        )]
     };
 
-    if grouped_paths.is_empty() {
+    if grouped_locations.is_empty() {
         // If we have no paths to open, show the welcome screen if this is the first launch
         if matches!(KEY_VALUE_STORE.read_kvp(FIRST_OPEN), Ok(None)) {
             cx.update(|cx| show_welcome_view(app_state, cx).detach())
@@ -406,20 +395,48 @@ async fn open_workspaces(
         // If there are paths to open, open a workspace for each grouping of paths
         let mut errored = false;
 
-        for workspace_paths in grouped_paths {
-            let workspace_failed_to_open = open_workspace(
-                workspace_paths,
-                open_new_workspace,
-                wait,
-                responses,
-                env.as_ref(),
-                &app_state,
-                cx,
-            )
-            .await;
-
-            if workspace_failed_to_open {
-                errored = true
+        for location in grouped_locations {
+            match location {
+                SerializedWorkspaceLocation::Local(workspace_paths, _) => {
+                    let workspace_paths = workspace_paths
+                        .paths()
+                        .iter()
+                        .map(|path| path.to_string_lossy().to_string())
+                        .collect();
+
+                    let workspace_failed_to_open = open_local_workspace(
+                        workspace_paths,
+                        open_new_workspace,
+                        wait,
+                        responses,
+                        env.as_ref(),
+                        &app_state,
+                        cx,
+                    )
+                    .await;
+
+                    if workspace_failed_to_open {
+                        errored = true
+                    }
+                }
+                SerializedWorkspaceLocation::Ssh(ssh_project) => {
+                    let app_state = app_state.clone();
+                    cx.spawn(|mut cx| async move {
+                        open_ssh_project(
+                            ssh_project.connection_options(),
+                            ssh_project.paths.into_iter().map(PathBuf::from).collect(),
+                            app_state,
+                            OpenOptions::default(),
+                            &mut cx,
+                        )
+                        .await
+                        .log_err();
+                    })
+                    .detach();
+                    // We don't set `errored` here, because for ssh projects, the
+                    // error is displayed in the window.
+                }
+                SerializedWorkspaceLocation::DevServer(_) => {}
             }
         }
 
@@ -431,7 +448,7 @@ async fn open_workspaces(
     Ok(())
 }
 
-async fn open_workspace(
+async fn open_local_workspace(
     workspace_paths: Vec<String>,
     open_new_workspace: Option<bool>,
     wait: bool,
@@ -563,7 +580,7 @@ mod tests {
     use serde_json::json;
     use workspace::{AppState, Workspace};
 
-    use crate::zed::{open_listener::open_workspace, tests::init_test};
+    use crate::zed::{open_listener::open_local_workspace, tests::init_test};
 
     #[gpui::test]
     async fn test_open_workspace_with_directory(cx: &mut TestAppContext) {
@@ -678,7 +695,7 @@ mod tests {
 
         let errored = cx
             .spawn(|mut cx| async move {
-                open_workspace(
+                open_local_workspace(
                     workspace_paths,
                     open_new_workspace,
                     false,

From 792f583b97e17301232f96d79e58ca512f44ed8c Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Mon, 14 Oct 2024 15:19:10 +0200
Subject: [PATCH 640/762] Revert "chore: Bump taffy to 0.5.2 (#18729)" (#19189)

This reverts commit a99750fd35ef4f44409f474228285b1842c1b7d3.

@huacnlee found that commit to have a bad impact on perf and triaged it
for us in
https://github.com/zed-industries/zed/pull/18729#issuecomment-2410445980
Closes #ISSUE

Release Notes:

- N/A
---
 Cargo.lock               | 8 ++++----
 crates/gpui/Cargo.toml   | 2 +-
 crates/gpui/src/taffy.rs | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a76e7e5a6d745b..db14b8c7ae431c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5110,9 +5110,9 @@ dependencies = [
 
 [[package]]
 name = "grid"
-version = "0.14.0"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be136d9dacc2a13cc70bb6c8f902b414fb2641f8db1314637c6b7933411a8f82"
+checksum = "d196ffc1627db18a531359249b2bf8416178d84b729f3cebeb278f285fb9b58c"
 
 [[package]]
 name = "group"
@@ -11430,9 +11430,9 @@ dependencies = [
 
 [[package]]
 name = "taffy"
-version = "0.5.2"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cb893bff0f80ae17d3a57e030622a967b8dbc90e38284d9b4b1442e23873c94"
+checksum = "9ec17858c2d465b2f734b798b920818a974faf0babb15d7fef81818a4b2d16f1"
 dependencies = [
  "arrayvec",
  "grid",
diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml
index 8e982da85598b9..b7fafb805809d1 100644
--- a/crates/gpui/Cargo.toml
+++ b/crates/gpui/Cargo.toml
@@ -103,7 +103,7 @@ smallvec.workspace = true
 smol.workspace = true
 strum.workspace = true
 sum_tree.workspace = true
-taffy = "0.5"
+taffy = "0.4.3"
 thiserror.workspace = true
 util.workspace = true
 uuid.workspace = true
diff --git a/crates/gpui/src/taffy.rs b/crates/gpui/src/taffy.rs
index 9d99078ae5fc15..84f4d73fea8ff7 100644
--- a/crates/gpui/src/taffy.rs
+++ b/crates/gpui/src/taffy.rs
@@ -174,7 +174,7 @@ impl TaffyLayoutEngine {
             .compute_layout_with_measure(
                 id.into(),
                 available_space.into(),
-                |known_dimensions, available_space, _node_id, node_context, _style| {
+                |known_dimensions, available_space, _id, node_context| {
                     let Some(node_context) = node_context else {
                         return taffy::geometry::Size::default();
                     };

From 7d5fe66b54cb8c73966ce9d0b07a1485bd8d46d5 Mon Sep 17 00:00:00 2001
From: Shish <shish@shishnet.org>
Date: Mon, 14 Oct 2024 14:36:31 +0100
Subject: [PATCH 641/762] remote: Disable ControlPersist for master ssh
 connection (#19193)

remote: Disable ControlPersist for master ssh connection

`ControlPersist=yes` combined with `ControlMaster=yes` silently forces
`ForkAfterAuthentication=yes` (even when the user has explicitly set it
to `no` - reported upstream in [0]) - and the latter makes the ssh
subprocess disappear, which makes us think that the connection died

(This is only an issue for people who have `ControlPersist=yes` in their
`ssh_config`, and perhaps the answer is "if that option breaks things,
don't use that option?" - but it's an option that makes sense _most_ of
the time, it's just in this edge-case of "creating an ssh connection
with -N and expecting the process to stay in the foreground" where it
_must_ be set to no)

I think the alternative approach is to tell people "if you want to use
persistent connections, have a separate ~/.ssh/config entry for
servername (to ssh into) and servername-no-persist (to zed into)", which
is possible, but ugh. Kind of a messy situation >.<


Tests:

- Before: Connections to my server result in "Failed to connect: ." (The
error message is attempting to show stderr, but stderr is empty)

- After: Connections to my server work reliably


[0] https://bugzilla.mindrot.org/show_bug.cgi?id=3743


Release Notes:

- N/A
---
 crates/remote/src/ssh_session.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 564b94070f2ffc..7a2073bb55ef98 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -1144,7 +1144,14 @@ impl SshRemoteConnection {
             .stderr(Stdio::piped())
             .env("SSH_ASKPASS_REQUIRE", "force")
             .env("SSH_ASKPASS", &askpass_script_path)
-            .args(["-N", "-o", "ControlMaster=yes", "-o"])
+            .args([
+                "-N",
+                "-o",
+                "ControlPersist=no",
+                "-o",
+                "ControlMaster=yes",
+                "-o",
+            ])
             .arg(format!("ControlPath={}", socket_path.display()))
             .arg(&url)
             .spawn()?;

From 3ff52a816e4aaead85a085f5aad1a086a3318be6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E5=B0=8F=E7=99=BD?= <364772080@qq.com>
Date: Mon, 14 Oct 2024 23:23:16 +0800
Subject: [PATCH 642/762] windows: Fix opening wrong path when clicking path in
 the terminal view (#18726)

Closes #18550

This PR removes the prefix `\\?\`.

https://github.com/user-attachments/assets/f4f4333c-5d87-4f0f-b12c-fb2108703b6a


Release Notes:

- N/A
---
 crates/terminal_view/src/terminal_view.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs
index 28a3d61d654282..b2cbae0dfe695f 100644
--- a/crates/terminal_view/src/terminal_view.rs
+++ b/crates/terminal_view/src/terminal_view.rs
@@ -798,6 +798,7 @@ fn possible_open_paths_metadata(
     cx.background_executor().spawn(async move {
         let mut paths_with_metadata = Vec::with_capacity(potential_paths.len());
 
+        #[cfg(not(target_os = "windows"))]
         let mut fetch_metadata_tasks = potential_paths
             .into_iter()
             .map(|potential_path| async {
@@ -813,6 +814,20 @@ fn possible_open_paths_metadata(
             })
             .collect::<FuturesUnordered<_>>();
 
+        #[cfg(target_os = "windows")]
+        let mut fetch_metadata_tasks = potential_paths
+            .iter()
+            .map(|potential_path| async {
+                let metadata = fs.metadata(potential_path).await.ok().flatten();
+                let path = PathBuf::from(
+                    potential_path
+                        .to_string_lossy()
+                        .trim_start_matches("\\\\?\\"),
+                );
+                (PathWithPosition { path, row, column }, metadata)
+            })
+            .collect::<FuturesUnordered<_>>();
+
         while let Some((path, metadata)) = fetch_metadata_tasks.next().await {
             if let Some(metadata) = metadata {
                 paths_with_metadata.push((path, metadata));

From 6986f081d030c7fe15545b6ecc342560b3ef04ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E5=B0=8F=E7=99=BD?= <364772080@qq.com>
Date: Mon, 14 Oct 2024 23:27:15 +0800
Subject: [PATCH 643/762] supermaven: Fix crash when editing non-ASCII text
 (#19153)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes #19051
Closes #19182


#### How to reproduce this crash:
1. Open any file and input some ASCII characters.
2. Replace these characters with `你好`.
3. Press `backspace`.
4. Crash.



https://github.com/user-attachments/assets/ea5c5340-29a5-42c8-98c5-6e60770445a4



The issue lies with the `prefix_offset` introduced in #18858. After the
buffer is modified, this value is not always valid and may fall within a
`char boundary`, which results in a crash.



Release Notes:

- Fixed Supermaven crashing on deleting non-ASCII text
---
 crates/supermaven/src/supermaven.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/supermaven/src/supermaven.rs b/crates/supermaven/src/supermaven.rs
index 38e11a2300a642..68a55504028f70 100644
--- a/crates/supermaven/src/supermaven.rs
+++ b/crates/supermaven/src/supermaven.rs
@@ -217,11 +217,11 @@ fn find_relevant_completion<'a>(
         };
 
         let current_cursor_offset = cursor_position.to_offset(buffer);
-        let original_cursor_offset = state.prefix_offset;
-        if current_cursor_offset < original_cursor_offset {
+        if current_cursor_offset < state.prefix_offset {
             continue;
         }
 
+        let original_cursor_offset = buffer.clip_offset(state.prefix_offset, text::Bias::Left);
         let text_inserted_since_completion_request =
             buffer.text_for_range(original_cursor_offset..current_cursor_offset);
         let mut trimmed_completion = state_completion;

From 6e2869a321de7a51a970f97012f00cf3335ea06e Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Mon, 14 Oct 2024 17:31:51 +0200
Subject: [PATCH 644/762] Prevent deadlock when create a new meter/price on
 Stripe (#19196)

This also puts the entire state of `StripeBilling` behind a `RwLock`.
When fetching the existing prices and meters, or when inserting new
ones, we acquire a write lock and hold it until the Stripe request
completes. This prevents two concurrent calls to `get_or_insert_price`
from inserting the same data twice.

Creating a new meter/price is unusual, so in practice we'll acquire a
read lock most of the time.

/cc @rtfeldman @maxdeviant

Release Notes:

- N/A
---
 crates/collab/src/stripe_billing.rs | 199 +++++++++++++++-------------
 1 file changed, 107 insertions(+), 92 deletions(-)

diff --git a/crates/collab/src/stripe_billing.rs b/crates/collab/src/stripe_billing.rs
index ee7d93979dafe6..c121d8e8fddb32 100644
--- a/crates/collab/src/stripe_billing.rs
+++ b/crates/collab/src/stripe_billing.rs
@@ -8,11 +8,16 @@ use serde::{Deserialize, Serialize};
 use tokio::sync::RwLock;
 
 pub struct StripeBilling {
-    meters_by_event_name: RwLock<HashMap<String, StripeMeter>>,
-    price_ids_by_meter_id: RwLock<HashMap<String, stripe::PriceId>>,
+    state: RwLock<StripeBillingState>,
     client: Arc<stripe::Client>,
 }
 
+#[derive(Default)]
+struct StripeBillingState {
+    meters_by_event_name: HashMap<String, StripeMeter>,
+    price_ids_by_meter_id: HashMap<String, stripe::PriceId>,
+}
+
 pub struct StripeModel {
     input_tokens_price: StripeBillingPrice,
     input_cache_creation_tokens_price: StripeBillingPrice,
@@ -29,36 +34,36 @@ impl StripeBilling {
     pub fn new(client: Arc<stripe::Client>) -> Self {
         Self {
             client,
-            meters_by_event_name: RwLock::new(HashMap::default()),
-            price_ids_by_meter_id: RwLock::new(HashMap::default()),
+            state: RwLock::default(),
         }
     }
 
     pub async fn initialize(&self) -> Result<()> {
-        log::info!("initializing StripeBilling");
+        log::info!("StripeBilling: initializing");
 
-        {
-            let meters = StripeMeter::list(&self.client).await?.data;
-            let mut meters_by_event_name = self.meters_by_event_name.write().await;
-            for meter in meters {
-                meters_by_event_name.insert(meter.event_name.clone(), meter);
-            }
+        let mut state = self.state.write().await;
+
+        let (meters, prices) = futures::try_join!(
+            StripeMeter::list(&self.client),
+            stripe::Price::list(&self.client, &stripe::ListPrices::default())
+        )?;
+
+        for meter in meters.data {
+            state
+                .meters_by_event_name
+                .insert(meter.event_name.clone(), meter);
         }
 
-        {
-            let prices = stripe::Price::list(&self.client, &stripe::ListPrices::default())
-                .await?
-                .data;
-            let mut price_ids_by_meter_id = self.price_ids_by_meter_id.write().await;
-            for price in prices {
-                if let Some(recurring) = price.recurring {
-                    if let Some(meter) = recurring.meter {
-                        price_ids_by_meter_id.insert(meter, price.id);
-                    }
+        for price in prices.data {
+            if let Some(recurring) = price.recurring {
+                if let Some(meter) = recurring.meter {
+                    state.price_ids_by_meter_id.insert(meter, price.id);
                 }
             }
         }
 
+        log::info!("StripeBilling: initialized");
+
         Ok(())
     }
 
@@ -105,79 +110,89 @@ impl StripeBilling {
         price_description: &str,
         price_per_million_tokens: Cents,
     ) -> Result<StripeBillingPrice> {
-        let meter =
-            if let Some(meter) = self.meters_by_event_name.read().await.get(meter_event_name) {
-                meter.clone()
-            } else {
-                let meter = StripeMeter::create(
-                    &self.client,
-                    StripeCreateMeterParams {
-                        default_aggregation: DefaultAggregation { formula: "sum" },
-                        display_name: price_description.to_string(),
-                        event_name: meter_event_name,
-                    },
-                )
-                .await?;
-                self.meters_by_event_name
-                    .write()
-                    .await
-                    .insert(meter_event_name.to_string(), meter.clone());
-                meter
-            };
-
-        let price_id =
-            if let Some(price_id) = self.price_ids_by_meter_id.read().await.get(&meter.id) {
-                price_id.clone()
-            } else {
-                let price = stripe::Price::create(
-                    &self.client,
-                    stripe::CreatePrice {
+        // Fast code path when the meter and the price already exist.
+        {
+            let state = self.state.read().await;
+            if let Some(meter) = state.meters_by_event_name.get(meter_event_name) {
+                if let Some(price_id) = state.price_ids_by_meter_id.get(&meter.id) {
+                    return Ok(StripeBillingPrice {
+                        id: price_id.clone(),
+                        meter_event_name: meter_event_name.to_string(),
+                    });
+                }
+            }
+        }
+
+        let mut state = self.state.write().await;
+        let meter = if let Some(meter) = state.meters_by_event_name.get(meter_event_name) {
+            meter.clone()
+        } else {
+            let meter = StripeMeter::create(
+                &self.client,
+                StripeCreateMeterParams {
+                    default_aggregation: DefaultAggregation { formula: "sum" },
+                    display_name: price_description.to_string(),
+                    event_name: meter_event_name,
+                },
+            )
+            .await?;
+            state
+                .meters_by_event_name
+                .insert(meter_event_name.to_string(), meter.clone());
+            meter
+        };
+
+        let price_id = if let Some(price_id) = state.price_ids_by_meter_id.get(&meter.id) {
+            price_id.clone()
+        } else {
+            let price = stripe::Price::create(
+                &self.client,
+                stripe::CreatePrice {
+                    active: Some(true),
+                    billing_scheme: Some(stripe::PriceBillingScheme::PerUnit),
+                    currency: stripe::Currency::USD,
+                    currency_options: None,
+                    custom_unit_amount: None,
+                    expand: &[],
+                    lookup_key: None,
+                    metadata: None,
+                    nickname: None,
+                    product: None,
+                    product_data: Some(stripe::CreatePriceProductData {
+                        id: None,
                         active: Some(true),
-                        billing_scheme: Some(stripe::PriceBillingScheme::PerUnit),
-                        currency: stripe::Currency::USD,
-                        currency_options: None,
-                        custom_unit_amount: None,
-                        expand: &[],
-                        lookup_key: None,
                         metadata: None,
-                        nickname: None,
-                        product: None,
-                        product_data: Some(stripe::CreatePriceProductData {
-                            id: None,
-                            active: Some(true),
-                            metadata: None,
-                            name: price_description.to_string(),
-                            statement_descriptor: None,
-                            tax_code: None,
-                            unit_label: None,
-                        }),
-                        recurring: Some(stripe::CreatePriceRecurring {
-                            aggregate_usage: None,
-                            interval: stripe::CreatePriceRecurringInterval::Month,
-                            interval_count: None,
-                            trial_period_days: None,
-                            usage_type: Some(stripe::CreatePriceRecurringUsageType::Metered),
-                            meter: Some(meter.id.clone()),
-                        }),
-                        tax_behavior: None,
-                        tiers: None,
-                        tiers_mode: None,
-                        transfer_lookup_key: None,
-                        transform_quantity: None,
-                        unit_amount: None,
-                        unit_amount_decimal: Some(&format!(
-                            "{:.12}",
-                            price_per_million_tokens.0 as f64 / 1_000_000f64
-                        )),
-                    },
-                )
-                .await?;
-                self.price_ids_by_meter_id
-                    .write()
-                    .await
-                    .insert(meter.id, price.id.clone());
-                price.id
-            };
+                        name: price_description.to_string(),
+                        statement_descriptor: None,
+                        tax_code: None,
+                        unit_label: None,
+                    }),
+                    recurring: Some(stripe::CreatePriceRecurring {
+                        aggregate_usage: None,
+                        interval: stripe::CreatePriceRecurringInterval::Month,
+                        interval_count: None,
+                        trial_period_days: None,
+                        usage_type: Some(stripe::CreatePriceRecurringUsageType::Metered),
+                        meter: Some(meter.id.clone()),
+                    }),
+                    tax_behavior: None,
+                    tiers: None,
+                    tiers_mode: None,
+                    transfer_lookup_key: None,
+                    transform_quantity: None,
+                    unit_amount: None,
+                    unit_amount_decimal: Some(&format!(
+                        "{:.12}",
+                        price_per_million_tokens.0 as f64 / 1_000_000f64
+                    )),
+                },
+            )
+            .await?;
+            state
+                .price_ids_by_meter_id
+                .insert(meter.id, price.id.clone());
+            price.id
+        };
 
         Ok(StripeBillingPrice {
             id: price_id,

From 41ba4178fcfa4fb7665dcba532677572ad38a23e Mon Sep 17 00:00:00 2001
From: wannacu <76616478+wannacu@users.noreply.github.com>
Date: Tue, 15 Oct 2024 03:46:04 +0800
Subject: [PATCH 645/762] gpui: Fix crash caused by ownership leak (#19185)

- Closes #18811

Release Notes:

- N/A
---
 crates/gpui/src/platform/linux/x11/client.rs | 28 +++++++++++---------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs
index b5a5a00910b8a7..d18bc4b2777280 100644
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -675,11 +675,12 @@ impl X11Client {
                         }
                     }
                 } else if event.type_ == state.atoms.XdndLeave {
-                    window.handle_input(PlatformInput::FileDrop(FileDropEvent::Pending {
-                        position: state.xdnd_state.position,
-                    }));
+                    let position = state.xdnd_state.position;
+                    drop(state);
+                    window
+                        .handle_input(PlatformInput::FileDrop(FileDropEvent::Pending { position }));
                     window.handle_input(PlatformInput::FileDrop(FileDropEvent::Exited {}));
-                    state.xdnd_state = Xdnd::default();
+                    self.0.borrow_mut().xdnd_state = Xdnd::default();
                 } else if event.type_ == state.atoms.XdndPosition {
                     if let Ok(pos) = state
                         .xcb_connection
@@ -709,9 +710,10 @@ impl X11Client {
                         state.xdnd_state.other_window,
                         arg4,
                     );
-                    window.handle_input(PlatformInput::FileDrop(FileDropEvent::Pending {
-                        position: state.xdnd_state.position,
-                    }));
+                    let position = state.xdnd_state.position;
+                    drop(state);
+                    window
+                        .handle_input(PlatformInput::FileDrop(FileDropEvent::Pending { position }));
                 } else if event.type_ == state.atoms.XdndDrop {
                     xdnd_send_finished(
                         &state.xcb_connection,
@@ -719,10 +721,11 @@ impl X11Client {
                         event.window,
                         state.xdnd_state.other_window,
                     );
-                    window.handle_input(PlatformInput::FileDrop(FileDropEvent::Submit {
-                        position: state.xdnd_state.position,
-                    }));
-                    state.xdnd_state = Xdnd::default();
+                    let position = state.xdnd_state.position;
+                    drop(state);
+                    window
+                        .handle_input(PlatformInput::FileDrop(FileDropEvent::Submit { position }));
+                    self.0.borrow_mut().xdnd_state = Xdnd::default();
                 }
             }
             Event::SelectionNotify(event) => {
@@ -751,8 +754,9 @@ impl X11Client {
                                 position: state.xdnd_state.position,
                                 paths: crate::ExternalPaths(paths),
                             });
+                            drop(state);
                             window.handle_input(input);
-                            state.xdnd_state.retrieved = true;
+                            self.0.borrow_mut().xdnd_state.retrieved = true;
                         }
                         Err(_) => {}
                     }

From 62de03f2869766168c6a6b2a9a034f8942a0fd6f Mon Sep 17 00:00:00 2001
From: CharlesChen0823 <yongchen0823@gmail.com>
Date: Tue, 15 Oct 2024 14:27:34 +0800
Subject: [PATCH 646/762] tab: Fix copy wrong relative path for tab (#19206)

Closes #19204

Release Notes:

- Fixed relative paths copied incorrectly from tabs
([#19204](https://github.com/zed-industries/zed/issues/19204))
---
 crates/workspace/src/pane.rs | 34 ++++++++++++++++------------------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index 9333afa42a7412..c205f2a8e59a00 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -1747,17 +1747,6 @@ impl Pane {
         }
     }
 
-    fn copy_relative_path(&mut self, _: &CopyRelativePath, cx: &mut ViewContext<Self>) {
-        if let Some(clipboard_text) = self
-            .active_item()
-            .as_ref()
-            .and_then(|entry| entry.project_path(cx))
-            .map(|p| p.path.to_string_lossy().to_string())
-        {
-            cx.write_to_clipboard(ClipboardItem::new_string(clipboard_text));
-        }
-    }
-
     pub fn icon_color(selected: bool) -> Color {
         if selected {
             Color::Default
@@ -2102,6 +2091,11 @@ impl Pane {
                         let parent_abs_path = entry_abs_path
                             .as_deref()
                             .and_then(|abs_path| Some(abs_path.parent()?.to_path_buf()));
+                        let relative_path = pane
+                            .read(cx)
+                            .item_for_entry(entry, cx)
+                            .and_then(|item| item.project_path(cx))
+                            .map(|project_path| project_path.path);
 
                         let entry_id = entry.to_proto();
                         menu = menu
@@ -2117,13 +2111,17 @@ impl Pane {
                                     }),
                                 )
                             })
-                            .entry(
-                                "Copy Relative Path",
-                                Some(Box::new(CopyRelativePath)),
-                                cx.handler_for(&pane, move |pane, cx| {
-                                    pane.copy_relative_path(&CopyRelativePath, cx);
-                                }),
-                            )
+                            .when_some(relative_path, |menu, relative_path| {
+                                menu.entry(
+                                    "Copy Relative Path",
+                                    Some(Box::new(CopyRelativePath)),
+                                    cx.handler_for(&pane, move |_, cx| {
+                                        cx.write_to_clipboard(ClipboardItem::new_string(
+                                            relative_path.to_string_lossy().to_string(),
+                                        ));
+                                    }),
+                                )
+                            })
                             .map(pin_tab_entries)
                             .separator()
                             .entry(

From be7b24fcf74c2c2f219976c8d0e06b103cb3964b Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 15 Oct 2024 11:26:23 +0200
Subject: [PATCH 647/762] ssh remote: Shutdown SSH & server process correctly
 on app quit (#19210)

Release Notes:

- N/A

Co-authored-by: Bennet <bennet@zed.dev>
---
 crates/project/src/project.rs    | 42 +++++++++++++++------
 crates/remote/src/ssh_session.rs | 65 +++++++++++++++++---------------
 2 files changed, 65 insertions(+), 42 deletions(-)

diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 68f07f1ca9191e..2692c711bf5313 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -746,17 +746,6 @@ impl Project {
             });
             cx.subscribe(&lsp_store, Self::on_lsp_store_event).detach();
 
-            cx.on_release(|this, cx| {
-                if let Some(ssh_client) = this.ssh_client.as_ref() {
-                    ssh_client
-                        .read(cx)
-                        .to_proto_client()
-                        .send(proto::ShutdownRemoteServer {})
-                        .log_err();
-                }
-            })
-            .detach();
-
             cx.subscribe(&ssh, Self::on_ssh_event).detach();
             cx.observe(&ssh, |_, _, cx| cx.notify()).detach();
 
@@ -769,7 +758,22 @@ impl Project {
                 join_project_response_message_id: 0,
                 client_state: ProjectClientState::Local,
                 client_subscriptions: Vec::new(),
-                _subscriptions: vec![cx.on_release(Self::release)],
+                _subscriptions: vec![
+                    cx.on_release(Self::release),
+                    cx.on_app_quit(|this, cx| {
+                        let shutdown = this.ssh_client.take().and_then(|client| {
+                            client
+                                .read(cx)
+                                .shutdown_processes(Some(proto::ShutdownRemoteServer {}))
+                        });
+
+                        cx.background_executor().spawn(async move {
+                            if let Some(shutdown) = shutdown {
+                                shutdown.await;
+                            }
+                        })
+                    }),
+                ],
                 active_entry: None,
                 snippets,
                 languages,
@@ -1094,6 +1098,20 @@ impl Project {
     }
 
     fn release(&mut self, cx: &mut AppContext) {
+        if let Some(client) = self.ssh_client.take() {
+            let shutdown = client
+                .read(cx)
+                .shutdown_processes(Some(proto::ShutdownRemoteServer {}));
+
+            cx.background_executor()
+                .spawn(async move {
+                    if let Some(shutdown) = shutdown {
+                        shutdown.await;
+                    }
+                })
+                .detach()
+        }
+
         match &self.client_state {
             ProjectClientState::Local => {}
             ProjectClientState::Shared { .. } => {
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 7a2073bb55ef98..ccb66a0c626e04 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -424,12 +424,6 @@ pub struct SshRemoteClient {
     state: Arc<Mutex<Option<State>>>,
 }
 
-impl Drop for SshRemoteClient {
-    fn drop(&mut self) {
-        self.shutdown_processes();
-    }
-}
-
 #[derive(Debug)]
 pub enum SshRemoteEvent {
     Disconnected,
@@ -449,19 +443,11 @@ impl SshRemoteClient {
             let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();
 
             let client = cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx))?;
-            let this = cx.new_model(|cx| {
-                cx.on_app_quit(|this: &mut Self, _| {
-                    this.shutdown_processes();
-                    futures::future::ready(())
-                })
-                .detach();
-
-                Self {
-                    client: client.clone(),
-                    unique_identifier: unique_identifier.clone(),
-                    connection_options: connection_options.clone(),
-                    state: Arc::new(Mutex::new(Some(State::Connecting))),
-                }
+            let this = cx.new_model(|_| Self {
+                client: client.clone(),
+                unique_identifier: unique_identifier.clone(),
+                connection_options: connection_options.clone(),
+                state: Arc::new(Mutex::new(Some(State::Connecting))),
             })?;
 
             let (proxy, proxy_incoming_tx, proxy_outgoing_rx) =
@@ -506,25 +492,44 @@ impl SshRemoteClient {
         })
     }
 
-    fn shutdown_processes(&self) {
-        let Some(state) = self.state.lock().take() else {
-            return;
-        };
+    pub fn shutdown_processes<T: RequestMessage>(
+        &self,
+        shutdown_request: Option<T>,
+    ) -> Option<impl Future<Output = ()>> {
+        let state = self.state.lock().take()?;
         log::info!("shutting down ssh processes");
 
         let State::Connected {
             multiplex_task,
             heartbeat_task,
-            ..
+            ssh_connection,
+            delegate,
+            forwarder,
         } = state
         else {
-            return;
+            return None;
         };
-        // Drop `multiplex_task` because it owns our ssh_proxy_process, which is a
-        // child of master_process.
-        drop(multiplex_task);
-        // Now drop the rest of state, which kills master process.
-        drop(heartbeat_task);
+
+        let client = self.client.clone();
+
+        Some(async move {
+            if let Some(shutdown_request) = shutdown_request {
+                client.send(shutdown_request).log_err();
+                // We wait 50ms instead of waiting for a response, because
+                // waiting for a response would require us to wait on the main thread
+                // which we want to avoid in an `on_app_quit` callback.
+                Timer::after(Duration::from_millis(50)).await;
+            }
+
+            // Drop `multiplex_task` because it owns our ssh_proxy_process, which is a
+            // child of master_process.
+            drop(multiplex_task);
+            // Now drop the rest of state, which kills master process.
+            drop(heartbeat_task);
+            drop(ssh_connection);
+            drop(delegate);
+            drop(forwarder);
+        })
     }
 
     fn reconnect(&mut self, cx: &mut ModelContext<Self>) -> Result<()> {

From db7417f3b5b2b7c088b8933282d3a535f5114e57 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Tue, 15 Oct 2024 12:38:03 +0200
Subject: [PATCH 648/762] Rework file picker for SSH modal (#19020)

This PR changes the SSH modal design so its more keyboard
navigation-friendly and adds the server nickname feature.

Release Notes:

- N/A

---------

Co-authored-by: Danilo <danilo@zed.dev>
Co-authored-by: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
---
 Cargo.lock                                    |    2 +-
 assets/keymaps/default-macos.json             |    1 +
 crates/file_finder/src/file_finder.rs         |    2 +
 crates/file_finder/src/open_path_prompt.rs    |   24 +-
 crates/gpui/src/shared_string.rs              |   11 +
 crates/gpui/src/window.rs                     |    6 +
 crates/picker/src/picker.rs                   |    2 +-
 crates/recent_projects/Cargo.toml             |    2 +-
 crates/recent_projects/src/dev_servers.rs     | 1188 +++++++++++------
 crates/recent_projects/src/ssh_connections.rs |  102 +-
 crates/title_bar/src/title_bar.rs             |   13 +-
 crates/ui/src/components/list/list_item.rs    |    3 +-
 12 files changed, 868 insertions(+), 488 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index db14b8c7ae431c..6fb0c1ad6dc8ef 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8968,6 +8968,7 @@ dependencies = [
  "client",
  "dev_server_projects",
  "editor",
+ "file_finder",
  "futures 0.3.30",
  "fuzzy",
  "gpui",
@@ -8988,7 +8989,6 @@ dependencies = [
  "task",
  "terminal_view",
  "ui",
- "ui_input",
  "util",
  "workspace",
 ]
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index 3de9a1495eb3b7..c39b7c06daed59 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -395,6 +395,7 @@
       // Change the default action on `menu::Confirm` by setting the parameter
       // "alt-cmd-o": ["projects::OpenRecent", {"create_new_window": true }],
       "alt-cmd-o": "projects::OpenRecent",
+      "ctrl-cmd-o": "projects::OpenRemote",
       "alt-cmd-b": "branches::OpenRecent",
       "ctrl-~": "workspace::NewTerminal",
       "cmd-s": "workspace::Save",
diff --git a/crates/file_finder/src/file_finder.rs b/crates/file_finder/src/file_finder.rs
index ba125b979cc60b..4202e6e2d09585 100644
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -5,6 +5,8 @@ mod file_finder_settings;
 mod new_path_prompt;
 mod open_path_prompt;
 
+pub use open_path_prompt::OpenPathDelegate;
+
 use collections::HashMap;
 use editor::{scroll::Autoscroll, Bias, Editor};
 use file_finder_settings::FileFinderSettings;
diff --git a/crates/file_finder/src/open_path_prompt.rs b/crates/file_finder/src/open_path_prompt.rs
index 5d977d10b9872f..0736d4189b7197 100644
--- a/crates/file_finder/src/open_path_prompt.rs
+++ b/crates/file_finder/src/open_path_prompt.rs
@@ -26,6 +26,20 @@ pub struct OpenPathDelegate {
     should_dismiss: bool,
 }
 
+impl OpenPathDelegate {
+    pub fn new(tx: oneshot::Sender<Option<Vec<PathBuf>>>, lister: DirectoryLister) -> Self {
+        Self {
+            tx: Some(tx),
+            lister,
+            selected_index: 0,
+            directory_state: None,
+            matches: Vec::new(),
+            cancel_flag: Arc::new(AtomicBool::new(false)),
+            should_dismiss: true,
+        }
+    }
+}
+
 struct DirectoryState {
     path: String,
     match_candidates: Vec<StringMatchCandidate>,
@@ -48,15 +62,7 @@ impl OpenPathPrompt {
         cx: &mut ViewContext<Workspace>,
     ) {
         workspace.toggle_modal(cx, |cx| {
-            let delegate = OpenPathDelegate {
-                tx: Some(tx),
-                lister: lister.clone(),
-                selected_index: 0,
-                directory_state: None,
-                matches: Vec::new(),
-                cancel_flag: Arc::new(AtomicBool::new(false)),
-                should_dismiss: true,
-            };
+            let delegate = OpenPathDelegate::new(tx, lister.clone());
 
             let picker = Picker::uniform_list(delegate, cx).width(rems(34.));
             let query = lister.default_query(cx);
diff --git a/crates/gpui/src/shared_string.rs b/crates/gpui/src/shared_string.rs
index e1fd4f1a5caa9c..1fbd337bd0995e 100644
--- a/crates/gpui/src/shared_string.rs
+++ b/crates/gpui/src/shared_string.rs
@@ -1,5 +1,6 @@
 use derive_more::{Deref, DerefMut};
 
+use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::{borrow::Borrow, sync::Arc};
 use util::arc_cow::ArcCow;
@@ -16,6 +17,16 @@ impl SharedString {
     }
 }
 
+impl JsonSchema for SharedString {
+    fn schema_name() -> String {
+        String::schema_name()
+    }
+
+    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        String::json_schema(gen)
+    }
+}
+
 impl Default for SharedString {
     fn default() -> Self {
         Self(ArcCow::Owned(Arc::default()))
diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs
index 98349f8c4945bf..2d896f2ee8d22b 100644
--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -4905,6 +4905,12 @@ impl From<(&'static str, usize)> for ElementId {
     }
 }
 
+impl From<(SharedString, usize)> for ElementId {
+    fn from((name, id): (SharedString, usize)) -> Self {
+        ElementId::NamedInteger(name, id)
+    }
+}
+
 impl From<(&'static str, u64)> for ElementId {
     fn from((name, id): (&'static str, u64)) -> Self {
         ElementId::NamedInteger(name.into(), id as usize)
diff --git a/crates/picker/src/picker.rs b/crates/picker/src/picker.rs
index 8350be2b20e07d..a9512606d27845 100644
--- a/crates/picker/src/picker.rs
+++ b/crates/picker/src/picker.rs
@@ -476,7 +476,7 @@ impl<D: PickerDelegate> Picker<D> {
         }
     }
 
-    pub fn set_query(&self, query: impl Into<Arc<str>>, cx: &mut ViewContext<Self>) {
+    pub fn set_query(&self, query: impl Into<Arc<str>>, cx: &mut WindowContext<'_>) {
         if let Head::Editor(ref editor) = &self.head {
             editor.update(cx, |editor, cx| {
                 editor.set_text(query, cx);
diff --git a/crates/recent_projects/Cargo.toml b/crates/recent_projects/Cargo.toml
index 2eea6321a07769..2b428009c4ae93 100644
--- a/crates/recent_projects/Cargo.toml
+++ b/crates/recent_projects/Cargo.toml
@@ -18,6 +18,7 @@ auto_update.workspace = true
 release_channel.workspace = true
 client.workspace = true
 editor.workspace = true
+file_finder.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
@@ -36,7 +37,6 @@ smol.workspace = true
 task.workspace = true
 terminal_view.workspace = true
 ui.workspace = true
-ui_input.workspace = true
 util.workspace = true
 workspace.workspace = true
 
diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index b80a011ca35e24..62cfeab830a6ac 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 use std::path::PathBuf;
+use std::sync::Arc;
 use std::time::Duration;
 
 use anyhow::anyhow;
@@ -7,39 +8,46 @@ use anyhow::Context;
 use anyhow::Result;
 use dev_server_projects::{DevServer, DevServerId, DevServerProjectId};
 use editor::Editor;
+use file_finder::OpenPathDelegate;
+use futures::channel::oneshot;
+use futures::future::Shared;
+use futures::FutureExt;
+use gpui::canvas;
 use gpui::pulsating_between;
 use gpui::AsyncWindowContext;
 use gpui::ClipboardItem;
-use gpui::PathPromptOptions;
 use gpui::Subscription;
 use gpui::Task;
 use gpui::WeakView;
 use gpui::{
-    Action, Animation, AnimationExt, AnyElement, AppContext, DismissEvent, EventEmitter,
-    FocusHandle, FocusableView, Model, ScrollHandle, View, ViewContext,
+    Animation, AnimationExt, AnyElement, AppContext, DismissEvent, EventEmitter, FocusHandle,
+    FocusableView, FontWeight, Model, ScrollHandle, View, ViewContext,
 };
+use picker::Picker;
 use project::terminals::wrap_for_ssh;
 use project::terminals::SshCommand;
-use rpc::{proto::DevServerStatus, ErrorCode, ErrorExt};
+use project::Project;
+use rpc::proto::DevServerStatus;
 use settings::update_settings_file;
 use settings::Settings;
 use task::HideStrategy;
 use task::RevealStrategy;
 use task::SpawnInTerminal;
 use terminal_view::terminal_panel::TerminalPanel;
-use ui::ElevationIndex;
 use ui::Section;
-use ui::{prelude::*, IconButtonShape, List, ListItem, Modal, ModalFooter, ModalHeader, Tooltip};
-use ui_input::{FieldLabelLayout, TextField};
+use ui::{prelude::*, List, ListItem, ListSeparator, Modal, ModalHeader, Tooltip};
 use util::ResultExt;
+use workspace::notifications::NotificationId;
 use workspace::OpenOptions;
-use workspace::{notifications::DetachAndPromptErr, AppState, ModalView, Workspace};
+use workspace::Toast;
+use workspace::{notifications::DetachAndPromptErr, ModalView, Workspace};
 
 use crate::open_dev_server_project;
 use crate::ssh_connections::connect_over_ssh;
 use crate::ssh_connections::open_ssh_project;
 use crate::ssh_connections::RemoteSettingsContent;
 use crate::ssh_connections::SshConnection;
+use crate::ssh_connections::SshConnectionHeader;
 use crate::ssh_connections::SshConnectionModal;
 use crate::ssh_connections::SshProject;
 use crate::ssh_connections::SshPrompt;
@@ -52,24 +60,251 @@ pub struct DevServerProjects {
     scroll_handle: ScrollHandle,
     dev_server_store: Model<dev_server_projects::Store>,
     workspace: WeakView<Workspace>,
-    project_path_input: View<Editor>,
-    dev_server_name_input: View<TextField>,
     _dev_server_subscription: Subscription,
+    selectable_items: SelectableItemList,
 }
 
-#[derive(Default)]
 struct CreateDevServer {
+    address_editor: View<Editor>,
     creating: Option<Task<Option<()>>>,
     ssh_prompt: Option<View<SshPrompt>>,
 }
 
-struct CreateDevServerProject {
-    dev_server_id: DevServerId,
-    _opening: Option<Subscription>,
+impl CreateDevServer {
+    fn new(cx: &mut WindowContext<'_>) -> Self {
+        let address_editor = cx.new_view(Editor::single_line);
+        address_editor.update(cx, |this, cx| {
+            this.focus_handle(cx).focus(cx);
+        });
+        Self {
+            address_editor,
+            creating: None,
+            ssh_prompt: None,
+        }
+    }
+}
+
+struct ProjectPicker {
+    connection_string: SharedString,
+    picker: View<Picker<OpenPathDelegate>>,
+    _path_task: Shared<Task<Option<()>>>,
+}
+
+type SelectedItemCallback =
+    Box<dyn Fn(&mut DevServerProjects, &mut ViewContext<DevServerProjects>) + 'static>;
+
+/// Used to implement keyboard navigation for SSH modal.
+#[derive(Default)]
+struct SelectableItemList {
+    items: Vec<SelectedItemCallback>,
+    active_item: Option<usize>,
+}
+
+struct EditNicknameState {
+    index: usize,
+    editor: View<Editor>,
+}
+
+impl EditNicknameState {
+    fn new(index: usize, cx: &mut WindowContext<'_>) -> Self {
+        let this = Self {
+            index,
+            editor: cx.new_view(Editor::single_line),
+        };
+        let starting_text = SshSettings::get_global(cx)
+            .ssh_connections()
+            .nth(index)
+            .and_then(|state| state.nickname.clone())
+            .filter(|text| !text.is_empty());
+        this.editor.update(cx, |this, cx| {
+            this.set_placeholder_text("Add a nickname for this server", cx);
+            if let Some(starting_text) = starting_text {
+                this.set_text(starting_text, cx);
+            }
+        });
+        this.editor.focus_handle(cx).focus(cx);
+        this
+    }
 }
 
+impl SelectableItemList {
+    fn reset(&mut self) {
+        self.items.clear();
+    }
+
+    fn reset_selection(&mut self) {
+        self.active_item.take();
+    }
+
+    fn prev(&mut self, _: &mut WindowContext<'_>) {
+        match self.active_item.as_mut() {
+            Some(active_index) => {
+                *active_index = active_index.checked_sub(1).unwrap_or(self.items.len() - 1)
+            }
+            None => {
+                self.active_item = Some(self.items.len() - 1);
+            }
+        }
+    }
+
+    fn next(&mut self, _: &mut WindowContext<'_>) {
+        match self.active_item.as_mut() {
+            Some(active_index) => {
+                if *active_index + 1 < self.items.len() {
+                    *active_index += 1;
+                } else {
+                    *active_index = 0;
+                }
+            }
+            None => {
+                self.active_item = Some(0);
+            }
+        }
+    }
+
+    fn add_item(&mut self, callback: SelectedItemCallback) {
+        self.items.push(callback)
+    }
+
+    fn is_selected(&self) -> bool {
+        self.active_item == self.items.len().checked_sub(1)
+    }
+
+    fn confirm(&self, dev_modal: &mut DevServerProjects, cx: &mut ViewContext<DevServerProjects>) {
+        if let Some(active_item) = self.active_item.and_then(|ix| self.items.get(ix)) {
+            active_item(dev_modal, cx);
+        }
+    }
+}
+
+impl ProjectPicker {
+    fn new(
+        ix: usize,
+        connection_string: SharedString,
+        project: Model<Project>,
+        workspace: WeakView<Workspace>,
+        cx: &mut ViewContext<DevServerProjects>,
+    ) -> View<Self> {
+        let (tx, rx) = oneshot::channel();
+        let lister = project::DirectoryLister::Project(project.clone());
+        let query = lister.default_query(cx);
+        let delegate = file_finder::OpenPathDelegate::new(tx, lister);
+
+        let picker = cx.new_view(|cx| {
+            let picker = Picker::uniform_list(delegate, cx)
+                .width(rems(34.))
+                .modal(false);
+            picker.set_query(query, cx);
+            picker
+        });
+        cx.new_view(|cx| {
+            let _path_task = cx
+                .spawn({
+                    let workspace = workspace.clone();
+                    move |_, mut cx| async move {
+                        let Ok(Some(paths)) = rx.await else {
+                            workspace
+                                .update(&mut cx, |workspace, cx| {
+                                    let weak = cx.view().downgrade();
+                                    workspace
+                                        .toggle_modal(cx, |cx| DevServerProjects::new(cx, weak));
+                                })
+                                .log_err()?;
+                            return None;
+                        };
+
+                        let app_state = workspace
+                            .update(&mut cx, |workspace, _| workspace.app_state().clone())
+                            .ok()?;
+                        let options = cx
+                            .update(|cx| (app_state.build_window_options)(None, cx))
+                            .log_err()?;
+
+                        cx.open_window(options, |cx| {
+                            cx.activate_window();
+
+                            let fs = app_state.fs.clone();
+                            update_settings_file::<SshSettings>(fs, cx, {
+                                let paths = paths
+                                    .iter()
+                                    .map(|path| path.to_string_lossy().to_string())
+                                    .collect();
+                                move |setting, _| {
+                                    if let Some(server) = setting
+                                        .ssh_connections
+                                        .as_mut()
+                                        .and_then(|connections| connections.get_mut(ix))
+                                    {
+                                        server.projects.push(SshProject { paths })
+                                    }
+                                }
+                            });
+
+                            let tasks = paths
+                                .into_iter()
+                                .map(|path| {
+                                    project.update(cx, |project, cx| {
+                                        project.find_or_create_worktree(&path, true, cx)
+                                    })
+                                })
+                                .collect::<Vec<_>>();
+                            cx.spawn(|_| async move {
+                                for task in tasks {
+                                    task.await?;
+                                }
+                                Ok(())
+                            })
+                            .detach_and_prompt_err(
+                                "Failed to open path",
+                                cx,
+                                |_, _| None,
+                            );
+
+                            cx.new_view(|cx| {
+                                let workspace =
+                                    Workspace::new(None, project.clone(), app_state.clone(), cx);
+
+                                workspace
+                                    .client()
+                                    .telemetry()
+                                    .report_app_event("create ssh project".to_string());
+
+                                workspace
+                            })
+                        })
+                        .log_err();
+                        Some(())
+                    }
+                })
+                .shared();
+
+            Self {
+                _path_task,
+                picker,
+                connection_string,
+            }
+        })
+    }
+}
+
+impl gpui::Render for ProjectPicker {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        v_flex()
+            .child(
+                SshConnectionHeader {
+                    connection_string: self.connection_string.clone(),
+                    nickname: None,
+                }
+                .render(cx),
+            )
+            .child(self.picker.clone())
+    }
+}
 enum Mode {
-    Default(Option<CreateDevServerProject>),
+    Default,
+    ViewServerOptions(usize, SshConnection),
+    EditNickname(EditNicknameState),
+    ProjectPicker(View<ProjectPicker>),
     CreateDevServer(CreateDevServer),
 }
 
@@ -89,15 +324,6 @@ impl DevServerProjects {
     }
 
     pub fn new(cx: &mut ViewContext<Self>, workspace: WeakView<Workspace>) -> Self {
-        let project_path_input = cx.new_view(|cx| {
-            let mut editor = Editor::single_line(cx);
-            editor.set_placeholder_text("Project path (~/work/zed, /workspace/zed, …)", cx);
-            editor
-        });
-        let dev_server_name_input = cx.new_view(|cx| {
-            TextField::new(cx, "Name", "192.168.0.1").with_label(FieldLabelLayout::Hidden)
-        });
-
         let focus_handle = cx.focus_handle();
         let dev_server_store = dev_server_projects::Store::global(cx);
 
@@ -112,131 +338,49 @@ impl DevServerProjects {
         });
 
         Self {
-            mode: Mode::Default(None),
+            mode: Mode::Default,
             focus_handle,
             scroll_handle: ScrollHandle::new(),
             dev_server_store,
-            project_path_input,
-            dev_server_name_input,
             workspace,
             _dev_server_subscription: subscription,
+            selectable_items: Default::default(),
         }
     }
 
-    pub fn create_dev_server_project(
-        &mut self,
-        dev_server_id: DevServerId,
-        cx: &mut ViewContext<Self>,
-    ) {
-        let mut path = self.project_path_input.read(cx).text(cx).trim().to_string();
-
-        if path.is_empty() {
+    fn next_item(&mut self, _: &menu::SelectNext, cx: &mut ViewContext<Self>) {
+        if !matches!(self.mode, Mode::Default | Mode::ViewServerOptions(_, _)) {
             return;
         }
-
-        if !path.starts_with('/') && !path.starts_with('~') {
-            path = format!("~/{}", path);
-        }
-
-        if self
-            .dev_server_store
-            .read(cx)
-            .projects_for_server(dev_server_id)
-            .iter()
-            .any(|p| p.paths.iter().any(|p| p == &path))
-        {
-            cx.spawn(|_, mut cx| async move {
-                cx.prompt(
-                    gpui::PromptLevel::Critical,
-                    "Failed to create project",
-                    Some(&format!("{} is already open on this dev server.", path)),
-                    &["Ok"],
-                )
-                .await
-            })
-            .detach_and_log_err(cx);
+        self.selectable_items.next(cx);
+    }
+    fn prev_item(&mut self, _: &menu::SelectPrev, cx: &mut ViewContext<Self>) {
+        if !matches!(self.mode, Mode::Default | Mode::ViewServerOptions(_, _)) {
             return;
         }
+        self.selectable_items.prev(cx);
+    }
+    pub fn project_picker(
+        ix: usize,
+        connection_options: remote::SshConnectionOptions,
+        project: Model<Project>,
+        cx: &mut ViewContext<Self>,
+        workspace: WeakView<Workspace>,
+    ) -> Self {
+        let mut this = Self::new(cx, workspace.clone());
+        this.mode = Mode::ProjectPicker(ProjectPicker::new(
+            ix,
+            connection_options.connection_string().into(),
+            project,
+            workspace,
+            cx,
+        ));
 
-        let create = {
-            let path = path.clone();
-            self.dev_server_store.update(cx, |store, cx| {
-                store.create_dev_server_project(dev_server_id, path, cx)
-            })
-        };
-
-        cx.spawn(|this, mut cx| async move {
-            let result = create.await;
-            this.update(&mut cx, |this, cx| {
-                if let Ok(result) = &result {
-                    if let Some(dev_server_project_id) =
-                        result.dev_server_project.as_ref().map(|p| p.id)
-                    {
-                        let subscription =
-                            cx.observe(&this.dev_server_store, move |this, store, cx| {
-                                if let Some(project_id) = store
-                                    .read(cx)
-                                    .dev_server_project(DevServerProjectId(dev_server_project_id))
-                                    .and_then(|p| p.project_id)
-                                {
-                                    this.project_path_input.update(cx, |editor, cx| {
-                                        editor.set_text("", cx);
-                                    });
-                                    this.mode = Mode::Default(None);
-                                    if let Some(app_state) = AppState::global(cx).upgrade() {
-                                        workspace::join_dev_server_project(
-                                            DevServerProjectId(dev_server_project_id),
-                                            project_id,
-                                            app_state,
-                                            None,
-                                            cx,
-                                        )
-                                        .detach_and_prompt_err(
-                                            "Could not join project",
-                                            cx,
-                                            |_, _| None,
-                                        )
-                                    }
-                                }
-                            });
-
-                        this.mode = Mode::Default(Some(CreateDevServerProject {
-                            dev_server_id,
-                            _opening: Some(subscription),
-                        }));
-                    }
-                } else {
-                    this.mode = Mode::Default(Some(CreateDevServerProject {
-                        dev_server_id,
-                        _opening: None,
-                    }));
-                }
-            })
-            .log_err();
-            result
-        })
-        .detach_and_prompt_err("Failed to create project", cx, move |e, _| {
-            match e.error_code() {
-                ErrorCode::DevServerOffline => Some(
-                    "The dev server is offline. Please log in and check it is connected."
-                        .to_string(),
-                ),
-                ErrorCode::DevServerProjectPathDoesNotExist => {
-                    Some(format!("The path `{}` does not exist on the server.", path))
-                }
-                _ => None,
-            }
-        });
-
-        self.mode = Mode::Default(Some(CreateDevServerProject {
-            dev_server_id,
-
-            _opening: None,
-        }));
+        this
     }
 
-    fn create_ssh_server(&mut self, cx: &mut ViewContext<Self>) {
-        let host = get_text(&self.dev_server_name_input, cx);
+    fn create_ssh_server(&mut self, editor: View<Editor>, cx: &mut ViewContext<Self>) {
+        let host = get_text(&editor, cx);
         if host.is_empty() {
             return;
         }
@@ -287,23 +431,35 @@ impl DevServerProjects {
                         });
 
                         this.add_ssh_server(connection_options, cx);
-                        this.mode = Mode::Default(None);
+                        this.mode = Mode::Default;
+                        this.selectable_items.reset_selection();
                         cx.notify()
                     })
                     .log_err(),
                 None => this
                     .update(&mut cx, |this, cx| {
-                        this.mode = Mode::CreateDevServer(CreateDevServer::default());
+                        this.mode = Mode::CreateDevServer(CreateDevServer::new(cx));
                         cx.notify()
                     })
                     .log_err(),
             };
             None
         });
-        self.mode = Mode::CreateDevServer(CreateDevServer {
-            ssh_prompt: Some(ssh_prompt.clone()),
-            creating: Some(creating),
-        });
+        let mut state = CreateDevServer::new(cx);
+        state.address_editor = editor;
+        state.ssh_prompt = Some(ssh_prompt.clone());
+        state.creating = Some(creating);
+        self.mode = Mode::CreateDevServer(state);
+    }
+
+    fn view_server_options(
+        &mut self,
+        (index, connection): (usize, SshConnection),
+        cx: &mut ViewContext<Self>,
+    ) {
+        self.selectable_items.reset_selection();
+        self.mode = Mode::ViewServerOptions(index, connection);
+        cx.notify();
     }
 
     fn create_ssh_project(
@@ -331,12 +487,12 @@ impl DevServerProjects {
 
                 let connect = connect_over_ssh(
                     connection_options.dev_server_identifier(),
-                    connection_options,
+                    connection_options.clone(),
                     prompt,
                     cx,
                 )
                 .prompt_err("Failed to connect", cx, |_, _| None);
-                cx.spawn(|workspace, mut cx| async move {
+                cx.spawn(move |workspace, mut cx| async move {
                     let Some(session) = connect.await else {
                         workspace
                             .update(&mut cx, |workspace, cx| {
@@ -346,9 +502,11 @@ impl DevServerProjects {
                             .log_err();
                         return;
                     };
-                    let Ok((app_state, project, paths)) =
-                        workspace.update(&mut cx, |workspace, cx| {
+
+                    workspace
+                        .update(&mut cx, |workspace, cx| {
                             let app_state = workspace.app_state().clone();
+                            let weak = cx.view().downgrade();
                             let project = project::Project::ssh(
                                 session,
                                 app_state.client.clone(),
@@ -358,91 +516,17 @@ impl DevServerProjects {
                                 app_state.fs.clone(),
                                 cx,
                             );
-                            let paths = workspace.prompt_for_open_path(
-                                PathPromptOptions {
-                                    files: true,
-                                    directories: true,
-                                    multiple: true,
-                                },
-                                project::DirectoryLister::Project(project.clone()),
-                                cx,
-                            );
-                            (app_state, project, paths)
-                        })
-                    else {
-                        return;
-                    };
-
-                    let Ok(Some(paths)) = paths.await else {
-                        workspace
-                            .update(&mut cx, |workspace, cx| {
-                                let weak = cx.view().downgrade();
-                                workspace.toggle_modal(cx, |cx| DevServerProjects::new(cx, weak));
-                            })
-                            .log_err();
-                        return;
-                    };
-
-                    let Some(options) = cx
-                        .update(|cx| (app_state.build_window_options)(None, cx))
-                        .log_err()
-                    else {
-                        return;
-                    };
-
-                    cx.open_window(options, |cx| {
-                        cx.activate_window();
-
-                        let fs = app_state.fs.clone();
-                        update_settings_file::<SshSettings>(fs, cx, {
-                            let paths = paths
-                                .iter()
-                                .map(|path| path.to_string_lossy().to_string())
-                                .collect();
-                            move |setting, _| {
-                                if let Some(server) = setting
-                                    .ssh_connections
-                                    .as_mut()
-                                    .and_then(|connections| connections.get_mut(ix))
-                                {
-                                    server.projects.push(SshProject { paths })
-                                }
-                            }
-                        });
-
-                        let tasks = paths
-                            .into_iter()
-                            .map(|path| {
-                                project.update(cx, |project, cx| {
-                                    project.find_or_create_worktree(&path, true, cx)
-                                })
-                            })
-                            .collect::<Vec<_>>();
-                        cx.spawn(|_| async move {
-                            for task in tasks {
-                                task.await?;
-                            }
-                            Ok(())
-                        })
-                        .detach_and_prompt_err(
-                            "Failed to open path",
-                            cx,
-                            |_, _| None,
-                        );
-
-                        cx.new_view(|cx| {
-                            let workspace =
-                                Workspace::new(None, project.clone(), app_state.clone(), cx);
-
-                            workspace
-                                .client()
-                                .telemetry()
-                                .report_app_event("create ssh project".to_string());
-
-                            workspace
+                            workspace.toggle_modal(cx, |cx| {
+                                DevServerProjects::project_picker(
+                                    ix,
+                                    connection_options,
+                                    project,
+                                    cx,
+                                    weak,
+                                )
+                            });
                         })
-                    })
-                    .log_err();
+                        .ok();
                 })
                 .detach()
             })
@@ -451,10 +535,12 @@ impl DevServerProjects {
 
     fn confirm(&mut self, _: &menu::Confirm, cx: &mut ViewContext<Self>) {
         match &self.mode {
-            Mode::Default(None) => {}
-            Mode::Default(Some(create_project)) => {
-                self.create_dev_server_project(create_project.dev_server_id, cx);
+            Mode::Default | Mode::ViewServerOptions(_, _) => {
+                let items = std::mem::take(&mut self.selectable_items);
+                items.confirm(self, cx);
+                self.selectable_items = items;
             }
+            Mode::ProjectPicker(_) => {}
             Mode::CreateDevServer(state) => {
                 if let Some(prompt) = state.ssh_prompt.as_ref() {
                     prompt.update(cx, |prompt, cx| {
@@ -463,22 +549,41 @@ impl DevServerProjects {
                     return;
                 }
 
-                self.create_ssh_server(cx);
+                state.address_editor.update(cx, |this, _| {
+                    this.set_read_only(true);
+                });
+                self.create_ssh_server(state.address_editor.clone(), cx);
+            }
+            Mode::EditNickname(state) => {
+                let text = Some(state.editor.read(cx).text(cx))
+                    .filter(|text| !text.is_empty())
+                    .map(SharedString::from);
+                let index = state.index;
+                self.update_settings_file(cx, move |setting, _| {
+                    if let Some(connections) = setting.ssh_connections.as_mut() {
+                        if let Some(connection) = connections.get_mut(index) {
+                            connection.nickname = text;
+                        }
+                    }
+                });
+                self.mode = Mode::Default;
+                self.selectable_items.reset_selection();
+                self.focus_handle.focus(cx);
             }
         }
     }
 
     fn cancel(&mut self, _: &menu::Cancel, cx: &mut ViewContext<Self>) {
         match &self.mode {
-            Mode::Default(None) => cx.emit(DismissEvent),
+            Mode::Default => cx.emit(DismissEvent),
             Mode::CreateDevServer(state) if state.ssh_prompt.is_some() => {
-                self.mode = Mode::CreateDevServer(CreateDevServer {
-                    ..Default::default()
-                });
+                self.mode = Mode::CreateDevServer(CreateDevServer::new(cx));
+                self.selectable_items.reset_selection();
                 cx.notify();
             }
             _ => {
-                self.mode = Mode::Default(None);
+                self.mode = Mode::Default;
+                self.selectable_items.reset_selection();
                 self.focus_handle(cx).focus(cx);
                 cx.notify();
             }
@@ -491,126 +596,119 @@ impl DevServerProjects {
         ssh_connection: SshConnection,
         cx: &mut ViewContext<Self>,
     ) -> impl IntoElement {
+        let (main_label, aux_label) = if let Some(nickname) = ssh_connection.nickname.clone() {
+            let aux_label = SharedString::from(format!("({})", ssh_connection.host));
+            (nickname, Some(aux_label))
+        } else {
+            (ssh_connection.host.clone(), None)
+        };
         v_flex()
             .w_full()
-            .px(Spacing::Small.rems(cx) + Spacing::Small.rems(cx))
+            .border_b_1()
+            .border_color(cx.theme().colors().border_variant)
+            .mb_1()
             .child(
                 h_flex()
-                    .w_full()
                     .group("ssh-server")
-                    .justify_between()
+                    .w_full()
+                    .pt_0p5()
+                    .px_2p5()
+                    .gap_1()
+                    .overflow_hidden()
+                    .whitespace_nowrap()
+                    .w_full()
                     .child(
-                        h_flex()
-                            .gap_2()
-                            .w_full()
-                            .child(
-                                div()
-                                    .id(("status", ix))
-                                    .relative()
-                                    .child(Icon::new(IconName::Server).size(IconSize::Small)),
-                            )
-                            .child(
-                                h_flex()
-                                    .max_w(rems(26.))
-                                    .overflow_hidden()
-                                    .whitespace_nowrap()
-                                    .child(Label::new(ssh_connection.host.clone())),
-                            ),
+                        Label::new(main_label)
+                            .size(LabelSize::Small)
+                            .weight(FontWeight::SEMIBOLD)
+                            .color(Color::Muted),
                     )
-                    .child(
-                        h_flex()
-                            .visible_on_hover("ssh-server")
-                            .gap_1()
-                            .child({
-                                IconButton::new("copy-dev-server-address", IconName::Copy)
-                                    .icon_size(IconSize::Small)
-                                    .on_click(cx.listener(move |this, _, cx| {
-                                        this.update_settings_file(cx, move |servers, cx| {
-                                            if let Some(content) = servers
-                                                .ssh_connections
-                                                .as_ref()
-                                                .and_then(|connections| {
-                                                    connections
-                                                        .get(ix)
-                                                        .map(|connection| connection.host.clone())
-                                                })
-                                            {
-                                                cx.write_to_clipboard(ClipboardItem::new_string(
-                                                    content,
-                                                ));
-                                            }
-                                        });
-                                    }))
-                                    .tooltip(|cx| Tooltip::text("Copy Server Address", cx))
-                            })
-                            .child({
-                                IconButton::new("remove-dev-server", IconName::TrashAlt)
-                                    .icon_size(IconSize::Small)
-                                    .on_click(cx.listener(move |this, _, cx| {
-                                        this.delete_ssh_server(ix, cx)
-                                    }))
-                                    .tooltip(|cx| Tooltip::text("Remove Dev Server", cx))
-                            }),
+                    .children(
+                        aux_label.map(|label| {
+                            Label::new(label).size(LabelSize::Small).color(Color::Muted)
+                        }),
                     ),
             )
             .child(
-                v_flex()
-                    .w_full()
-                    .border_l_1()
-                    .border_color(cx.theme().colors().border_variant)
-                    .mb_1()
-                    .mx_1p5()
-                    .pl_2()
-                    .child(
-                        List::new()
-                            .empty_message("No projects.")
-                            .children(ssh_connection.projects.iter().enumerate().map(|(pix, p)| {
-                                v_flex().gap_0p5().child(self.render_ssh_project(
-                                    ix,
-                                    &ssh_connection,
-                                    pix,
-                                    p,
-                                    cx,
-                                ))
-                            }))
-                            .child(
-                                h_flex().mt_1().pl_1().child(
-                                    Button::new(("new-remote_project", ix), "Open Folder…")
-                                        .size(ButtonSize::Default)
-                                        .layer(ElevationIndex::ModalSurface)
-                                        .icon(IconName::Plus)
-                                        .icon_color(Color::Muted)
-                                        .icon_position(IconPosition::Start)
-                                        .on_click(cx.listener(move |this, _, cx| {
+                v_flex().w_full().gap_1().mb_1().child(
+                    List::new()
+                        .empty_message("No projects.")
+                        .children(ssh_connection.projects.iter().enumerate().map(|(pix, p)| {
+                            v_flex().gap_0p5().child(self.render_ssh_project(
+                                ix,
+                                &ssh_connection,
+                                pix,
+                                p,
+                                cx,
+                            ))
+                        }))
+                        .child(h_flex().map(|this| {
+                            self.selectable_items.add_item(Box::new({
+                                let ssh_connection = ssh_connection.clone();
+                                move |this, cx| {
+                                    this.create_ssh_project(ix, ssh_connection.clone(), cx);
+                                }
+                            }));
+                            let is_selected = self.selectable_items.is_selected();
+                            this.child(
+                                ListItem::new(("new-remote-project", ix))
+                                    .selected(is_selected)
+                                    .inset(true)
+                                    .spacing(ui::ListItemSpacing::Sparse)
+                                    .start_slot(Icon::new(IconName::Plus).color(Color::Muted))
+                                    .child(Label::new("Open Folder"))
+                                    .on_click(cx.listener({
+                                        let ssh_connection = ssh_connection.clone();
+                                        move |this, _, cx| {
                                             this.create_ssh_project(ix, ssh_connection.clone(), cx);
-                                        })),
-                                ),
-                            ),
-                    ),
+                                        }
+                                    })),
+                            )
+                        }))
+                        .child(h_flex().map(|this| {
+                            self.selectable_items.add_item(Box::new({
+                                let ssh_connection = ssh_connection.clone();
+                                move |this, cx| {
+                                    this.view_server_options((ix, ssh_connection.clone()), cx);
+                                }
+                            }));
+                            let is_selected = self.selectable_items.is_selected();
+                            this.child(
+                                ListItem::new(("server-options", ix))
+                                    .selected(is_selected)
+                                    .inset(true)
+                                    .spacing(ui::ListItemSpacing::Sparse)
+                                    .start_slot(Icon::new(IconName::Settings).color(Color::Muted))
+                                    .child(Label::new("View Server Options"))
+                                    .on_click(cx.listener({
+                                        let ssh_connection = ssh_connection.clone();
+                                        move |this, _, cx| {
+                                            this.view_server_options(
+                                                (ix, ssh_connection.clone()),
+                                                cx,
+                                            );
+                                        }
+                                    })),
+                            )
+                        })),
+                ),
             )
     }
 
     fn render_ssh_project(
-        &self,
+        &mut self,
         server_ix: usize,
         server: &SshConnection,
         ix: usize,
         project: &SshProject,
         cx: &ViewContext<Self>,
     ) -> impl IntoElement {
-        let project = project.clone();
         let server = server.clone();
 
-        ListItem::new(("remote-project", ix))
-            .inset(true)
-            .spacing(ui::ListItemSpacing::Sparse)
-            .start_slot(
-                Icon::new(IconName::Folder)
-                    .color(Color::Muted)
-                    .size(IconSize::Small),
-            )
-            .child(Label::new(project.paths.join(", ")))
-            .on_click(cx.listener(move |this, _, cx| {
+        let element_id_base = SharedString::from(format!("remote-project-{server_ix}"));
+        let callback = Arc::new({
+            let project = project.clone();
+            move |this: &mut Self, cx: &mut ViewContext<Self>| {
                 let Some(app_state) = this
                     .workspace
                     .update(cx, |workspace, _| workspace.app_state().clone())
@@ -642,12 +740,32 @@ impl DevServerProjects {
                     }
                 })
                 .detach();
-            }))
+            }
+        });
+        self.selectable_items.add_item(Box::new({
+            let callback = callback.clone();
+            move |this, cx| callback(this, cx)
+        }));
+        let is_selected = self.selectable_items.is_selected();
+
+        ListItem::new((element_id_base, ix))
+            .inset(true)
+            .selected(is_selected)
+            .spacing(ui::ListItemSpacing::Sparse)
+            .start_slot(
+                Icon::new(IconName::Folder)
+                    .color(Color::Muted)
+                    .size(IconSize::Small),
+            )
+            .child(Label::new(project.paths.join(", ")))
+            .on_click(cx.listener(move |this, _, cx| callback(this, cx)))
             .end_hover_slot::<AnyElement>(Some(
                 IconButton::new("remove-remote-project", IconName::TrashAlt)
+                    .icon_size(IconSize::Small)
                     .on_click(
                         cx.listener(move |this, _, cx| this.delete_ssh_project(server_ix, ix, cx)),
                     )
+                    .size(ButtonSize::Large)
                     .tooltip(|cx| Tooltip::text("Delete Remote Project", cx))
                     .into_any_element(),
             ))
@@ -698,10 +816,11 @@ impl DevServerProjects {
                 .ssh_connections
                 .get_or_insert(Default::default())
                 .push(SshConnection {
-                    host: connection_options.host,
+                    host: SharedString::from(connection_options.host),
                     username: connection_options.username,
                     port: connection_options.port,
                     projects: vec![],
+                    nickname: None,
                 })
         });
     }
@@ -711,16 +830,17 @@ impl DevServerProjects {
         state: &CreateDevServer,
         cx: &mut ViewContext<Self>,
     ) -> impl IntoElement {
-        let creating = state.creating.is_some();
         let ssh_prompt = state.ssh_prompt.clone();
 
-        self.dev_server_name_input.update(cx, |input, cx| {
-            input.editor().update(cx, |editor, cx| {
-                if editor.text(cx).is_empty() {
-                    editor.set_placeholder_text("ssh me@my.server / ssh@secret-box:2222", cx);
-                }
-            })
+        state.address_editor.update(cx, |editor, cx| {
+            if editor.text(cx).is_empty() {
+                editor.set_placeholder_text(
+                    "Enter the command you use to SSH into this server: e.g., ssh me@my.server",
+                    cx,
+                );
+            }
         });
+
         let theme = cx.theme();
 
         v_flex()
@@ -729,50 +849,11 @@ impl DevServerProjects {
             .size_full()
             .flex_1()
             .child(
-                h_flex()
+                div()
                     .p_2()
-                    .gap_2()
-                    .items_center()
-                    .border_b_1()
-                    .border_color(theme.colors().border_variant)
-                    .child(
-                        IconButton::new("cancel-dev-server-creation", IconName::ArrowLeft)
-                            .shape(IconButtonShape::Square)
-                            .on_click(|_, cx| {
-                                cx.dispatch_action(menu::Cancel.boxed_clone());
-                            }),
-                    )
-                    .child(Label::new("Connect New Dev Server")),
-            )
-            .child(
-                v_flex()
-                    .p_3()
                     .border_b_1()
                     .border_color(theme.colors().border_variant)
-                    .child(Label::new("SSH Arguments"))
-                    .child(
-                        Label::new("Enter the command you use to SSH into this server.")
-                            .size(LabelSize::Small)
-                            .color(Color::Muted),
-                    )
-                    .child(
-                        h_flex()
-                            .mt_2()
-                            .w_full()
-                            .gap_2()
-                            .child(self.dev_server_name_input.clone())
-                            .child(
-                                Button::new("create-dev-server", "Connect Server")
-                                    .style(ButtonStyle::Filled)
-                                    .layer(ElevationIndex::ModalSurface)
-                                    .disabled(creating)
-                                    .on_click(cx.listener({
-                                        move |this, _, cx| {
-                                            this.create_ssh_server(cx);
-                                        }
-                                    })),
-                            ),
-                    ),
+                    .child(state.address_editor.clone()),
             )
             .child(
                 h_flex()
@@ -788,10 +869,11 @@ impl DevServerProjects {
                                 h_flex()
                                     .p_2()
                                     .w_full()
+                                    .items_center()
                                     .justify_center()
-                                    .gap_1p5()
+                                    .gap_2()
                                     .child(
-                                        div().p_1().rounded_lg().bg(color).with_animation(
+                                        div().size_1p5().rounded_full().bg(color).with_animation(
                                             "pulse-ssh-waiting-for-connection",
                                             Animation::new(Duration::from_secs(2))
                                                 .repeat()
@@ -809,75 +891,306 @@ impl DevServerProjects {
             )
     }
 
+    fn render_view_options(
+        &mut self,
+        index: usize,
+        connection: SshConnection,
+        cx: &mut ViewContext<Self>,
+    ) -> impl IntoElement {
+        let connection_string = connection.host.clone();
+
+        div()
+            .size_full()
+            .child(
+                SshConnectionHeader {
+                    connection_string: connection_string.clone(),
+                    nickname: connection.nickname.clone(),
+                }
+                .render(cx),
+            )
+            .child(
+                v_flex()
+                    .py_1()
+                    .child({
+                        self.selectable_items.add_item(Box::new({
+                            move |this, cx| {
+                                this.mode = Mode::EditNickname(EditNicknameState::new(index, cx));
+                                cx.notify();
+                            }
+                        }));
+                        let is_selected = self.selectable_items.is_selected();
+                        let label = if connection.nickname.is_some() {
+                            "Edit Nickname"
+                        } else {
+                            "Add Nickname to Server"
+                        };
+                        ListItem::new("add-nickname")
+                            .selected(is_selected)
+                            .inset(true)
+                            .spacing(ui::ListItemSpacing::Sparse)
+                            .start_slot(Icon::new(IconName::Pencil).color(Color::Muted))
+                            .child(Label::new(label))
+                            .on_click(cx.listener(move |this, _, cx| {
+                                this.mode = Mode::EditNickname(EditNicknameState::new(index, cx));
+                                cx.notify();
+                            }))
+                    })
+                    .child({
+                        let workspace = self.workspace.clone();
+                        fn callback(
+                            workspace: WeakView<Workspace>,
+                            connection_string: SharedString,
+                            cx: &mut WindowContext<'_>,
+                        ) {
+                            cx.write_to_clipboard(ClipboardItem::new_string(
+                                connection_string.to_string(),
+                            ));
+                            workspace
+                                .update(cx, |this, cx| {
+                                    struct SshServerAddressCopiedToClipboard;
+                                    let notification = format!(
+                                        "Copied server address ({}) to clipboard",
+                                        connection_string
+                                    );
+
+                                    this.show_toast(
+                                        Toast::new(
+                                            NotificationId::identified::<
+                                                SshServerAddressCopiedToClipboard,
+                                            >(
+                                                connection_string.clone()
+                                            ),
+                                            notification,
+                                        )
+                                        .autohide(),
+                                        cx,
+                                    );
+                                })
+                                .ok();
+                        }
+                        self.selectable_items.add_item(Box::new({
+                            let workspace = workspace.clone();
+                            let connection_string = connection_string.clone();
+                            move |_, cx| {
+                                callback(workspace.clone(), connection_string.clone(), cx);
+                            }
+                        }));
+                        let is_selected = self.selectable_items.is_selected();
+                        ListItem::new("copy-server-address")
+                            .selected(is_selected)
+                            .inset(true)
+                            .spacing(ui::ListItemSpacing::Sparse)
+                            .start_slot(Icon::new(IconName::Copy).color(Color::Muted))
+                            .child(Label::new("Copy Server Address"))
+                            .end_hover_slot(
+                                Label::new(connection_string.clone()).color(Color::Muted),
+                            )
+                            .on_click({
+                                let connection_string = connection_string.clone();
+                                move |_, cx| {
+                                    callback(workspace.clone(), connection_string.clone(), cx);
+                                }
+                            })
+                    })
+                    .child({
+                        fn remove_ssh_server(
+                            dev_servers: View<DevServerProjects>,
+                            workspace: WeakView<Workspace>,
+                            index: usize,
+                            connection_string: SharedString,
+                            cx: &mut WindowContext<'_>,
+                        ) {
+                            workspace
+                                .update(cx, |this, cx| {
+                                    struct SshServerRemoval;
+                                    let notification = format!(
+                                        "Do you really want to remove server `{}`?",
+                                        connection_string
+                                    );
+                                    this.show_toast(
+                                        Toast::new(
+                                            NotificationId::identified::<SshServerRemoval>(
+                                                connection_string.clone(),
+                                            ),
+                                            notification,
+                                        )
+                                        .on_click(
+                                            "Yes, delete it",
+                                            move |cx| {
+                                                dev_servers.update(cx, |this, cx| {
+                                                    this.delete_ssh_server(index, cx);
+                                                    this.mode = Mode::Default;
+                                                    cx.notify();
+                                                })
+                                            },
+                                        ),
+                                        cx,
+                                    );
+                                })
+                                .ok();
+                        }
+                        self.selectable_items.add_item(Box::new({
+                            let connection_string = connection_string.clone();
+                            move |this, cx| {
+                                remove_ssh_server(
+                                    cx.view().clone(),
+                                    this.workspace.clone(),
+                                    index,
+                                    connection_string.clone(),
+                                    cx,
+                                );
+                            }
+                        }));
+                        let is_selected = self.selectable_items.is_selected();
+                        ListItem::new("delete-server")
+                            .selected(is_selected)
+                            .inset(true)
+                            .spacing(ui::ListItemSpacing::Sparse)
+                            .start_slot(Icon::new(IconName::Trash).color(Color::Error))
+                            .child(Label::new("Delete Server").color(Color::Error))
+                            .on_click(cx.listener(move |this, _, cx| {
+                                remove_ssh_server(
+                                    cx.view().clone(),
+                                    this.workspace.clone(),
+                                    index,
+                                    connection_string.clone(),
+                                    cx,
+                                );
+                            }))
+                    })
+                    .child(ListSeparator)
+                    .child({
+                        self.selectable_items.add_item(Box::new({
+                            move |this, cx| {
+                                this.mode = Mode::Default;
+                                cx.notify();
+                            }
+                        }));
+                        let is_selected = self.selectable_items.is_selected();
+                        ListItem::new("go-back")
+                            .selected(is_selected)
+                            .inset(true)
+                            .spacing(ui::ListItemSpacing::Sparse)
+                            .start_slot(Icon::new(IconName::ArrowLeft).color(Color::Muted))
+                            .child(Label::new("Go Back"))
+                            .on_click(cx.listener(|this, _, cx| {
+                                this.mode = Mode::Default;
+                                cx.notify()
+                            }))
+                    }),
+            )
+    }
+
+    fn render_edit_nickname(
+        &self,
+        state: &EditNicknameState,
+        cx: &mut ViewContext<Self>,
+    ) -> impl IntoElement {
+        let Some(connection) = SshSettings::get_global(cx)
+            .ssh_connections()
+            .nth(state.index)
+        else {
+            return v_flex();
+        };
+
+        let connection_string = connection.host.clone();
+
+        v_flex()
+            .child(
+                SshConnectionHeader {
+                    connection_string,
+                    nickname: connection.nickname.clone(),
+                }
+                .render(cx),
+            )
+            .child(h_flex().p_2().child(state.editor.clone()))
+    }
+
     fn render_default(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         let dev_servers = self.dev_server_store.read(cx).dev_servers();
         let ssh_connections = SshSettings::get_global(cx)
             .ssh_connections()
             .collect::<Vec<_>>();
+        self.selectable_items.add_item(Box::new(|this, cx| {
+            this.mode = Mode::CreateDevServer(CreateDevServer::new(cx));
+            cx.notify();
+        }));
+
+        let is_selected = self.selectable_items.is_selected();
+        let connect_button = ListItem::new("register-dev-server-button")
+            .selected(is_selected)
+            .inset(true)
+            .spacing(ui::ListItemSpacing::Sparse)
+            .start_slot(Icon::new(IconName::Plus).color(Color::Muted))
+            .child(Label::new("Connect New Server"))
+            .on_click(cx.listener(|this, _, cx| {
+                let state = CreateDevServer::new(cx);
+                this.mode = Mode::CreateDevServer(state);
+
+                cx.notify();
+            }));
+
+        let footer = format!("Servers: {}", ssh_connections.len() + dev_servers.len());
+        let mut modal_section = v_flex()
+            .id("ssh-server-list")
+            .overflow_y_scroll()
+            .size_full()
+            .child(connect_button)
+            .child(ListSeparator)
+            .child(
+                List::new()
+                    .empty_message("No dev servers registered yet.")
+                    .children(ssh_connections.iter().cloned().enumerate().map(
+                        |(ix, connection)| {
+                            self.render_ssh_connection(ix, connection, cx)
+                                .into_any_element()
+                        },
+                    )),
+            )
+            .into_any_element();
 
-        let footer = format!("Connections: {}", ssh_connections.len() + dev_servers.len());
         Modal::new("remote-projects", Some(self.scroll_handle.clone()))
             .header(
                 ModalHeader::new().child(
                     h_flex()
                         .justify_between()
                         .child(Headline::new("Remote Projects (alpha)").size(HeadlineSize::XSmall))
-                        .child(
-                            Button::new("register-dev-server-button", "Connect New Server")
-                                .style(ButtonStyle::Filled)
-                                .layer(ElevationIndex::ModalSurface)
-                                .icon(IconName::Plus)
-                                .icon_position(IconPosition::Start)
-                                .icon_color(Color::Muted)
-                                .on_click(cx.listener(|this, _, cx| {
-                                    this.mode = Mode::CreateDevServer(CreateDevServer {
-                                        ..Default::default()
-                                    });
-                                    this.dev_server_name_input.update(cx, |text_field, cx| {
-                                        text_field.editor().update(cx, |editor, cx| {
-                                            editor.set_text("", cx);
-                                        });
-                                    });
-                                    cx.notify();
-                                })),
-                        ),
+                        .child(Label::new(footer).size(LabelSize::Small)),
                 ),
             )
             .section(
                 Section::new().padded(false).child(
-                    div()
+                    v_flex()
+                        .min_h(rems(28.))
+                        .size_full()
+                        .pt_1p5()
                         .border_y_1()
                         .border_color(cx.theme().colors().border_variant)
-                        .w_full()
                         .child(
-                            div().p_2().child(
-                                List::new()
-                                    .empty_message("No dev servers registered yet.")
-                                    .children(ssh_connections.iter().cloned().enumerate().map(
-                                        |(ix, connection)| {
-                                            self.render_ssh_connection(ix, connection, cx)
-                                                .into_any_element()
-                                        },
-                                    )),
-                            ),
+                            canvas(
+                                |bounds, cx| {
+                                    modal_section.prepaint_as_root(
+                                        bounds.origin,
+                                        bounds.size.into(),
+                                        cx,
+                                    );
+                                    modal_section
+                                },
+                                |_, mut modal_section, cx| {
+                                    modal_section.paint(cx);
+                                },
+                            )
+                            .size_full()
+                            .min_h_full()
+                            .flex_1(),
                         ),
                 ),
             )
-            .footer(
-                ModalFooter::new()
-                    .start_slot(div().child(Label::new(footer).size(LabelSize::Small))),
-            )
     }
 }
 
-fn get_text(element: &View<TextField>, cx: &mut WindowContext) -> String {
-    element
-        .read(cx)
-        .editor()
-        .read(cx)
-        .text(cx)
-        .trim()
-        .to_string()
+fn get_text(element: &View<Editor>, cx: &mut WindowContext) -> String {
+    element.read(cx).text(cx).trim().to_string()
 }
 
 impl ModalView for DevServerProjects {}
@@ -892,27 +1205,36 @@ impl EventEmitter<DismissEvent> for DevServerProjects {}
 
 impl Render for DevServerProjects {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        self.selectable_items.reset();
         div()
             .track_focus(&self.focus_handle)
             .elevation_3(cx)
             .key_context("DevServerModal")
             .on_action(cx.listener(Self::cancel))
             .on_action(cx.listener(Self::confirm))
+            .on_action(cx.listener(Self::prev_item))
+            .on_action(cx.listener(Self::next_item))
             .capture_any_mouse_down(cx.listener(|this, _, cx| {
                 this.focus_handle(cx).focus(cx);
             }))
             .on_mouse_down_out(cx.listener(|this, _, cx| {
-                if matches!(this.mode, Mode::Default(None)) {
+                if matches!(this.mode, Mode::Default) {
                     cx.emit(DismissEvent)
                 }
             }))
             .w(rems(34.))
-            .max_h(rems(40.))
             .child(match &self.mode {
-                Mode::Default(_) => self.render_default(cx).into_any_element(),
+                Mode::Default => self.render_default(cx).into_any_element(),
+                Mode::ViewServerOptions(index, connection) => self
+                    .render_view_options(*index, connection.clone(), cx)
+                    .into_any_element(),
+                Mode::ProjectPicker(element) => element.clone().into_any_element(),
                 Mode::CreateDevServer(state) => {
                     self.render_create_dev_server(state, cx).into_any_element()
                 }
+                Mode::EditNickname(state) => {
+                    self.render_edit_nickname(state, cx).into_any_element()
+                }
             })
     }
 }
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index a78a1dbcdf84f4..6eb27aa25a09c9 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -16,9 +16,9 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 use ui::{
-    div, h_flex, prelude::*, v_flex, ActiveTheme, ButtonCommon, Clickable, Color, Icon, IconButton,
-    IconName, IconSize, InteractiveElement, IntoElement, Label, LabelCommon, Styled, Tooltip,
-    ViewContext, VisualContext, WindowContext,
+    div, h_flex, prelude::*, v_flex, ActiveTheme, Color, Icon, IconName, IconSize,
+    InteractiveElement, IntoElement, Label, LabelCommon, Styled, ViewContext, VisualContext,
+    WindowContext,
 };
 use workspace::{AppState, ModalView, Workspace};
 
@@ -35,17 +35,20 @@ impl SshSettings {
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
 pub struct SshConnection {
-    pub host: String,
+    pub host: SharedString,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub username: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub port: Option<u16>,
     pub projects: Vec<SshProject>,
+    /// Name to use for this server in UI.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nickname: Option<SharedString>,
 }
 impl From<SshConnection> for SshConnectionOptions {
     fn from(val: SshConnection) -> Self {
         SshConnectionOptions {
-            host: val.host,
+            host: val.host.into(),
             username: val.username,
             port: val.port,
             password: None,
@@ -87,7 +90,10 @@ pub struct SshConnectionModal {
 }
 
 impl SshPrompt {
-    pub fn new(connection_options: &SshConnectionOptions, cx: &mut ViewContext<Self>) -> Self {
+    pub(crate) fn new(
+        connection_options: &SshConnectionOptions,
+        cx: &mut ViewContext<Self>,
+    ) -> Self {
         let connection_string = connection_options.connection_string().into();
         Self {
             connection_string,
@@ -231,12 +237,57 @@ impl SshConnectionModal {
     }
 }
 
+pub(crate) struct SshConnectionHeader {
+    pub(crate) connection_string: SharedString,
+    pub(crate) nickname: Option<SharedString>,
+}
+
+impl RenderOnce for SshConnectionHeader {
+    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
+        let theme = cx.theme();
+
+        let mut header_color = theme.colors().text;
+        header_color.fade_out(0.96);
+
+        let (main_label, meta_label) = if let Some(nickname) = self.nickname {
+            (nickname, Some(format!("({})", self.connection_string)))
+        } else {
+            (self.connection_string, None)
+        };
+
+        h_flex()
+            .p_1()
+            .rounded_t_md()
+            .w_full()
+            .gap_2()
+            .justify_center()
+            .border_b_1()
+            .border_color(theme.colors().border_variant)
+            .bg(header_color)
+            .child(Icon::new(IconName::Server).size(IconSize::XSmall))
+            .child(
+                h_flex()
+                    .gap_1()
+                    .child(
+                        Label::new(main_label)
+                            .size(ui::LabelSize::Small)
+                            .single_line(),
+                    )
+                    .children(meta_label.map(|label| {
+                        Label::new(label)
+                            .size(ui::LabelSize::Small)
+                            .single_line()
+                            .color(Color::Muted)
+                    })),
+            )
+    }
+}
+
 impl Render for SshConnectionModal {
     fn render(&mut self, cx: &mut ui::ViewContext<Self>) -> impl ui::IntoElement {
         let connection_string = self.prompt.read(cx).connection_string.clone();
         let theme = cx.theme();
-        let mut header_color = cx.theme().colors().text;
-        header_color.fade_out(0.96);
+
         let body_color = theme.colors().editor_background;
 
         v_flex()
@@ -248,36 +299,11 @@ impl Render for SshConnectionModal {
             .border_1()
             .border_color(theme.colors().border)
             .child(
-                h_flex()
-                    .relative()
-                    .p_1()
-                    .rounded_t_md()
-                    .border_b_1()
-                    .border_color(theme.colors().border)
-                    .bg(header_color)
-                    .justify_between()
-                    .child(
-                        div().absolute().left_0p5().top_0p5().child(
-                            IconButton::new("ssh-connection-cancel", IconName::ArrowLeft)
-                                .icon_size(IconSize::XSmall)
-                                .on_click(cx.listener(move |this, _, cx| {
-                                    this.dismiss(&Default::default(), cx);
-                                }))
-                                .tooltip(|cx| Tooltip::for_action("Back", &menu::Cancel, cx)),
-                        ),
-                    )
-                    .child(
-                        h_flex()
-                            .w_full()
-                            .gap_2()
-                            .justify_center()
-                            .child(Icon::new(IconName::Server).size(IconSize::XSmall))
-                            .child(
-                                Label::new(connection_string)
-                                    .size(ui::LabelSize::Small)
-                                    .single_line(),
-                            ),
-                    ),
+                SshConnectionHeader {
+                    connection_string,
+                    nickname: None,
+                }
+                .render(cx),
             )
             .child(
                 h_flex()
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index 4e196b8bbfc827..d0307d5625a5b8 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -293,15 +293,20 @@ impl TitleBar {
 
         let meta = SharedString::from(meta);
 
-        let indicator = div()
+        let indicator = h_flex()
+            // We're using the circle inside a circle approach because, otherwise, by using borders
+            // we'd get a very thin, leaking indicator color, which is not what we want.
             .absolute()
             .size_2p5()
             .right_0()
             .bottom_0()
+            .bg(indicator_border_color)
+            .size_2p5()
             .rounded_full()
-            .border_2()
-            .border_color(indicator_border_color)
-            .bg(indicator_color.color(cx));
+            .items_center()
+            .justify_center()
+            .overflow_hidden()
+            .child(Indicator::dot().color(indicator_color));
 
         Some(
             div()
diff --git a/crates/ui/src/components/list/list_item.rs b/crates/ui/src/components/list/list_item.rs
index 37076737a6be0e..dd2467f7b04eaa 100644
--- a/crates/ui/src/components/list/list_item.rs
+++ b/crates/ui/src/components/list/list_item.rs
@@ -193,6 +193,7 @@ impl RenderOnce for ListItem {
                     .id("inner_list_item")
                     .w_full()
                     .relative()
+                    .items_center()
                     .gap_1()
                     .px(Spacing::Medium.rems(cx))
                     .map(|this| match self.spacing {
@@ -247,7 +248,7 @@ impl RenderOnce for ListItem {
                             .flex_grow()
                             .flex_shrink_0()
                             .flex_basis(relative(0.25))
-                            .gap(Spacing::Small.rems(cx))
+                            .gap(Spacing::Medium.rems(cx))
                             .map(|list_content| {
                                 if self.overflow_x {
                                     list_content

From 397e4bee0a9ab26ccfb36596dc6440ae3a31f0e8 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 15 Oct 2024 16:04:29 +0200
Subject: [PATCH 649/762] ssh remoting: Forward LSP logs to client (#19212)

Release Notes:

- N/A

---------

Co-authored-by: Bennet Bo Fenner <bennet@zed.dev>
---
 crates/collab/src/db/queries/projects.rs     |   1 +
 crates/collab/src/db/queries/rooms.rs        |   1 +
 crates/language_tools/src/lsp_log.rs         | 192 +++++++++++--------
 crates/language_tools/src/lsp_log_tests.rs   |   3 +
 crates/project/src/lsp_store.rs              |  89 ++++++++-
 crates/project/src/project.rs                |   8 +-
 crates/project/src/project_tests.rs          |  14 +-
 crates/proto/proto/zed.proto                 |  19 +-
 crates/proto/src/proto.rs                    |   2 +
 crates/remote_server/Cargo.toml              |   1 +
 crates/remote_server/src/headless_project.rs |  10 +
 11 files changed, 245 insertions(+), 95 deletions(-)

diff --git a/crates/collab/src/db/queries/projects.rs b/crates/collab/src/db/queries/projects.rs
index ceac78203d9a1b..f4eabf49791c93 100644
--- a/crates/collab/src/db/queries/projects.rs
+++ b/crates/collab/src/db/queries/projects.rs
@@ -838,6 +838,7 @@ impl Database {
                 .map(|language_server| proto::LanguageServer {
                     id: language_server.id as u64,
                     name: language_server.name,
+                    worktree_id: None,
                 })
                 .collect(),
             dev_server_project_id: project.dev_server_project_id,
diff --git a/crates/collab/src/db/queries/rooms.rs b/crates/collab/src/db/queries/rooms.rs
index baba0f2cf9d7c2..a0bb9fed698654 100644
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@@ -718,6 +718,7 @@ impl Database {
             .map(|language_server| proto::LanguageServer {
                 id: language_server.id as u64,
                 name: language_server.name,
+                worktree_id: None,
             })
             .collect::<Vec<_>>();
 
diff --git a/crates/language_tools/src/lsp_log.rs b/crates/language_tools/src/lsp_log.rs
index aee39ff0a088e7..9f6eb62817d633 100644
--- a/crates/language_tools/src/lsp_log.rs
+++ b/crates/language_tools/src/lsp_log.rs
@@ -11,7 +11,7 @@ use language::{LanguageServerId, LanguageServerName};
 use lsp::{
     notification::SetTrace, IoKind, LanguageServer, MessageType, SetTraceParams, TraceValue,
 };
-use project::{search::SearchQuery, Project};
+use project::{search::SearchQuery, Project, WorktreeId};
 use std::{borrow::Cow, sync::Arc};
 use ui::{prelude::*, Button, Checkbox, ContextMenu, Label, PopoverMenu, Selection};
 use workspace::{
@@ -99,6 +99,8 @@ impl Message for RpcMessage {
 }
 
 struct LanguageServerState {
+    name: Option<LanguageServerName>,
+    worktree_id: Option<WorktreeId>,
     kind: LanguageServerKind,
     log_messages: VecDeque<LogMessage>,
     trace_messages: VecDeque<TraceMessage>,
@@ -108,15 +110,34 @@ struct LanguageServerState {
     io_logs_subscription: Option<lsp::Subscription>,
 }
 
-enum LanguageServerKind {
+#[derive(PartialEq, Clone)]
+pub enum LanguageServerKind {
     Local { project: WeakModel<Project> },
-    Global { name: LanguageServerName },
+    Remote { project: WeakModel<Project> },
+    Global,
+}
+
+impl LanguageServerKind {
+    fn is_remote(&self) -> bool {
+        matches!(self, LanguageServerKind::Remote { .. })
+    }
+}
+
+impl std::fmt::Debug for LanguageServerKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LanguageServerKind::Local { .. } => write!(f, "LanguageServerKind::Local"),
+            LanguageServerKind::Remote { .. } => write!(f, "LanguageServerKind::Remote"),
+            LanguageServerKind::Global => write!(f, "LanguageServerKind::Global"),
+        }
+    }
 }
 
 impl LanguageServerKind {
     fn project(&self) -> Option<&WeakModel<Project>> {
         match self {
             Self::Local { project } => Some(project),
+            Self::Remote { project } => Some(project),
             Self::Global { .. } => None,
         }
     }
@@ -175,6 +196,7 @@ pub(crate) struct LogMenuItem {
     pub rpc_trace_enabled: bool,
     pub selected_entry: LogKind,
     pub trace_level: lsp::TraceValue,
+    pub server_kind: LanguageServerKind,
 }
 
 actions!(debug, [OpenLanguageServerLogs]);
@@ -184,7 +206,7 @@ pub fn init(cx: &mut AppContext) {
 
     cx.observe_new_views(move |workspace: &mut Workspace, cx| {
         let project = workspace.project();
-        if project.read(cx).is_local() {
+        if project.read(cx).is_local() || project.read(cx).is_via_ssh() {
             log_store.update(cx, |store, cx| {
                 store.add_project(project, cx);
             });
@@ -193,7 +215,7 @@ pub fn init(cx: &mut AppContext) {
         let log_store = log_store.clone();
         workspace.register_action(move |workspace, _: &OpenLanguageServerLogs, cx| {
             let project = workspace.project().read(cx);
-            if project.is_local() {
+            if project.is_local() || project.is_via_ssh() {
                 workspace.split_item(
                     SplitDirection::Right,
                     Box::new(cx.new_view(|cx| {
@@ -233,11 +255,12 @@ impl LogStore {
                                         .ok();
                                 },
                             ));
+                        let name = LanguageServerName::new_static("copilot");
                         this.add_language_server(
-                            LanguageServerKind::Global {
-                                name: LanguageServerName::new_static("copilot"),
-                            },
+                            LanguageServerKind::Global,
                             server.server_id(),
+                            Some(name),
+                            None,
                             Some(server.clone()),
                             cx,
                         );
@@ -279,42 +302,44 @@ impl LogStore {
                         this.language_servers
                             .retain(|_, state| state.kind.project() != Some(&weak_project));
                     }),
-                    cx.subscribe(project, |this, project, event, cx| match event {
-                        project::Event::LanguageServerAdded(id) => {
-                            let read_project = project.read(cx);
-                            if let Some(server) = read_project.language_server_for_id(*id, cx) {
+                    cx.subscribe(project, |this, project, event, cx| {
+                        let server_kind = if project.read(cx).is_via_ssh() {
+                            LanguageServerKind::Remote {
+                                project: project.downgrade(),
+                            }
+                        } else {
+                            LanguageServerKind::Local {
+                                project: project.downgrade(),
+                            }
+                        };
+
+                        match event {
+                            project::Event::LanguageServerAdded(id, name, worktree_id) => {
                                 this.add_language_server(
-                                    LanguageServerKind::Local {
-                                        project: project.downgrade(),
-                                    },
-                                    server.server_id(),
-                                    Some(server),
+                                    server_kind,
+                                    *id,
+                                    Some(name.clone()),
+                                    *worktree_id,
+                                    project.read(cx).language_server_for_id(*id, cx),
                                     cx,
                                 );
                             }
-                        }
-                        project::Event::LanguageServerRemoved(id) => {
-                            this.remove_language_server(*id, cx);
-                        }
-                        project::Event::LanguageServerLog(id, typ, message) => {
-                            this.add_language_server(
-                                LanguageServerKind::Local {
-                                    project: project.downgrade(),
-                                },
-                                *id,
-                                None,
-                                cx,
-                            );
-                            match typ {
-                                project::LanguageServerLogType::Log(typ) => {
-                                    this.add_language_server_log(*id, *typ, message, cx);
-                                }
-                                project::LanguageServerLogType::Trace(_) => {
-                                    this.add_language_server_trace(*id, message, cx);
+                            project::Event::LanguageServerRemoved(id) => {
+                                this.remove_language_server(*id, cx);
+                            }
+                            project::Event::LanguageServerLog(id, typ, message) => {
+                                this.add_language_server(server_kind, *id, None, None, None, cx);
+                                match typ {
+                                    project::LanguageServerLogType::Log(typ) => {
+                                        this.add_language_server_log(*id, *typ, message, cx);
+                                    }
+                                    project::LanguageServerLogType::Trace(_) => {
+                                        this.add_language_server_trace(*id, message, cx);
+                                    }
                                 }
                             }
+                            _ => {}
                         }
-                        _ => {}
                     }),
                 ],
             },
@@ -332,12 +357,16 @@ impl LogStore {
         &mut self,
         kind: LanguageServerKind,
         server_id: LanguageServerId,
+        name: Option<LanguageServerName>,
+        worktree_id: Option<WorktreeId>,
         server: Option<Arc<LanguageServer>>,
         cx: &mut ModelContext<Self>,
     ) -> Option<&mut LanguageServerState> {
         let server_state = self.language_servers.entry(server_id).or_insert_with(|| {
             cx.notify();
             LanguageServerState {
+                name: None,
+                worktree_id: None,
                 kind,
                 rpc_state: None,
                 log_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
@@ -348,6 +377,13 @@ impl LogStore {
             }
         });
 
+        if let Some(name) = name {
+            server_state.name = Some(name);
+        }
+        if let Some(worktree_id) = worktree_id {
+            server_state.worktree_id = Some(worktree_id);
+        }
+
         if let Some(server) = server.filter(|_| server_state.io_logs_subscription.is_none()) {
             let io_tx = self.io_tx.clone();
             let server_id = server.server_id();
@@ -448,14 +484,14 @@ impl LogStore {
         self.language_servers
             .iter()
             .filter_map(move |(id, state)| match &state.kind {
-                LanguageServerKind::Local { project } => {
+                LanguageServerKind::Local { project } | LanguageServerKind::Remote { project } => {
                     if project == lookup_project {
                         Some(*id)
                     } else {
                         None
                     }
                 }
-                LanguageServerKind::Global { .. } => Some(*id),
+                LanguageServerKind::Global => Some(*id),
             })
     }
 
@@ -662,21 +698,40 @@ impl LspLogView {
     pub(crate) fn menu_items<'a>(&'a self, cx: &'a AppContext) -> Option<Vec<LogMenuItem>> {
         let log_store = self.log_store.read(cx);
 
-        let mut rows = self
-            .project
-            .read(cx)
-            .language_servers(cx)
-            .filter_map(|(server_id, language_server_name, worktree_id)| {
-                let worktree = self.project.read(cx).worktree_for_id(worktree_id, cx)?;
-                let state = log_store.language_servers.get(&server_id)?;
-                Some(LogMenuItem {
-                    server_id,
-                    server_name: language_server_name,
-                    worktree_root_name: worktree.read(cx).root_name().to_string(),
+        let unknown_server = LanguageServerName::new_static("unknown server");
+
+        let mut rows = log_store
+            .language_servers
+            .iter()
+            .filter_map(|(server_id, state)| match &state.kind {
+                LanguageServerKind::Local { .. } | LanguageServerKind::Remote { .. } => {
+                    let worktree_root_name = state
+                        .worktree_id
+                        .and_then(|id| self.project.read(cx).worktree_for_id(id, cx))
+                        .map(|worktree| worktree.read(cx).root_name().to_string())
+                        .unwrap_or_else(|| "Unknown worktree".to_string());
+
+                    let state = log_store.language_servers.get(&server_id)?;
+                    Some(LogMenuItem {
+                        server_id: *server_id,
+                        server_name: state.name.clone().unwrap_or(unknown_server.clone()),
+                        server_kind: state.kind.clone(),
+                        worktree_root_name,
+                        rpc_trace_enabled: state.rpc_state.is_some(),
+                        selected_entry: self.active_entry_kind,
+                        trace_level: lsp::TraceValue::Off,
+                    })
+                }
+
+                LanguageServerKind::Global => Some(LogMenuItem {
+                    server_id: *server_id,
+                    server_name: state.name.clone().unwrap_or(unknown_server.clone()),
+                    server_kind: state.kind.clone(),
+                    worktree_root_name: "supplementary".to_string(),
                     rpc_trace_enabled: state.rpc_state.is_some(),
                     selected_entry: self.active_entry_kind,
                     trace_level: lsp::TraceValue::Off,
-                })
+                }),
             })
             .chain(
                 self.project
@@ -687,6 +742,7 @@ impl LspLogView {
                         Some(LogMenuItem {
                             server_id,
                             server_name: name.clone(),
+                            server_kind: state.kind.clone(),
                             worktree_root_name: "supplementary".to_string(),
                             rpc_trace_enabled: state.rpc_state.is_some(),
                             selected_entry: self.active_entry_kind,
@@ -694,22 +750,6 @@ impl LspLogView {
                         })
                     }),
             )
-            .chain(
-                log_store
-                    .language_servers
-                    .iter()
-                    .filter_map(|(server_id, state)| match &state.kind {
-                        LanguageServerKind::Global { name } => Some(LogMenuItem {
-                            server_id: *server_id,
-                            server_name: name.clone(),
-                            worktree_root_name: "supplementary".to_string(),
-                            rpc_trace_enabled: state.rpc_state.is_some(),
-                            selected_entry: self.active_entry_kind,
-                            trace_level: lsp::TraceValue::Off,
-                        }),
-                        _ => None,
-                    }),
-            )
             .collect::<Vec<_>>();
         rows.sort_by_key(|row| row.server_id);
         rows.dedup_by_key(|row| row.server_id);
@@ -1075,13 +1115,9 @@ impl Render for LspLogToolbarItemView {
                                         view.show_logs_for_server(row.server_id, cx);
                                     }),
                                 );
-                            if server_selected && row.selected_entry == LogKind::Logs {
-                                let selected_ix = menu.select_last();
-                                debug_assert_eq!(
-                                    Some(ix * 4 + 1),
-                                    selected_ix,
-                                    "Could not scroll to a just added LSP menu item"
-                                );
+                            // We do not support tracing for remote language servers right now
+                            if row.server_kind.is_remote() {
+                                return menu;
                             }
                             menu = menu.entry(
                                 SERVER_TRACE,
@@ -1090,14 +1126,6 @@ impl Render for LspLogToolbarItemView {
                                     view.show_trace_for_server(row.server_id, cx);
                                 }),
                             );
-                            if server_selected && row.selected_entry == LogKind::Trace {
-                                let selected_ix = menu.select_last();
-                                debug_assert_eq!(
-                                    Some(ix * 4 + 2),
-                                    selected_ix,
-                                    "Could not scroll to a just added LSP menu item"
-                                );
-                            }
                             menu = menu.custom_entry(
                                 {
                                     let log_toolbar_view = log_toolbar_view.clone();
diff --git a/crates/language_tools/src/lsp_log_tests.rs b/crates/language_tools/src/lsp_log_tests.rs
index 3ead6954340e88..6b45cfc8dcb3ad 100644
--- a/crates/language_tools/src/lsp_log_tests.rs
+++ b/crates/language_tools/src/lsp_log_tests.rs
@@ -95,6 +95,9 @@ async fn test_lsp_logs(cx: &mut TestAppContext) {
                 rpc_trace_enabled: false,
                 selected_entry: LogKind::Logs,
                 trace_level: lsp::TraceValue::Off,
+                server_kind: lsp_log::LanguageServerKind::Local {
+                    project: project.downgrade()
+                }
             }]
         );
         assert_eq!(view.editor.read(cx).text(cx), "hello from the server\n");
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 01e40ec6a00489..58d6b07e565c42 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -696,7 +696,7 @@ pub struct LspStore {
 }
 
 pub enum LspStoreEvent {
-    LanguageServerAdded(LanguageServerId),
+    LanguageServerAdded(LanguageServerId, LanguageServerName, Option<WorktreeId>),
     LanguageServerRemoved(LanguageServerId),
     LanguageServerUpdate {
         language_server_id: LanguageServerId,
@@ -752,6 +752,7 @@ impl LspStore {
         client.add_model_request_handler(Self::handle_restart_language_servers);
         client.add_model_message_handler(Self::handle_start_language_server);
         client.add_model_message_handler(Self::handle_update_language_server);
+        client.add_model_message_handler(Self::handle_language_server_log);
         client.add_model_message_handler(Self::handle_update_diagnostic_summary);
         client.add_model_request_handler(Self::handle_format_buffers);
         client.add_model_request_handler(Self::handle_resolve_completion_documentation);
@@ -3087,6 +3088,7 @@ impl LspStore {
                     server: Some(proto::LanguageServer {
                         id: server_id.0 as u64,
                         name: status.name.clone(),
+                        worktree_id: None,
                     }),
                 })
                 .log_err();
@@ -3907,16 +3909,23 @@ impl LspStore {
             .payload
             .server
             .ok_or_else(|| anyhow!("invalid server"))?;
+
         this.update(&mut cx, |this, cx| {
+            let server_id = LanguageServerId(server.id as usize);
             this.language_server_statuses.insert(
-                LanguageServerId(server.id as usize),
+                server_id,
                 LanguageServerStatus {
-                    name: server.name,
+                    name: server.name.clone(),
                     pending_work: Default::default(),
                     has_pending_diagnostic_updates: false,
                     progress_tokens: Default::default(),
                 },
             );
+            cx.emit(LspStoreEvent::LanguageServerAdded(
+                server_id,
+                LanguageServerName(server.name.into()),
+                server.worktree_id.map(WorktreeId::from_proto),
+            ));
             cx.notify();
         })?;
         Ok(())
@@ -3984,6 +3993,29 @@ impl LspStore {
         })?
     }
 
+    async fn handle_language_server_log(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::LanguageServerLog>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        let language_server_id = LanguageServerId(envelope.payload.language_server_id as usize);
+        let log_type = envelope
+            .payload
+            .log_type
+            .map(LanguageServerLogType::from_proto)
+            .context("invalid language server log type")?;
+
+        let message = envelope.payload.message;
+
+        this.update(&mut cx, |_, cx| {
+            cx.emit(LspStoreEvent::LanguageServerLog(
+                language_server_id,
+                log_type,
+                message,
+            ));
+        })
+    }
+
     pub fn disk_based_diagnostics_started(
         &mut self,
         language_server_id: LanguageServerId,
@@ -6356,7 +6388,11 @@ impl LspStore {
             },
         );
 
-        cx.emit(LspStoreEvent::LanguageServerAdded(server_id));
+        cx.emit(LspStoreEvent::LanguageServerAdded(
+            server_id,
+            language_server.name().into(),
+            Some(key.0),
+        ));
 
         if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {
             downstream_client
@@ -6365,6 +6401,7 @@ impl LspStore {
                     server: Some(proto::LanguageServer {
                         id: server_id.0 as u64,
                         name: language_server.name().to_string(),
+                        worktree_id: Some(key.0.to_proto()),
                     }),
                 })
                 .log_err();
@@ -6546,8 +6583,8 @@ impl LspStore {
         if let Some(local) = self.as_local_mut() {
             local
                 .supplementary_language_servers
-                .insert(id, (name, server));
-            cx.emit(LspStoreEvent::LanguageServerAdded(id));
+                .insert(id, (name.clone(), server));
+            cx.emit(LspStoreEvent::LanguageServerAdded(id, name, None));
         }
     }
 
@@ -7289,6 +7326,46 @@ pub enum LanguageServerLogType {
     Trace(Option<String>),
 }
 
+impl LanguageServerLogType {
+    pub fn to_proto(&self) -> proto::language_server_log::LogType {
+        match self {
+            Self::Log(log_type) => {
+                let message_type = match *log_type {
+                    MessageType::ERROR => 1,
+                    MessageType::WARNING => 2,
+                    MessageType::INFO => 3,
+                    MessageType::LOG => 4,
+                    other => {
+                        log::warn!("Unknown lsp log message type: {:?}", other);
+                        4
+                    }
+                };
+                proto::language_server_log::LogType::LogMessageType(message_type)
+            }
+            Self::Trace(message) => {
+                proto::language_server_log::LogType::LogTrace(proto::LspLogTrace {
+                    message: message.clone(),
+                })
+            }
+        }
+    }
+
+    pub fn from_proto(log_type: proto::language_server_log::LogType) -> Self {
+        match log_type {
+            proto::language_server_log::LogType::LogMessageType(message_type) => {
+                Self::Log(match message_type {
+                    1 => MessageType::ERROR,
+                    2 => MessageType::WARNING,
+                    3 => MessageType::INFO,
+                    4 => MessageType::LOG,
+                    _ => MessageType::LOG,
+                })
+            }
+            proto::language_server_log::LogType::LogTrace(trace) => Self::Trace(trace.message),
+        }
+    }
+}
+
 pub enum LanguageServerState {
     Starting(Task<Option<Arc<LanguageServer>>>),
 
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 2692c711bf5313..f4040a3d12c6e7 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -219,7 +219,7 @@ enum ProjectClientState {
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Event {
-    LanguageServerAdded(LanguageServerId),
+    LanguageServerAdded(LanguageServerId, LanguageServerName, Option<WorktreeId>),
     LanguageServerRemoved(LanguageServerId),
     LanguageServerLog(LanguageServerId, LanguageServerLogType, String),
     Notification(String),
@@ -2090,9 +2090,9 @@ impl Project {
                 path: path.clone(),
                 language_server_id: *language_server_id,
             }),
-            LspStoreEvent::LanguageServerAdded(language_server_id) => {
-                cx.emit(Event::LanguageServerAdded(*language_server_id))
-            }
+            LspStoreEvent::LanguageServerAdded(language_server_id, name, worktree_id) => cx.emit(
+                Event::LanguageServerAdded(*language_server_id, name.clone(), *worktree_id),
+            ),
             LspStoreEvent::LanguageServerRemoved(language_server_id) => {
                 cx.emit(Event::LanguageServerRemoved(*language_server_id))
             }
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index f5cfba2ffdbacc..17eeae1c3dac93 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -1185,7 +1185,11 @@ async fn test_disk_based_diagnostics_progress(cx: &mut gpui::TestAppContext) {
     let fake_server = fake_servers.next().await.unwrap();
     assert_eq!(
         events.next().await.unwrap(),
-        Event::LanguageServerAdded(LanguageServerId(0)),
+        Event::LanguageServerAdded(
+            LanguageServerId(0),
+            fake_server.server.name().into(),
+            Some(worktree_id)
+        ),
     );
 
     fake_server
@@ -1295,6 +1299,8 @@ async fn test_restarting_server_with_diagnostics_running(cx: &mut gpui::TestAppC
         },
     );
 
+    let worktree_id = project.update(cx, |p, cx| p.worktrees(cx).next().unwrap().read(cx).id());
+
     let buffer = project
         .update(cx, |project, cx| project.open_local_buffer("/dir/a.rs", cx))
         .await
@@ -1314,7 +1320,11 @@ async fn test_restarting_server_with_diagnostics_running(cx: &mut gpui::TestAppC
     let fake_server = fake_servers.next().await.unwrap();
     assert_eq!(
         events.next().await.unwrap(),
-        Event::LanguageServerAdded(LanguageServerId(1))
+        Event::LanguageServerAdded(
+            LanguageServerId(1),
+            fake_server.server.name().into(),
+            Some(worktree_id)
+        )
     );
     fake_server.start_progress(progress_token).await;
     assert_eq!(
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index f6711f8db939b6..52a73cd7f1dc8b 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -269,7 +269,7 @@ message Envelope {
 
         GetLlmToken get_llm_token = 235;
         GetLlmTokenResponse get_llm_token_response = 236;
-        RefreshLlmToken refresh_llm_token = 259; // current max
+        RefreshLlmToken refresh_llm_token = 259;
 
         LspExtSwitchSourceHeader lsp_ext_switch_source_header = 241;
         LspExtSwitchSourceHeaderResponse lsp_ext_switch_source_header_response = 242;
@@ -286,6 +286,8 @@ message Envelope {
         ShutdownRemoteServer shutdown_remote_server = 257;
 
         RemoveWorktree remove_worktree = 258;
+
+        LanguageServerLog language_server_log = 260; // current max
     }
 
     reserved 87 to 88;
@@ -1294,6 +1296,7 @@ message LamportTimestamp {
 message LanguageServer {
     uint64 id = 1;
     string name = 2;
+    optional uint64 worktree_id = 3;
 }
 
 message StartLanguageServer {
@@ -1347,6 +1350,20 @@ message LspDiskBasedDiagnosticsUpdating {}
 
 message LspDiskBasedDiagnosticsUpdated {}
 
+message LanguageServerLog {
+    uint64 project_id = 1;
+    uint64 language_server_id = 2;
+    oneof log_type {
+        uint32 log_message_type = 3;
+        LspLogTrace log_trace = 4;
+    }
+    string message = 5;
+}
+
+message LspLogTrace {
+    optional string message = 1;
+}
+
 message UpdateChannels {
     repeated Channel channels = 1;
     repeated uint64 delete_channels = 4;
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 2c038c2e1caadc..15841a70770922 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -366,6 +366,7 @@ messages!(
     (CheckFileExistsResponse, Background),
     (ShutdownRemoteServer, Foreground),
     (RemoveWorktree, Foreground),
+    (LanguageServerLog, Foreground),
 );
 
 request_messages!(
@@ -562,6 +563,7 @@ entity_messages!(
     LspExtSwitchSourceHeader,
     UpdateUserSettings,
     CheckFileExists,
+    LanguageServerLog,
 );
 
 entity_messages!(
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index 25c5860a00900e..d822721c1eb8a2 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -33,6 +33,7 @@ gpui.workspace = true
 language.workspace = true
 languages.workspace = true
 log.workspace = true
+lsp.workspace = true
 node_runtime.workspace = true
 project.workspace = true
 remote.workspace = true
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 96d769a50cae8f..701b80842b8ceb 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -203,6 +203,16 @@ impl HeadlessProject {
                     })
                     .log_err();
             }
+            LspStoreEvent::LanguageServerLog(language_server_id, log_type, message) => {
+                self.session
+                    .send(proto::LanguageServerLog {
+                        project_id: SSH_PROJECT_ID,
+                        language_server_id: language_server_id.to_proto(),
+                        message: message.clone(),
+                        log_type: Some(log_type.to_proto()),
+                    })
+                    .log_err();
+            }
             _ => {}
         }
     }

From 4fa75a78b99377d630d53e5d62be515f935a4ecf Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Tue, 15 Oct 2024 16:28:47 +0200
Subject: [PATCH 650/762] gpui: Improve performance of laying out long lines
 (#19215)

TL;DR: Another O(n^2) strikes.

In #19194 we received a report about a 7Mb JSON file that Zed struggles
with. Naturally this file showcased a O(n^2) in line layout; this file
has one long line.

During line layout for Mac we have to convert between UTF-16 and UTF-8
indices in the string, as CoreText works with UTF-16 and Rust strings
are UTF-8. The problem stemmed from the fact that we were re-seeking our
string converter on each glyph, which boils down to: we were reparsing
[0..curr_string_position] bytes up to full length of the string, which
is the O(n^2) in question. This PR changes this behaviour to reuse the
Index Converter if the position we're seeking to is not yet reached.
Basically, we're treating the converter as forward iterator and we try
to seek with the same iterator, if possible.

Where previously you could not even open the file in OP (within
reasonable time frame, I waited for 40 seconds before giving up), now
you can do it in.. slightly over a second. The best part is: the
experience is still not ideal. Typing in the buffer is sluggish. Still,
this is a start.


Release Notes:

- Mac: Improved performance with very long lines
---
 crates/editor/src/editor.rs                 | 11 ++---------
 crates/gpui/src/platform/mac/text_system.rs | 15 +++++++++------
 2 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index e2818bcd96263c..453c012e4d7cfd 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -13087,18 +13087,11 @@ fn snippet_completions(
         return vec![];
     }
     let snapshot = buffer.read(cx).text_snapshot();
-    let chunks = snapshot.reversed_chunks_in_range(text::Anchor::MIN..buffer_position);
-
-    let mut lines = chunks.lines();
-    let Some(line_at) = lines.next().filter(|line| !line.is_empty()) else {
-        return vec![];
-    };
+    let chars = snapshot.reversed_chars_for_range(text::Anchor::MIN..buffer_position);
 
     let scope = language.map(|language| language.default_scope());
     let classifier = CharClassifier::new(scope).for_completion(true);
-    let mut last_word = line_at
-        .chars()
-        .rev()
+    let mut last_word = chars
         .take_while(|c| classifier.is_word(*c))
         .collect::<String>();
     last_word = last_word.chars().rev().collect();
diff --git a/crates/gpui/src/platform/mac/text_system.rs b/crates/gpui/src/platform/mac/text_system.rs
index 5ed12f8671f135..3db1bf9bcd52b3 100644
--- a/crates/gpui/src/platform/mac/text_system.rs
+++ b/crates/gpui/src/platform/mac/text_system.rs
@@ -470,9 +470,10 @@ impl MacTextSystemState {
 
         // Retrieve the glyphs from the shaped line, converting UTF16 offsets to UTF8 offsets.
         let line = CTLine::new_with_attributed_string(string.as_concrete_TypeRef());
-
-        let mut runs = Vec::new();
-        for run in line.glyph_runs().into_iter() {
+        let glyph_runs = line.glyph_runs();
+        let mut runs = Vec::with_capacity(glyph_runs.len() as usize);
+        let mut ix_converter = StringIndexConverter::new(text);
+        for run in glyph_runs.into_iter() {
             let attributes = run.attributes().unwrap();
             let font = unsafe {
                 attributes
@@ -482,7 +483,6 @@ impl MacTextSystemState {
             };
             let font_id = self.id_for_native_font(font);
 
-            let mut ix_converter = StringIndexConverter::new(text);
             let mut glyphs = SmallVec::new();
             for ((glyph_id, position), glyph_utf16_ix) in run
                 .glyphs()
@@ -491,6 +491,10 @@ impl MacTextSystemState {
                 .zip(run.string_indices().iter())
             {
                 let glyph_utf16_ix = usize::try_from(*glyph_utf16_ix).unwrap();
+                if ix_converter.utf16_ix > glyph_utf16_ix {
+                    // We cannot reuse current index converter, as it can only seek forward. Restart the search.
+                    ix_converter = StringIndexConverter::new(text);
+                }
                 ix_converter.advance_to_utf16_ix(glyph_utf16_ix);
                 glyphs.push(ShapedGlyph {
                     id: GlyphId(*glyph_id as u32),
@@ -500,9 +504,8 @@ impl MacTextSystemState {
                 });
             }
 
-            runs.push(ShapedRun { font_id, glyphs })
+            runs.push(ShapedRun { font_id, glyphs });
         }
-
         let typographic_bounds = line.get_typographic_bounds();
         LineLayout {
             runs,

From 0eb6bfd3239ab46d6be4fce98111d4213b4c0516 Mon Sep 17 00:00:00 2001
From: Bennet Bo Fenner <bennet@zed.dev>
Date: Tue, 15 Oct 2024 16:37:56 +0200
Subject: [PATCH 651/762] ssh remoting: Treat other message as heartbeat
 (#19219)

This improves the heartbeat detection logic. We now treat any other
incoming message from the ssh remote server
as a heartbeat message, meaning that we can detect re-connects earlier.

It also changes the connection handling to await futures detached.

Co-Authored-by: Thorsten <thorsten@zed.dev>

Release Notes:

- N/A

---------

Co-authored-by: Thorsten <thorsten@zed.dev>
Co-authored-by: Antonio <antonio@zed.dev>
---
 crates/remote/src/ssh_session.rs | 107 ++++++++++++++++++++-----------
 1 file changed, 68 insertions(+), 39 deletions(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index ccb66a0c626e04..2db494ecbe15a9 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -9,7 +9,7 @@ use anyhow::{anyhow, Context as _, Result};
 use collections::HashMap;
 use futures::{
     channel::{
-        mpsc::{self, UnboundedReceiver, UnboundedSender},
+        mpsc::{self, Sender, UnboundedReceiver, UnboundedSender},
         oneshot,
     },
     future::BoxFuture,
@@ -28,7 +28,6 @@ use rpc::{
 use smol::{
     fs,
     process::{self, Child, Stdio},
-    Timer,
 };
 use std::{
     any::TypeId,
@@ -441,6 +440,7 @@ impl SshRemoteClient {
         cx.spawn(|mut cx| async move {
             let (outgoing_tx, outgoing_rx) = mpsc::unbounded::<Envelope>();
             let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();
+            let (connection_activity_tx, connection_activity_rx) = mpsc::channel::<()>(1);
 
             let client = cx.update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx))?;
             let this = cx.new_model(|_| Self {
@@ -467,6 +467,7 @@ impl SshRemoteClient {
                 ssh_proxy_process,
                 proxy_incoming_tx,
                 proxy_outgoing_rx,
+                connection_activity_tx,
                 &mut cx,
             );
 
@@ -476,7 +477,7 @@ impl SshRemoteClient {
                 return Err(error);
             }
 
-            let heartbeat_task = Self::heartbeat(this.downgrade(), &mut cx);
+            let heartbeat_task = Self::heartbeat(this.downgrade(), connection_activity_rx, &mut cx);
 
             this.update(&mut cx, |this, _| {
                 *this.state.lock() = Some(State::Connected {
@@ -518,7 +519,7 @@ impl SshRemoteClient {
                 // We wait 50ms instead of waiting for a response, because
                 // waiting for a response would require us to wait on the main thread
                 // which we want to avoid in an `on_app_quit` callback.
-                Timer::after(Duration::from_millis(50)).await;
+                smol::Timer::after(Duration::from_millis(50)).await;
             }
 
             // Drop `multiplex_task` because it owns our ssh_proxy_process, which is a
@@ -632,6 +633,7 @@ impl SshRemoteClient {
             let (incoming_tx, outgoing_rx) = forwarder.into_channels().await;
             let (forwarder, proxy_incoming_tx, proxy_outgoing_rx) =
                 ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
+            let (connection_activity_tx, connection_activity_rx) = mpsc::channel::<()>(1);
 
             let (ssh_connection, ssh_process) = match Self::establish_connection(
                 identifier,
@@ -653,6 +655,7 @@ impl SshRemoteClient {
                 ssh_process,
                 proxy_incoming_tx,
                 proxy_outgoing_rx,
+                connection_activity_tx,
                 &mut cx,
             );
 
@@ -665,7 +668,7 @@ impl SshRemoteClient {
                 delegate,
                 forwarder,
                 multiplex_task,
-                heartbeat_task: Self::heartbeat(this.clone(), &mut cx),
+                heartbeat_task: Self::heartbeat(this.clone(), connection_activity_rx, &mut cx),
             }
         });
 
@@ -717,41 +720,60 @@ impl SshRemoteClient {
         Ok(())
     }
 
-    fn heartbeat(this: WeakModel<Self>, cx: &mut AsyncAppContext) -> Task<Result<()>> {
+    fn heartbeat(
+        this: WeakModel<Self>,
+        mut connection_activity_rx: mpsc::Receiver<()>,
+        cx: &mut AsyncAppContext,
+    ) -> Task<Result<()>> {
         let Ok(client) = this.update(cx, |this, _| this.client.clone()) else {
             return Task::ready(Err(anyhow!("SshRemoteClient lost")));
         };
+
         cx.spawn(|mut cx| {
             let this = this.clone();
             async move {
                 let mut missed_heartbeats = 0;
 
-                let mut timer = Timer::interval(HEARTBEAT_INTERVAL);
+                let keepalive_timer = cx.background_executor().timer(HEARTBEAT_INTERVAL).fuse();
+                futures::pin_mut!(keepalive_timer);
+
                 loop {
-                    timer.next().await;
-
-                    log::debug!("Sending heartbeat to server...");
-
-                    let result = client.ping(HEARTBEAT_TIMEOUT).await;
-                    if result.is_err() {
-                        missed_heartbeats += 1;
-                        log::warn!(
-                            "No heartbeat from server after {:?}. Missed heartbeat {} out of {}.",
-                            HEARTBEAT_TIMEOUT,
-                            missed_heartbeats,
-                            MAX_MISSED_HEARTBEATS
-                        );
-                    } else if missed_heartbeats != 0 {
-                        missed_heartbeats = 0;
-                    } else {
-                        continue;
-                    }
+                    select_biased! {
+                        _ = connection_activity_rx.next().fuse() => {
+                            keepalive_timer.set(cx.background_executor().timer(HEARTBEAT_INTERVAL).fuse());
+                        }
+                        _ = keepalive_timer => {
+                            log::debug!("Sending heartbeat to server...");
 
-                    let result = this.update(&mut cx, |this, mut cx| {
-                        this.handle_heartbeat_result(missed_heartbeats, &mut cx)
-                    })?;
-                    if result.is_break() {
-                        return Ok(());
+                            let result = select_biased! {
+                                _ = connection_activity_rx.next().fuse() => {
+                                    Ok(())
+                                }
+                                ping_result = client.ping(HEARTBEAT_TIMEOUT).fuse() => {
+                                    ping_result
+                                }
+                            };
+                            if result.is_err() {
+                                missed_heartbeats += 1;
+                                log::warn!(
+                                    "No heartbeat from server after {:?}. Missed heartbeat {} out of {}.",
+                                    HEARTBEAT_TIMEOUT,
+                                    missed_heartbeats,
+                                    MAX_MISSED_HEARTBEATS
+                                );
+                            } else if missed_heartbeats != 0 {
+                                missed_heartbeats = 0;
+                            } else {
+                                continue;
+                            }
+
+                            let result = this.update(&mut cx, |this, mut cx| {
+                                this.handle_heartbeat_result(missed_heartbeats, &mut cx)
+                            })?;
+                            if result.is_break() {
+                                return Ok(());
+                            }
+                        }
                     }
                 }
             }
@@ -792,6 +814,7 @@ impl SshRemoteClient {
         mut ssh_proxy_process: Child,
         incoming_tx: UnboundedSender<Envelope>,
         mut outgoing_rx: UnboundedReceiver<Envelope>,
+        mut connection_activity_tx: Sender<()>,
         cx: &AsyncAppContext,
     ) -> Task<Result<()>> {
         let mut child_stderr = ssh_proxy_process.stderr.take().unwrap();
@@ -833,6 +856,7 @@ impl SshRemoteClient {
                                 let message_len = message_len_from_buffer(&stdout_buffer);
                                 match read_message_with_len(&mut child_stdout, &mut stdout_buffer, message_len).await {
                                     Ok(envelope) => {
+                                        connection_activity_tx.try_send(()).ok();
                                         incoming_tx.unbounded_send(envelope).ok();
                                     }
                                     Err(error) => {
@@ -863,6 +887,8 @@ impl SshRemoteClient {
                                 }
                                 stderr_buffer.drain(0..start_ix);
                                 stderr_offset -= start_ix;
+
+                                connection_activity_tx.try_send(()).ok();
                             }
                             Err(error) => {
                                 Err(anyhow!("error reading stderr: {error:?}"))?;
@@ -1392,16 +1418,19 @@ impl ChannelClient {
                             cx.clone(),
                         ) {
                             log::debug!("ssh message received. name:{type_name}");
-                            match future.await {
-                                Ok(_) => {
-                                    log::debug!("ssh message handled. name:{type_name}");
-                                }
-                                Err(error) => {
-                                    log::error!(
-                                        "error handling message. type:{type_name}, error:{error}",
-                                    );
+                            cx.foreground_executor().spawn(async move {
+                                match future.await {
+                                    Ok(_) => {
+                                        log::debug!("ssh message handled. name:{type_name}");
+                                    }
+                                    Err(error) => {
+                                        log::error!(
+                                            "error handling message. type:{type_name}, error:{error}",
+                                        );
+                                    }
                                 }
-                            }
+                            }).detach();
+
                         } else {
                             log::error!("unhandled ssh message name:{type_name}");
                         }

From ba69f48ccf34b9297e87c976765f35d6e75aa25b Mon Sep 17 00:00:00 2001
From: cabrinha <yuppie@hey.com>
Date: Tue, 15 Oct 2024 07:40:47 -0700
Subject: [PATCH 652/762] docs: Add Helm extension docs (#19095)

Merge after this:
- https://github.com/zed-industries/extensions/pull/746

Release Notes:

- N/A

---------

Co-authored-by: Peter Tripp <peter@zed.dev>
Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 docs/src/SUMMARY.md        |  1 +
 docs/src/languages/helm.md | 22 ++++++++++++++++++++++
 2 files changed, 23 insertions(+)
 create mode 100644 docs/src/languages/helm.md

diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
index 4f5491b7bd4a37..f3339ecbe61ea3 100644
--- a/docs/src/SUMMARY.md
+++ b/docs/src/SUMMARY.md
@@ -77,6 +77,7 @@
 - [Go](./languages/go.md)
 - [Groovy](./languages/groovy.md)
 - [Haskell](./languages/haskell.md)
+- [Helm](./languages/helm.md)
 - [HTML](./languages/html.md)
 - [Java](./languages/java.md)
 - [JavaScript](./languages/javascript.md)
diff --git a/docs/src/languages/helm.md b/docs/src/languages/helm.md
new file mode 100644
index 00000000000000..284a7b92a87ca5
--- /dev/null
+++ b/docs/src/languages/helm.md
@@ -0,0 +1,22 @@
+# Helm
+
+Support for Helm in Zed is provided by the community-maintained [Helm extension](https://github.com/cabrinha/helm.zed).
+
+- Tree-sitter: [tree-sitter-go-template](https://github.com/ngalaiko/tree-sitter-go-template/tree/master)
+- Language Server: [mrjosh/helm-ls](https://github.com/mrjosh/helm-ls)
+
+## Setup
+
+Enable Helm language for Helm files by editing your `.zed/settings.json` and adding:
+
+```json
+  "file_types": {
+    "Helm": [
+      "**/templates/**/*.tpl",
+      "**/templates/**/*.yaml",
+      "**/templates/**/*.yml",
+      "**/helmfile.d/**/*.yaml",
+      "**/helmfile.d/**/*.yml"
+    ]
+  }
+```

From 096d37a1ed53276c028affe885ed90d6f2227b62 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 15 Oct 2024 11:04:54 -0400
Subject: [PATCH 653/762] Remove outdated requirements.txt (#19223)

Release Notes:

- N/A
---
 script/update_top_ranking_issues/requirements.txt | 6 ------
 1 file changed, 6 deletions(-)
 delete mode 100644 script/update_top_ranking_issues/requirements.txt

diff --git a/script/update_top_ranking_issues/requirements.txt b/script/update_top_ranking_issues/requirements.txt
deleted file mode 100644
index 26daca27966d44..00000000000000
--- a/script/update_top_ranking_issues/requirements.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-mypy==1.6.0
-PyGithub==2.3.0
-pytz==2022.1
-ruff==0.3.4
-typer==0.9.0
-types-pytz==2023.3.1.1

From 1732441f48029d7de07ed199fb9fc4b155ec9a2d Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 15 Oct 2024 11:08:02 -0400
Subject: [PATCH 654/762] Use python 3.13 (#19225)

Release Notes:

- N/A
---
 .../update_all_top_ranking_issues.yml         |  6 +--
 .../update_weekly_top_ranking_issues.yml      |  6 +--
 .../update_top_ranking_issues/.python-version |  2 +-
 .../update_top_ranking_issues/pyproject.toml  |  2 +-
 script/update_top_ranking_issues/uv.lock      | 43 +------------------
 5 files changed, 9 insertions(+), 50 deletions(-)

diff --git a/.github/workflows/update_all_top_ranking_issues.yml b/.github/workflows/update_all_top_ranking_issues.yml
index 72b21748715e20..8291ccf3fa7e4d 100644
--- a/.github/workflows/update_all_top_ranking_issues.yml
+++ b/.github/workflows/update_all_top_ranking_issues.yml
@@ -17,9 +17,9 @@ jobs:
           version: "latest"
           enable-cache: true
           cache-dependency-glob: "script/update_top_ranking_issues/pyproject.toml"
-      - name: Install Python 3.12
-        run: uv python install 3.12
+      - name: Install Python 3.13
+        run: uv python install 3.13
       - name: Install dependencies
-        run: uv sync --project script/update_top_ranking_issues -p 3.12
+        run: uv sync --project script/update_top_ranking_issues -p 3.13
       - name: Run script
         run: uv run --project script/update_top_ranking_issues script/update_top_ranking_issues/main.py --github-token ${{ secrets.GITHUB_TOKEN }} --issue-reference-number 5393
diff --git a/.github/workflows/update_weekly_top_ranking_issues.yml b/.github/workflows/update_weekly_top_ranking_issues.yml
index e6639bf05e5638..f7eae61e264109 100644
--- a/.github/workflows/update_weekly_top_ranking_issues.yml
+++ b/.github/workflows/update_weekly_top_ranking_issues.yml
@@ -17,9 +17,9 @@ jobs:
           version: "latest"
           enable-cache: true
           cache-dependency-glob: "script/update_top_ranking_issues/pyproject.toml"
-      - name: Install Python 3.12
-        run: uv python install 3.12
+      - name: Install Python 3.13
+        run: uv python install 3.13
       - name: Install dependencies
-        run: uv sync --project script/update_top_ranking_issues -p 3.12
+        run: uv sync --project script/update_top_ranking_issues -p 3.13
       - name: Run script
         run: uv run --project script/update_top_ranking_issues script/update_top_ranking_issues/main.py --github-token ${{ secrets.GITHUB_TOKEN }} --issue-reference-number 6952 --query-day-interval 7
diff --git a/script/update_top_ranking_issues/.python-version b/script/update_top_ranking_issues/.python-version
index e4fba218358722..24ee5b1be9961e 100644
--- a/script/update_top_ranking_issues/.python-version
+++ b/script/update_top_ranking_issues/.python-version
@@ -1 +1 @@
-3.12
+3.13
diff --git a/script/update_top_ranking_issues/pyproject.toml b/script/update_top_ranking_issues/pyproject.toml
index 49ce0568e1d404..c79efba5dc68a5 100644
--- a/script/update_top_ranking_issues/pyproject.toml
+++ b/script/update_top_ranking_issues/pyproject.toml
@@ -2,7 +2,7 @@
 name = "update-top-ranking-issues"
 version = "0.1.0"
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.13"
 dependencies = [
     "mypy>=1.11.2",
     "pygithub>=2.4.0",
diff --git a/script/update_top_ranking_issues/uv.lock b/script/update_top_ranking_issues/uv.lock
index 47fdf5f32c226f..636b702105cbd4 100644
--- a/script/update_top_ranking_issues/uv.lock
+++ b/script/update_top_ranking_issues/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-requires-python = ">=3.12"
+requires-python = ">=3.13"
 
 [[package]]
 name = "certifi"
@@ -19,17 +19,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 },
-    { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 },
-    { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 },
-    { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 },
-    { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 },
-    { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 },
-    { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 },
-    { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 },
-    { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 },
-    { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 },
-    { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 },
     { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 },
     { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 },
     { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 },
@@ -49,21 +38,6 @@ version = "3.4.0"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", size = 106620 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d3/0b/4b7a70987abf9b8196845806198975b6aab4ce016632f817ad758a5aa056/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6", size = 194445 },
-    { url = "https://files.pythonhosted.org/packages/50/89/354cc56cf4dd2449715bc9a0f54f3aef3dc700d2d62d1fa5bbea53b13426/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf", size = 125275 },
-    { url = "https://files.pythonhosted.org/packages/fa/44/b730e2a2580110ced837ac083d8ad222343c96bb6b66e9e4e706e4d0b6df/charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db", size = 119020 },
-    { url = "https://files.pythonhosted.org/packages/9d/e4/9263b8240ed9472a2ae7ddc3e516e71ef46617fe40eaa51221ccd4ad9a27/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1", size = 139128 },
-    { url = "https://files.pythonhosted.org/packages/6b/e3/9f73e779315a54334240353eaea75854a9a690f3f580e4bd85d977cb2204/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03", size = 149277 },
-    { url = "https://files.pythonhosted.org/packages/1a/cf/f1f50c2f295312edb8a548d3fa56a5c923b146cd3f24114d5adb7e7be558/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284", size = 142174 },
-    { url = "https://files.pythonhosted.org/packages/16/92/92a76dc2ff3a12e69ba94e7e05168d37d0345fa08c87e1fe24d0c2a42223/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15", size = 143838 },
-    { url = "https://files.pythonhosted.org/packages/a4/01/2117ff2b1dfc61695daf2babe4a874bca328489afa85952440b59819e9d7/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8", size = 146149 },
-    { url = "https://files.pythonhosted.org/packages/f6/9b/93a332b8d25b347f6839ca0a61b7f0287b0930216994e8bf67a75d050255/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2", size = 140043 },
-    { url = "https://files.pythonhosted.org/packages/ab/f6/7ac4a01adcdecbc7a7587767c776d53d369b8b971382b91211489535acf0/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719", size = 148229 },
-    { url = "https://files.pythonhosted.org/packages/9d/be/5708ad18161dee7dc6a0f7e6cf3a88ea6279c3e8484844c0590e50e803ef/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631", size = 151556 },
-    { url = "https://files.pythonhosted.org/packages/5a/bb/3d8bc22bacb9eb89785e83e6723f9888265f3a0de3b9ce724d66bd49884e/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b", size = 149772 },
-    { url = "https://files.pythonhosted.org/packages/f7/fa/d3fc622de05a86f30beea5fc4e9ac46aead4731e73fd9055496732bcc0a4/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565", size = 144800 },
-    { url = "https://files.pythonhosted.org/packages/9a/65/bdb9bc496d7d190d725e96816e20e2ae3a6fa42a5cac99c3c3d6ff884118/charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7", size = 94836 },
-    { url = "https://files.pythonhosted.org/packages/3e/67/7b72b69d25b89c0b3cea583ee372c43aa24df15f0e0f8d3982c57804984b/charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9", size = 102187 },
     { url = "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", size = 194617 },
     { url = "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", size = 125310 },
     { url = "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", size = 119126 },
@@ -184,11 +158,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/5c/86/5d7cbc4974fd564550b80fbb8103c05501ea11aa7835edf3351d90095896/mypy-1.11.2.tar.gz", hash = "sha256:7f9993ad3e0ffdc95c2a14b66dee63729f021968bff8ad911867579c65d13a79", size = 3078806 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/35/3a/ed7b12ecc3f6db2f664ccf85cb2e004d3e90bec928e9d7be6aa2f16b7cdf/mypy-1.11.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:e8960dbbbf36906c5c0b7f4fbf2f0c7ffb20f4898e6a879fcf56a41a08b0d318", size = 10990335 },
-    { url = "https://files.pythonhosted.org/packages/04/e4/1a9051e2ef10296d206519f1df13d2cc896aea39e8683302f89bf5792a59/mypy-1.11.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:06d26c277962f3fb50e13044674aa10553981ae514288cb7d0a738f495550b36", size = 10007119 },
-    { url = "https://files.pythonhosted.org/packages/f3/3c/350a9da895f8a7e87ade0028b962be0252d152e0c2fbaafa6f0658b4d0d4/mypy-1.11.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6e7184632d89d677973a14d00ae4d03214c8bc301ceefcdaf5c474866814c987", size = 12506856 },
-    { url = "https://files.pythonhosted.org/packages/b6/49/ee5adf6a49ff13f4202d949544d3d08abb0ea1f3e7f2a6d5b4c10ba0360a/mypy-1.11.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3a66169b92452f72117e2da3a576087025449018afc2d8e9bfe5ffab865709ca", size = 12952066 },
-    { url = "https://files.pythonhosted.org/packages/27/c0/b19d709a42b24004d720db37446a42abadf844d5c46a2c442e2a074d70d9/mypy-1.11.2-cp312-cp312-win_amd64.whl", hash = "sha256:969ea3ef09617aff826885a22ece0ddef69d95852cdad2f60c8bb06bf1f71f70", size = 9664000 },
     { url = "https://files.pythonhosted.org/packages/42/3a/bdf730640ac523229dd6578e8a581795720a9321399de494374afc437ec5/mypy-1.11.2-py3-none-any.whl", hash = "sha256:b499bc07dbdcd3de92b0a8b29fdf592c111276f6a12fe29c30f6c417dd546d12", size = 2619625 },
 ]
 
@@ -385,15 +354,5 @@ version = "1.16.0"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/95/4c/063a912e20bcef7124e0df97282a8af3ff3e4b603ce84c481d6d7346be0a/wrapt-1.16.0.tar.gz", hash = "sha256:5f370f952971e7d17c7d1ead40e49f32345a7f7a5373571ef44d800d06b1899d", size = 53972 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/92/17/224132494c1e23521868cdd57cd1e903f3b6a7ba6996b7b8f077ff8ac7fe/wrapt-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5eb404d89131ec9b4f748fa5cfb5346802e5ee8836f57d516576e61f304f3b7b", size = 37614 },
-    { url = "https://files.pythonhosted.org/packages/6a/d7/cfcd73e8f4858079ac59d9db1ec5a1349bc486ae8e9ba55698cc1f4a1dff/wrapt-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9090c9e676d5236a6948330e83cb89969f433b1943a558968f659ead07cb3b36", size = 38316 },
-    { url = "https://files.pythonhosted.org/packages/7e/79/5ff0a5c54bda5aec75b36453d06be4f83d5cd4932cc84b7cb2b52cee23e2/wrapt-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94265b00870aa407bd0cbcfd536f17ecde43b94fb8d228560a1e9d3041462d73", size = 86322 },
-    { url = "https://files.pythonhosted.org/packages/c4/81/e799bf5d419f422d8712108837c1d9bf6ebe3cb2a81ad94413449543a923/wrapt-1.16.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2058f813d4f2b5e3a9eb2eb3faf8f1d99b81c3e51aeda4b168406443e8ba809", size = 79055 },
-    { url = "https://files.pythonhosted.org/packages/62/62/30ca2405de6a20448ee557ab2cd61ab9c5900be7cbd18a2639db595f0b98/wrapt-1.16.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98b5e1f498a8ca1858a1cdbffb023bfd954da4e3fa2c0cb5853d40014557248b", size = 87291 },
-    { url = "https://files.pythonhosted.org/packages/49/4e/5d2f6d7b57fc9956bf06e944eb00463551f7d52fc73ca35cfc4c2cdb7aed/wrapt-1.16.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:14d7dc606219cdd7405133c713f2c218d4252f2a469003f8c46bb92d5d095d81", size = 90374 },
-    { url = "https://files.pythonhosted.org/packages/a6/9b/c2c21b44ff5b9bf14a83252a8b973fb84923764ff63db3e6dfc3895cf2e0/wrapt-1.16.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:49aac49dc4782cb04f58986e81ea0b4768e4ff197b57324dcbd7699c5dfb40b9", size = 83896 },
-    { url = "https://files.pythonhosted.org/packages/14/26/93a9fa02c6f257df54d7570dfe8011995138118d11939a4ecd82cb849613/wrapt-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:418abb18146475c310d7a6dc71143d6f7adec5b004ac9ce08dc7a34e2babdc5c", size = 91738 },
-    { url = "https://files.pythonhosted.org/packages/a2/5b/4660897233eb2c8c4de3dc7cefed114c61bacb3c28327e64150dc44ee2f6/wrapt-1.16.0-cp312-cp312-win32.whl", hash = "sha256:685f568fa5e627e93f3b52fda002c7ed2fa1800b50ce51f6ed1d572d8ab3e7fc", size = 35568 },
-    { url = "https://files.pythonhosted.org/packages/5c/cc/8297f9658506b224aa4bd71906447dea6bb0ba629861a758c28f67428b91/wrapt-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:dcdba5c86e368442528f7060039eda390cc4091bfd1dca41e8046af7c910dda8", size = 37653 },
     { url = "https://files.pythonhosted.org/packages/ff/21/abdedb4cdf6ff41ebf01a74087740a709e2edb146490e4d9beea054b0b7a/wrapt-1.16.0-py3-none-any.whl", hash = "sha256:6906c4100a8fcbf2fa735f6059214bb13b97f75b1a61777fcf6432121ef12ef1", size = 23362 },
 ]

From 8924b3fb5b20774b3ec9d2b14036fb8bf8c698a1 Mon Sep 17 00:00:00 2001
From: thataboy <dearbart@yahoo.com>
Date: Tue, 15 Oct 2024 10:10:01 -0700
Subject: [PATCH 655/762] Fix block cursor obscuring placeholder text and
 editor text in some cases (#18114)

---
 crates/editor/src/element.rs | 39 ++++++++++++++++++++++++++++++------
 1 file changed, 33 insertions(+), 6 deletions(-)

diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 89fa23ab1caacb..8a2ec5cd0d5272 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -64,7 +64,7 @@ use std::{
     sync::Arc,
 };
 use sum_tree::Bias;
-use theme::{ActiveTheme, PlayerColor};
+use theme::{ActiveTheme, Appearance, PlayerColor};
 use ui::prelude::*;
 use ui::{h_flex, ButtonLike, ButtonStyle, ContextMenu, Tooltip};
 use util::RangeExt;
@@ -1015,8 +1015,20 @@ impl EditorElement {
                         block_width = em_width;
                     }
                     let block_text = if let CursorShape::Block = selection.cursor_shape {
-                        snapshot.display_chars_at(cursor_position).next().and_then(
-                            |(character, _)| {
+                        snapshot
+                            .display_chars_at(cursor_position)
+                            .next()
+                            .or_else(|| {
+                                if cursor_column == 0 {
+                                    snapshot
+                                        .placeholder_text()
+                                        .and_then(|s| s.chars().next())
+                                        .map(|c| (c, cursor_position))
+                                } else {
+                                    None
+                                }
+                            })
+                            .and_then(|(character, _)| {
                                 let text = if character == '\n' {
                                     SharedString::from(" ")
                                 } else {
@@ -1031,6 +1043,22 @@ impl EditorElement {
                                     })
                                     .unwrap_or(self.style.text.font());
 
+                                // Invert the text color for the block cursor. Ensure that the text
+                                // color is opaque enough to be visible against the background color.
+                                //
+                                // 0.75 is an arbitrary threshold to determine if the background color is
+                                // opaque enough to use as a text color.
+                                //
+                                // TODO: In the future we should ensure themes have a `text_inverse` color.
+                                let color = if cx.theme().colors().editor_background.a < 0.75 {
+                                    match cx.theme().appearance {
+                                        Appearance::Dark => Hsla::black(),
+                                        Appearance::Light => Hsla::white(),
+                                    }
+                                } else {
+                                    cx.theme().colors().editor_background
+                                };
+
                                 cx.text_system()
                                     .shape_line(
                                         text,
@@ -1038,15 +1066,14 @@ impl EditorElement {
                                         &[TextRun {
                                             len,
                                             font,
-                                            color: self.style.background,
+                                            color,
                                             background_color: None,
                                             strikethrough: None,
                                             underline: None,
                                         }],
                                     )
                                     .log_err()
-                            },
-                        )
+                            })
                     } else {
                         None
                     };

From e3c6ba4bd7486cc42ffb8831f4257b98ce2582a6 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Tue, 15 Oct 2024 19:20:06 +0200
Subject: [PATCH 656/762] ssh remote: Revert #19193 and treat killed proxy as
 non-zero (#19234)

This does two things.

Important one: it reverts #19193, which lead to our whole process
handling breaking. When the `proxy` process was killed, it apparently
didn't close the stdout/stderr anymore, which meant we would not detect
when it died. (Watching its `status()` in the io loop also didn't work!)

We should figure out how to keep our process handling working before we
make this change in #19193, which sounds reasonable.

Second, less important thing: I think we should treat the process being
killed from a signal as non-zero, as an error.

Release Notes:

- N/A
---
 crates/remote/src/ssh_session.rs | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 2db494ecbe15a9..fbe6e3e0fa89a7 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -846,7 +846,10 @@ impl SshRemoteClient {
                                 child_stdin.close().await?;
                                 outgoing_rx.close();
                                 let status = ssh_proxy_process.status().await?;
-                                return Ok(status.code());
+                                // If we don't have a code, we assume process
+                                // has been killed and treat it as non-zero exit
+                                // code
+                                return Ok(status.code().or_else(|| Some(1)));
                             }
                             Ok(len) => {
                                 if len < stdout_buffer.len() {
@@ -1175,14 +1178,7 @@ impl SshRemoteConnection {
             .stderr(Stdio::piped())
             .env("SSH_ASKPASS_REQUIRE", "force")
             .env("SSH_ASKPASS", &askpass_script_path)
-            .args([
-                "-N",
-                "-o",
-                "ControlPersist=no",
-                "-o",
-                "ControlMaster=yes",
-                "-o",
-            ])
+            .args(["-N", "-o", "ControlMaster=yes", "-o"])
             .arg(format!("ControlPath={}", socket_path.display()))
             .arg(&url)
             .spawn()?;

From 695176898e809fe097b5f6ea6db5712cf1cfefe0 Mon Sep 17 00:00:00 2001
From: CharlesChen0823 <yongchen0823@gmail.com>
Date: Wed, 16 Oct 2024 01:41:51 +0800
Subject: [PATCH 657/762] project_search: Fix message displayed when no results
 are found (#19108)

when no result found, always display `Search all files`, which is
confused.

Release Notes:

- Fixed an issue where the project search would sometimes show "Search
all files" when there were no results.

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 crates/search/src/project_search.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs
index 693d4b265867fb..1bc49551a71497 100644
--- a/crates/search/src/project_search.rs
+++ b/crates/search/src/project_search.rs
@@ -289,7 +289,6 @@ impl ProjectSearch {
                     .await;
 
                 this.update(&mut cx, |this, cx| {
-                    this.no_results = Some(false);
                     this.match_ranges.extend(match_ranges);
                     cx.notify();
                 })
@@ -297,6 +296,9 @@ impl ProjectSearch {
             }
 
             this.update(&mut cx, |this, cx| {
+                if !this.match_ranges.is_empty() {
+                    this.no_results = Some(false);
+                }
                 this.limit_reached = limit_reached;
                 this.pending_search.take();
                 cx.notify();

From 56163b1e3595b98986a2ada8d54df8b72bfc6187 Mon Sep 17 00:00:00 2001
From: Peter Schilling <peter@schpet.com>
Date: Tue, 15 Oct 2024 12:02:18 -0700
Subject: [PATCH 658/762] Add ability to reload a file (#18395)

Closes #13212

Release Notes:

- Added reload command
- vim: Added `:e[dit]`, `:e[dit]!` which calls reload
---
 crates/editor/src/actions.rs |  1 +
 crates/editor/src/editor.rs  | 12 ++++++++++--
 crates/editor/src/element.rs |  3 ++-
 crates/vim/src/command.rs    |  2 ++
 4 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs
index 502b70361b4f8e..b0c7877979f39b 100644
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -294,6 +294,7 @@ gpui::actions!(
         RevealInFileManager,
         ReverseLines,
         RevertFile,
+        ReloadFile,
         RevertSelectedHunks,
         Rewrap,
         ScrollCursorBottom,
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 453c012e4d7cfd..d07002040c555d 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -161,11 +161,11 @@ use ui::{
 };
 use util::{defer, maybe, post_inc, RangeExt, ResultExt, TryFutureExt};
 use workspace::item::{ItemHandle, PreviewTabsSettings};
-use workspace::notifications::{DetachAndPromptErr, NotificationId};
+use workspace::notifications::{DetachAndPromptErr, NotificationId, NotifyTaskExt};
 use workspace::{
     searchable::SearchEvent, ItemNavHistory, SplitDirection, ViewId, Workspace, WorkspaceId,
 };
-use workspace::{OpenInTerminal, OpenTerminal, TabBarSettings, Toast};
+use workspace::{Item as WorkspaceItem, OpenInTerminal, OpenTerminal, TabBarSettings, Toast};
 
 use crate::hover_links::find_url;
 use crate::signature_help::{SignatureHelpHiddenBy, SignatureHelpState};
@@ -6241,6 +6241,13 @@ impl Editor {
         }
     }
 
+    pub fn reload_file(&mut self, _: &ReloadFile, cx: &mut ViewContext<Self>) {
+        let Some(project) = self.project.clone() else {
+            return;
+        };
+        self.reload(project, cx).detach_and_notify_err(cx);
+    }
+
     pub fn revert_selected_hunks(&mut self, _: &RevertSelectedHunks, cx: &mut ViewContext<Self>) {
         let revert_changes = self.gather_revert_changes(&self.selections.disjoint_anchors(), cx);
         if !revert_changes.is_empty() {
@@ -13624,6 +13631,7 @@ pub enum EditorEvent {
     TransactionBegun {
         transaction_id: clock::Lamport,
     },
+    Reloaded,
     CursorShapeChanged,
 }
 
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 8a2ec5cd0d5272..49bb9d7b925087 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -437,7 +437,8 @@ impl EditorElement {
         register_action(view, cx, Editor::revert_file);
         register_action(view, cx, Editor::revert_selected_hunks);
         register_action(view, cx, Editor::apply_selected_diff_hunks);
-        register_action(view, cx, Editor::open_active_item_in_terminal)
+        register_action(view, cx, Editor::open_active_item_in_terminal);
+        register_action(view, cx, Editor::reload_file)
     }
 
     fn register_key_listeners(&self, cx: &mut WindowContext, layout: &EditorLayout) {
diff --git a/crates/vim/src/command.rs b/crates/vim/src/command.rs
index 605bc3a05e43c8..47975f4cfd0c31 100644
--- a/crates/vim/src/command.rs
+++ b/crates/vim/src/command.rs
@@ -685,6 +685,8 @@ fn generate_commands(_: &AppContext) -> Vec<VimCommand> {
         VimCommand::new(("$", ""), EndOfDocument),
         VimCommand::new(("%", ""), EndOfDocument),
         VimCommand::new(("0", ""), StartOfDocument),
+        VimCommand::new(("e", "dit"), editor::actions::ReloadFile)
+            .bang(editor::actions::ReloadFile),
     ]
 }
 

From 5445f898e82cbfd4f4ab030ed080a44b53f1b01b Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 15 Oct 2024 15:41:20 -0400
Subject: [PATCH 659/762] ruby: Move Ruby extension to zed-extensions/ruby repo
 (#19098)

---
 Cargo.lock                                    |   7 -
 Cargo.toml                                    |   1 -
 docs/src/languages/ruby.md                    |   4 +-
 extensions/ruby/Cargo.toml                    |  16 --
 extensions/ruby/LICENSE-APACHE                |   1 -
 extensions/ruby/extension.toml                |  31 ---
 extensions/ruby/languages/erb/config.toml     |   9 -
 extensions/ruby/languages/erb/highlights.scm  |  12 --
 extensions/ruby/languages/erb/injections.scm  |   7 -
 extensions/ruby/languages/rbs/config.toml     |  10 -
 extensions/ruby/languages/rbs/highlights.scm  | 144 -------------
 extensions/ruby/languages/rbs/indents.scm     |  14 --
 extensions/ruby/languages/rbs/injections.scm  |   2 -
 extensions/ruby/languages/ruby/brackets.scm   |  14 --
 extensions/ruby/languages/ruby/config.toml    |  51 -----
 extensions/ruby/languages/ruby/embedding.scm  |  22 --
 extensions/ruby/languages/ruby/highlights.scm | 202 ------------------
 extensions/ruby/languages/ruby/indents.scm    |  18 --
 extensions/ruby/languages/ruby/injections.scm |   8 -
 extensions/ruby/languages/ruby/outline.scm    |  20 --
 extensions/ruby/languages/ruby/overrides.scm  |   3 -
 extensions/ruby/languages/ruby/runnables.scm  |  58 -----
 extensions/ruby/languages/ruby/tasks.json     |   7 -
 extensions/ruby/src/language_servers.rs       |   7 -
 .../ruby/src/language_servers/rubocop.rs      |  59 -----
 .../ruby/src/language_servers/ruby_lsp.rs     | 128 -----------
 .../ruby/src/language_servers/solargraph.rs   | 156 --------------
 extensions/ruby/src/ruby.rs                   |  88 --------
 28 files changed, 2 insertions(+), 1097 deletions(-)
 delete mode 100644 extensions/ruby/Cargo.toml
 delete mode 120000 extensions/ruby/LICENSE-APACHE
 delete mode 100644 extensions/ruby/extension.toml
 delete mode 100644 extensions/ruby/languages/erb/config.toml
 delete mode 100644 extensions/ruby/languages/erb/highlights.scm
 delete mode 100644 extensions/ruby/languages/erb/injections.scm
 delete mode 100644 extensions/ruby/languages/rbs/config.toml
 delete mode 100644 extensions/ruby/languages/rbs/highlights.scm
 delete mode 100644 extensions/ruby/languages/rbs/indents.scm
 delete mode 100644 extensions/ruby/languages/rbs/injections.scm
 delete mode 100644 extensions/ruby/languages/ruby/brackets.scm
 delete mode 100644 extensions/ruby/languages/ruby/config.toml
 delete mode 100644 extensions/ruby/languages/ruby/embedding.scm
 delete mode 100644 extensions/ruby/languages/ruby/highlights.scm
 delete mode 100644 extensions/ruby/languages/ruby/indents.scm
 delete mode 100644 extensions/ruby/languages/ruby/injections.scm
 delete mode 100644 extensions/ruby/languages/ruby/outline.scm
 delete mode 100644 extensions/ruby/languages/ruby/overrides.scm
 delete mode 100644 extensions/ruby/languages/ruby/runnables.scm
 delete mode 100644 extensions/ruby/languages/ruby/tasks.json
 delete mode 100644 extensions/ruby/src/language_servers.rs
 delete mode 100644 extensions/ruby/src/language_servers/rubocop.rs
 delete mode 100644 extensions/ruby/src/language_servers/ruby_lsp.rs
 delete mode 100644 extensions/ruby/src/language_servers/solargraph.rs
 delete mode 100644 extensions/ruby/src/ruby.rs

diff --git a/Cargo.lock b/Cargo.lock
index 6fb0c1ad6dc8ef..61d7ee8e671d0e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14828,13 +14828,6 @@ dependencies = [
  "zed_extension_api 0.1.0",
 ]
 
-[[package]]
-name = "zed_ruby"
-version = "0.2.0"
-dependencies = [
- "zed_extension_api 0.1.0",
-]
-
 [[package]]
 name = "zed_ruff"
 version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index 47cd3f915f69ad..5507fc7383e7da 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -156,7 +156,6 @@ members = [
     "extensions/proto",
     "extensions/purescript",
     "extensions/ruff",
-    "extensions/ruby",
     "extensions/slash-commands-example",
     "extensions/snippets",
     "extensions/svelte",
diff --git a/docs/src/languages/ruby.md b/docs/src/languages/ruby.md
index e8bec34a71caa3..9bf8b42e42ab05 100644
--- a/docs/src/languages/ruby.md
+++ b/docs/src/languages/ruby.md
@@ -1,6 +1,6 @@
 # Ruby
 
-Ruby support is available through the [Ruby extension](https://github.com/zed-industries/zed/tree/main/extensions/ruby).
+Ruby support is available through the [Ruby extension](https://github.com/zed-extensions/ruby).
 
 - Tree-sitters:
   - [tree-sitter-ruby](https://github.com/tree-sitter/tree-sitter-ruby)
@@ -25,7 +25,7 @@ In addition to these two language servers, Zed also supports [rubocop](https://g
 
 ## Configuring a language server
 
-The [Ruby extension](https://github.com/zed-industries/zed/tree/main/extensions/ruby) offers both `solargraph` and `ruby-lsp` language server support.
+The [Ruby extension](https://github.com/zed-extensions/ruby) offers both `solargraph` and `ruby-lsp` language server support.
 
 ### Using `solargraph`
 
diff --git a/extensions/ruby/Cargo.toml b/extensions/ruby/Cargo.toml
deleted file mode 100644
index 2d9ef229af816a..00000000000000
--- a/extensions/ruby/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "zed_ruby"
-version = "0.2.0"
-edition = "2021"
-publish = false
-license = "Apache-2.0"
-
-[lints]
-workspace = true
-
-[lib]
-path = "src/ruby.rs"
-crate-type = ["cdylib"]
-
-[dependencies]
-zed_extension_api = "0.1.0"
diff --git a/extensions/ruby/LICENSE-APACHE b/extensions/ruby/LICENSE-APACHE
deleted file mode 120000
index 1cd601d0a3affa..00000000000000
--- a/extensions/ruby/LICENSE-APACHE
+++ /dev/null
@@ -1 +0,0 @@
-../../LICENSE-APACHE
\ No newline at end of file
diff --git a/extensions/ruby/extension.toml b/extensions/ruby/extension.toml
deleted file mode 100644
index 6862069e7226d9..00000000000000
--- a/extensions/ruby/extension.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-id = "ruby"
-name = "Ruby"
-description = "Ruby support."
-version = "0.2.0"
-schema_version = 1
-authors = ["Vitaly Slobodin <vitaliy.slobodin@gmail.com>"]
-repository = "https://github.com/zed-industries/zed"
-
-[language_servers.solargraph]
-name = "Solargraph"
-languages = ["Ruby"]
-
-[language_servers.ruby-lsp]
-name = "Ruby LSP"
-languages = ["Ruby", "ERB"]
-
-[language_servers.rubocop]
-name = "Rubocop"
-languages = ["Ruby"]
-
-[grammars.ruby]
-repository = "https://github.com/tree-sitter/tree-sitter-ruby"
-commit = "7dbc1e2d0e2d752577655881f73b4573f3fe85d4"
-
-[grammars.embedded_template]
-repository = "https://github.com/tree-sitter/tree-sitter-embedded-template"
-commit = "91fc5ae1140d5c9d922312431f7d251a48d7b8ce"
-
-[grammars.rbs]
-repository = "https://github.com/joker1007/tree-sitter-rbs"
-commit = "8d8e65ac3f77fbc9e15b1cdb9f980a3e0ac3ab99"
diff --git a/extensions/ruby/languages/erb/config.toml b/extensions/ruby/languages/erb/config.toml
deleted file mode 100644
index 5ec987e139acaa..00000000000000
--- a/extensions/ruby/languages/erb/config.toml
+++ /dev/null
@@ -1,9 +0,0 @@
-name = "ERB"
-grammar = "embedded_template"
-path_suffixes = ["erb"]
-autoclose_before = ">})"
-brackets = [
-    { start = "<", end = ">", close = true, newline = true },
-]
-block_comment = ["<%#", "%>"]
-scope_opt_in_language_servers = ["tailwindcss-language-server"]
diff --git a/extensions/ruby/languages/erb/highlights.scm b/extensions/ruby/languages/erb/highlights.scm
deleted file mode 100644
index 0bf76a7d4916d9..00000000000000
--- a/extensions/ruby/languages/erb/highlights.scm
+++ /dev/null
@@ -1,12 +0,0 @@
-(comment_directive) @comment
-
-[
-  "<%#"
-  "<%"
-  "<%="
-  "<%_"
-  "<%-"
-  "%>"
-  "-%>"
-  "_%>"
-] @keyword
diff --git a/extensions/ruby/languages/erb/injections.scm b/extensions/ruby/languages/erb/injections.scm
deleted file mode 100644
index 7a69a818ef31d7..00000000000000
--- a/extensions/ruby/languages/erb/injections.scm
+++ /dev/null
@@ -1,7 +0,0 @@
-((code) @content
- (#set! "language" "ruby")
- (#set! "combined"))
-
-((content) @content
- (#set! "language" "html")
- (#set! "combined"))
diff --git a/extensions/ruby/languages/rbs/config.toml b/extensions/ruby/languages/rbs/config.toml
deleted file mode 100644
index fbb502746bf4cc..00000000000000
--- a/extensions/ruby/languages/rbs/config.toml
+++ /dev/null
@@ -1,10 +0,0 @@
-name = "RBS"
-grammar = "rbs"
-path_suffixes = ["rbs"]
-autoclose_before = "]})"
-brackets = [
-    { start = "(", end = ")", close = true, newline = false },
-    { start = "{", end = "}", close = true, newline = false },
-    { start = "[", end = "]", close = true, newline = false },
-]
-line_comments = ["#"]
diff --git a/extensions/ruby/languages/rbs/highlights.scm b/extensions/ruby/languages/rbs/highlights.scm
deleted file mode 100644
index a5f8db14abeb67..00000000000000
--- a/extensions/ruby/languages/rbs/highlights.scm
+++ /dev/null
@@ -1,144 +0,0 @@
-; Taken from https://github.com/nvim-treesitter/nvim-treesitter/blob/master/queries/rbs/highlights.scm
-; Use directive
-(use_clause
-  [
-    (type_name)
-    (simple_type_name)
-  ] @type)
-
-; Builtin constants and Keywords
-[
-  "true"
-  "false"
-] @boolean
-
-"nil" @constant.builtin
-
-[
-  "use"
-  "as"
-  "module"
-  "def"
-  "attr_reader"
-  "attr_writer"
-  "attr_accessor"
-  "end"
-  "alias"
-] @keyword
-
-[
-  "interface"
-  "type"
-  "class"
-] @keyword.type
-
-(class_decl
-  "end" @keyword.type)
-
-(interface_decl
-  "end" @keyword.type)
-
-"def" @keyword.function
-
-; Members of declaration
-[
-  "include"
-  "extend"
-  "prepend"
-] @function.method
-
-(visibility) @keyword.modifier
-
-(comment) @comment
-
-(method_member
-  (method_name
-    [
-      (identifier)
-      (constant)
-      (operator)
-      (setter)
-    ] @function.method))
-
-[
-  (ivar_name)
-  (cvar_name)
-] @variable.member
-
-(alias_member
-  (method_name) @function)
-
-(class_name
-  (constant) @type)
-
-(module_name
-  (constant) @type)
-
-(interface_name
-  (interface) @type)
-
-(alias_name
-  (identifier) @type)
-
-(type_variable) @constant
-
-(namespace
-  (constant) @module)
-
-(builtin_type) @type.builtin
-
-(const_name
-  (constant) @constant)
-
-(global_name) @variable
-
-; Standard Arguments
-(parameter
-  (var_name) @variable.parameter)
-
-; Keyword Arguments
-(keyword) @variable.parameter
-
-; Self
-(self) @variable.builtin
-
-; Literal
-(type
-  (symbol_literal) @string.special.symbol)
-
-(type
-  (string_literal
-    (escape_sequence) @string.escape))
-
-(type
-  (string_literal) @string)
-
-(type
-  (integer_literal) @number)
-
-; Operators
-[
-  "="
-  "->"
-  "<"
-  "**"
-  "*"
-  "&"
-  "|"
-  "^"
-] @operator
-
-; Punctuation
-[
-  "("
-  ")"
-  "["
-  "]"
-  "{"
-  "}"
-] @punctuation.bracket
-
-[
-  ","
-  "."
-] @punctuation.delimiter
diff --git a/extensions/ruby/languages/rbs/indents.scm b/extensions/ruby/languages/rbs/indents.scm
deleted file mode 100644
index b37b378979f1e4..00000000000000
--- a/extensions/ruby/languages/rbs/indents.scm
+++ /dev/null
@@ -1,14 +0,0 @@
-[
-  (class_decl)
-  (module_decl)
-  (interface_decl)
-  (parameters)
-  (tuple_type)
-  (record_type)
-] @indent.begin
-
-(_ "[" "]" @end) @indent
-(_ "{" "}" @end) @indent
-(_ "(" ")" @end) @indent
-
-(comment) @indent.ignore
diff --git a/extensions/ruby/languages/rbs/injections.scm b/extensions/ruby/languages/rbs/injections.scm
deleted file mode 100644
index 2f0e58eb643151..00000000000000
--- a/extensions/ruby/languages/rbs/injections.scm
+++ /dev/null
@@ -1,2 +0,0 @@
-((comment) @injection.content
-  (#set! injection.language "comment"))
diff --git a/extensions/ruby/languages/ruby/brackets.scm b/extensions/ruby/languages/ruby/brackets.scm
deleted file mode 100644
index f5129f8f310ce4..00000000000000
--- a/extensions/ruby/languages/ruby/brackets.scm
+++ /dev/null
@@ -1,14 +0,0 @@
-("[" @open "]" @close)
-("{" @open "}" @close)
-("\"" @open "\"" @close)
-("do" @open "end" @close)
-
-(block_parameters "|" @open "|" @close)
-(interpolation "#{" @open "}" @close)
-
-(if "if" @open "end" @close)
-(unless "unless" @open "end" @close)
-(begin "begin" @open "end" @close)
-(module "module" @open "end" @close)
-(_ . "def" @open "end" @close)
-(_ . "class" @open "end" @close)
diff --git a/extensions/ruby/languages/ruby/config.toml b/extensions/ruby/languages/ruby/config.toml
deleted file mode 100644
index e52ec3ddcb5d5f..00000000000000
--- a/extensions/ruby/languages/ruby/config.toml
+++ /dev/null
@@ -1,51 +0,0 @@
-name = "Ruby"
-grammar = "ruby"
-path_suffixes = [
-    "rb",
-    "Gemfile",
-    "Guardfile",
-    "rake",
-    "Rakefile",
-    "ru",
-    "thor",
-    "cap",
-    "capfile",
-    "Capfile",
-    "jbuilder",
-    "rabl",
-    "rxml",
-    "builder",
-    "gemspec",
-    "rdoc",
-    "thor",
-    "pryrc",
-    "simplecov",
-    "Steepfile",
-    "Podfile",
-    "Brewfile",
-    "Vagrantfile",
-    "Puppetfile",
-]
-first_line_pattern = '^#!.*\bruby\b'
-line_comments = ["# "]
-autoclose_before = ";:.,=}])>"
-brackets = [
-    { start = "{", end = "}", close = true, newline = true },
-    { start = "[", end = "]", close = true, newline = true },
-    { start = "(", end = ")", close = true, newline = true },
-    { start = "\"", end = "\"", close = true, newline = false, not_in = [
-        "comment",
-        "string",
-    ] },
-    { start = "'", end = "'", close = true, newline = false, not_in = [
-        "comment",
-        "string",
-    ] },
-]
-collapsed_placeholder = "# ..."
-tab_size = 2
-scope_opt_in_language_servers = ["tailwindcss-language-server"]
-
-[overrides.string]
-word_characters = ["-"]
-opt_into_language_servers = ["tailwindcss-language-server"]
diff --git a/extensions/ruby/languages/ruby/embedding.scm b/extensions/ruby/languages/ruby/embedding.scm
deleted file mode 100644
index 7a101e6b092538..00000000000000
--- a/extensions/ruby/languages/ruby/embedding.scm
+++ /dev/null
@@ -1,22 +0,0 @@
-(
-    (comment)* @context
-    .
-    [
-        (module
-            "module" @name
-            name: (_) @name)
-        (method
-            "def" @name
-            name: (_) @name
-            body: (body_statement) @collapse)
-        (class
-            "class" @name
-            name: (_) @name)
-        (singleton_method
-            "def" @name
-            object: (_) @name
-            "." @name
-            name: (_) @name
-            body: (body_statement) @collapse)
-        ] @item
-    )
diff --git a/extensions/ruby/languages/ruby/highlights.scm b/extensions/ruby/languages/ruby/highlights.scm
deleted file mode 100644
index 7b4d2ff616b7cd..00000000000000
--- a/extensions/ruby/languages/ruby/highlights.scm
+++ /dev/null
@@ -1,202 +0,0 @@
-; Keywords
-
-[
-  "alias"
-  "and"
-  "begin"
-  "break"
-  "case"
-  "class"
-  "def"
-  "do"
-  "else"
-  "elsif"
-  "end"
-  "ensure"
-  "for"
-  "if"
-  "in"
-  "module"
-  "next"
-  "or"
-  "rescue"
-  "retry"
-  "return"
-  "then"
-  "unless"
-  "until"
-  "when"
-  "while"
-  "yield"
-] @keyword
-
-((identifier) @keyword
- (#match? @keyword "^(private|protected|public)$"))
-
-; Function calls
-
-((identifier) @function.method.builtin
- (#eq? @function.method.builtin "require"))
-
-"defined?" @function.method.builtin
-
-(call
-  method: [(identifier) (constant)] @function.method)
-
-; Function definitions
-
-(alias (identifier) @function.method)
-(setter (identifier) @function.method)
-(method name: [(identifier) (constant)] @function.method)
-(singleton_method name: [(identifier) (constant)] @function.method)
-(method_parameters [
-  (identifier) @variable.parameter
-  (optional_parameter name: (identifier) @variable.parameter)
-  (keyword_parameter [name: (identifier) (":")] @variable.parameter)
-  ])
-
-(block_parameters (identifier) @variable.parameter)
-
-; Identifiers
-
-((identifier) @constant.builtin
- (#match? @constant.builtin "^__(FILE|LINE|ENCODING)__$"))
-
-(file) @constant.builtin
-(line) @constant.builtin
-(encoding) @constant.builtin
-
-(hash_splat_nil
-  "**" @operator
-) @constant.builtin
-
-(global_variable) @constant
-
-(constant) @type
-
-((constant) @constant
- (#match? @constant "^[A-Z\\d_]+$"))
-
-(superclass
-  (constant) @type.super)
-
-(superclass
-  (scope_resolution
-    (constant) @type.super))
-
-(superclass
-  (scope_resolution
-    (scope_resolution
-      (constant) @type.super)))
-
-(self) @variable.special
-(super) @variable.special
-
-[
-  (class_variable)
-  (instance_variable)
-] @variable.member
-
-
-; Literals
-
-[
-  (string)
-  (bare_string)
-  (subshell)
-  (heredoc_body)
-  (heredoc_beginning)
-] @string
-
-[
-  (simple_symbol)
-  (delimited_symbol)
-  (hash_key_symbol)
-  (bare_symbol)
-] @string.special.symbol
-
-(regex) @string.regex
-(escape_sequence) @string.escape
-
-[
-  (integer)
-  (float)
-] @number
-
-[
-  (nil)
-  (true)
-  (false)
-] @constant.builtin
-
-(comment) @comment
-
-; Operators
-
-[
-  "!"
-  "~"
-  "+"
-  "-"
-  "**"
-  "*"
-  "/"
-  "%"
-  "<<"
-  ">>"
-  "&"
-  "|"
-  "^"
-  ">"
-  "<"
-  "<="
-  ">="
-  "=="
-  "!="
-  "=~"
-  "!~"
-  "<=>"
-  "||"
-  "&&"
-  ".."
-  "..."
-  "="
-  "**="
-  "*="
-  "/="
-  "%="
-  "+="
-  "-="
-  "<<="
-  ">>="
-  "&&="
-  "&="
-  "||="
-  "|="
-  "^="
-  "=>"
-  "->"
-  (operator)
-] @operator
-
-[
-  ","
-  ";"
-  "."
-  "::"
-] @punctuation.delimiter
-
-[
-  "("
-  ")"
-  "["
-  "]"
-  "{"
-  "}"
-  "%w("
-  "%i("
-] @punctuation.bracket
-
-(interpolation
-  "#{" @punctuation.special
-  "}" @punctuation.special) @embedded
diff --git a/extensions/ruby/languages/ruby/indents.scm b/extensions/ruby/languages/ruby/indents.scm
deleted file mode 100644
index 0dab1a7c2be589..00000000000000
--- a/extensions/ruby/languages/ruby/indents.scm
+++ /dev/null
@@ -1,18 +0,0 @@
-(method "end" @end) @indent
-(class "end" @end) @indent
-(module "end" @end) @indent
-(begin "end" @end) @indent
-(singleton_method "end" @end) @indent
-(do_block "end" @end) @indent
-
-(then) @indent
-(call) @indent
-
-(ensure) @outdent
-(rescue) @outdent
-(else) @outdent
-
-
-(_ "[" "]" @end) @indent
-(_ "{" "}" @end) @indent
-(_ "(" ")" @end) @indent
diff --git a/extensions/ruby/languages/ruby/injections.scm b/extensions/ruby/languages/ruby/injections.scm
deleted file mode 100644
index 3ad8143b858a13..00000000000000
--- a/extensions/ruby/languages/ruby/injections.scm
+++ /dev/null
@@ -1,8 +0,0 @@
-(heredoc_body
-  (heredoc_content) @content
-  (heredoc_end) @language
-  (#downcase! @language))
-
-((regex
-  (string_content) @content)
-  (#set! "language" "regex"))
diff --git a/extensions/ruby/languages/ruby/outline.scm b/extensions/ruby/languages/ruby/outline.scm
deleted file mode 100644
index 544257ac0c32e0..00000000000000
--- a/extensions/ruby/languages/ruby/outline.scm
+++ /dev/null
@@ -1,20 +0,0 @@
-(class
-    "class" @context
-    name: (_) @name) @item
-
-((identifier) @context
-  (#match? @context "^(private|protected|public)$")) @item
-
-(method
-    "def" @context
-    name: (_) @name) @item
-
-(singleton_method
-    "def" @context
-    object: (_) @context
-    "." @context
-    name: (_) @name) @item
-
-(module
-    "module" @context
-    name: (_) @name) @item
diff --git a/extensions/ruby/languages/ruby/overrides.scm b/extensions/ruby/languages/ruby/overrides.scm
deleted file mode 100644
index 7ff82bd3457cc6..00000000000000
--- a/extensions/ruby/languages/ruby/overrides.scm
+++ /dev/null
@@ -1,3 +0,0 @@
-(comment) @comment
-(string) @string
-[(simple_symbol) (delimited_symbol)] @simple_symbol
diff --git a/extensions/ruby/languages/ruby/runnables.scm b/extensions/ruby/languages/ruby/runnables.scm
deleted file mode 100644
index a3e7654a057cf1..00000000000000
--- a/extensions/ruby/languages/ruby/runnables.scm
+++ /dev/null
@@ -1,58 +0,0 @@
-; Adapted from the following sources:
-; Minitest: https://github.com/zidhuss/neotest-minitest/blob/main/lua/neotest-minitest/init.lua
-; RSpec: https://github.com/olimorris/neotest-rspec/blob/main/lua/neotest-rspec/init.lua
-
-; Tests that inherit from a specific class
-(
-    (class
-        name: [
-          (constant) @run
-          (scope_resolution scope: (constant) name: (constant) @run)
-        ]
-        (superclass (scope_resolution) @superclass (#match? @superclass "(::IntegrationTest|::TestCase|::SystemTestCase|Minitest::Test|TLDR)$"))
-    ) @_ruby-test
-    (#set! tag ruby-test)
-)
-
-(
-    (call
-        method: (identifier) @run (#eq? @run "test")
-        arguments: (argument_list (string (string_content) @_name))
-    ) @_ruby-test
-    (#set! tag ruby-test)
-)
-
-; Methods that begin with test_
-(
-    (method
-        name: (identifier) @run (#match? @run "^test_")
-    ) @_ruby-test
-    (#set! tag ruby-test)
-)
-
-; System tests that inherit from ApplicationSystemTestCase
-(
-    (class
-        name: (constant) @run (superclass) @superclass (#match? @superclass "(ApplicationSystemTestCase)$")
-    ) @_ruby-test
-    (#set! tag ruby-test)
-)
-
-; Examples
-(
-    (call
-       method: (identifier) @run (#any-of? @run "describe" "context" "it" "its" "specify")
-       arguments: (argument_list . (_) @_name)
-    ) @_ruby-test
-    (#set! tag ruby-test)
-)
-
-; Examples (one-liner syntax)
-(
-    (call
-        method: (identifier) @run (#any-of? @run "it" "its" "specify")
-        block: (_) @_name
-        !arguments
-    ) @_ruby-test
-    (#set! tag ruby-test)
-)
diff --git a/extensions/ruby/languages/ruby/tasks.json b/extensions/ruby/languages/ruby/tasks.json
deleted file mode 100644
index bba53c38f34cf6..00000000000000
--- a/extensions/ruby/languages/ruby/tasks.json
+++ /dev/null
@@ -1,7 +0,0 @@
-[
-  {
-    "label": "test $ZED_RELATIVE_FILE:$ZED_ROW",
-    "command": "echo 'To run tests, configure tasks in your \".zed/tasks.json\" file as described in the Ruby extension documentation.'",
-    "tags": ["ruby-test"]
-  }
-]
diff --git a/extensions/ruby/src/language_servers.rs b/extensions/ruby/src/language_servers.rs
deleted file mode 100644
index 3ad3de55ea898d..00000000000000
--- a/extensions/ruby/src/language_servers.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-mod rubocop;
-mod ruby_lsp;
-mod solargraph;
-
-pub use rubocop::*;
-pub use ruby_lsp::*;
-pub use solargraph::*;
diff --git a/extensions/ruby/src/language_servers/rubocop.rs b/extensions/ruby/src/language_servers/rubocop.rs
deleted file mode 100644
index d8e342bd510199..00000000000000
--- a/extensions/ruby/src/language_servers/rubocop.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-use zed_extension_api::{self as zed, settings::LspSettings, LanguageServerId, Result};
-
-pub struct RubocopBinary {
-    pub path: String,
-    pub args: Option<Vec<String>>,
-}
-
-pub struct Rubocop {}
-
-impl Rubocop {
-    pub const LANGUAGE_SERVER_ID: &'static str = "rubocop";
-
-    pub fn new() -> Self {
-        Self {}
-    }
-
-    pub fn language_server_command(
-        &mut self,
-        language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<zed::Command> {
-        let binary = self.language_server_binary(language_server_id, worktree)?;
-
-        Ok(zed::Command {
-            command: binary.path,
-            args: binary.args.unwrap_or_else(|| vec!["--lsp".to_string()]),
-            env: worktree.shell_env(),
-        })
-    }
-
-    fn language_server_binary(
-        &self,
-        _language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<RubocopBinary> {
-        let binary_settings = LspSettings::for_worktree("rubocop", worktree)
-            .ok()
-            .and_then(|lsp_settings| lsp_settings.binary);
-        let binary_args = binary_settings
-            .as_ref()
-            .and_then(|binary_settings| binary_settings.arguments.clone());
-
-        if let Some(path) = binary_settings.and_then(|binary_settings| binary_settings.path) {
-            return Ok(RubocopBinary {
-                path,
-                args: binary_args,
-            });
-        }
-
-        if let Some(path) = worktree.which("rubocop") {
-            return Ok(RubocopBinary {
-                path,
-                args: binary_args,
-            });
-        }
-
-        Err("rubocop must be installed manually. Install it with `gem install rubocop` or specify the 'binary' path to it via local settings.".to_string())
-    }
-}
diff --git a/extensions/ruby/src/language_servers/ruby_lsp.rs b/extensions/ruby/src/language_servers/ruby_lsp.rs
deleted file mode 100644
index 0f3bb2265e26f6..00000000000000
--- a/extensions/ruby/src/language_servers/ruby_lsp.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-use zed_extension_api::{
-    self as zed,
-    lsp::{Completion, CompletionKind, Symbol, SymbolKind},
-    settings::LspSettings,
-    CodeLabel, CodeLabelSpan, LanguageServerId, Result,
-};
-
-pub struct RubyLspBinary {
-    pub path: String,
-    pub args: Option<Vec<String>>,
-}
-
-pub struct RubyLsp {}
-
-impl RubyLsp {
-    pub const LANGUAGE_SERVER_ID: &'static str = "ruby-lsp";
-
-    pub fn new() -> Self {
-        Self {}
-    }
-
-    pub fn language_server_command(
-        &mut self,
-        language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<zed::Command> {
-        let binary = self.language_server_binary(language_server_id, worktree)?;
-
-        Ok(zed::Command {
-            command: binary.path,
-            args: binary.args.unwrap_or_default(),
-            env: worktree.shell_env(),
-        })
-    }
-
-    fn language_server_binary(
-        &self,
-        _language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<RubyLspBinary> {
-        let binary_settings = LspSettings::for_worktree("ruby-lsp", worktree)
-            .ok()
-            .and_then(|lsp_settings| lsp_settings.binary);
-        let binary_args = binary_settings
-            .as_ref()
-            .and_then(|binary_settings| binary_settings.arguments.clone());
-
-        if let Some(path) = binary_settings.and_then(|binary_settings| binary_settings.path) {
-            return Ok(RubyLspBinary {
-                path,
-                args: binary_args,
-            });
-        }
-
-        if let Some(path) = worktree.which("ruby-lsp") {
-            return Ok(RubyLspBinary {
-                path,
-                args: binary_args,
-            });
-        }
-
-        Err(
-            "ruby-lsp must be installed manually. Install it with `gem install ruby-lsp`."
-                .to_string(),
-        )
-    }
-
-    pub fn label_for_completion(&self, completion: Completion) -> Option<CodeLabel> {
-        let highlight_name = match completion.kind? {
-            CompletionKind::Class | CompletionKind::Module => "type",
-            CompletionKind::Constant => "constant",
-            CompletionKind::Method => "function.method",
-            CompletionKind::Reference => "function.method",
-            CompletionKind::Keyword => "keyword",
-            _ => return None,
-        };
-
-        let len = completion.label.len();
-        let name_span = CodeLabelSpan::literal(completion.label, Some(highlight_name.to_string()));
-
-        Some(CodeLabel {
-            code: Default::default(),
-            spans: vec![name_span],
-            filter_range: (0..len).into(),
-        })
-    }
-
-    pub fn label_for_symbol(&self, symbol: Symbol) -> Option<CodeLabel> {
-        let name = &symbol.name;
-
-        match symbol.kind {
-            SymbolKind::Method => {
-                let code = format!("def {name}; end");
-                let filter_range = 0..name.len();
-                let display_range = 4..4 + name.len();
-
-                Some(CodeLabel {
-                    code,
-                    spans: vec![CodeLabelSpan::code_range(display_range)],
-                    filter_range: filter_range.into(),
-                })
-            }
-            SymbolKind::Class | SymbolKind::Module => {
-                let code = format!("class {name}; end");
-                let filter_range = 0..name.len();
-                let display_range = 6..6 + name.len();
-
-                Some(CodeLabel {
-                    code,
-                    spans: vec![CodeLabelSpan::code_range(display_range)],
-                    filter_range: filter_range.into(),
-                })
-            }
-            SymbolKind::Constant => {
-                let code = name.to_uppercase().to_string();
-                let filter_range = 0..name.len();
-                let display_range = 0..name.len();
-
-                Some(CodeLabel {
-                    code,
-                    spans: vec![CodeLabelSpan::code_range(display_range)],
-                    filter_range: filter_range.into(),
-                })
-            }
-            _ => None,
-        }
-    }
-}
diff --git a/extensions/ruby/src/language_servers/solargraph.rs b/extensions/ruby/src/language_servers/solargraph.rs
deleted file mode 100644
index af736d610466b2..00000000000000
--- a/extensions/ruby/src/language_servers/solargraph.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-use zed::lsp::{Completion, CompletionKind, Symbol, SymbolKind};
-use zed::{CodeLabel, CodeLabelSpan};
-use zed_extension_api::settings::LspSettings;
-use zed_extension_api::{self as zed, LanguageServerId, Result};
-
-pub struct SolargraphBinary {
-    pub path: String,
-    pub args: Option<Vec<String>>,
-}
-
-pub struct Solargraph {}
-
-impl Solargraph {
-    pub const LANGUAGE_SERVER_ID: &'static str = "solargraph";
-
-    pub fn new() -> Self {
-        Self {}
-    }
-
-    pub fn language_server_command(
-        &mut self,
-        language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<zed::Command> {
-        let binary = self.language_server_binary(language_server_id, worktree)?;
-
-        Ok(zed::Command {
-            command: binary.path,
-            args: binary.args.unwrap_or_else(|| vec!["stdio".to_string()]),
-            env: worktree.shell_env(),
-        })
-    }
-
-    fn language_server_binary(
-        &self,
-        _language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<SolargraphBinary> {
-        let binary_settings = LspSettings::for_worktree("solargraph", worktree)
-            .ok()
-            .and_then(|lsp_settings| lsp_settings.binary);
-        let binary_args = binary_settings
-            .as_ref()
-            .and_then(|binary_settings| binary_settings.arguments.clone());
-
-        if let Some(path) = binary_settings.and_then(|binary_settings| binary_settings.path) {
-            return Ok(SolargraphBinary {
-                path,
-                args: binary_args,
-            });
-        }
-
-        if let Some(path) = worktree.which("solargraph") {
-            return Ok(SolargraphBinary {
-                path,
-                args: binary_args,
-            });
-        }
-
-        Err("solargraph must be installed manually".to_string())
-    }
-
-    pub fn label_for_completion(&self, completion: Completion) -> Option<CodeLabel> {
-        let highlight_name = match completion.kind? {
-            CompletionKind::Class | CompletionKind::Module => "type",
-            CompletionKind::Constant => "constant",
-            CompletionKind::Method => "function.method",
-            CompletionKind::Keyword => {
-                if completion.label.starts_with(':') {
-                    "string.special.symbol"
-                } else {
-                    "keyword"
-                }
-            }
-            CompletionKind::Variable => {
-                if completion.label.starts_with('@') {
-                    "property"
-                } else {
-                    return None;
-                }
-            }
-            _ => return None,
-        };
-
-        let len = completion.label.len();
-        let name_span = CodeLabelSpan::literal(completion.label, Some(highlight_name.to_string()));
-
-        Some(CodeLabel {
-            code: Default::default(),
-            spans: if let Some(detail) = completion.detail {
-                vec![
-                    name_span,
-                    CodeLabelSpan::literal(" ", None),
-                    CodeLabelSpan::literal(detail, None),
-                ]
-            } else {
-                vec![name_span]
-            },
-            filter_range: (0..len).into(),
-        })
-    }
-
-    pub fn label_for_symbol(&self, symbol: Symbol) -> Option<CodeLabel> {
-        let name = &symbol.name;
-
-        return match symbol.kind {
-            SymbolKind::Method => {
-                let mut parts = name.split('#');
-                let container_name = parts.next()?;
-                let method_name = parts.next()?;
-
-                if parts.next().is_some() {
-                    return None;
-                }
-
-                let filter_range = 0..name.len();
-
-                let spans = vec![
-                    CodeLabelSpan::literal(container_name, Some("type".to_string())),
-                    CodeLabelSpan::literal("#", None),
-                    CodeLabelSpan::literal(method_name, Some("function.method".to_string())),
-                ];
-
-                Some(CodeLabel {
-                    code: name.to_string(),
-                    spans,
-                    filter_range: filter_range.into(),
-                })
-            }
-            SymbolKind::Class | SymbolKind::Module => {
-                let class = "class ";
-                let code = format!("{class}{name}");
-                let filter_range = 0..name.len();
-                let display_range = class.len()..class.len() + name.len();
-
-                Some(CodeLabel {
-                    code,
-                    spans: vec![CodeLabelSpan::code_range(display_range)],
-                    filter_range: filter_range.into(),
-                })
-            }
-            SymbolKind::Constant => {
-                let code = name.to_uppercase().to_string();
-                let filter_range = 0..name.len();
-                let display_range = 0..name.len();
-
-                Some(CodeLabel {
-                    code,
-                    spans: vec![CodeLabelSpan::code_range(display_range)],
-                    filter_range: filter_range.into(),
-                })
-            }
-            _ => None,
-        };
-    }
-}
diff --git a/extensions/ruby/src/ruby.rs b/extensions/ruby/src/ruby.rs
deleted file mode 100644
index 1c8476e40f9993..00000000000000
--- a/extensions/ruby/src/ruby.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-mod language_servers;
-
-use zed::lsp::{Completion, Symbol};
-use zed::settings::LspSettings;
-use zed::{serde_json, CodeLabel, LanguageServerId};
-use zed_extension_api::{self as zed, Result};
-
-use crate::language_servers::{Rubocop, RubyLsp, Solargraph};
-
-struct RubyExtension {
-    solargraph: Option<Solargraph>,
-    ruby_lsp: Option<RubyLsp>,
-    rubocop: Option<Rubocop>,
-}
-
-impl zed::Extension for RubyExtension {
-    fn new() -> Self {
-        Self {
-            solargraph: None,
-            ruby_lsp: None,
-            rubocop: None,
-        }
-    }
-
-    fn language_server_command(
-        &mut self,
-        language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<zed::Command> {
-        match language_server_id.as_ref() {
-            Solargraph::LANGUAGE_SERVER_ID => {
-                let solargraph = self.solargraph.get_or_insert_with(Solargraph::new);
-                solargraph.language_server_command(language_server_id, worktree)
-            }
-            RubyLsp::LANGUAGE_SERVER_ID => {
-                let ruby_lsp = self.ruby_lsp.get_or_insert_with(RubyLsp::new);
-                ruby_lsp.language_server_command(language_server_id, worktree)
-            }
-            Rubocop::LANGUAGE_SERVER_ID => {
-                let rubocop = self.rubocop.get_or_insert_with(Rubocop::new);
-                rubocop.language_server_command(language_server_id, worktree)
-            }
-            language_server_id => Err(format!("unknown language server: {language_server_id}")),
-        }
-    }
-
-    fn label_for_symbol(
-        &self,
-        language_server_id: &LanguageServerId,
-        symbol: Symbol,
-    ) -> Option<CodeLabel> {
-        match language_server_id.as_ref() {
-            Solargraph::LANGUAGE_SERVER_ID => self.solargraph.as_ref()?.label_for_symbol(symbol),
-            RubyLsp::LANGUAGE_SERVER_ID => self.ruby_lsp.as_ref()?.label_for_symbol(symbol),
-            _ => None,
-        }
-    }
-
-    fn label_for_completion(
-        &self,
-        language_server_id: &LanguageServerId,
-        completion: Completion,
-    ) -> Option<CodeLabel> {
-        match language_server_id.as_ref() {
-            Solargraph::LANGUAGE_SERVER_ID => {
-                self.solargraph.as_ref()?.label_for_completion(completion)
-            }
-            RubyLsp::LANGUAGE_SERVER_ID => self.ruby_lsp.as_ref()?.label_for_completion(completion),
-            _ => None,
-        }
-    }
-
-    fn language_server_initialization_options(
-        &mut self,
-        language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<Option<serde_json::Value>> {
-        let initialization_options =
-            LspSettings::for_worktree(language_server_id.as_ref(), worktree)
-                .ok()
-                .and_then(|lsp_settings| lsp_settings.initialization_options.clone())
-                .unwrap_or_default();
-
-        Ok(Some(serde_json::json!(initialization_options)))
-    }
-}
-
-zed::register_extension!(RubyExtension);

From b682fc6d1dad395ef97255307485c6da00f99c69 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 15 Oct 2024 15:47:43 -0400
Subject: [PATCH 660/762] Use multi-line regex for '\s' (#19241)

---
 crates/project/src/search.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/project/src/search.rs b/crates/project/src/search.rs
index 4205f3173039c2..56e822aaeb9742 100644
--- a/crates/project/src/search.rs
+++ b/crates/project/src/search.rs
@@ -125,7 +125,7 @@ impl SearchQuery {
             query = word_query
         }
 
-        let multiline = query.contains('\n') || query.contains("\\n");
+        let multiline = query.contains('\n') || query.contains("\\n") || query.contains("\\s");
         let regex = RegexBuilder::new(&query)
             .case_insensitive(!case_sensitive)
             .multi_line(multiline)

From d806df9f169020bda0073c80051e07e3c0d8d16a Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 15 Oct 2024 15:55:18 -0400
Subject: [PATCH 661/762] Ensure issues without core labels have triage labels
 (#19243)

Sometimes, issues are created outside of issue templates (which we don't
prefer, but we can't prevent). This updates our top-ranking issues
script such that it will add `triage` and `admin read` labels to any
issue that is missing a core label, so that we don't miss the issues
when doing the next triage.

Release Notes:

- N/A
---
 script/label_data.json                        |  3 ++-
 script/update_top_ranking_issues/main.py      | 22 ++++++++++-----
 .../update_top_ranking_issues/pyproject.toml  |  1 +
 script/update_top_ranking_issues/uv.lock      | 27 +++++++++++++++++++
 4 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/script/label_data.json b/script/label_data.json
index 48c5d52200e084..3ff1d46c9dc4a1 100644
--- a/script/label_data.json
+++ b/script/label_data.json
@@ -9,5 +9,6 @@
     "support"
   ],
   "additional_labels": ["ai", "linux", "vim", "windows"],
-  "ignored_label": "ignore top-ranking issues"
+  "ignored_label": "ignore top-ranking issues",
+  "new_issue_labels": ["triage", "admin read"]
 }
diff --git a/script/update_top_ranking_issues/main.py b/script/update_top_ranking_issues/main.py
index 534b5e67213408..786e30a9cb5b79 100644
--- a/script/update_top_ranking_issues/main.py
+++ b/script/update_top_ranking_issues/main.py
@@ -15,29 +15,30 @@
 app: Typer = typer.Typer()
 
 DATETIME_FORMAT: str = "%m/%d/%Y %I:%M %p"
+LABEL_DATA_FILE_PATH = pathlib.Path(__file__).parent.parent / "label_data.json"
+ISSUES_PER_LABEL: int = 20
+MISSING_LABEL_ERROR_MESSAGE: str = "missing core label"
 
-label_data_file_path = pathlib.Path(__file__).parent.parent / "label_data.json"
-
-with open(label_data_file_path, "r") as label_data_file:
+with open(LABEL_DATA_FILE_PATH, "r") as label_data_file:
     label_data = json.load(label_data_file)
     CORE_LABELS: set[str] = set(label_data["core_labels"])
     # A set of labels for adding in labels that we want present in the final
     # report, but that we don't want being defined as a core label, since issues
     # with without core labels are flagged as errors.
     ADDITIONAL_LABELS: set[str] = set(label_data["additional_labels"])
+    NEW_ISSSUE_LABELS: set[str] = set(label_data["new_issue_labels"])
     IGNORED_LABEL: str = label_data["ignored_label"]
 
 
-ISSUES_PER_LABEL: int = 20
-
-
 class IssueData:
     def __init__(self, issue: Issue) -> None:
+        self.title = issue.title
         self.url: str = issue.html_url
         self.like_count: int = issue._rawData["reactions"]["+1"]  # type: ignore [attr-defined]
         self.creation_datetime: str = issue.created_at.strftime(DATETIME_FORMAT)
         # TODO: Change script to support storing labels here, rather than directly in the script
         self.labels: set[str] = {label["name"] for label in issue._rawData["labels"]}  # type: ignore [attr-defined]
+        self._issue = issue
 
 
 @app.command()
@@ -87,6 +88,13 @@ def main(
     else:
         print(issue_text)
 
+    for error_message, issue_data in error_message_to_erroneous_issue_data.items():
+        if error_message == MISSING_LABEL_ERROR_MESSAGE:
+            for issue in issue_data:
+                # Used as a dry-run flag
+                if issue_reference_number:
+                    issue._issue.add_to_labels(*NEW_ISSSUE_LABELS)
+
     remaining_requests_after: int = github.rate_limiting[0]
     print(f"Remaining requests after: {remaining_requests_after}")
     print(f"Requests used: {remaining_requests_before - remaining_requests_after}")
@@ -191,7 +199,7 @@ def get_error_message_to_erroneous_issues(
     query: str = f"repo:{repository.full_name} is:open is:issue {filter_labels_text}"
 
     for issue in github.search_issues(query):
-        error_message_to_erroneous_issues["missing core label"].append(issue)
+        error_message_to_erroneous_issues[MISSING_LABEL_ERROR_MESSAGE].append(issue)
 
     return error_message_to_erroneous_issues
 
diff --git a/script/update_top_ranking_issues/pyproject.toml b/script/update_top_ranking_issues/pyproject.toml
index c79efba5dc68a5..88619d4d408877 100644
--- a/script/update_top_ranking_issues/pyproject.toml
+++ b/script/update_top_ranking_issues/pyproject.toml
@@ -7,6 +7,7 @@ dependencies = [
     "mypy>=1.11.2",
     "pygithub>=2.4.0",
     "pytz>=2024.2",
+    "ruff>=0.6.9",
     "typer>=0.12.5",
     "types-pytz>=2024.2.0.20241003",
 ]
diff --git a/script/update_top_ranking_issues/uv.lock b/script/update_top_ranking_issues/uv.lock
index 636b702105cbd4..f7bd526d2a7886 100644
--- a/script/update_top_ranking_issues/uv.lock
+++ b/script/update_top_ranking_issues/uv.lock
@@ -276,6 +276,31 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/67/91/5474b84e505a6ccc295b2d322d90ff6aa0746745717839ee0c5fb4fdcceb/rich-13.9.2-py3-none-any.whl", hash = "sha256:8c82a3d3f8dcfe9e734771313e606b39d8247bb6b826e196f4914b333b743cf1", size = 242117 },
 ]
 
+[[package]]
+name = "ruff"
+version = "0.6.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/0d/6148a48dab5662ca1d5a93b7c0d13c03abd3cc7e2f35db08410e47cef15d/ruff-0.6.9.tar.gz", hash = "sha256:b076ef717a8e5bc819514ee1d602bbdca5b4420ae13a9cf61a0c0a4f53a2baa2", size = 3095355 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6e/8f/f7a0a0ef1818662efb32ed6df16078c95da7a0a3248d64c2410c1e27799f/ruff-0.6.9-py3-none-linux_armv6l.whl", hash = "sha256:064df58d84ccc0ac0fcd63bc3090b251d90e2a372558c0f057c3f75ed73e1ccd", size = 10440526 },
+    { url = "https://files.pythonhosted.org/packages/8b/69/b179a5faf936a9e2ab45bb412a668e4661eded964ccfa19d533f29463ef6/ruff-0.6.9-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:140d4b5c9f5fc7a7b074908a78ab8d384dd7f6510402267bc76c37195c02a7ec", size = 10034612 },
+    { url = "https://files.pythonhosted.org/packages/c7/ef/fd1b4be979c579d191eeac37b5cfc0ec906de72c8bcd8595e2c81bb700c1/ruff-0.6.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:53fd8ca5e82bdee8da7f506d7b03a261f24cd43d090ea9db9a1dc59d9313914c", size = 9706197 },
+    { url = "https://files.pythonhosted.org/packages/29/61/b376d775deb5851cb48d893c568b511a6d3625ef2c129ad5698b64fb523c/ruff-0.6.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:645d7d8761f915e48a00d4ecc3686969761df69fb561dd914a773c1a8266e14e", size = 10751855 },
+    { url = "https://files.pythonhosted.org/packages/13/d7/def9e5f446d75b9a9c19b24231a3a658c075d79163b08582e56fa5dcfa38/ruff-0.6.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eae02b700763e3847595b9d2891488989cac00214da7f845f4bcf2989007d577", size = 10200889 },
+    { url = "https://files.pythonhosted.org/packages/6c/d6/7f34160818bcb6e84ce293a5966cba368d9112ff0289b273fbb689046047/ruff-0.6.9-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7d5ccc9e58112441de8ad4b29dcb7a86dc25c5f770e3c06a9d57e0e5eba48829", size = 11038678 },
+    { url = "https://files.pythonhosted.org/packages/13/34/a40ff8ae62fb1b26fb8e6fa7e64bc0e0a834b47317880de22edd6bfb54fb/ruff-0.6.9-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:417b81aa1c9b60b2f8edc463c58363075412866ae4e2b9ab0f690dc1e87ac1b5", size = 11808682 },
+    { url = "https://files.pythonhosted.org/packages/2e/6d/25a4386ae4009fc798bd10ba48c942d1b0b3e459b5403028f1214b6dd161/ruff-0.6.9-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3c866b631f5fbce896a74a6e4383407ba7507b815ccc52bcedabb6810fdb3ef7", size = 11330446 },
+    { url = "https://files.pythonhosted.org/packages/f7/f6/bdf891a9200d692c94ebcd06ae5a2fa5894e522f2c66c2a12dd5d8cb2654/ruff-0.6.9-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7b118afbb3202f5911486ad52da86d1d52305b59e7ef2031cea3425142b97d6f", size = 12483048 },
+    { url = "https://files.pythonhosted.org/packages/a7/86/96f4252f41840e325b3fa6c48297e661abb9f564bd7dcc0572398c8daa42/ruff-0.6.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a67267654edc23c97335586774790cde402fb6bbdb3c2314f1fc087dee320bfa", size = 10936855 },
+    { url = "https://files.pythonhosted.org/packages/45/87/801a52d26c8dbf73424238e9908b9ceac430d903c8ef35eab1b44fcfa2bd/ruff-0.6.9-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3ef0cc774b00fec123f635ce5c547dac263f6ee9fb9cc83437c5904183b55ceb", size = 10713007 },
+    { url = "https://files.pythonhosted.org/packages/be/27/6f7161d90320a389695e32b6ebdbfbedde28ccbf52451e4b723d7ce744ad/ruff-0.6.9-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:12edd2af0c60fa61ff31cefb90aef4288ac4d372b4962c2864aeea3a1a2460c0", size = 10274594 },
+    { url = "https://files.pythonhosted.org/packages/00/52/dc311775e7b5f5b19831563cb1572ecce63e62681bccc609867711fae317/ruff-0.6.9-py3-none-musllinux_1_2_i686.whl", hash = "sha256:55bb01caeaf3a60b2b2bba07308a02fca6ab56233302406ed5245180a05c5625", size = 10608024 },
+    { url = "https://files.pythonhosted.org/packages/98/b6/be0a1ddcbac65a30c985cf7224c4fce786ba2c51e7efeb5178fe410ed3cf/ruff-0.6.9-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:925d26471fa24b0ce5a6cdfab1bb526fb4159952385f386bdcc643813d472039", size = 10982085 },
+    { url = "https://files.pythonhosted.org/packages/bb/a4/c84bc13d0b573cf7bb7d17b16d6d29f84267c92d79b2f478d4ce322e8e72/ruff-0.6.9-py3-none-win32.whl", hash = "sha256:eb61ec9bdb2506cffd492e05ac40e5bc6284873aceb605503d8494180d6fc84d", size = 8522088 },
+    { url = "https://files.pythonhosted.org/packages/74/be/fc352bd8ca40daae8740b54c1c3e905a7efe470d420a268cd62150248c91/ruff-0.6.9-py3-none-win_amd64.whl", hash = "sha256:785d31851c1ae91f45b3d8fe23b8ae4b5170089021fbb42402d811135f0b7117", size = 9359275 },
+    { url = "https://files.pythonhosted.org/packages/3e/14/fd026bc74ded05e2351681545a5f626e78ef831f8edce064d61acd2e6ec7/ruff-0.6.9-py3-none-win_arm64.whl", hash = "sha256:a9641e31476d601f83cd602608739a0840e348bda93fec9f1ee816f8b6798b93", size = 8679879 },
+]
+
 [[package]]
 name = "shellingham"
 version = "1.5.4"
@@ -326,6 +351,7 @@ dependencies = [
     { name = "mypy" },
     { name = "pygithub" },
     { name = "pytz" },
+    { name = "ruff" },
     { name = "typer" },
     { name = "types-pytz" },
 ]
@@ -335,6 +361,7 @@ requires-dist = [
     { name = "mypy", specifier = ">=1.11.2" },
     { name = "pygithub", specifier = ">=2.4.0" },
     { name = "pytz", specifier = ">=2024.2" },
+    { name = "ruff", specifier = ">=0.6.9" },
     { name = "typer", specifier = ">=0.12.5" },
     { name = "types-pytz", specifier = ">=2024.2.0.20241003" },
 ]

From 973143fa352770587c8a8ea4cd7758bc819e3492 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Tue, 15 Oct 2024 16:01:50 -0400
Subject: [PATCH 662/762] Fix variable name typo (#19244)

Release Notes:

- N/A
---
 script/update_top_ranking_issues/main.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/script/update_top_ranking_issues/main.py b/script/update_top_ranking_issues/main.py
index 786e30a9cb5b79..b7983b1f376183 100644
--- a/script/update_top_ranking_issues/main.py
+++ b/script/update_top_ranking_issues/main.py
@@ -26,7 +26,7 @@
     # report, but that we don't want being defined as a core label, since issues
     # with without core labels are flagged as errors.
     ADDITIONAL_LABELS: set[str] = set(label_data["additional_labels"])
-    NEW_ISSSUE_LABELS: set[str] = set(label_data["new_issue_labels"])
+    NEW_ISSUE_LABELS: set[str] = set(label_data["new_issue_labels"])
     IGNORED_LABEL: str = label_data["ignored_label"]
 
 
@@ -93,7 +93,7 @@ def main(
             for issue in issue_data:
                 # Used as a dry-run flag
                 if issue_reference_number:
-                    issue._issue.add_to_labels(*NEW_ISSSUE_LABELS)
+                    issue._issue.add_to_labels(*NEW_ISSUE_LABELS)
 
     remaining_requests_after: int = github.rate_limiting[0]
     print(f"Remaining requests after: {remaining_requests_after}")

From c00f2d88426120a3fcd94fb3d3e1e1401e5ec575 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 15 Oct 2024 16:02:12 -0400
Subject: [PATCH 663/762] Add Diff language (#19129)

---
 Cargo.lock                               | 11 +++++++++++
 Cargo.toml                               |  1 +
 assets/settings/default.json             |  4 ++++
 crates/languages/Cargo.toml              |  2 ++
 crates/languages/src/diff/config.toml    |  4 ++++
 crates/languages/src/diff/highlights.scm | 15 +++++++++++++++
 crates/languages/src/lib.rs              |  2 ++
 docs/src/languages/diff.md               | 17 +++++++++++++++++
 8 files changed, 56 insertions(+)
 create mode 100644 crates/languages/src/diff/config.toml
 create mode 100644 crates/languages/src/diff/highlights.scm
 create mode 100644 docs/src/languages/diff.md

diff --git a/Cargo.lock b/Cargo.lock
index 61d7ee8e671d0e..f83feb4689db3f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6373,6 +6373,7 @@ dependencies = [
  "tree-sitter-c",
  "tree-sitter-cpp",
  "tree-sitter-css",
+ "tree-sitter-diff",
  "tree-sitter-go",
  "tree-sitter-gomod",
  "tree-sitter-gowork",
@@ -12308,6 +12309,16 @@ dependencies = [
  "tree-sitter-language",
 ]
 
+[[package]]
+name = "tree-sitter-diff"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfe1e5ca280a65dfe5ba4205c1bcc84edf486464fed315db53dee6da9a335889"
+dependencies = [
+ "cc",
+ "tree-sitter-language",
+]
+
 [[package]]
 name = "tree-sitter-elixir"
 version = "0.3.0"
diff --git a/Cargo.toml b/Cargo.toml
index 5507fc7383e7da..4a4ddb44244441 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -449,6 +449,7 @@ tree-sitter-go = "0.23"
 tree-sitter-go-mod = { git = "https://github.com/zed-industries/tree-sitter-go-mod", rev = "a9aea5e358cde4d0f8ff20b7bc4fa311e359c7ca", package = "tree-sitter-gomod" }
 tree-sitter-gowork = { git = "https://github.com/zed-industries/tree-sitter-go-work", rev = "acb0617bf7f4fda02c6217676cc64acb89536dc7" }
 tree-sitter-heex = { git = "https://github.com/zed-industries/tree-sitter-heex", rev = "1dd45142fbb05562e35b2040c6129c9bca346592" }
+tree-sitter-diff = "0.1.0"
 tree-sitter-html = "0.20"
 tree-sitter-jsdoc = "0.23"
 tree-sitter-json = "0.23"
diff --git a/assets/settings/default.json b/assets/settings/default.json
index d299f05766b5ca..f16b37ba59bae9 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -850,6 +850,10 @@
     "Dart": {
       "tab_size": 2
     },
+    "Diff": {
+      "remove_trailing_whitespace_on_save": false,
+      "ensure_final_newline_on_save": false
+    },
     "Elixir": {
       "language_servers": ["elixir-ls", "!next-ls", "!lexical", "..."]
     },
diff --git a/crates/languages/Cargo.toml b/crates/languages/Cargo.toml
index dc7868ea86dda4..33fa874ec8690a 100644
--- a/crates/languages/Cargo.toml
+++ b/crates/languages/Cargo.toml
@@ -15,6 +15,7 @@ load-grammars = [
     "tree-sitter-c",
     "tree-sitter-cpp",
     "tree-sitter-css",
+    "tree-sitter-diff",
     "tree-sitter-go",
     "tree-sitter-go-mod",
     "tree-sitter-gowork",
@@ -59,6 +60,7 @@ tree-sitter-bash = { workspace = true, optional = true }
 tree-sitter-c = { workspace = true, optional = true }
 tree-sitter-cpp = { workspace = true, optional = true }
 tree-sitter-css = { workspace = true, optional = true }
+tree-sitter-diff = { workspace = true, optional = true }
 tree-sitter-go = { workspace = true, optional = true }
 tree-sitter-go-mod = { workspace = true, optional = true }
 tree-sitter-gowork = { workspace = true, optional = true }
diff --git a/crates/languages/src/diff/config.toml b/crates/languages/src/diff/config.toml
new file mode 100644
index 00000000000000..e8cc71c93640b5
--- /dev/null
+++ b/crates/languages/src/diff/config.toml
@@ -0,0 +1,4 @@
+name = "Diff"
+grammar = "diff"
+path_suffixes = ["diff", "patch"]
+brackets = []
diff --git a/crates/languages/src/diff/highlights.scm b/crates/languages/src/diff/highlights.scm
new file mode 100644
index 00000000000000..d8e600882c2307
--- /dev/null
+++ b/crates/languages/src/diff/highlights.scm
@@ -0,0 +1,15 @@
+[
+  (addition)
+  (new_file)
+] @diff.plus
+
+[
+  (deletion)
+  (old_file)
+] @diff.minus
+
+(commit) @constant
+
+(location) @attribute
+
+(command) @function
diff --git a/crates/languages/src/lib.rs b/crates/languages/src/lib.rs
index 374b32c0ac3494..03c4735d6d645b 100644
--- a/crates/languages/src/lib.rs
+++ b/crates/languages/src/lib.rs
@@ -37,6 +37,7 @@ pub fn init(languages: Arc<LanguageRegistry>, node_runtime: NodeRuntime, cx: &mu
         ("c", tree_sitter_c::LANGUAGE),
         ("cpp", tree_sitter_cpp::LANGUAGE),
         ("css", tree_sitter_css::LANGUAGE),
+        ("diff", tree_sitter_diff::LANGUAGE),
         ("go", tree_sitter_go::LANGUAGE),
         ("gomod", tree_sitter_go_mod::LANGUAGE),
         ("gowork", tree_sitter_gowork::LANGUAGE),
@@ -105,6 +106,7 @@ pub fn init(languages: Arc<LanguageRegistry>, node_runtime: NodeRuntime, cx: &mu
         "css",
         vec![Arc::new(css::CssLspAdapter::new(node_runtime.clone())),]
     );
+    language!("diff");
     language!("go", vec![Arc::new(go::GoLspAdapter)], GoContextProvider);
     language!("gomod", vec![Arc::new(go::GoLspAdapter)], GoContextProvider);
     language!(
diff --git a/docs/src/languages/diff.md b/docs/src/languages/diff.md
new file mode 100644
index 00000000000000..2c8db980dd8f78
--- /dev/null
+++ b/docs/src/languages/diff.md
@@ -0,0 +1,17 @@
+# Diff
+
+Diff support is available natively in Zed.
+
+- Tree Sitter: [zed-industries/the-mikedavis/tree-sitter-diff](https://github.com/the-mikedavis/tree-sitter-diff)
+
+## Configuration
+
+Zed will not attempt to format diff files and has [`remove_trailing_whitespace_on_save`](https://zed.dev/docs/configuring-zed#remove-trailing-whitespace-on-save) and [`ensure-final-newline-on-save`](https://zed.dev/docs/configuring-zed#ensure-final-newline-on-save) set to false.
+
+Zed will automatically recognize files with `patch` and `diff` extensions as Diff files. To recognize other extensions, add them to `file_types` in your Zed settings.json:
+
+```json
+  "file_types": {
+    "Diff": ["dif"]
+  },
+```

From d63a49647fa2b652095d63cd1ee5ae9b690ad52b Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Tue, 15 Oct 2024 17:21:04 -0400
Subject: [PATCH 664/762] Glob documentation (#18789)

Leaving this unlinked for now because I'm not sure where it belongs.
Plan to write up something for regexes too.
---
 docs/src/SUMMARY.md |  4 ++-
 docs/src/globs.md   | 80 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+), 1 deletion(-)
 create mode 100644 docs/src/globs.md

diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
index f3339ecbe61ea3..7480468320cecd 100644
--- a/docs/src/SUMMARY.md
+++ b/docs/src/SUMMARY.md
@@ -16,9 +16,11 @@
 - [Key bindings](./key-bindings.md)
 - [Snippets](./snippets.md)
 - [Themes](./themes.md)
-<!-- - [Fonts](./fonts.md) -->
 - [Vim Mode](./vim.md)
 
+<!-- - [Globs](./globs.md) -->
+<!-- - [Fonts](./fonts.md) -->
+
 # Using Zed
 
 - [Multibuffers](./multibuffers.md)
diff --git a/docs/src/globs.md b/docs/src/globs.md
new file mode 100644
index 00000000000000..f3dfbc0acdef73
--- /dev/null
+++ b/docs/src/globs.md
@@ -0,0 +1,80 @@
+# Globs
+
+Zed supports the use of [glob](<https://en.wikipedia.org/wiki/Glob_(programming)>) patterns that are the formal name for Unix shell-style path matching wildcards like `*.md` or `docs/src/**/*.md` supported by sh, bash, zsh, etc. A glob is similar but distinct from a [regex (regular expression)](https://en.wikipedia.org/wiki/Regular_expression). You may be In Zed these are commonly used when matching filenames.
+
+## Glob Flavor
+
+Zed uses two different rust crates for matching glob patterns:
+
+- [ignore crate](https://docs.rs/ignore/latest/ignore/) for matching glob patterns stored in `.gitignore` files
+- [glob crate](https://docs.rs/glob/latest/glob/) for matching file paths in Zed
+
+While simple expressions are portable across environments (e.g. running `ls *.py` or `*.tmp` in a gitignore) there is significant divergence in the support for and syntax of more advanced features varies (character classes, exclusions, `**`, etc) across implementations. For the rest of this document we will be describing globs as supported in Zed via the `glob` crate implementation. Please see [References](#references) below for documentation links for glob pattern syntax for `.gitignore`, shells and other programming languages.
+
+The `glob` crate is implemented entirely in rust and does not rely on the `glob` / `fnmatch` interfaces provided by your platforms libc. This means that globs in Zed should behave similarly with across platforms.
+
+## Introduction
+
+A glob "pattern" is used to match a file name or complete file path. For example, when using "Search all files" {#kb project_search::ToggleFocus} you can click the funnel shaped Toggle Filters" button or {#kb project_search::ToggleFilters} and it will show additional search fields for "Include" and "Exclude" which support specifying glob patterns for matching file paths and file names.
+
+When creating a glob pattern you can use one or multiple special characters:
+
+| Special Character | Meaning                                                           |
+| ----------------- | ----------------------------------------------------------------- |
+| `?`               | Matches any single character                                      |
+| `*`               | Matches any (possibly empty) sequence of characters               |
+| `**`              | Matches the current directory and arbitrary subdirectories        |
+| `[abc]`           | Matches any one character in the brackets                         |
+| `[a-z]`           | Matches any of a range of characters (ordered by Unicode)         |
+| `[!...]`          | The negation of `[...]` (matches a character not in the brackets) |
+
+Notes:
+
+1. Shell-style brace-expansions like `{a,b,c}` are not supported.
+2. To match a literal `-` character inside brackets it must come first `[-abc]` or last `[abc-]`.
+3. To match the literal `[` character use `[[]` or put it as the first character in the group `[[abc]`.
+4. To match the literal `]` character use `[]]` or put it as the last character in the group `[abc]]`.
+
+## Examples
+
+### Matching file extensions
+
+If you wanted to only search Markdown files add `*.md` to the "Include" search field.
+
+### Case insensitive matching
+
+Globs in Zed are case-sensitive, so `*.c` will not match `main.C` (even on case-insensitive filesystems like HFS+/APFS on MacOS). Instead use brackets to match characters. So instead of `*.c` use `*.[cC]`.
+
+### Matching directories
+
+If you wanted to search the [zed repository](https://github.com/zed-industries/zed) for examples of [Configuring Language Servers](https://zed.dev/docs/configuring-languages#configuring-language-servers) (under `"lsp"` in Zed settings.json) you could search for `"lsp"` and in the "Include" filter specify `docs/**/*.md`. This would only match files whose path was under the `docs` directory or any nested subdirectories `**/` of that folder with a filename that ends in `.md`.
+
+If instead you wanted to restrict yourself only to [Zed Language-Specific Documentation](https://zed.dev/docs/languages) pages you could define a narrower pattern of: `docs/src/languages/*.md` this would match [`docs/src/languages/rust.md`](https://github.com/zed-industries/zed/blob/main/docs/src/languages/rust.md) and [`docs/src/languages/cpp.md`](https://github.com/zed-industries/zed/blob/main/docs/src/languages/cpp.md) but not [`docs/src/configuring-languages.md`](https://github.com/zed-industries/zed/blob/main/docs/src/configuring-languages.md).
+
+### Implicit Wildcards
+
+When using the "Include" / "Exclude" filters on a Project Search each glob is wrapped in implicit wildcards. For example to exclude any files with license in the path or filename from your search just type type `license` in the exclude box. Behind the scenes Zed transforms `license` to `**license**`. This means that files named `license.*`, `*.license` or inside a `license` subdirectory will all be filtered out. This enables users to easily filter for `*.ts` without having to remember to type `**/*.ts` every time.
+
+Alternatively, if in your Zed settings you wanted a [`file_types`](./configuring-zed.md#file-types) override which only applied to a certain directory you must explicitly include the wildcard globs. For example, if you had a directory of template files with the `html` extension that you wanted to recognize as Jinja2 template you could use the following:
+
+```json
+{
+  "file_types": {
+    "C++": ["[cC]"],
+    "Jinja2": ["**/templates/*.html"]
+  }
+}
+```
+
+## References
+
+While globs in Zed are implemented as described above, when writing code using globs in other languages, please reference your platform's glob documentation:
+
+- [MacOS fnmatch](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/fnmatch.3.html) (BSD C Standard Library)
+- [Linux fnmatch](https://www.gnu.org/software/libc/manual/html_node/Wildcard-Matching.html) (GNU C Standard Library)
+- [POSIX fnmatch](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fnmatch.html) (POSIX Specification)
+- [node-glob](https://github.com/isaacs/node-glob) (Node.js `glob` package)
+- [Python glob](https://docs.python.org/3/library/glob.html) (Python Standard Library)
+- [Golang glob](https://pkg.go.dev/path/filepath#Match) (Go Standard Library)
+- [gitignore patterns](https://git-scm.com/docs/gitignore) (Gitignore Pattern Format)
+- [PowerShell: About Wildcards](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_wildcards) (Wildcards in PowerShell)

From b752548742970bb4536a4aa3a79c6ac70c98cbf7 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Tue, 15 Oct 2024 17:55:58 -0400
Subject: [PATCH 665/762] storybook: Load GPUI with default features (#19253)

This PR makes it so the Storybook loads GPUI with the default features
enabled.

This fixes a panic that would occur when trying to run any of the
stories.

Release Notes:

- N/A
---
 crates/storybook/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/storybook/Cargo.toml b/crates/storybook/Cargo.toml
index a27079489bb943..34f045466f377f 100644
--- a/crates/storybook/Cargo.toml
+++ b/crates/storybook/Cargo.toml
@@ -20,7 +20,7 @@ ctrlc = "3.4"
 dialoguer = { version = "0.11.0", features = ["fuzzy-select"] }
 editor.workspace = true
 fuzzy.workspace = true
-gpui.workspace = true
+gpui = { workspace = true, default-features = true }
 indoc.workspace = true
 language.workspace = true
 log.workspace = true

From b64919aa11560e5d5ae952b797a424b589876212 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Wed, 16 Oct 2024 01:39:27 +0200
Subject: [PATCH 666/762] ssh: Refine the modal UI (#19256)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR refines the SSH modal UI, adjusting spacing and alignment. Via
these changes, I'm also introducing the ability for the `empty_message`
on the `List` component to receive not just a string but any element.
The custom way in which the SSH modal was designed made it feel like
this was needed for proper spacing.

<img width="700" alt="Screenshot 2024-10-16 at 1 20 54 AM"
src="https://github.com/user-attachments/assets/f2e0586b-4c9f-4497-b4cb-e90c8157512b">


Release Notes:

- N/A
---
 crates/recent_projects/src/dev_servers.rs | 157 +++++++++++-----------
 crates/ui/src/components/list/list.rs     |  36 ++++-
 crates/ui/src/components/modal.rs         |   2 +
 3 files changed, 111 insertions(+), 84 deletions(-)

diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 62cfeab830a6ac..8fe501258a0bf9 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -35,7 +35,7 @@ use task::RevealStrategy;
 use task::SpawnInTerminal;
 use terminal_view::terminal_panel::TerminalPanel;
 use ui::Section;
-use ui::{prelude::*, List, ListItem, ListSeparator, Modal, ModalHeader, Tooltip};
+use ui::{prelude::*, IconButtonShape, List, ListItem, ListSeparator, Modal, ModalHeader, Tooltip};
 use util::ResultExt;
 use workspace::notifications::NotificationId;
 use workspace::OpenOptions;
@@ -604,19 +604,16 @@ impl DevServerProjects {
         };
         v_flex()
             .w_full()
-            .border_b_1()
-            .border_color(cx.theme().colors().border_variant)
-            .mb_1()
+            .child(ListSeparator)
             .child(
                 h_flex()
                     .group("ssh-server")
                     .w_full()
                     .pt_0p5()
-                    .px_2p5()
+                    .px_3()
                     .gap_1()
                     .overflow_hidden()
                     .whitespace_nowrap()
-                    .w_full()
                     .child(
                         Label::new(main_label)
                             .size(LabelSize::Small)
@@ -630,68 +627,63 @@ impl DevServerProjects {
                     ),
             )
             .child(
-                v_flex().w_full().gap_1().mb_1().child(
-                    List::new()
-                        .empty_message("No projects.")
-                        .children(ssh_connection.projects.iter().enumerate().map(|(pix, p)| {
-                            v_flex().gap_0p5().child(self.render_ssh_project(
-                                ix,
-                                &ssh_connection,
-                                pix,
-                                p,
-                                cx,
-                            ))
-                        }))
-                        .child(h_flex().map(|this| {
-                            self.selectable_items.add_item(Box::new({
-                                let ssh_connection = ssh_connection.clone();
-                                move |this, cx| {
-                                    this.create_ssh_project(ix, ssh_connection.clone(), cx);
-                                }
-                            }));
-                            let is_selected = self.selectable_items.is_selected();
-                            this.child(
-                                ListItem::new(("new-remote-project", ix))
-                                    .selected(is_selected)
-                                    .inset(true)
-                                    .spacing(ui::ListItemSpacing::Sparse)
-                                    .start_slot(Icon::new(IconName::Plus).color(Color::Muted))
-                                    .child(Label::new("Open Folder"))
-                                    .on_click(cx.listener({
-                                        let ssh_connection = ssh_connection.clone();
-                                        move |this, _, cx| {
-                                            this.create_ssh_project(ix, ssh_connection.clone(), cx);
-                                        }
-                                    })),
-                            )
-                        }))
-                        .child(h_flex().map(|this| {
-                            self.selectable_items.add_item(Box::new({
-                                let ssh_connection = ssh_connection.clone();
-                                move |this, cx| {
-                                    this.view_server_options((ix, ssh_connection.clone()), cx);
-                                }
-                            }));
-                            let is_selected = self.selectable_items.is_selected();
-                            this.child(
-                                ListItem::new(("server-options", ix))
-                                    .selected(is_selected)
-                                    .inset(true)
-                                    .spacing(ui::ListItemSpacing::Sparse)
-                                    .start_slot(Icon::new(IconName::Settings).color(Color::Muted))
-                                    .child(Label::new("View Server Options"))
-                                    .on_click(cx.listener({
-                                        let ssh_connection = ssh_connection.clone();
-                                        move |this, _, cx| {
-                                            this.view_server_options(
-                                                (ix, ssh_connection.clone()),
-                                                cx,
-                                            );
-                                        }
-                                    })),
-                            )
-                        })),
-                ),
+                List::new()
+                    .empty_message("No projects.")
+                    .children(ssh_connection.projects.iter().enumerate().map(|(pix, p)| {
+                        v_flex().gap_0p5().child(self.render_ssh_project(
+                            ix,
+                            &ssh_connection,
+                            pix,
+                            p,
+                            cx,
+                        ))
+                    }))
+                    .child(h_flex().map(|this| {
+                        self.selectable_items.add_item(Box::new({
+                            let ssh_connection = ssh_connection.clone();
+                            move |this, cx| {
+                                this.create_ssh_project(ix, ssh_connection.clone(), cx);
+                            }
+                        }));
+                        let is_selected = self.selectable_items.is_selected();
+                        this.child(
+                            ListItem::new(("new-remote-project", ix))
+                                .selected(is_selected)
+                                .inset(true)
+                                .spacing(ui::ListItemSpacing::Sparse)
+                                .start_slot(Icon::new(IconName::Plus).color(Color::Muted))
+                                .child(Label::new("Open Folder"))
+                                .on_click(cx.listener({
+                                    let ssh_connection = ssh_connection.clone();
+                                    move |this, _, cx| {
+                                        this.create_ssh_project(ix, ssh_connection.clone(), cx);
+                                    }
+                                })),
+                        )
+                    }))
+                    .child(h_flex().map(|this| {
+                        self.selectable_items.add_item(Box::new({
+                            let ssh_connection = ssh_connection.clone();
+                            move |this, cx| {
+                                this.view_server_options((ix, ssh_connection.clone()), cx);
+                            }
+                        }));
+                        let is_selected = self.selectable_items.is_selected();
+                        this.child(
+                            ListItem::new(("server-options", ix))
+                                .selected(is_selected)
+                                .inset(true)
+                                .spacing(ui::ListItemSpacing::Sparse)
+                                .start_slot(Icon::new(IconName::Settings).color(Color::Muted))
+                                .child(Label::new("View Server Options"))
+                                .on_click(cx.listener({
+                                    let ssh_connection = ssh_connection.clone();
+                                    move |this, _, cx| {
+                                        this.view_server_options((ix, ssh_connection.clone()), cx);
+                                    }
+                                })),
+                        )
+                    })),
             )
     }
 
@@ -762,6 +754,7 @@ impl DevServerProjects {
             .end_hover_slot::<AnyElement>(Some(
                 IconButton::new("remove-remote-project", IconName::TrashAlt)
                     .icon_size(IconSize::Small)
+                    .shape(IconButtonShape::Square)
                     .on_click(
                         cx.listener(move |this, _, cx| this.delete_ssh_project(server_ix, ix, cx)),
                     )
@@ -1117,6 +1110,7 @@ impl DevServerProjects {
         }));
 
         let is_selected = self.selectable_items.is_selected();
+
         let connect_button = ListItem::new("register-dev-server-button")
             .selected(is_selected)
             .inset(true)
@@ -1130,16 +1124,21 @@ impl DevServerProjects {
                 cx.notify();
             }));
 
-        let footer = format!("Servers: {}", ssh_connections.len() + dev_servers.len());
         let mut modal_section = v_flex()
             .id("ssh-server-list")
             .overflow_y_scroll()
             .size_full()
             .child(connect_button)
-            .child(ListSeparator)
             .child(
                 List::new()
-                    .empty_message("No dev servers registered yet.")
+                    .empty_message(
+                        v_flex()
+                            .child(ListSeparator)
+                            .child(div().px_3().child(
+                                Label::new("No dev servers registered yet.").color(Color::Muted),
+                            ))
+                            .into_any_element(),
+                    )
                     .children(ssh_connections.iter().cloned().enumerate().map(
                         |(ix, connection)| {
                             self.render_ssh_connection(ix, connection, cx)
@@ -1149,23 +1148,25 @@ impl DevServerProjects {
             )
             .into_any_element();
 
+        let server_count = format!("Servers: {}", ssh_connections.len() + dev_servers.len());
+
         Modal::new("remote-projects", Some(self.scroll_handle.clone()))
             .header(
                 ModalHeader::new().child(
                     h_flex()
+                        .items_center()
                         .justify_between()
                         .child(Headline::new("Remote Projects (alpha)").size(HeadlineSize::XSmall))
-                        .child(Label::new(footer).size(LabelSize::Small)),
+                        .child(Label::new(server_count).size(LabelSize::Small)),
                 ),
             )
             .section(
                 Section::new().padded(false).child(
                     v_flex()
-                        .min_h(rems(28.))
+                        .min_h(rems(20.))
+                        .flex_1()
                         .size_full()
-                        .pt_1p5()
-                        .border_y_1()
-                        .border_color(cx.theme().colors().border_variant)
+                        .child(ListSeparator)
                         .child(
                             canvas(
                                 |bounds, cx| {
@@ -1180,9 +1181,7 @@ impl DevServerProjects {
                                     modal_section.paint(cx);
                                 },
                             )
-                            .size_full()
-                            .min_h_full()
-                            .flex_1(),
+                            .size_full(),
                         ),
                 ),
             )
diff --git a/crates/ui/src/components/list/list.rs b/crates/ui/src/components/list/list.rs
index e112a558ee3eeb..e4cc74b2c0b2a9 100644
--- a/crates/ui/src/components/list/list.rs
+++ b/crates/ui/src/components/list/list.rs
@@ -5,11 +5,16 @@ use smallvec::SmallVec;
 
 use crate::{prelude::*, v_flex, Label, ListHeader};
 
+pub enum EmptyMessage {
+    Text(SharedString),
+    Element(AnyElement),
+}
+
 #[derive(IntoElement)]
 pub struct List {
     /// Message to display when the list is empty
     /// Defaults to "No items"
-    empty_message: SharedString,
+    empty_message: EmptyMessage,
     header: Option<ListHeader>,
     toggle: Option<bool>,
     children: SmallVec<[AnyElement; 2]>,
@@ -24,15 +29,15 @@ impl Default for List {
 impl List {
     pub fn new() -> Self {
         Self {
-            empty_message: "No items".into(),
+            empty_message: EmptyMessage::Text("No items".into()),
             header: None,
             toggle: None,
             children: SmallVec::new(),
         }
     }
 
-    pub fn empty_message(mut self, empty_message: impl Into<SharedString>) -> Self {
-        self.empty_message = empty_message.into();
+    pub fn empty_message(mut self, message: impl Into<EmptyMessage>) -> Self {
+        self.empty_message = message.into();
         self
     }
 
@@ -53,6 +58,24 @@ impl ParentElement for List {
     }
 }
 
+impl From<String> for EmptyMessage {
+    fn from(s: String) -> Self {
+        EmptyMessage::Text(SharedString::from(s))
+    }
+}
+
+impl From<&str> for EmptyMessage {
+    fn from(s: &str) -> Self {
+        EmptyMessage::Text(SharedString::from(s.to_owned()))
+    }
+}
+
+impl From<AnyElement> for EmptyMessage {
+    fn from(e: AnyElement) -> Self {
+        EmptyMessage::Element(e)
+    }
+}
+
 impl RenderOnce for List {
     fn render(self, cx: &mut WindowContext) -> impl IntoElement {
         v_flex()
@@ -62,7 +85,10 @@ impl RenderOnce for List {
             .map(|this| match (self.children.is_empty(), self.toggle) {
                 (false, _) => this.children(self.children),
                 (true, Some(false)) => this,
-                (true, _) => this.child(Label::new(self.empty_message.clone()).color(Color::Muted)),
+                (true, _) => match self.empty_message {
+                    EmptyMessage::Text(text) => this.child(Label::new(text).color(Color::Muted)),
+                    EmptyMessage::Element(element) => this.child(element),
+                },
             })
     }
 }
diff --git a/crates/ui/src/components/modal.rs b/crates/ui/src/components/modal.rs
index 512f9601a86b48..f8fdaede19844d 100644
--- a/crates/ui/src/components/modal.rs
+++ b/crates/ui/src/components/modal.rs
@@ -77,6 +77,7 @@ impl RenderOnce for Modal {
                 v_flex()
                     .id(self.container_id.clone())
                     .w_full()
+                    .flex_1()
                     .gap(Spacing::Large.rems(cx))
                     .when_some(
                         self.container_scroll_handler,
@@ -344,6 +345,7 @@ impl RenderOnce for Section {
         } else {
             v_flex()
                 .w_full()
+                .flex_1()
                 .gap_y(Spacing::Small.rems(cx))
                 .when(self.padded, |this| {
                     this.px(Spacing::Medium.rems(cx) + Spacing::Medium.rems(cx))

From 182230a0ba865e860ccee978e8c071ab87feb1b7 Mon Sep 17 00:00:00 2001
From: Alvaro Gaona <alvgaona@gmail.com>
Date: Wed, 16 Oct 2024 02:45:26 -0300
Subject: [PATCH 667/762] Fix C++ configuration documentation (#19258)

- Update the binary JSON object
- Add .clangd configuration file summary


![image](https://github.com/user-attachments/assets/5c4cfd26-3cd8-4d12-96fc-483596c74287)

Release Notes:

- N/A
---
 docs/src/languages/cpp.md | 31 ++++++++++++++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

diff --git a/docs/src/languages/cpp.md b/docs/src/languages/cpp.md
index 8ba2be78e1ba46..127330dd940dc5 100644
--- a/docs/src/languages/cpp.md
+++ b/docs/src/languages/cpp.md
@@ -17,9 +17,38 @@ To use a binary in a custom location, add the following to your `settings.json`:
     "clangd": {
       "binary": {
         "path": "/path/to/clangd",
-        "args": []
+        "arguments": []
       }
     }
   }
 }
 ```
+
+If you want to disable Zed looking for a `clangd` binary, you can set `ignore_system-version` to `true`:
+
+```json
+{
+  "lsp": {
+    "clangd": {
+      "binary": {
+        "ignore_system_version": true
+      }
+    }
+  }
+}
+```
+
+## More server configuration
+
+In the root of your project, it is generally common to create a `.clangd` file to set extra configuration.
+
+```text
+CompileFlags:
+  Add:
+    - "--include-directory=/path/to/include"
+Diagnostics:
+  MissingIncludes: Strict
+  UnusedIncludes: Strict
+```
+
+For more advanced usage of clangd configuration file, take a look into their [official page](https://clangd.llvm.org/config.html).

From 1dda039f3812e46f1e1791120acf4f4747d62068 Mon Sep 17 00:00:00 2001
From: CharlesChen0823 <yongchen0823@gmail.com>
Date: Wed, 16 Oct 2024 14:08:37 +0800
Subject: [PATCH 668/762] remote_server: local build also need feature
 `debug-embed` (#19265)

it's waste me one more hour. IMO, this also need for `build_local`

Release Notes:

- N/A
---
 crates/recent_projects/src/ssh_connections.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 6eb27aa25a09c9..d3752a7b123f92 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -468,6 +468,8 @@ impl SshClientDelegate {
                 "build",
                 "--package",
                 "remote_server",
+                "--features",
+                "debug-embed",
                 "--target-dir",
                 "target/remote_server",
             ]))

From f944ebc4cbc6deb55cfbd6b0466631ea8d3e56a7 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Tue, 15 Oct 2024 23:32:44 -0700
Subject: [PATCH 669/762] Add settings to remote servers, use XDG paths on
 remote, and enable node LSPs (#19176)

Supersedes https://github.com/zed-industries/zed/pull/19166

TODO:
- [x] Update basic zed paths
- [x] update create_state_directory
- [x] Use this with `NodeRuntime`
- [x] Add server settings
- [x] Add an 'open server settings command'
- [x] Make sure it all works


Release Notes:

- Updated the actions `zed::OpenLocalSettings` and `zed::OpenLocalTasks`
to `zed::OpenProjectSettings` and `zed::OpenProjectTasks`.

---------

Co-authored-by: Conrad <conrad@zed.dev>
Co-authored-by: Richard <richard@zed.dev>
---
 Cargo.lock                                    |   4 +
 assets/settings/initial_server_settings.json  |   7 +
 crates/assistant/src/inline_assistant.rs      |   2 +-
 .../assistant/src/slash_command_settings.rs   |   5 +-
 .../src/terminal_inline_assistant.rs          |   2 +-
 crates/auto_update/src/auto_update.rs         |   2 +-
 crates/client/src/client.rs                   |  19 +-
 .../remote_editing_collaboration_tests.rs     |  24 +-
 crates/editor/src/git/blame.rs                |  13 +-
 crates/extension/src/extension_settings.rs    |   5 +-
 crates/extensions_ui/src/extension_suggest.rs |   2 +-
 crates/gpui/src/app/entity_map.rs             |   6 +
 crates/http_client/src/http_client.rs         |   6 +
 crates/language/src/language.rs               |   2 +-
 crates/paths/src/paths.rs                     |  11 +
 crates/project/src/lsp_store.rs               |  11 +-
 crates/project/src/project.rs                 | 124 +++++++---
 crates/project/src/project_settings.rs        |  67 +++---
 crates/project/src/task_store.rs              |   7 +-
 crates/project/src/terminals.rs               |   6 +-
 crates/project/src/worktree_store.rs          |  18 +-
 crates/project_panel/src/project_panel.rs     |   7 +-
 crates/proto/proto/zed.proto                  |  22 +-
 crates/proto/src/proto.rs                     |  10 +-
 crates/recent_projects/Cargo.toml             |   1 +
 crates/recent_projects/src/dev_servers.rs     |   4 +-
 crates/recent_projects/src/ssh_connections.rs |  16 +-
 crates/remote/src/ssh_session.rs              |  10 +-
 crates/remote_server/Cargo.toml               |   6 +-
 crates/remote_server/src/headless_project.rs  |  91 +++++++-
 .../remote_server/src/remote_editing_tests.rs |  62 ++++-
 crates/remote_server/src/remote_server.rs     |   2 +-
 crates/remote_server/src/unix.rs              | 219 +++++++++++++++---
 crates/settings/src/settings.rs               |   6 +-
 crates/settings/src/settings_store.rs         |  86 +++++--
 crates/theme/src/settings.rs                  |   7 +-
 crates/vim/src/vim.rs                         |  11 +-
 crates/welcome/src/base_keymap_setting.rs     |   3 +
 crates/workspace/src/notifications.rs         |  27 +--
 crates/workspace/src/workspace.rs             |  39 ++--
 crates/zed/src/zed.rs                         |  45 +++-
 crates/zed/src/zed/app_menus.rs               |   2 +-
 crates/zed_actions/src/lib.rs                 |   1 +
 docs/src/configuring-zed.md                   |   2 +-
 44 files changed, 804 insertions(+), 218 deletions(-)
 create mode 100644 assets/settings/initial_server_settings.json

diff --git a/Cargo.lock b/Cargo.lock
index f83feb4689db3f..6f1d7b2c9ca06d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8977,6 +8977,7 @@ dependencies = [
  "log",
  "menu",
  "ordered-float 2.10.1",
+ "paths",
  "picker",
  "project",
  "release_channel",
@@ -9136,6 +9137,7 @@ name = "remote_server"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "async-watch",
  "backtrace",
  "cargo_toml",
  "clap",
@@ -9151,8 +9153,10 @@ dependencies = [
  "log",
  "lsp",
  "node_runtime",
+ "paths",
  "project",
  "remote",
+ "reqwest_client",
  "rpc",
  "rust-embed",
  "serde",
diff --git a/assets/settings/initial_server_settings.json b/assets/settings/initial_server_settings.json
new file mode 100644
index 00000000000000..d6ec33e6012838
--- /dev/null
+++ b/assets/settings/initial_server_settings.json
@@ -0,0 +1,7 @@
+// Server-specific settings
+//
+// For a full list of overridable settings, and general information on settings,
+// see the documentation: https://zed.dev/docs/configuring-zed#settings-files
+{
+  "lsp": {}
+}
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index 4ecf8dd37e5e08..ce01e63b513db0 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -2278,7 +2278,7 @@ impl InlineAssist {
                                             struct InlineAssistantError;
 
                                             let id =
-                                                NotificationId::identified::<InlineAssistantError>(
+                                                NotificationId::composite::<InlineAssistantError>(
                                                     assist_id.0,
                                                 );
 
diff --git a/crates/assistant/src/slash_command_settings.rs b/crates/assistant/src/slash_command_settings.rs
index c524b37803edea..5918769d711c3f 100644
--- a/crates/assistant/src/slash_command_settings.rs
+++ b/crates/assistant/src/slash_command_settings.rs
@@ -38,7 +38,10 @@ impl Settings for SlashCommandSettings {
 
     fn load(sources: SettingsSources<Self::FileContent>, _cx: &mut AppContext) -> Result<Self> {
         SettingsSources::<Self::FileContent>::json_merge_with(
-            [sources.default].into_iter().chain(sources.user),
+            [sources.default]
+                .into_iter()
+                .chain(sources.user)
+                .chain(sources.server),
         )
     }
 }
diff --git a/crates/assistant/src/terminal_inline_assistant.rs b/crates/assistant/src/terminal_inline_assistant.rs
index d30ec2df11a793..41b8d9eb88ac25 100644
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -414,7 +414,7 @@ impl TerminalInlineAssist {
                                             struct InlineAssistantError;
 
                                             let id =
-                                                NotificationId::identified::<InlineAssistantError>(
+                                                NotificationId::composite::<InlineAssistantError>(
                                                     assist_id.0,
                                                 );
 
diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index bb952990fccc87..d501e6d93fdc11 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -130,7 +130,7 @@ impl Settings for AutoUpdateSetting {
     type FileContent = Option<AutoUpdateSettingContent>;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
-        let auto_update = [sources.release_channel, sources.user]
+        let auto_update = [sources.server, sources.release_channel, sources.user]
             .into_iter()
             .find_map(|value| value.copied().flatten())
             .unwrap_or(sources.default.ok_or_else(Self::missing_default)?);
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 49f3ff4b146f4b..33e2bff6fbc508 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -141,6 +141,7 @@ impl Settings for ProxySettings {
         Ok(Self {
             proxy: sources
                 .user
+                .or(sources.server)
                 .and_then(|value| value.proxy.clone())
                 .or(sources.default.proxy.clone()),
         })
@@ -472,15 +473,21 @@ impl settings::Settings for TelemetrySettings {
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
         Ok(Self {
-            diagnostics: sources.user.as_ref().and_then(|v| v.diagnostics).unwrap_or(
-                sources
-                    .default
-                    .diagnostics
-                    .ok_or_else(Self::missing_default)?,
-            ),
+            diagnostics: sources
+                .user
+                .as_ref()
+                .or(sources.server.as_ref())
+                .and_then(|v| v.diagnostics)
+                .unwrap_or(
+                    sources
+                        .default
+                        .diagnostics
+                        .ok_or_else(Self::missing_default)?,
+                ),
             metrics: sources
                 .user
                 .as_ref()
+                .or(sources.server.as_ref())
                 .and_then(|v| v.metrics)
                 .unwrap_or(sources.default.metrics.ok_or_else(Self::missing_default)?),
         })
diff --git a/crates/collab/src/tests/remote_editing_collaboration_tests.rs b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
index 7de50511ea2766..dae33457555ec4 100644
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -2,10 +2,12 @@ use crate::tests::TestServer;
 use call::ActiveCall;
 use fs::{FakeFs, Fs as _};
 use gpui::{Context as _, TestAppContext};
-use language::language_settings::all_language_settings;
+use http_client::BlockedHttpClient;
+use language::{language_settings::all_language_settings, LanguageRegistry};
+use node_runtime::NodeRuntime;
 use project::ProjectPath;
 use remote::SshRemoteClient;
-use remote_server::HeadlessProject;
+use remote_server::{HeadlessAppState, HeadlessProject};
 use serde_json::json;
 use std::{path::Path, sync::Arc};
 
@@ -48,8 +50,22 @@ async fn test_sharing_an_ssh_remote_project(
 
     // User A connects to the remote project via SSH.
     server_cx.update(HeadlessProject::init);
-    let _headless_project =
-        server_cx.new_model(|cx| HeadlessProject::new(server_ssh, remote_fs.clone(), cx));
+    let remote_http_client = Arc::new(BlockedHttpClient);
+    let node = NodeRuntime::unavailable();
+    let languages = Arc::new(LanguageRegistry::new(server_cx.executor()));
+    let _headless_project = server_cx.new_model(|cx| {
+        client::init_settings(cx);
+        HeadlessProject::new(
+            HeadlessAppState {
+                session: server_ssh,
+                fs: remote_fs.clone(),
+                http_client: remote_http_client,
+                node_runtime: node,
+                languages,
+            },
+            cx,
+        )
+    });
 
     let (project_a, worktree_id) = client_a
         .build_ssh_project("/code/project1", client_ssh, cx_a)
diff --git a/crates/editor/src/git/blame.rs b/crates/editor/src/git/blame.rs
index 303ead16b22319..1ac134530532c0 100644
--- a/crates/editor/src/git/blame.rs
+++ b/crates/editor/src/git/blame.rs
@@ -403,7 +403,10 @@ impl GitBlame {
                     if this.user_triggered {
                         log::error!("failed to get git blame data: {error:?}");
                         let notification = format!("{:#}", error).trim().to_string();
-                        cx.emit(project::Event::Notification(notification));
+                        cx.emit(project::Event::Toast {
+                            notification_id: "git-blame".into(),
+                            message: notification,
+                        });
                     } else {
                         // If we weren't triggered by a user, we just log errors in the background, instead of sending
                         // notifications.
@@ -619,9 +622,11 @@ mod tests {
         let event = project.next_event(cx).await;
         assert_eq!(
             event,
-            project::Event::Notification(
-                "Failed to blame \"file.txt\": failed to get blame for \"file.txt\"".to_string()
-            )
+            project::Event::Toast {
+                notification_id: "git-blame".into(),
+                message: "Failed to blame \"file.txt\": failed to get blame for \"file.txt\""
+                    .to_string()
+            }
         );
 
         blame.update(cx, |blame, cx| {
diff --git a/crates/extension/src/extension_settings.rs b/crates/extension/src/extension_settings.rs
index a2ab7ac9cca73b..cfae4482c90eca 100644
--- a/crates/extension/src/extension_settings.rs
+++ b/crates/extension/src/extension_settings.rs
@@ -42,7 +42,10 @@ impl Settings for ExtensionSettings {
 
     fn load(sources: SettingsSources<Self::FileContent>, _cx: &mut AppContext) -> Result<Self> {
         SettingsSources::<Self::FileContent>::json_merge_with(
-            [sources.default].into_iter().chain(sources.user),
+            [sources.default]
+                .into_iter()
+                .chain(sources.user)
+                .chain(sources.server),
         )
     }
 }
diff --git a/crates/extensions_ui/src/extension_suggest.rs b/crates/extensions_ui/src/extension_suggest.rs
index ed003f25b7f235..b21621537fdf12 100644
--- a/crates/extensions_ui/src/extension_suggest.rs
+++ b/crates/extensions_ui/src/extension_suggest.rs
@@ -163,7 +163,7 @@ pub(crate) fn suggest(buffer: Model<Buffer>, cx: &mut ViewContext<Workspace>) {
 
         struct ExtensionSuggestionNotification;
 
-        let notification_id = NotificationId::identified::<ExtensionSuggestionNotification>(
+        let notification_id = NotificationId::composite::<ExtensionSuggestionNotification>(
             SharedString::from(extension_id.clone()),
         );
 
diff --git a/crates/gpui/src/app/entity_map.rs b/crates/gpui/src/app/entity_map.rs
index e4da2a3010ae35..5f65cebdb2828e 100644
--- a/crates/gpui/src/app/entity_map.rs
+++ b/crates/gpui/src/app/entity_map.rs
@@ -567,6 +567,12 @@ pub struct WeakModel<T> {
     entity_type: PhantomData<T>,
 }
 
+impl<T> std::fmt::Debug for WeakModel<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct(type_name::<WeakModel<T>>()).finish()
+    }
+}
+
 unsafe impl<T> Send for WeakModel<T> {}
 unsafe impl<T> Sync for WeakModel<T> {}
 
diff --git a/crates/http_client/src/http_client.rs b/crates/http_client/src/http_client.rs
index 3d4a41f4a61df1..3aadf7496f5f67 100644
--- a/crates/http_client/src/http_client.rs
+++ b/crates/http_client/src/http_client.rs
@@ -317,6 +317,12 @@ pub fn read_proxy_from_env() -> Option<Uri> {
 
 pub struct BlockedHttpClient;
 
+impl BlockedHttpClient {
+    pub fn new() -> Self {
+        BlockedHttpClient
+    }
+}
+
 impl HttpClient for BlockedHttpClient {
     fn send(
         &self,
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index fad799da19898d..c1c9cfebbead5e 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -367,7 +367,7 @@ pub trait LspAdapter: 'static + Send + Sync {
             }
 
             let Some(container_dir) = delegate.language_server_download_dir(&self.name()).await else {
-                anyhow::bail!("cannot download language servers for remotes (yet)")
+                anyhow::bail!("no language server download dir defined")
             };
 
             let mut binary = try_fetch_server_binary(self.as_ref(), &delegate, container_dir.to_path_buf(), cx).await;
diff --git a/crates/paths/src/paths.rs b/crates/paths/src/paths.rs
index 7f662d0325d1bf..1649ccb475de92 100644
--- a/crates/paths/src/paths.rs
+++ b/crates/paths/src/paths.rs
@@ -5,6 +5,11 @@ use std::sync::OnceLock;
 
 pub use util::paths::home_dir;
 
+/// Returns the relative path to the zed_server directory on the ssh host.
+pub fn remote_server_dir_relative() -> &'static Path {
+    Path::new(".zed_server")
+}
+
 /// Returns the path to the configuration directory used by Zed.
 pub fn config_dir() -> &'static PathBuf {
     static CONFIG_DIR: OnceLock<PathBuf> = OnceLock::new();
@@ -96,6 +101,12 @@ pub fn logs_dir() -> &'static PathBuf {
     })
 }
 
+/// Returns the path to the zed server directory on this ssh host.
+pub fn remote_server_state_dir() -> &'static PathBuf {
+    static REMOTE_SERVER_STATE: OnceLock<PathBuf> = OnceLock::new();
+    REMOTE_SERVER_STATE.get_or_init(|| return support_dir().join("server_state"))
+}
+
 /// Returns the path to the `Zed.log` file.
 pub fn log_file() -> &'static PathBuf {
     static LOG_FILE: OnceLock<PathBuf> = OnceLock::new();
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 58d6b07e565c42..6b0042638dc7a1 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -27,7 +27,7 @@ use gpui::{
     AppContext, AsyncAppContext, Context, Entity, EventEmitter, Model, ModelContext, PromptLevel,
     Task, WeakModel,
 };
-use http_client::{BlockedHttpClient, HttpClient};
+use http_client::HttpClient;
 use language::{
     language_settings::{
         all_language_settings, language_settings, AllLanguageSettings, FormatOnSave, Formatter,
@@ -116,7 +116,7 @@ impl FormatTrigger {
 }
 
 pub struct LocalLspStore {
-    http_client: Option<Arc<dyn HttpClient>>,
+    http_client: Arc<dyn HttpClient>,
     environment: Model<ProjectEnvironment>,
     fs: Arc<dyn Fs>,
     yarn: Model<YarnPathStore>,
@@ -839,7 +839,7 @@ impl LspStore {
         prettier_store: Model<PrettierStore>,
         environment: Model<ProjectEnvironment>,
         languages: Arc<LanguageRegistry>,
-        http_client: Option<Arc<dyn HttpClient>>,
+        http_client: Arc<dyn HttpClient>,
         fs: Arc<dyn Fs>,
         cx: &mut ModelContext<Self>,
     ) -> Self {
@@ -7579,10 +7579,7 @@ impl LocalLspAdapterDelegate {
             .as_local()
             .expect("LocalLspAdapterDelegate cannot be constructed on a remote");
 
-        let http_client = local
-            .http_client
-            .clone()
-            .unwrap_or_else(|| Arc::new(BlockedHttpClient));
+        let http_client = local.http_client.clone();
 
         Self::new(lsp_store, worktree, http_client, local.fs.clone(), cx)
     }
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index f4040a3d12c6e7..6e731e9cbadd01 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -222,8 +222,13 @@ pub enum Event {
     LanguageServerAdded(LanguageServerId, LanguageServerName, Option<WorktreeId>),
     LanguageServerRemoved(LanguageServerId),
     LanguageServerLog(LanguageServerId, LanguageServerLogType, String),
-    Notification(String),
-    LocalSettingsUpdated(Result<(), InvalidSettingsError>),
+    Toast {
+        notification_id: SharedString,
+        message: String,
+    },
+    HideToast {
+        notification_id: SharedString,
+    },
     LanguageServerPrompt(LanguageServerPromptRequest),
     LanguageNotFound(Model<Buffer>),
     ActiveEntryChanged(Option<ProjectEntryId>),
@@ -633,7 +638,7 @@ impl Project {
                     prettier_store.clone(),
                     environment.clone(),
                     languages.clone(),
-                    Some(client.http_client()),
+                    client.http_client(),
                     fs.clone(),
                     cx,
                 )
@@ -694,7 +699,7 @@ impl Project {
             let snippets =
                 SnippetProvider::new(fs.clone(), BTreeSet::from_iter([global_snippets_dir]), cx);
 
-            let ssh_proto = ssh.read(cx).to_proto_client();
+            let ssh_proto = ssh.read(cx).proto_client();
             let worktree_store =
                 cx.new_model(|_| WorktreeStore::remote(false, ssh_proto.clone(), 0, None));
             cx.subscribe(&worktree_store, Self::on_worktree_store_event)
@@ -703,7 +708,7 @@ impl Project {
             let buffer_store = cx.new_model(|cx| {
                 BufferStore::remote(
                     worktree_store.clone(),
-                    ssh.read(cx).to_proto_client(),
+                    ssh.read(cx).proto_client(),
                     SSH_PROJECT_ID,
                     cx,
                 )
@@ -716,7 +721,7 @@ impl Project {
                     fs.clone(),
                     buffer_store.downgrade(),
                     worktree_store.clone(),
-                    ssh.read(cx).to_proto_client(),
+                    ssh.read(cx).proto_client(),
                     SSH_PROJECT_ID,
                     cx,
                 )
@@ -809,6 +814,8 @@ impl Project {
             ssh_proto.add_model_message_handler(Self::handle_create_buffer_for_peer);
             ssh_proto.add_model_message_handler(Self::handle_update_worktree);
             ssh_proto.add_model_message_handler(Self::handle_update_project);
+            ssh_proto.add_model_message_handler(Self::handle_toast);
+            ssh_proto.add_model_message_handler(Self::handle_hide_toast);
             ssh_proto.add_model_request_handler(BufferStore::handle_update_buffer);
             BufferStore::init(&ssh_proto);
             LspStore::init(&ssh_proto);
@@ -2065,7 +2072,7 @@ impl Project {
                 if let Some(ref ssh_client) = self.ssh_client {
                     ssh_client
                         .read(cx)
-                        .to_proto_client()
+                        .proto_client()
                         .send(proto::CloseBuffer {
                             project_id: 0,
                             buffer_id: buffer_id.to_proto(),
@@ -2136,7 +2143,10 @@ impl Project {
                     .ok();
                 }
             }
-            LspStoreEvent::Notification(message) => cx.emit(Event::Notification(message.clone())),
+            LspStoreEvent::Notification(message) => cx.emit(Event::Toast {
+                notification_id: "lsp".into(),
+                message: message.clone(),
+            }),
             LspStoreEvent::SnippetEdit {
                 buffer_id,
                 edits,
@@ -2180,9 +2190,20 @@ impl Project {
         cx: &mut ModelContext<Self>,
     ) {
         match event {
-            SettingsObserverEvent::LocalSettingsUpdated(error) => {
-                cx.emit(Event::LocalSettingsUpdated(error.clone()))
-            }
+            SettingsObserverEvent::LocalSettingsUpdated(result) => match result {
+                Err(InvalidSettingsError::LocalSettings { message, path }) => {
+                    let message =
+                        format!("Failed to set local settings in {:?}:\n{}", path, message);
+                    cx.emit(Event::Toast {
+                        notification_id: "local-settings".into(),
+                        message,
+                    });
+                }
+                Ok(_) => cx.emit(Event::HideToast {
+                    notification_id: "local-settings".into(),
+                }),
+                Err(_) => {}
+            },
         }
     }
 
@@ -2262,7 +2283,7 @@ impl Project {
 
         if let Some(ssh) = &self.ssh_client {
             ssh.read(cx)
-                .to_proto_client()
+                .proto_client()
                 .send(proto::RemoveWorktree {
                     worktree_id: id_to_remove.to_proto(),
                 })
@@ -2295,7 +2316,7 @@ impl Project {
 
                 if let Some(ssh) = &self.ssh_client {
                     ssh.read(cx)
-                        .to_proto_client()
+                        .proto_client()
                         .send(proto::UpdateBuffer {
                             project_id: 0,
                             buffer_id: buffer_id.to_proto(),
@@ -2632,6 +2653,35 @@ impl Project {
         })
     }
 
+    pub fn open_server_settings(
+        &mut self,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<Model<Buffer>>> {
+        let guard = self.retain_remotely_created_models(cx);
+        let Some(ssh_client) = self.ssh_client.as_ref() else {
+            return Task::ready(Err(anyhow!("not an ssh project")));
+        };
+
+        let proto_client = ssh_client.read(cx).proto_client();
+
+        cx.spawn(|this, mut cx| async move {
+            let buffer = proto_client
+                .request(proto::OpenServerSettings {
+                    project_id: SSH_PROJECT_ID,
+                })
+                .await?;
+
+            let buffer = this
+                .update(&mut cx, |this, cx| {
+                    anyhow::Ok(this.wait_for_remote_buffer(BufferId::new(buffer.buffer_id)?, cx))
+                })??
+                .await;
+
+            drop(guard);
+            buffer
+        })
+    }
+
     pub fn open_local_buffer_via_lsp(
         &mut self,
         abs_path: lsp::Url,
@@ -2982,7 +3032,7 @@ impl Project {
         let (tx, rx) = smol::channel::unbounded();
 
         let (client, remote_id): (AnyProtoClient, _) = if let Some(ssh_client) = &self.ssh_client {
-            (ssh_client.read(cx).to_proto_client(), 0)
+            (ssh_client.read(cx).proto_client(), 0)
         } else if let Some(remote_id) = self.remote_id() {
             (self.client.clone().into(), remote_id)
         } else {
@@ -3069,14 +3119,9 @@ impl Project {
         visible: bool,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<(Model<Worktree>, PathBuf)>> {
-        let abs_path = abs_path.as_ref();
-        if let Some((tree, relative_path)) = self.find_worktree(abs_path, cx) {
-            Task::ready(Ok((tree, relative_path)))
-        } else {
-            let worktree = self.create_worktree(abs_path, visible, cx);
-            cx.background_executor()
-                .spawn(async move { Ok((worktree.await?, PathBuf::new())) })
-        }
+        self.worktree_store.update(cx, |worktree_store, cx| {
+            worktree_store.find_or_create_worktree(abs_path, visible, cx)
+        })
     }
 
     pub fn find_worktree(
@@ -3138,7 +3183,7 @@ impl Project {
         } else if let Some(ssh_client) = self.ssh_client.as_ref() {
             let request = ssh_client
                 .read(cx)
-                .to_proto_client()
+                .proto_client()
                 .request(proto::CheckFileExists {
                     project_id: SSH_PROJECT_ID,
                     path: path.to_string(),
@@ -3215,7 +3260,7 @@ impl Project {
                 path: query,
             };
 
-            let response = session.read(cx).to_proto_client().request(request);
+            let response = session.read(cx).proto_client().request(request);
             cx.background_executor().spawn(async move {
                 let response = response.await?;
                 Ok(response.entries.into_iter().map(PathBuf::from).collect())
@@ -3239,7 +3284,7 @@ impl Project {
         }
     }
 
-    fn create_worktree(
+    pub fn create_worktree(
         &mut self,
         abs_path: impl AsRef<Path>,
         visible: bool,
@@ -3544,6 +3589,33 @@ impl Project {
         })?
     }
 
+    async fn handle_toast(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::Toast>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        this.update(&mut cx, |_, cx| {
+            cx.emit(Event::Toast {
+                notification_id: envelope.payload.notification_id.into(),
+                message: envelope.payload.message,
+            });
+            Ok(())
+        })?
+    }
+
+    async fn handle_hide_toast(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::HideToast>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        this.update(&mut cx, |_, cx| {
+            cx.emit(Event::HideToast {
+                notification_id: envelope.payload.notification_id.into(),
+            });
+            Ok(())
+        })?
+    }
+
     // Collab sends UpdateWorktree protos as messages
     async fn handle_update_worktree(
         this: Model<Self>,
@@ -3572,7 +3644,7 @@ impl Project {
                 let mut payload = envelope.payload.clone();
                 payload.project_id = SSH_PROJECT_ID;
                 cx.background_executor()
-                    .spawn(ssh.read(cx).to_proto_client().request(payload))
+                    .spawn(ssh.read(cx).proto_client().request(payload))
                     .detach_and_log_err(cx);
             }
             this.buffer_store.clone()
diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs
index 49378fbc1dc7e4..3ecf0e300878ca 100644
--- a/crates/project/src/project_settings.rs
+++ b/crates/project/src/project_settings.rs
@@ -538,26 +538,47 @@ impl SettingsObserver {
         let task_store = self.task_store.clone();
 
         for (directory, kind, file_content) in settings_contents {
-            let result = match kind {
+            match kind {
                 LocalSettingsKind::Settings | LocalSettingsKind::Editorconfig => cx
-                    .update_global::<SettingsStore, anyhow::Result<()>>(|store, cx| {
-                        store.set_local_settings(
+                    .update_global::<SettingsStore, _>(|store, cx| {
+                        let result = store.set_local_settings(
                             worktree_id,
                             directory.clone(),
                             kind,
                             file_content.as_deref(),
                             cx,
-                        )
+                        );
+
+                        match result {
+                            Err(InvalidSettingsError::LocalSettings { path, message }) => {
+                                log::error!(
+                                    "Failed to set local settings in {:?}: {:?}",
+                                    path,
+                                    message
+                                );
+                                cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Err(
+                                    InvalidSettingsError::LocalSettings { path, message },
+                                )));
+                            }
+                            Err(e) => {
+                                log::error!("Failed to set local settings: {e}");
+                            }
+                            Ok(_) => {
+                                cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Ok(())));
+                            }
+                        }
                     }),
                 LocalSettingsKind::Tasks => task_store.update(cx, |task_store, cx| {
-                    task_store.update_user_tasks(
-                        Some(SettingsLocation {
-                            worktree_id,
-                            path: directory.as_ref(),
-                        }),
-                        file_content.as_deref(),
-                        cx,
-                    )
+                    task_store
+                        .update_user_tasks(
+                            Some(SettingsLocation {
+                                worktree_id,
+                                path: directory.as_ref(),
+                            }),
+                            file_content.as_deref(),
+                            cx,
+                        )
+                        .log_err();
                 }),
             };
 
@@ -572,28 +593,6 @@ impl SettingsObserver {
                     })
                     .log_err();
             }
-
-            match result {
-                Err(error) => {
-                    if let Ok(error) = error.downcast::<InvalidSettingsError>() {
-                        if let InvalidSettingsError::LocalSettings {
-                            ref path,
-                            ref message,
-                        } = error
-                        {
-                            log::error!(
-                                "Failed to set local settings in {:?}: {:?}",
-                                path,
-                                message
-                            );
-                            cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Err(error)));
-                        }
-                    }
-                }
-                Ok(()) => {
-                    cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Ok(())));
-                }
-            }
         }
     }
 }
diff --git a/crates/project/src/task_store.rs b/crates/project/src/task_store.rs
index 55ee780fc56e98..45b62697c3df37 100644
--- a/crates/project/src/task_store.rs
+++ b/crates/project/src/task_store.rs
@@ -298,9 +298,10 @@ impl TaskStore {
                     let result = task_store.update_user_tasks(None, Some(&user_tasks_content), cx);
                     if let Err(err) = &result {
                         log::error!("Failed to load user tasks: {err}");
-                        cx.emit(crate::Event::Notification(format!(
-                            "Invalid global tasks file\n{err}"
-                        )));
+                        cx.emit(crate::Event::Toast {
+                            notification_id: "load-user-tasks".into(),
+                            message: format!("Invalid global tasks file\n{err}"),
+                        });
                     }
                     cx.refresh();
                 }) else {
diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs
index 11b3152f0cf660..ac4e890aaddfa6 100644
--- a/crates/project/src/terminals.rs
+++ b/crates/project/src/terminals.rs
@@ -367,7 +367,11 @@ pub fn wrap_for_ssh(
         // replace ith with something that works
         let tilde_prefix = "~/";
         if path.starts_with(tilde_prefix) {
-            let trimmed_path = &path_string[tilde_prefix.len()..];
+            let trimmed_path = path_string
+                .trim_start_matches("/")
+                .trim_start_matches("~")
+                .trim_start_matches("/");
+
             format!("cd \"$HOME/{trimmed_path}\"; {env_changes} {to_run}")
         } else {
             format!("cd {path:?}; {env_changes} {to_run}")
diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 6e04a884b91877..55eb0108e2109b 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -153,6 +153,22 @@ impl WorktreeStore {
         None
     }
 
+    pub fn find_or_create_worktree(
+        &mut self,
+        abs_path: impl AsRef<Path>,
+        visible: bool,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<(Model<Worktree>, PathBuf)>> {
+        let abs_path = abs_path.as_ref();
+        if let Some((tree, relative_path)) = self.find_worktree(abs_path, cx) {
+            Task::ready(Ok((tree, relative_path)))
+        } else {
+            let worktree = self.create_worktree(abs_path, visible, cx);
+            cx.background_executor()
+                .spawn(async move { Ok((worktree.await?, PathBuf::new())) })
+        }
+    }
+
     pub fn entry_for_id<'a>(
         &'a self,
         entry_id: ProjectEntryId,
@@ -957,7 +973,7 @@ impl WorktreeStore {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 enum WorktreeHandle {
     Strong(Model<Worktree>),
     Weak(WeakModel<Worktree>),
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index b4f07c66d30655..08a0ef4b4060b4 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -880,9 +880,10 @@ impl ProjectPanel {
 
                             if is_dir {
                                 project_panel.project.update(cx, |_, cx| {
-                                    cx.emit(project::Event::Notification(format!(
-                                        "Created an excluded directory at {abs_path:?}.\nAlter `file_scan_exclusions` in the settings to show it in the panel"
-                                    )))
+                                    cx.emit(project::Event::Toast {
+                                        notification_id: "excluded-directory".into(),
+                                        message: format!("Created an excluded directory at {abs_path:?}.\nAlter `file_scan_exclusions` in the settings to show it in the panel")
+                                    })
                                 });
                                 None
                             } else {
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index 52a73cd7f1dc8b..fbd1cf42151348 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -287,7 +287,12 @@ message Envelope {
 
         RemoveWorktree remove_worktree = 258;
 
-        LanguageServerLog language_server_log = 260; // current max
+        LanguageServerLog language_server_log = 260;
+
+        Toast toast = 261;
+        HideToast hide_toast = 262;
+
+        OpenServerSettings open_server_settings = 263; // current max
     }
 
     reserved 87 to 88;
@@ -2487,3 +2492,18 @@ message ShutdownRemoteServer {}
 message RemoveWorktree {
     uint64 worktree_id = 1;
 }
+
+message Toast {
+    uint64 project_id = 1;
+    string notification_id = 2;
+    string message = 3;
+}
+
+message HideToast {
+    uint64 project_id = 1;
+    string notification_id = 2;
+}
+
+message OpenServerSettings {
+    uint64 project_id = 1;
+}
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 15841a70770922..84554399801653 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -367,6 +367,9 @@ messages!(
     (ShutdownRemoteServer, Foreground),
     (RemoveWorktree, Foreground),
     (LanguageServerLog, Foreground),
+    (Toast, Background),
+    (HideToast, Background),
+    (OpenServerSettings, Foreground),
 );
 
 request_messages!(
@@ -490,7 +493,8 @@ request_messages!(
     (AddWorktree, AddWorktreeResponse),
     (CheckFileExists, CheckFileExistsResponse),
     (ShutdownRemoteServer, Ack),
-    (RemoveWorktree, Ack)
+    (RemoveWorktree, Ack),
+    (OpenServerSettings, OpenBufferResponse)
 );
 
 entity_messages!(
@@ -564,6 +568,10 @@ entity_messages!(
     UpdateUserSettings,
     CheckFileExists,
     LanguageServerLog,
+    Toast,
+    HideToast,
+    OpenServerSettings,
+
 );
 
 entity_messages!(
diff --git a/crates/recent_projects/Cargo.toml b/crates/recent_projects/Cargo.toml
index 2b428009c4ae93..3dadcbef37509d 100644
--- a/crates/recent_projects/Cargo.toml
+++ b/crates/recent_projects/Cargo.toml
@@ -39,6 +39,7 @@ terminal_view.workspace = true
 ui.workspace = true
 util.workspace = true
 workspace.workspace = true
+paths.workspace = true
 
 [dev-dependencies]
 editor = { workspace = true, features = ["test-support"] }
diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 8fe501258a0bf9..89772a1fe81f95 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -948,7 +948,7 @@ impl DevServerProjects {
 
                                     this.show_toast(
                                         Toast::new(
-                                            NotificationId::identified::<
+                                            NotificationId::composite::<
                                                 SshServerAddressCopiedToClipboard,
                                             >(
                                                 connection_string.clone()
@@ -1002,7 +1002,7 @@ impl DevServerProjects {
                                     );
                                     this.show_toast(
                                         Toast::new(
-                                            NotificationId::identified::<SshServerRemoval>(
+                                            NotificationId::composite::<SshServerRemoval>(
                                                 connection_string.clone(),
                                             ),
                                             notification,
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index d3752a7b123f92..06fb08b3fe493d 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -10,6 +10,7 @@ use gpui::{
     Transformation, View,
 };
 use gpui::{AppContext, Model};
+
 use release_channel::{AppVersion, ReleaseChannel};
 use remote::{SshConnectionOptions, SshPlatform, SshRemoteClient};
 use schemars::JsonSchema;
@@ -377,9 +378,18 @@ impl remote::SshClientDelegate for SshClientDelegate {
         rx
     }
 
-    fn remote_server_binary_path(&self, cx: &mut AsyncAppContext) -> Result<PathBuf> {
+    fn remote_server_binary_path(
+        &self,
+        platform: SshPlatform,
+        cx: &mut AsyncAppContext,
+    ) -> Result<PathBuf> {
         let release_channel = cx.update(|cx| ReleaseChannel::global(cx))?;
-        Ok(format!(".local/zed-remote-server-{}", release_channel.dev_name()).into())
+        Ok(paths::remote_server_dir_relative().join(format!(
+            "zed-remote-server-{}-{}-{}",
+            release_channel.dev_name(),
+            platform.os,
+            platform.arch
+        )))
     }
 }
 
@@ -487,7 +497,7 @@ impl SshClientDelegate {
             let path = std::env::current_dir()?.join("target/remote_server/debug/remote_server.gz");
             return Ok(Some((path, version)));
         } else if let Some(triple) = platform.triple() {
-            smol::fs::create_dir_all("target/remote-server").await?;
+            smol::fs::create_dir_all("target/remote_server").await?;
 
             self.update_status(Some("Installing cross.rs for cross-compilation"), cx);
             log::info!("installing cross");
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index fbe6e3e0fa89a7..4d131425492da8 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -137,7 +137,11 @@ pub trait SshClientDelegate: Send + Sync {
         prompt: String,
         cx: &mut AsyncAppContext,
     ) -> oneshot::Receiver<Result<String>>;
-    fn remote_server_binary_path(&self, cx: &mut AsyncAppContext) -> Result<PathBuf>;
+    fn remote_server_binary_path(
+        &self,
+        platform: SshPlatform,
+        cx: &mut AsyncAppContext,
+    ) -> Result<PathBuf>;
     fn get_server_binary(
         &self,
         platform: SshPlatform,
@@ -972,7 +976,7 @@ impl SshRemoteClient {
 
         let platform = ssh_connection.query_platform().await?;
         let (local_binary_path, version) = delegate.get_server_binary(platform, cx).await??;
-        let remote_binary_path = delegate.remote_server_binary_path(cx)?;
+        let remote_binary_path = delegate.remote_server_binary_path(platform, cx)?;
         ssh_connection
             .ensure_server_binary(
                 &delegate,
@@ -1021,7 +1025,7 @@ impl SshRemoteClient {
             .map(|ssh_connection| ssh_connection.socket.ssh_args())
     }
 
-    pub fn to_proto_client(&self) -> AnyProtoClient {
+    pub fn proto_client(&self) -> AnyProtoClient {
         self.client.clone().into()
     }
 
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index d822721c1eb8a2..6ba2c5c7c97ca7 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -22,6 +22,7 @@ debug-embed = ["dep:rust-embed"]
 test-support = ["fs/test-support"]
 
 [dependencies]
+async-watch.workspace = true
 anyhow.workspace = true
 backtrace = "0.3"
 clap.workspace = true
@@ -30,13 +31,16 @@ env_logger.workspace = true
 fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
+http_client.workspace = true
 language.workspace = true
 languages.workspace = true
 log.workspace = true
 lsp.workspace = true
 node_runtime.workspace = true
 project.workspace = true
+paths = { workspace = true }
 remote.workspace = true
+reqwest_client.workspace = true
 rpc.workspace = true
 rust-embed = { workspace = true, optional = true, features = ["debug-embed"] }
 serde.workspace = true
@@ -66,4 +70,4 @@ cargo_toml.workspace = true
 toml.workspace = true
 
 [package.metadata.cargo-machete]
-ignored = ["rust-embed"]
+ignored = ["rust-embed", "paths"]
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 701b80842b8ceb..f17c27a03cad43 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -1,6 +1,7 @@
 use anyhow::{anyhow, Result};
 use fs::Fs;
 use gpui::{AppContext, AsyncAppContext, Context, Model, ModelContext};
+use http_client::HttpClient;
 use language::{proto::serialize_operation, Buffer, BufferEvent, LanguageRegistry};
 use node_runtime::NodeRuntime;
 use project::{
@@ -16,6 +17,8 @@ use rpc::{
     proto::{self, SSH_PEER_ID, SSH_PROJECT_ID},
     AnyProtoClient, TypedEnvelope,
 };
+
+use settings::initial_server_settings_content;
 use smol::stream::StreamExt;
 use std::{
     path::{Path, PathBuf},
@@ -36,6 +39,14 @@ pub struct HeadlessProject {
     pub languages: Arc<LanguageRegistry>,
 }
 
+pub struct HeadlessAppState {
+    pub session: Arc<ChannelClient>,
+    pub fs: Arc<dyn Fs>,
+    pub http_client: Arc<dyn HttpClient>,
+    pub node_runtime: NodeRuntime,
+    pub languages: Arc<LanguageRegistry>,
+}
+
 impl HeadlessProject {
     pub fn init(cx: &mut AppContext) {
         settings::init(cx);
@@ -43,11 +54,16 @@ impl HeadlessProject {
         project::Project::init_settings(cx);
     }
 
-    pub fn new(session: Arc<ChannelClient>, fs: Arc<dyn Fs>, cx: &mut ModelContext<Self>) -> Self {
-        let languages = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
-
-        let node_runtime = NodeRuntime::unavailable();
-
+    pub fn new(
+        HeadlessAppState {
+            session,
+            fs,
+            http_client,
+            node_runtime,
+            languages,
+        }: HeadlessAppState,
+        cx: &mut ModelContext<Self>,
+    ) -> Self {
         languages::init(languages.clone(), node_runtime.clone(), cx);
 
         let worktree_store = cx.new_model(|cx| {
@@ -99,7 +115,7 @@ impl HeadlessProject {
                 prettier_store.clone(),
                 environment,
                 languages.clone(),
-                None,
+                http_client,
                 fs.clone(),
                 cx,
             );
@@ -139,6 +155,7 @@ impl HeadlessProject {
 
         client.add_model_request_handler(Self::handle_open_buffer_by_path);
         client.add_model_request_handler(Self::handle_find_search_candidates);
+        client.add_model_request_handler(Self::handle_open_server_settings);
 
         client.add_model_request_handler(BufferStore::handle_update_buffer);
         client.add_model_message_handler(BufferStore::handle_close_buffer);
@@ -203,6 +220,15 @@ impl HeadlessProject {
                     })
                     .log_err();
             }
+            LspStoreEvent::Notification(message) => {
+                self.session
+                    .send(proto::Toast {
+                        project_id: SSH_PROJECT_ID,
+                        notification_id: "lsp".to_string(),
+                        message: message.clone(),
+                    })
+                    .log_err();
+            }
             LspStoreEvent::LanguageServerLog(language_server_id, log_type, message) => {
                 self.session
                     .send(proto::LanguageServerLog {
@@ -336,6 +362,59 @@ impl HeadlessProject {
         })
     }
 
+    pub async fn handle_open_server_settings(
+        this: Model<Self>,
+        _: TypedEnvelope<proto::OpenServerSettings>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::OpenBufferResponse> {
+        let settings_path = paths::settings_file();
+        let (worktree, path) = this
+            .update(&mut cx, |this, cx| {
+                this.worktree_store.update(cx, |worktree_store, cx| {
+                    worktree_store.find_or_create_worktree(settings_path, false, cx)
+                })
+            })?
+            .await?;
+
+        let (buffer, buffer_store) = this.update(&mut cx, |this, cx| {
+            let buffer = this.buffer_store.update(cx, |buffer_store, cx| {
+                buffer_store.open_buffer(
+                    ProjectPath {
+                        worktree_id: worktree.read(cx).id(),
+                        path: path.into(),
+                    },
+                    cx,
+                )
+            });
+
+            (buffer, this.buffer_store.clone())
+        })?;
+
+        let buffer = buffer.await?;
+
+        let buffer_id = cx.update(|cx| {
+            if buffer.read(cx).is_empty() {
+                buffer.update(cx, |buffer, cx| {
+                    buffer.edit([(0..0, initial_server_settings_content())], None, cx)
+                });
+            }
+
+            let buffer_id = buffer.read_with(cx, |b, _| b.remote_id());
+
+            buffer_store.update(cx, |buffer_store, cx| {
+                buffer_store
+                    .create_buffer_for_peer(&buffer, SSH_PEER_ID, cx)
+                    .detach_and_log_err(cx);
+            });
+
+            buffer_id
+        })?;
+
+        Ok(proto::OpenBufferResponse {
+            buffer_id: buffer_id.to_proto(),
+        })
+    }
+
     pub async fn handle_find_search_candidates(
         this: Model<Self>,
         envelope: TypedEnvelope<proto::FindSearchCandidates>,
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 10cfb517abb802..41065ad5508310 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -3,7 +3,7 @@ use client::{Client, UserStore};
 use clock::FakeSystemClock;
 use fs::{FakeFs, Fs};
 use gpui::{Context, Model, TestAppContext};
-use http_client::FakeHttpClient;
+use http_client::{BlockedHttpClient, FakeHttpClient};
 use language::{
     language_settings::{all_language_settings, AllLanguageSettings},
     Buffer, FakeLspAdapter, LanguageConfig, LanguageMatcher, LanguageRegistry, LanguageServerName,
@@ -17,7 +17,7 @@ use project::{
 };
 use remote::SshRemoteClient;
 use serde_json::json;
-use settings::{Settings, SettingsLocation, SettingsStore};
+use settings::{initial_server_settings_content, Settings, SettingsLocation, SettingsStore};
 use smol::stream::StreamExt;
 use std::{
     path::{Path, PathBuf},
@@ -197,7 +197,7 @@ async fn test_remote_settings(cx: &mut TestAppContext, server_cx: &mut TestAppCo
 
     cx.update_global(|settings_store: &mut SettingsStore, cx| {
         settings_store.set_user_settings(
-            r#"{"languages":{"Rust":{"language_servers":["custom-rust-analyzer"]}}}"#,
+            r#"{"languages":{"Rust":{"language_servers":["from-local-settings"]}}}"#,
             cx,
         )
     })
@@ -210,7 +210,27 @@ async fn test_remote_settings(cx: &mut TestAppContext, server_cx: &mut TestAppCo
             AllLanguageSettings::get_global(cx)
                 .language(Some(&"Rust".into()))
                 .language_servers,
-            ["custom-rust-analyzer".to_string()]
+            ["from-local-settings".to_string()]
+        )
+    });
+
+    server_cx
+        .update_global(|settings_store: &mut SettingsStore, cx| {
+            settings_store.set_server_settings(
+                r#"{"languages":{"Rust":{"language_servers":["from-server-settings"]}}}"#,
+                cx,
+            )
+        })
+        .unwrap();
+
+    cx.run_until_parked();
+
+    server_cx.read(|cx| {
+        assert_eq!(
+            AllLanguageSettings::get_global(cx)
+                .language(Some(&"Rust".into()))
+                .language_servers,
+            ["from-server-settings".to_string()]
         )
     });
 
@@ -606,6 +626,21 @@ async fn test_adding_then_removing_then_adding_worktrees(
     })
 }
 
+#[gpui::test]
+async fn test_open_server_settings(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {
+    let (project, _headless, _fs) = init_test(cx, server_cx).await;
+    let buffer = project.update(cx, |project, cx| project.open_server_settings(cx));
+    cx.executor().run_until_parked();
+    let buffer = buffer.await.unwrap();
+
+    cx.update(|cx| {
+        assert_eq!(
+            buffer.read(cx).text(),
+            initial_server_settings_content().to_string()
+        )
+    })
+}
+
 fn init_logger() {
     if std::env::var("RUST_LOG").is_ok() {
         env_logger::try_init().ok();
@@ -642,8 +677,23 @@ async fn init_test(
     );
 
     server_cx.update(HeadlessProject::init);
-    let headless =
-        server_cx.new_model(|cx| HeadlessProject::new(ssh_server_client, fs.clone(), cx));
+    let http_client = Arc::new(BlockedHttpClient);
+    let node_runtime = NodeRuntime::unavailable();
+    let languages = Arc::new(LanguageRegistry::new(cx.executor()));
+    let headless = server_cx.new_model(|cx| {
+        client::init_settings(cx);
+
+        HeadlessProject::new(
+            crate::HeadlessAppState {
+                session: ssh_server_client,
+                fs: fs.clone(),
+                http_client,
+                node_runtime,
+                languages,
+            },
+            cx,
+        )
+    });
     let project = build_project(ssh_remote_client, cx);
 
     project
diff --git a/crates/remote_server/src/remote_server.rs b/crates/remote_server/src/remote_server.rs
index 2321ee1c6eb52a..52003969af4dfb 100644
--- a/crates/remote_server/src/remote_server.rs
+++ b/crates/remote_server/src/remote_server.rs
@@ -6,4 +6,4 @@ pub mod unix;
 #[cfg(test)]
 mod remote_editing_tests;
 
-pub use headless_project::HeadlessProject;
+pub use headless_project::{HeadlessAppState, HeadlessProject};
diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs
index 2b487803fbe67e..2972991b7bc64a 100644
--- a/crates/remote_server/src/unix.rs
+++ b/crates/remote_server/src/unix.rs
@@ -1,27 +1,37 @@
+use crate::headless_project::HeadlessAppState;
 use crate::HeadlessProject;
 use anyhow::{anyhow, Context, Result};
-use fs::RealFs;
+use client::ProxySettings;
+use fs::{Fs, RealFs};
 use futures::channel::mpsc;
 use futures::{select, select_biased, AsyncRead, AsyncWrite, AsyncWriteExt, FutureExt, SinkExt};
-use gpui::{AppContext, Context as _};
+use gpui::{AppContext, Context as _, ModelContext, UpdateGlobal as _};
+use http_client::{read_proxy_from_env, Uri};
+use language::LanguageRegistry;
+use node_runtime::{NodeBinaryOptions, NodeRuntime};
+use paths::logs_dir;
+use project::project_settings::ProjectSettings;
 use remote::proxy::ProxyLaunchError;
 use remote::ssh_session::ChannelClient;
 use remote::{
     json_log::LogRecord,
     protocol::{read_message, write_message},
 };
-use rpc::proto::Envelope;
+use reqwest_client::ReqwestClient;
+use rpc::proto::{self, Envelope, SSH_PROJECT_ID};
+use settings::{watch_config_file, Settings, SettingsStore};
 use smol::channel::{Receiver, Sender};
 use smol::io::AsyncReadExt;
+
 use smol::Async;
 use smol::{net::unix::UnixListener, stream::StreamExt as _};
 use std::{
-    env,
     io::Write,
     mem,
     path::{Path, PathBuf},
     sync::Arc,
 };
+use util::ResultExt;
 
 fn init_logging_proxy() {
     env_logger::builder()
@@ -266,6 +276,22 @@ fn start_server(
     ChannelClient::new(incoming_rx, outgoing_tx, cx)
 }
 
+fn init_paths() -> anyhow::Result<()> {
+    for path in [
+        paths::config_dir(),
+        paths::extensions_dir(),
+        paths::languages_dir(),
+        paths::logs_dir(),
+        paths::temp_dir(),
+    ]
+    .iter()
+    {
+        std::fs::create_dir_all(path)
+            .map_err(|e| anyhow!("Could not create directory {:?}: {}", path, e))?;
+    }
+    Ok(())
+}
+
 pub fn execute_run(
     log_file: PathBuf,
     pid_file: PathBuf,
@@ -275,6 +301,7 @@ pub fn execute_run(
 ) -> Result<()> {
     let log_rx = init_logging_server(log_file)?;
     init_panic_hook();
+    init_paths()?;
 
     log::info!(
         "starting up. pid_file: {:?}, stdin_socket: {:?}, stdout_socket: {:?}, stderr_socket: {:?}",
@@ -297,8 +324,43 @@ pub fn execute_run(
         log::info!("gpui app started, initializing server");
         let session = start_server(listeners, log_rx, cx);
 
+        client::init_settings(cx);
+
         let project = cx.new_model(|cx| {
-            HeadlessProject::new(session, Arc::new(RealFs::new(Default::default(), None)), cx)
+            let fs = Arc::new(RealFs::new(Default::default(), None));
+            let node_settings_rx = initialize_settings(session.clone(), fs.clone(), cx);
+
+            let proxy_url = read_proxy_settings(cx);
+
+            let http_client = Arc::new(
+                ReqwestClient::proxy_and_user_agent(
+                    proxy_url,
+                    &format!(
+                        "Zed-Server/{} ({}; {})",
+                        env!("CARGO_PKG_VERSION"),
+                        std::env::consts::OS,
+                        std::env::consts::ARCH
+                    ),
+                )
+                .expect("Could not start HTTP client"),
+            );
+
+            let node_runtime = NodeRuntime::new(http_client.clone(), node_settings_rx);
+
+            let mut languages = LanguageRegistry::new(cx.background_executor().clone());
+            languages.set_language_server_download_dir(paths::languages_dir().clone());
+            let languages = Arc::new(languages);
+
+            HeadlessProject::new(
+                HeadlessAppState {
+                    session,
+                    fs,
+                    http_client,
+                    node_runtime,
+                    languages,
+                },
+                cx,
+            )
         });
 
         mem::forget(project);
@@ -318,13 +380,15 @@ struct ServerPaths {
 
 impl ServerPaths {
     fn new(identifier: &str) -> Result<Self> {
-        let project_dir = create_state_directory(identifier)?;
+        let server_dir = paths::remote_server_state_dir().join(identifier);
+        std::fs::create_dir_all(&server_dir)?;
+        std::fs::create_dir_all(&logs_dir())?;
 
-        let pid_file = project_dir.join("server.pid");
-        let stdin_socket = project_dir.join("stdin.sock");
-        let stdout_socket = project_dir.join("stdout.sock");
-        let stderr_socket = project_dir.join("stderr.sock");
-        let log_file = project_dir.join("server.log");
+        let pid_file = server_dir.join("server.pid");
+        let stdin_socket = server_dir.join("stdin.sock");
+        let stdout_socket = server_dir.join("stdout.sock");
+        let stderr_socket = server_dir.join("stderr.sock");
+        let log_file = logs_dir().join(format!("server-{}.log", identifier));
 
         Ok(Self {
             pid_file,
@@ -358,7 +422,7 @@ pub fn execute_proxy(identifier: String, is_reconnecting: bool) -> Result<()> {
         }
 
         spawn_server(&server_paths)?;
-    }
+    };
 
     let stdin_task = smol::spawn(async move {
         let stdin = Async::new(std::io::stdin())?;
@@ -409,19 +473,6 @@ pub fn execute_proxy(identifier: String, is_reconnecting: bool) -> Result<()> {
     Ok(())
 }
 
-fn create_state_directory(identifier: &str) -> Result<PathBuf> {
-    let home_dir = env::var("HOME").unwrap_or_else(|_| ".".to_string());
-    let server_dir = PathBuf::from(home_dir)
-        .join(".local")
-        .join("state")
-        .join("zed-remote-server")
-        .join(identifier);
-
-    std::fs::create_dir_all(&server_dir)?;
-
-    Ok(server_dir)
-}
-
 fn kill_running_server(pid: u32, paths: &ServerPaths) -> Result<()> {
     log::info!("killing existing server with PID {}", pid);
     std::process::Command::new("kill")
@@ -453,7 +504,7 @@ fn spawn_server(paths: &ServerPaths) -> Result<()> {
     }
 
     let binary_name = std::env::current_exe()?;
-    let server_process = std::process::Command::new(binary_name)
+    let server_process = smol::process::Command::new(binary_name)
         .arg("run")
         .arg("--log-file")
         .arg(&paths.log_file)
@@ -484,6 +535,7 @@ fn spawn_server(paths: &ServerPaths) -> Result<()> {
         "server ready to accept connections. total time waited: {:?}",
         total_time_waited
     );
+
     Ok(())
 }
 
@@ -556,3 +608,118 @@ async fn write_size_prefixed_buffer<S: AsyncWrite + Unpin>(
     stream.write_all(buffer).await?;
     Ok(())
 }
+
+fn initialize_settings(
+    session: Arc<ChannelClient>,
+    fs: Arc<dyn Fs>,
+    cx: &mut AppContext,
+) -> async_watch::Receiver<Option<NodeBinaryOptions>> {
+    let user_settings_file_rx = watch_config_file(
+        &cx.background_executor(),
+        fs,
+        paths::settings_file().clone(),
+    );
+
+    handle_settings_file_changes(user_settings_file_rx, cx, {
+        let session = session.clone();
+        move |err, _cx| {
+            if let Some(e) = err {
+                log::info!("Server settings failed to change: {}", e);
+
+                session
+                    .send(proto::Toast {
+                        project_id: SSH_PROJECT_ID,
+                        notification_id: "server-settings-failed".to_string(),
+                        message: format!(
+                            "Error in settings on remote host {:?}: {}",
+                            paths::settings_file(),
+                            e
+                        ),
+                    })
+                    .log_err();
+            } else {
+                session
+                    .send(proto::HideToast {
+                        project_id: SSH_PROJECT_ID,
+                        notification_id: "server-settings-failed".to_string(),
+                    })
+                    .log_err();
+            }
+        }
+    });
+
+    let (tx, rx) = async_watch::channel(None);
+    cx.observe_global::<SettingsStore>(move |cx| {
+        let settings = &ProjectSettings::get_global(cx).node;
+        log::info!("Got new node settings: {:?}", settings);
+        let options = NodeBinaryOptions {
+            allow_path_lookup: !settings.ignore_system_version.unwrap_or_default(),
+            // TODO: Implement this setting
+            allow_binary_download: true,
+            use_paths: settings.path.as_ref().map(|node_path| {
+                let node_path = PathBuf::from(shellexpand::tilde(node_path).as_ref());
+                let npm_path = settings
+                    .npm_path
+                    .as_ref()
+                    .map(|path| PathBuf::from(shellexpand::tilde(&path).as_ref()));
+                (
+                    node_path.clone(),
+                    npm_path.unwrap_or_else(|| {
+                        let base_path = PathBuf::new();
+                        node_path.parent().unwrap_or(&base_path).join("npm")
+                    }),
+                )
+            }),
+        };
+        tx.send(Some(options)).log_err();
+    })
+    .detach();
+
+    rx
+}
+
+pub fn handle_settings_file_changes(
+    mut server_settings_file: mpsc::UnboundedReceiver<String>,
+    cx: &mut AppContext,
+    settings_changed: impl Fn(Option<anyhow::Error>, &mut AppContext) + 'static,
+) {
+    let server_settings_content = cx
+        .background_executor()
+        .block(server_settings_file.next())
+        .unwrap();
+    SettingsStore::update_global(cx, |store, cx| {
+        store
+            .set_server_settings(&server_settings_content, cx)
+            .log_err();
+    });
+    cx.spawn(move |cx| async move {
+        while let Some(server_settings_content) = server_settings_file.next().await {
+            let result = cx.update_global(|store: &mut SettingsStore, cx| {
+                let result = store.set_server_settings(&server_settings_content, cx);
+                if let Err(err) = &result {
+                    log::error!("Failed to load server settings: {err}");
+                }
+                settings_changed(result.err(), cx);
+                cx.refresh();
+            });
+            if result.is_err() {
+                break; // App dropped
+            }
+        }
+    })
+    .detach();
+}
+
+fn read_proxy_settings(cx: &mut ModelContext<'_, HeadlessProject>) -> Option<Uri> {
+    let proxy_str = ProxySettings::get_global(cx).proxy.to_owned();
+    let proxy_url = proxy_str
+        .as_ref()
+        .and_then(|input: &String| {
+            input
+                .parse::<Uri>()
+                .inspect_err(|e| log::error!("Error parsing proxy settings: {}", e))
+                .ok()
+        })
+        .or_else(read_proxy_from_env);
+    proxy_url
+}
diff --git a/crates/settings/src/settings.rs b/crates/settings/src/settings.rs
index 1092a9bd4d64ff..40c371d9951ff1 100644
--- a/crates/settings/src/settings.rs
+++ b/crates/settings/src/settings.rs
@@ -88,7 +88,11 @@ pub fn initial_user_settings_content() -> Cow<'static, str> {
     asset_str::<SettingsAssets>("settings/initial_user_settings.json")
 }
 
-pub fn initial_local_settings_content() -> Cow<'static, str> {
+pub fn initial_server_settings_content() -> Cow<'static, str> {
+    asset_str::<SettingsAssets>("settings/initial_server_settings.json")
+}
+
+pub fn initial_project_settings_content() -> Cow<'static, str> {
     asset_str::<SettingsAssets>("settings/initial_local_settings.json")
 }
 
diff --git a/crates/settings/src/settings_store.rs b/crates/settings/src/settings_store.rs
index c8768f007db352..60494a6aee2e9d 100644
--- a/crates/settings/src/settings_store.rs
+++ b/crates/settings/src/settings_store.rs
@@ -110,6 +110,8 @@ pub struct SettingsSources<'a, T> {
     pub user: Option<&'a T>,
     /// The user settings for the current release channel.
     pub release_channel: Option<&'a T>,
+    /// The server's settings.
+    pub server: Option<&'a T>,
     /// The project settings, ordered from least specific to most specific.
     pub project: &'a [&'a T],
 }
@@ -126,6 +128,7 @@ impl<'a, T: Serialize> SettingsSources<'a, T> {
             .into_iter()
             .chain(self.user)
             .chain(self.release_channel)
+            .chain(self.server)
             .chain(self.project.iter().copied())
     }
 
@@ -162,6 +165,7 @@ pub struct SettingsStore {
     setting_values: HashMap<TypeId, Box<dyn AnySettingValue>>,
     raw_default_settings: serde_json::Value,
     raw_user_settings: serde_json::Value,
+    raw_server_settings: Option<serde_json::Value>,
     raw_extension_settings: serde_json::Value,
     raw_local_settings:
         BTreeMap<(WorktreeId, Arc<Path>), HashMap<LocalSettingsKind, serde_json::Value>>,
@@ -219,6 +223,7 @@ impl SettingsStore {
             setting_values: Default::default(),
             raw_default_settings: serde_json::json!({}),
             raw_user_settings: serde_json::json!({}),
+            raw_server_settings: None,
             raw_extension_settings: serde_json::json!({}),
             raw_local_settings: Default::default(),
             tab_size_callback: Default::default(),
@@ -269,6 +274,13 @@ impl SettingsStore {
                     .log_err();
             }
 
+            let server_value = self
+                .raw_server_settings
+                .as_ref()
+                .and_then(|server_setting| {
+                    setting_value.deserialize_setting(server_setting).log_err()
+                });
+
             let extension_value = setting_value
                 .deserialize_setting(&self.raw_extension_settings)
                 .log_err();
@@ -277,9 +289,10 @@ impl SettingsStore {
                 .load_setting(
                     SettingsSources {
                         default: &default_settings,
-                        release_channel: release_channel_value.as_ref(),
                         extensions: extension_value.as_ref(),
                         user: user_value.as_ref(),
+                        release_channel: release_channel_value.as_ref(),
+                        server: server_value.as_ref(),
                         project: &[],
                     },
                     cx,
@@ -522,6 +535,29 @@ impl SettingsStore {
         Ok(())
     }
 
+    pub fn set_server_settings(
+        &mut self,
+        server_settings_content: &str,
+        cx: &mut AppContext,
+    ) -> Result<()> {
+        let settings: Option<serde_json::Value> = if server_settings_content.is_empty() {
+            None
+        } else {
+            parse_json_with_comments(server_settings_content)?
+        };
+
+        anyhow::ensure!(
+            settings
+                .as_ref()
+                .map(|value| value.is_object())
+                .unwrap_or(true),
+            "settings must be an object"
+        );
+        self.raw_server_settings = settings;
+        self.recompute_values(None, cx)?;
+        Ok(())
+    }
+
     /// Add or remove a set of local settings via a JSON string.
     pub fn set_local_settings(
         &mut self,
@@ -530,8 +566,8 @@ impl SettingsStore {
         kind: LocalSettingsKind,
         settings_content: Option<&str>,
         cx: &mut AppContext,
-    ) -> Result<()> {
-        anyhow::ensure!(
+    ) -> std::result::Result<(), InvalidSettingsError> {
+        debug_assert!(
             kind != LocalSettingsKind::Tasks,
             "Attempted to submit tasks into the settings store"
         );
@@ -541,7 +577,13 @@ impl SettingsStore {
             .entry((root_id, directory_path.clone()))
             .or_default();
         let changed = if settings_content.is_some_and(|content| !content.is_empty()) {
-            let new_contents = parse_json_with_comments(settings_content.unwrap())?;
+            let new_contents =
+                parse_json_with_comments(settings_content.unwrap()).map_err(|e| {
+                    InvalidSettingsError::LocalSettings {
+                        path: directory_path.join(local_settings_file_relative_path()),
+                        message: e.to_string(),
+                    }
+                })?;
             if Some(&new_contents) == raw_local_settings.get(&kind) {
                 false
             } else {
@@ -711,12 +753,16 @@ impl SettingsStore {
         &mut self,
         changed_local_path: Option<(WorktreeId, &Path)>,
         cx: &mut AppContext,
-    ) -> Result<()> {
+    ) -> Result<(), InvalidSettingsError> {
         // Reload the global and local values for every setting.
         let mut project_settings_stack = Vec::<DeserializedSetting>::new();
         let mut paths_stack = Vec::<Option<(WorktreeId, &Path)>>::new();
         for setting_value in self.setting_values.values_mut() {
-            let default_settings = setting_value.deserialize_setting(&self.raw_default_settings)?;
+            let default_settings = setting_value
+                .deserialize_setting(&self.raw_default_settings)
+                .map_err(|e| InvalidSettingsError::DefaultSettings {
+                    message: e.to_string(),
+                })?;
 
             let extension_settings = setting_value
                 .deserialize_setting(&self.raw_extension_settings)
@@ -725,12 +771,17 @@ impl SettingsStore {
             let user_settings = match setting_value.deserialize_setting(&self.raw_user_settings) {
                 Ok(settings) => Some(settings),
                 Err(error) => {
-                    return Err(anyhow!(InvalidSettingsError::UserSettings {
-                        message: error.to_string()
-                    }));
+                    return Err(InvalidSettingsError::UserSettings {
+                        message: error.to_string(),
+                    });
                 }
             };
 
+            let server_settings = self
+                .raw_server_settings
+                .as_ref()
+                .and_then(|setting| setting_value.deserialize_setting(setting).log_err());
+
             let mut release_channel_settings = None;
             if let Some(release_settings) = &self
                 .raw_user_settings
@@ -753,6 +804,7 @@ impl SettingsStore {
                             extensions: extension_settings.as_ref(),
                             user: user_settings.as_ref(),
                             release_channel: release_channel_settings.as_ref(),
+                            server: server_settings.as_ref(),
                             project: &[],
                         },
                         cx,
@@ -804,6 +856,7 @@ impl SettingsStore {
                                         extensions: extension_settings.as_ref(),
                                         user: user_settings.as_ref(),
                                         release_channel: release_channel_settings.as_ref(),
+                                        server: server_settings.as_ref(),
                                         project: &project_settings_stack.iter().collect::<Vec<_>>(),
                                     },
                                     cx,
@@ -818,10 +871,10 @@ impl SettingsStore {
                             }
                         }
                         Err(error) => {
-                            return Err(anyhow!(InvalidSettingsError::LocalSettings {
+                            return Err(InvalidSettingsError::LocalSettings {
                                 path: directory_path.join(local_settings_file_relative_path()),
-                                message: error.to_string()
-                            }));
+                                message: error.to_string(),
+                            });
                         }
                     }
                 }
@@ -835,13 +888,17 @@ impl SettingsStore {
 pub enum InvalidSettingsError {
     LocalSettings { path: PathBuf, message: String },
     UserSettings { message: String },
+    ServerSettings { message: String },
+    DefaultSettings { message: String },
 }
 
 impl std::fmt::Display for InvalidSettingsError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             InvalidSettingsError::LocalSettings { message, .. }
-            | InvalidSettingsError::UserSettings { message } => {
+            | InvalidSettingsError::UserSettings { message }
+            | InvalidSettingsError::ServerSettings { message }
+            | InvalidSettingsError::DefaultSettings { message } => {
                 write!(f, "{}", message)
             }
         }
@@ -893,6 +950,9 @@ impl<T: Settings> AnySettingValue for SettingValue<T> {
                 release_channel: values
                     .release_channel
                     .map(|value| value.0.downcast_ref::<T::FileContent>().unwrap()),
+                server: values
+                    .server
+                    .map(|value| value.0.downcast_ref::<T::FileContent>().unwrap()),
                 project: values
                     .project
                     .iter()
diff --git a/crates/theme/src/settings.rs b/crates/theme/src/settings.rs
index e4be957a1b0553..49f7ba3c836766 100644
--- a/crates/theme/src/settings.rs
+++ b/crates/theme/src/settings.rs
@@ -636,7 +636,12 @@ impl settings::Settings for ThemeSettings {
             unnecessary_code_fade: defaults.unnecessary_code_fade.unwrap_or(0.0),
         };
 
-        for value in sources.user.into_iter().chain(sources.release_channel) {
+        for value in sources
+            .user
+            .into_iter()
+            .chain(sources.release_channel)
+            .chain(sources.server)
+        {
             if let Some(value) = value.ui_density {
                 this.ui_density = value;
             }
diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs
index 024379e6acf28b..86a52aca255e53 100644
--- a/crates/vim/src/vim.rs
+++ b/crates/vim/src/vim.rs
@@ -1080,9 +1080,14 @@ impl Settings for VimModeSetting {
     type FileContent = Option<bool>;
 
     fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
-        Ok(Self(sources.user.copied().flatten().unwrap_or(
-            sources.default.ok_or_else(Self::missing_default)?,
-        )))
+        Ok(Self(
+            sources
+                .user
+                .or(sources.server)
+                .copied()
+                .flatten()
+                .unwrap_or(sources.default.ok_or_else(Self::missing_default)?),
+        ))
     }
 }
 
diff --git a/crates/welcome/src/base_keymap_setting.rs b/crates/welcome/src/base_keymap_setting.rs
index 1b52bbc9f94fbd..d212dd41703c89 100644
--- a/crates/welcome/src/base_keymap_setting.rs
+++ b/crates/welcome/src/base_keymap_setting.rs
@@ -96,6 +96,9 @@ impl Settings for BaseKeymap {
         if let Some(Some(user_value)) = sources.user.copied() {
             return Ok(user_value);
         }
+        if let Some(Some(server_value)) = sources.server.copied() {
+            return Ok(server_value);
+        }
         sources.default.ok_or_else(Self::missing_default)
     }
 }
diff --git a/crates/workspace/src/notifications.rs b/crates/workspace/src/notifications.rs
index ffab276dd1aedb..eee3d16a4ab336 100644
--- a/crates/workspace/src/notifications.rs
+++ b/crates/workspace/src/notifications.rs
@@ -16,30 +16,27 @@ pub fn init(cx: &mut AppContext) {
 }
 
 #[derive(Debug, PartialEq, Clone)]
-pub struct NotificationId {
-    /// A [`TypeId`] used to uniquely identify this notification.
-    type_id: TypeId,
-    /// A supplementary ID used to distinguish between multiple
-    /// notifications that have the same [`type_id`](Self::type_id);
-    id: Option<ElementId>,
+pub enum NotificationId {
+    Unique(TypeId),
+    Composite(TypeId, ElementId),
+    Named(SharedString),
 }
 
 impl NotificationId {
     /// Returns a unique [`NotificationId`] for the given type.
     pub fn unique<T: 'static>() -> Self {
-        Self {
-            type_id: TypeId::of::<T>(),
-            id: None,
-        }
+        Self::Unique(TypeId::of::<T>())
     }
 
     /// Returns a [`NotificationId`] for the given type that is also identified
     /// by the provided ID.
-    pub fn identified<T: 'static>(id: impl Into<ElementId>) -> Self {
-        Self {
-            type_id: TypeId::of::<T>(),
-            id: Some(id.into()),
-        }
+    pub fn composite<T: 'static>(id: impl Into<ElementId>) -> Self {
+        Self::Composite(TypeId::of::<T>(), id.into())
+    }
+
+    /// Builds a `NotificationId` out of the given string.
+    pub fn named(id: SharedString) -> Self {
+        Self::Named(id)
     }
 }
 
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 3c3b26b4c137d2..ec4079ba9f8af3 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -65,7 +65,7 @@ use release_channel::ReleaseChannel;
 use remote::{SshClientDelegate, SshConnectionOptions};
 use serde::Deserialize;
 use session::AppSession;
-use settings::{InvalidSettingsError, Settings};
+use settings::Settings;
 use shared_screen::SharedScreen;
 use sqlez::{
     bindable::{Bind, Column, StaticColumnCount},
@@ -839,31 +839,17 @@ impl Workspace {
                     }
                 }
 
-                project::Event::LocalSettingsUpdated(result) => {
-                    struct LocalSettingsUpdated;
-                    let id = NotificationId::unique::<LocalSettingsUpdated>();
-
-                    match result {
-                        Err(InvalidSettingsError::LocalSettings { message, path }) => {
-                            let full_message =
-                                format!("Failed to set local settings in {:?}:\n{}", path, message);
-                            this.show_notification(id, cx, |cx| {
-                                cx.new_view(|_| MessageNotification::new(full_message.clone()))
-                            })
-                        }
-                        Err(_) => {}
-                        Ok(_) => this.dismiss_notification(&id, cx),
-                    }
-                }
-
-                project::Event::Notification(message) => {
-                    struct ProjectNotification;
+                project::Event::Toast {
+                    notification_id,
+                    message,
+                } => this.show_notification(
+                    NotificationId::named(notification_id.clone()),
+                    cx,
+                    |cx| cx.new_view(|_| MessageNotification::new(message.clone())),
+                ),
 
-                    this.show_notification(
-                        NotificationId::unique::<ProjectNotification>(),
-                        cx,
-                        |cx| cx.new_view(|_| MessageNotification::new(message.clone())),
-                    )
+                project::Event::HideToast { notification_id } => {
+                    this.dismiss_notification(&NotificationId::named(notification_id.clone()), cx)
                 }
 
                 project::Event::LanguageServerPrompt(request) => {
@@ -874,7 +860,7 @@ impl Workspace {
                     let id = hasher.finish();
 
                     this.show_notification(
-                        NotificationId::identified::<LanguageServerPrompt>(id as usize),
+                        NotificationId::composite::<LanguageServerPrompt>(id as usize),
                         cx,
                         |cx| {
                             cx.new_view(|_| {
@@ -1808,6 +1794,7 @@ impl Workspace {
             .flat_map(|pane| {
                 pane.read(cx).items().filter_map(|item| {
                     if item.is_dirty(cx) {
+                        item.tab_description(0, cx);
                         Some((pane.downgrade(), item.boxed_clone()))
                     } else {
                         None
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index f5bc3a1847c6d5..c33cef4a4b2555 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -27,13 +27,14 @@ use anyhow::Context as _;
 use assets::Assets;
 use futures::{channel::mpsc, select_biased, StreamExt};
 use outline_panel::OutlinePanel;
+use project::Item;
 use project_panel::ProjectPanel;
 use quick_action_bar::QuickActionBar;
 use release_channel::{AppCommitSha, ReleaseChannel};
 use rope::Rope;
 use search::project_search::ProjectSearchBar;
 use settings::{
-    initial_local_settings_content, initial_tasks_content, KeymapFile, Settings, SettingsStore,
+    initial_project_settings_content, initial_tasks_content, KeymapFile, Settings, SettingsStore,
     DEFAULT_KEYMAP_PATH,
 };
 use std::any::TypeId;
@@ -53,7 +54,9 @@ use workspace::{
     open_new, AppState, NewFile, NewWindow, OpenLog, Toast, Workspace, WorkspaceSettings,
 };
 use workspace::{notifications::DetachAndPromptErr, Pane};
-use zed_actions::{OpenAccountSettings, OpenBrowser, OpenSettings, OpenZedUrl, Quit};
+use zed_actions::{
+    OpenAccountSettings, OpenBrowser, OpenServerSettings, OpenSettings, OpenZedUrl, Quit,
+};
 
 actions!(
     zed,
@@ -64,8 +67,8 @@ actions!(
         Minimize,
         OpenDefaultKeymap,
         OpenDefaultSettings,
-        OpenLocalSettings,
-        OpenLocalTasks,
+        OpenProjectSettings,
+        OpenProjectTasks,
         OpenTasks,
         ResetDatabase,
         ShowAll,
@@ -218,6 +221,7 @@ pub fn initialize_workspace(
 
         let handle = cx.view().downgrade();
         cx.on_window_should_close(move |cx| {
+
             handle
                 .update(cx, |workspace, cx| {
                     // We'll handle closing asynchronously
@@ -428,8 +432,8 @@ pub fn initialize_workspace(
                     );
                 },
             )
-            .register_action(open_local_settings_file)
-            .register_action(open_local_tasks_file)
+            .register_action(open_project_settings_file)
+            .register_action(open_project_tasks_file)
             .register_action(
                 move |workspace: &mut Workspace,
                       _: &OpenDefaultKeymap,
@@ -521,6 +525,25 @@ pub fn initialize_workspace(
                     }
                 }
             });
+        if workspace.project().read(cx).is_via_ssh() {
+            workspace.register_action({
+                move |workspace, _: &OpenServerSettings, cx| {
+                    let open_server_settings = workspace.project().update(cx, |project, cx| {
+                        project.open_server_settings(cx)
+                    });
+
+                    cx.spawn(|workspace, mut cx| async move {
+                        let buffer = open_server_settings.await?;
+
+                        workspace.update(&mut cx, |workspace, cx| {
+                            workspace.open_path(buffer.read(cx).project_path(cx).expect("Settings file must have a location"), None, true, cx)
+                        })?.await?;
+
+                        anyhow::Ok(())
+                    }).detach_and_log_err(cx);
+                }
+            });
+        }
 
         workspace.focus_handle(cx).focus(cx);
     })
@@ -813,22 +836,22 @@ pub fn load_default_keymap(cx: &mut AppContext) {
     }
 }
 
-fn open_local_settings_file(
+fn open_project_settings_file(
     workspace: &mut Workspace,
-    _: &OpenLocalSettings,
+    _: &OpenProjectSettings,
     cx: &mut ViewContext<Workspace>,
 ) {
     open_local_file(
         workspace,
         local_settings_file_relative_path(),
-        initial_local_settings_content(),
+        initial_project_settings_content(),
         cx,
     )
 }
 
-fn open_local_tasks_file(
+fn open_project_tasks_file(
     workspace: &mut Workspace,
-    _: &OpenLocalTasks,
+    _: &OpenProjectTasks,
     cx: &mut ViewContext<Workspace>,
 ) {
     open_local_file(
diff --git a/crates/zed/src/zed/app_menus.rs b/crates/zed/src/zed/app_menus.rs
index 2995595589d9c3..52e0eab3e3560a 100644
--- a/crates/zed/src/zed/app_menus.rs
+++ b/crates/zed/src/zed/app_menus.rs
@@ -19,7 +19,7 @@ pub fn app_menus() -> Vec<Menu> {
                         MenuItem::action("Open Key Bindings", zed_actions::OpenKeymap),
                         MenuItem::action("Open Default Settings", super::OpenDefaultSettings),
                         MenuItem::action("Open Default Key Bindings", super::OpenDefaultKeymap),
-                        MenuItem::action("Open Local Settings", super::OpenLocalSettings),
+                        MenuItem::action("Open Project Settings", super::OpenProjectSettings),
                         MenuItem::action("Select Theme...", theme_selector::Toggle::default()),
                     ],
                 }),
diff --git a/crates/zed_actions/src/lib.rs b/crates/zed_actions/src/lib.rs
index 4bd4796091b988..cedacb6d8495c8 100644
--- a/crates/zed_actions/src/lib.rs
+++ b/crates/zed_actions/src/lib.rs
@@ -27,6 +27,7 @@ actions!(
     [
         OpenSettings,
         OpenAccountSettings,
+        OpenServerSettings,
         Quit,
         OpenKeymap,
         About,
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 121e63c233e508..37d86e6481978f 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -15,7 +15,7 @@ TBD: Add settings documentation about how settings are merged as overlays. E.g.
 
 Your settings file can be opened with {#kb zed::OpenSettings}. By default it is located at `~/.config/zed/settings.json`, though if you have XDG_CONFIG_HOME in your environment on Linux it will be at `$XDG_CONFIG_HOME/zed/settings.json` instead.
 
-This configuration is merged with any local configuration inside your projects. You can open the project settings by running {#action zed::OpenLocalSettings} from the command palette. This will create a `.zed` directory containing`.zed/settings.json`.
+This configuration is merged with any local configuration inside your projects. You can open the project settings by running {#action zed::OpenProjectSettings} from the command palette. This will create a `.zed` directory containing`.zed/settings.json`.
 
 Although most projects will only need one settings file at the root, you can add more local settings files for subdirectories as needed. Not all settings can be set in local files, just those that impact the behavior of the editor and language tooling. For example you can set `tab_size`, `formatter` etc. but not `theme`, `vim_mode` and similar.
 

From a56f946a7d0734839f820d2943dabe7fa09a4b22 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 16 Oct 2024 10:06:45 +0300
Subject: [PATCH 670/762] Force astro-language-server to be the primary one for
 Astro (#19266)

Part of https://github.com/zed-industries/zed/issues/19239

Overall, this hardcoding approach has to stop and Zed better show some
notification/modal that proposes to select a primary language server,
when launching with the language that has no such settings.

Release Notes:

- Fixed Astro LSP interactions
---
 assets/settings/default.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index f16b37ba59bae9..4bde5ee174f782 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -824,6 +824,7 @@
   // Different settings for specific languages.
   "languages": {
     "Astro": {
+      "language_servers": ["astro-language-server", "..."],
       "prettier": {
         "allowed": true,
         "plugins": ["prettier-plugin-astro"]

From a77ec94cbcae5cb8d7e698323e19a0bbe95b7445 Mon Sep 17 00:00:00 2001
From: Axel Carlsson <93656815+axelcarl@users.noreply.github.com>
Date: Wed, 16 Oct 2024 12:11:17 +0200
Subject: [PATCH 671/762] vim: Add support for insert button (#19245)

This commit adds support for using the physical insert-button. First
click toggles insert mode and subsequent clicks toggle back and forth
between replace and insert mode.

Closes #19224

Release Notes:

- Added support for using the insert button for vim_mode.
---
 assets/keymaps/vim.json | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index fc3adcc95e24ca..8b2a728df3fccf 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -256,6 +256,7 @@
       "@": ["vim::PushOperator", "ReplayRegister"],
       "ctrl-pagedown": "pane::ActivateNextItem",
       "ctrl-pageup": "pane::ActivatePrevItem",
+      "insert": "vim::InsertBefore",
       // tree-sitter related commands
       "[ x": "editor::SelectLargerSyntaxNode",
       "] x": "editor::SelectSmallerSyntaxNode",
@@ -338,7 +339,8 @@
       "ctrl-t": "vim::Indent",
       "ctrl-d": "vim::Outdent",
       "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
-      "ctrl-r": ["vim::PushOperator", "Register"]
+      "ctrl-r": ["vim::PushOperator", "Register"],
+      "insert": "vim::ToggleReplace"
     }
   },
   {
@@ -357,7 +359,8 @@
       "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
       "backspace": "vim::UndoReplace",
       "tab": "vim::Tab",
-      "enter": "vim::Enter"
+      "enter": "vim::Enter",
+      "insert": "vim::InsertBefore"
     }
   },
   {

From 128619899ed498242030a256851202c7d4d5b743 Mon Sep 17 00:00:00 2001
From: Stanislav Alekseev <43210583+WeetHet@users.noreply.github.com>
Date: Wed, 16 Oct 2024 13:14:40 +0300
Subject: [PATCH 672/762] Environment loading fixes (#19144)

Closes #19040
Addresses the problem with annoying error messages on windows (see
comment from SomeoneToIgnore on #18567)

Release Notes:

- Fixed the bug where language servers from PATH would sometimes be
prioritised over the ones from `direnv`
- Stopped running environment loading on windows as it didn't work
anyways due to `SHELL` not being set
---
 crates/project/src/direnv.rs      | 10 +++++---
 crates/project/src/environment.rs | 42 ++++++++++++++++++++-----------
 2 files changed, 35 insertions(+), 17 deletions(-)

diff --git a/crates/project/src/direnv.rs b/crates/project/src/direnv.rs
index 682cb4b6090f56..10a05218a92f56 100644
--- a/crates/project/src/direnv.rs
+++ b/crates/project/src/direnv.rs
@@ -1,7 +1,7 @@
 use crate::environment::EnvironmentErrorMessage;
 use std::process::ExitStatus;
 
-#[cfg(not(any(test, feature = "test-support")))]
+#[cfg(not(any(target_os = "windows", test, feature = "test-support")))]
 use {collections::HashMap, std::path::Path, util::ResultExt};
 
 #[derive(Clone)]
@@ -30,14 +30,18 @@ impl From<DirenvError> for Option<EnvironmentErrorMessage> {
     }
 }
 
-#[cfg(not(any(test, feature = "test-support")))]
-pub async fn load_direnv_environment(dir: &Path) -> Result<HashMap<String, String>, DirenvError> {
+#[cfg(not(any(target_os = "windows", test, feature = "test-support")))]
+pub async fn load_direnv_environment(
+    env: &HashMap<String, String>,
+    dir: &Path,
+) -> Result<HashMap<String, String>, DirenvError> {
     let Ok(direnv_path) = which::which("direnv") else {
         return Err(DirenvError::NotFound);
     };
 
     let Some(direnv_output) = smol::process::Command::new(direnv_path)
         .args(["export", "json"])
+        .envs(env)
         .env("TERM", "dumb")
         .current_dir(dir)
         .output()
diff --git a/crates/project/src/environment.rs b/crates/project/src/environment.rs
index b7aa20a740a67a..69aba235a77299 100644
--- a/crates/project/src/environment.rs
+++ b/crates/project/src/environment.rs
@@ -208,7 +208,19 @@ async fn load_shell_environment(
     (Some(fake_env), None)
 }
 
-#[cfg(not(any(test, feature = "test-support")))]
+#[cfg(all(target_os = "windows", not(any(test, feature = "test-support"))))]
+async fn load_shell_environment(
+    _dir: &Path,
+    _load_direnv: &DirenvSettings,
+) -> (
+    Option<HashMap<String, String>>,
+    Option<EnvironmentErrorMessage>,
+) {
+    // TODO the current code works with Unix $SHELL only, implement environment loading on windows
+    (None, None)
+}
+
+#[cfg(not(any(target_os = "windows", test, feature = "test-support")))]
 async fn load_shell_environment(
     dir: &Path,
     load_direnv: &DirenvSettings,
@@ -225,18 +237,6 @@ async fn load_shell_environment(
         (None, Some(message))
     }
 
-    let (direnv_environment, direnv_error) = match load_direnv {
-        DirenvSettings::ShellHook => (None, None),
-        DirenvSettings::Direct => match load_direnv_environment(dir).await {
-            Ok(env) => (Some(env), None),
-            Err(err) => (
-                None,
-                <Option<EnvironmentErrorMessage> as From<DirenvError>>::from(err),
-            ),
-        },
-    };
-    let direnv_environment = direnv_environment.unwrap_or(HashMap::default());
-
     let marker = "ZED_SHELL_START";
     let Some(shell) = std::env::var("SHELL").log_err() else {
         return message("Failed to get login environment. SHELL environment variable is not set");
@@ -279,7 +279,6 @@ async fn load_shell_environment(
 
     let Some(output) = smol::process::Command::new(&shell)
         .args(["-l", "-i", "-c", &command])
-        .envs(direnv_environment)
         .output()
         .await
         .log_err()
@@ -305,5 +304,20 @@ async fn load_shell_environment(
         parsed_env.insert(key, value);
     });
 
+    let (direnv_environment, direnv_error) = match load_direnv {
+        DirenvSettings::ShellHook => (None, None),
+        DirenvSettings::Direct => match load_direnv_environment(&parsed_env, dir).await {
+            Ok(env) => (Some(env), None),
+            Err(err) => (
+                None,
+                <Option<EnvironmentErrorMessage> as From<DirenvError>>::from(err),
+            ),
+        },
+    };
+
+    for (key, value) in direnv_environment.unwrap_or(HashMap::default()) {
+        parsed_env.insert(key, value);
+    }
+
     (Some(parsed_env), direnv_error)
 }

From eddf70b5c429636f8561814ac4b29922c81bd8ae Mon Sep 17 00:00:00 2001
From: Stanislav Alekseev <43210583+WeetHet@users.noreply.github.com>
Date: Wed, 16 Oct 2024 13:41:01 +0300
Subject: [PATCH 673/762] Revert "lsp: Do not notify all language servers on
 file save" (#19183)

Reverts zed-industries/zed#17756. According to the existing
implementations of the LSP specification, namely
[Helix](https://github.com/helix-editor/helix/blob/a7651f5bf027ec98645d571ab05a685d97e1b772/helix-view/src/document.rs#L1038)
and, if I'm not wrong,
[VSCode](https://github.com/microsoft/vscode-languageserver-node/blob/main/client/src/common/textSynchronization.ts#L580),
`textDocument/didSave` has nothing to do with the watched files and
should be sent to the language servers connected to the buffers even if
the files are not watched by those. As the LSP spec doesn't say anything
about `didSave` being related to the watched files, and the reference
implementation in VSCode seemingly does not filter the notifications
according to those, it seems like this is an incorrect interpretation of
the specification

This also causes issues with language servers. See [Metals
issue](https://github.com/scalameta/metals-zed/issues/28#issuecomment-2410393150)
for example

Closes #18636

Release Notes:

- N/A
---
 crates/project/src/lsp_store.rs     | 16 ---------
 crates/project/src/project_tests.rs | 55 +++++------------------------
 2 files changed, 8 insertions(+), 63 deletions(-)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 6b0042638dc7a1..8c4fb1f349b47f 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -2900,27 +2900,11 @@ impl LspStore {
         let file = File::from_dyn(buffer.read(cx).file())?;
         let worktree_id = file.worktree_id(cx);
         let abs_path = file.as_local()?.abs_path(cx);
-        let worktree_path = file.as_local()?.path();
         let text_document = lsp::TextDocumentIdentifier {
             uri: lsp::Url::from_file_path(abs_path).log_err()?,
         };
 
-        let watched_paths_for_server = &self.as_local()?.language_server_watched_paths;
         for server in self.language_servers_for_worktree(worktree_id) {
-            let should_notify = maybe!({
-                Some(
-                    watched_paths_for_server
-                        .get(&server.server_id())?
-                        .read(cx)
-                        .worktree_paths
-                        .get(&worktree_id)?
-                        .is_match(worktree_path),
-                )
-            })
-            .unwrap_or_default();
-            if !should_notify {
-                continue;
-            }
             if let Some(include_text) = include_text(server.as_ref()) {
                 let text = if include_text {
                     Some(buffer.read(cx).text())
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index 17eeae1c3dac93..8795af4cb44bd5 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -385,34 +385,6 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {
 
     // A server is started up, and it is notified about Rust files.
     let mut fake_rust_server = fake_rust_servers.next().await.unwrap();
-    fake_rust_server
-        .request::<lsp::request::RegisterCapability>(lsp::RegistrationParams {
-            registrations: vec![lsp::Registration {
-                id: Default::default(),
-                method: "workspace/didChangeWatchedFiles".to_string(),
-                register_options: serde_json::to_value(
-                    lsp::DidChangeWatchedFilesRegistrationOptions {
-                        watchers: vec![
-                            lsp::FileSystemWatcher {
-                                glob_pattern: lsp::GlobPattern::String(
-                                    "/the-root/Cargo.toml".to_string(),
-                                ),
-                                kind: None,
-                            },
-                            lsp::FileSystemWatcher {
-                                glob_pattern: lsp::GlobPattern::String(
-                                    "/the-root/*.rs".to_string(),
-                                ),
-                                kind: None,
-                            },
-                        ],
-                    },
-                )
-                .ok(),
-            }],
-        })
-        .await
-        .unwrap();
     assert_eq!(
         fake_rust_server
             .receive_notification::<lsp::notification::DidOpenTextDocument>()
@@ -460,24 +432,6 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {
 
     // A json language server is started up and is only notified about the json buffer.
     let mut fake_json_server = fake_json_servers.next().await.unwrap();
-    fake_json_server
-        .request::<lsp::request::RegisterCapability>(lsp::RegistrationParams {
-            registrations: vec![lsp::Registration {
-                id: Default::default(),
-                method: "workspace/didChangeWatchedFiles".to_string(),
-                register_options: serde_json::to_value(
-                    lsp::DidChangeWatchedFilesRegistrationOptions {
-                        watchers: vec![lsp::FileSystemWatcher {
-                            glob_pattern: lsp::GlobPattern::String("/the-root/*.json".to_string()),
-                            kind: None,
-                        }],
-                    },
-                )
-                .ok(),
-            }],
-        })
-        .await
-        .unwrap();
     assert_eq!(
         fake_json_server
             .receive_notification::<lsp::notification::DidOpenTextDocument>()
@@ -528,7 +482,7 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {
         )
     );
 
-    // Save notifications are reported only to servers that signed up for a given extension.
+    // Save notifications are reported to all servers.
     project
         .update(cx, |project, cx| project.save_buffer(toml_buffer, cx))
         .await
@@ -540,6 +494,13 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {
             .text_document,
         lsp::TextDocumentIdentifier::new(lsp::Url::from_file_path("/the-root/Cargo.toml").unwrap())
     );
+    assert_eq!(
+        fake_json_server
+            .receive_notification::<lsp::notification::DidSaveTextDocument>()
+            .await
+            .text_document,
+        lsp::TextDocumentIdentifier::new(lsp::Url::from_file_path("/the-root/Cargo.toml").unwrap())
+    );
 
     // Renames are reported only to servers matching the buffer's language.
     fs.rename(

From 109ebc5f27001071ecd38491f65f3a69e0686d2d Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Wed, 16 Oct 2024 13:57:28 +0200
Subject: [PATCH 674/762] ui: Add Scrollbar component (#18927)

Closes #ISSUE

Release Notes:

- N/A
---
 crates/gpui/src/elements/div.rs           |   5 +
 crates/project_panel/src/project_panel.rs | 114 ++-----
 crates/project_panel/src/scrollbar.rs     | 277 ---------------
 crates/recent_projects/src/dev_servers.rs | 128 ++++---
 crates/ui/src/components.rs               |   2 +
 crates/ui/src/components/scrollbar.rs     | 396 ++++++++++++++++++++++
 6 files changed, 513 insertions(+), 409 deletions(-)
 delete mode 100644 crates/project_panel/src/scrollbar.rs
 create mode 100644 crates/ui/src/components/scrollbar.rs

diff --git a/crates/gpui/src/elements/div.rs b/crates/gpui/src/elements/div.rs
index d24c5d25da9881..6c3b577e4c5770 100644
--- a/crates/gpui/src/elements/div.rs
+++ b/crates/gpui/src/elements/div.rs
@@ -2575,4 +2575,9 @@ impl ScrollHandle {
     pub fn set_logical_scroll_top(&self, ix: usize, px: Pixels) {
         self.0.borrow_mut().requested_scroll_top = Some((ix, px));
     }
+
+    /// Get the count of children for scrollable item.
+    pub fn children_count(&self) -> usize {
+        self.0.borrow().child_bounds.len()
+    }
 }
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 08a0ef4b4060b4..121238b7d3dd02 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -1,8 +1,8 @@
 mod project_panel_settings;
-mod scrollbar;
+
 use client::{ErrorCode, ErrorExt};
-use scrollbar::ProjectPanelScrollbar;
 use settings::{Settings, SettingsStore};
+use ui::{Scrollbar, ScrollbarState};
 
 use db::kvp::KEY_VALUE_STORE;
 use editor::{
@@ -14,16 +14,14 @@ use file_icons::FileIcons;
 
 use anyhow::{anyhow, Context as _, Result};
 use collections::{hash_map, BTreeSet, HashMap};
-use core::f32;
 use git::repository::GitFileStatus;
 use gpui::{
     actions, anchored, deferred, div, impl_actions, px, uniform_list, Action, AnyElement,
     AppContext, AssetSource, AsyncWindowContext, ClipboardItem, DismissEvent, Div, DragMoveEvent,
-    Entity, EventEmitter, ExternalPaths, FocusHandle, FocusableView, InteractiveElement,
-    KeyContext, ListHorizontalSizingBehavior, ListSizingBehavior, Model, MouseButton,
-    MouseDownEvent, ParentElement, Pixels, Point, PromptLevel, Render, Stateful, Styled,
-    Subscription, Task, UniformListScrollHandle, View, ViewContext, VisualContext as _, WeakView,
-    WindowContext,
+    EventEmitter, ExternalPaths, FocusHandle, FocusableView, InteractiveElement, KeyContext,
+    ListHorizontalSizingBehavior, ListSizingBehavior, Model, MouseButton, MouseDownEvent,
+    ParentElement, Pixels, Point, PromptLevel, Render, Stateful, Styled, Subscription, Task,
+    UniformListScrollHandle, View, ViewContext, VisualContext as _, WeakView, WindowContext,
 };
 use indexmap::IndexMap;
 use menu::{Confirm, SelectFirst, SelectLast, SelectNext, SelectPrev};
@@ -34,12 +32,11 @@ use project::{
 use project_panel_settings::{ProjectPanelDockPosition, ProjectPanelSettings};
 use serde::{Deserialize, Serialize};
 use std::{
-    cell::{Cell, OnceCell},
+    cell::OnceCell,
     collections::HashSet,
     ffi::OsStr,
     ops::Range,
     path::{Path, PathBuf},
-    rc::Rc,
     sync::Arc,
     time::Duration,
 };
@@ -59,8 +56,8 @@ const NEW_ENTRY_ID: ProjectEntryId = ProjectEntryId::MAX;
 pub struct ProjectPanel {
     project: Model<Project>,
     fs: Arc<dyn Fs>,
-    scroll_handle: UniformListScrollHandle,
     focus_handle: FocusHandle,
+    scroll_handle: UniformListScrollHandle,
     visible_entries: Vec<(WorktreeId, Vec<Entry>, OnceCell<HashSet<Arc<Path>>>)>,
     /// Maps from leaf project entry ID to the currently selected ancestor.
     /// Relevant only for auto-fold dirs, where a single project panel entry may actually consist of several
@@ -82,8 +79,8 @@ pub struct ProjectPanel {
     width: Option<Pixels>,
     pending_serialization: Task<Option<()>>,
     show_scrollbar: bool,
-    vertical_scrollbar_drag_thumb_offset: Rc<Cell<Option<f32>>>,
-    horizontal_scrollbar_drag_thumb_offset: Rc<Cell<Option<f32>>>,
+    vertical_scrollbar_state: ScrollbarState,
+    horizontal_scrollbar_state: ScrollbarState,
     hide_scrollbar_task: Option<Task<()>>,
     max_width_item_index: Option<usize>,
 }
@@ -297,10 +294,10 @@ impl ProjectPanel {
             })
             .detach();
 
+            let scroll_handle = UniformListScrollHandle::new();
             let mut this = Self {
                 project: project.clone(),
                 fs: workspace.app_state().fs.clone(),
-                scroll_handle: UniformListScrollHandle::new(),
                 focus_handle,
                 visible_entries: Default::default(),
                 ancestors: Default::default(),
@@ -320,9 +317,12 @@ impl ProjectPanel {
                 pending_serialization: Task::ready(None),
                 show_scrollbar: !Self::should_autohide_scrollbar(cx),
                 hide_scrollbar_task: None,
-                vertical_scrollbar_drag_thumb_offset: Default::default(),
-                horizontal_scrollbar_drag_thumb_offset: Default::default(),
+                vertical_scrollbar_state: ScrollbarState::new(scroll_handle.clone())
+                    .parent_view(cx.view()),
+                horizontal_scrollbar_state: ScrollbarState::new(scroll_handle.clone())
+                    .parent_view(cx.view()),
                 max_width_item_index: None,
+                scroll_handle,
             };
             this.update_visible_entries(None, cx);
 
@@ -2606,37 +2606,11 @@ impl ProjectPanel {
     }
 
     fn render_vertical_scrollbar(&self, cx: &mut ViewContext<Self>) -> Option<Stateful<Div>> {
-        if !Self::should_show_scrollbar(cx) {
-            return None;
-        }
-        let scroll_handle = self.scroll_handle.0.borrow();
-        let total_list_length = scroll_handle
-            .last_item_size
-            .filter(|_| {
-                self.show_scrollbar || self.vertical_scrollbar_drag_thumb_offset.get().is_some()
-            })?
-            .contents
-            .height
-            .0 as f64;
-        let current_offset = scroll_handle.base_handle.offset().y.0.min(0.).abs() as f64;
-        let mut percentage = current_offset / total_list_length;
-        let end_offset = (current_offset + scroll_handle.base_handle.bounds().size.height.0 as f64)
-            / total_list_length;
-        // Uniform scroll handle might briefly report an offset greater than the length of a list;
-        // in such case we'll adjust the starting offset as well to keep the scrollbar thumb length stable.
-        let overshoot = (end_offset - 1.).clamp(0., 1.);
-        if overshoot > 0. {
-            percentage -= overshoot;
-        }
-        const MINIMUM_SCROLLBAR_PERCENTAGE_HEIGHT: f64 = 0.005;
-        if percentage + MINIMUM_SCROLLBAR_PERCENTAGE_HEIGHT > 1.0 || end_offset > total_list_length
+        if !Self::should_show_scrollbar(cx)
+            || !(self.show_scrollbar || self.vertical_scrollbar_state.is_dragging())
         {
             return None;
         }
-        if total_list_length < scroll_handle.base_handle.bounds().size.height.0 as f64 {
-            return None;
-        }
-        let end_offset = end_offset.clamp(percentage + MINIMUM_SCROLLBAR_PERCENTAGE_HEIGHT, 1.);
         Some(
             div()
                 .occlude()
@@ -2654,7 +2628,7 @@ impl ProjectPanel {
                 .on_mouse_up(
                     MouseButton::Left,
                     cx.listener(|this, _, cx| {
-                        if this.vertical_scrollbar_drag_thumb_offset.get().is_none()
+                        if !this.vertical_scrollbar_state.is_dragging()
                             && !this.focus_handle.contains_focused(cx)
                         {
                             this.hide_scrollbar(cx);
@@ -2674,48 +2648,20 @@ impl ProjectPanel {
                 .bottom_1()
                 .w(px(12.))
                 .cursor_default()
-                .child(ProjectPanelScrollbar::vertical(
-                    percentage as f32..end_offset as f32,
-                    self.scroll_handle.clone(),
-                    self.vertical_scrollbar_drag_thumb_offset.clone(),
-                    cx.view().entity_id(),
+                .children(Scrollbar::vertical(
+                    // percentage as f32..end_offset as f32,
+                    self.vertical_scrollbar_state.clone(),
                 )),
         )
     }
 
     fn render_horizontal_scrollbar(&self, cx: &mut ViewContext<Self>) -> Option<Stateful<Div>> {
-        if !Self::should_show_scrollbar(cx) {
-            return None;
-        }
-        let scroll_handle = self.scroll_handle.0.borrow();
-        let longest_item_width = scroll_handle
-            .last_item_size
-            .filter(|_| {
-                self.show_scrollbar || self.horizontal_scrollbar_drag_thumb_offset.get().is_some()
-            })
-            .filter(|size| size.contents.width > size.item.width)?
-            .contents
-            .width
-            .0 as f64;
-        let current_offset = scroll_handle.base_handle.offset().x.0.min(0.).abs() as f64;
-        let mut percentage = current_offset / longest_item_width;
-        let end_offset = (current_offset + scroll_handle.base_handle.bounds().size.width.0 as f64)
-            / longest_item_width;
-        // Uniform scroll handle might briefly report an offset greater than the length of a list;
-        // in such case we'll adjust the starting offset as well to keep the scrollbar thumb length stable.
-        let overshoot = (end_offset - 1.).clamp(0., 1.);
-        if overshoot > 0. {
-            percentage -= overshoot;
-        }
-        const MINIMUM_SCROLLBAR_PERCENTAGE_WIDTH: f64 = 0.005;
-        if percentage + MINIMUM_SCROLLBAR_PERCENTAGE_WIDTH > 1.0 || end_offset > longest_item_width
+        if !Self::should_show_scrollbar(cx)
+            || !(self.show_scrollbar || self.horizontal_scrollbar_state.is_dragging())
         {
             return None;
         }
-        if longest_item_width < scroll_handle.base_handle.bounds().size.width.0 as f64 {
-            return None;
-        }
-        let end_offset = end_offset.clamp(percentage + MINIMUM_SCROLLBAR_PERCENTAGE_WIDTH, 1.);
+
         Some(
             div()
                 .occlude()
@@ -2733,7 +2679,7 @@ impl ProjectPanel {
                 .on_mouse_up(
                     MouseButton::Left,
                     cx.listener(|this, _, cx| {
-                        if this.horizontal_scrollbar_drag_thumb_offset.get().is_none()
+                        if !this.horizontal_scrollbar_state.is_dragging()
                             && !this.focus_handle.contains_focused(cx)
                         {
                             this.hide_scrollbar(cx);
@@ -2754,11 +2700,9 @@ impl ProjectPanel {
                 .h(px(12.))
                 .cursor_default()
                 .when(self.width.is_some(), |this| {
-                    this.child(ProjectPanelScrollbar::horizontal(
-                        percentage as f32..end_offset as f32,
-                        self.scroll_handle.clone(),
-                        self.horizontal_scrollbar_drag_thumb_offset.clone(),
-                        cx.view().entity_id(),
+                    this.children(Scrollbar::horizontal(
+                        //percentage as f32..end_offset as f32,
+                        self.horizontal_scrollbar_state.clone(),
                     ))
                 }),
         )
diff --git a/crates/project_panel/src/scrollbar.rs b/crates/project_panel/src/scrollbar.rs
deleted file mode 100644
index cb7b15386c2070..00000000000000
--- a/crates/project_panel/src/scrollbar.rs
+++ /dev/null
@@ -1,277 +0,0 @@
-use std::{cell::Cell, ops::Range, rc::Rc};
-
-use gpui::{
-    point, quad, Bounds, ContentMask, Corners, Edges, EntityId, Hitbox, Hsla, MouseDownEvent,
-    MouseMoveEvent, MouseUpEvent, ScrollWheelEvent, Style, UniformListScrollHandle,
-};
-use ui::{prelude::*, px, relative, IntoElement};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum ScrollbarKind {
-    Horizontal,
-    Vertical,
-}
-
-pub(crate) struct ProjectPanelScrollbar {
-    thumb: Range<f32>,
-    scroll: UniformListScrollHandle,
-    // If Some(), there's an active drag, offset by percentage from the top of thumb.
-    scrollbar_drag_state: Rc<Cell<Option<f32>>>,
-    kind: ScrollbarKind,
-    parent_id: EntityId,
-}
-
-impl ProjectPanelScrollbar {
-    pub(crate) fn vertical(
-        thumb: Range<f32>,
-        scroll: UniformListScrollHandle,
-        scrollbar_drag_state: Rc<Cell<Option<f32>>>,
-        parent_id: EntityId,
-    ) -> Self {
-        Self {
-            thumb,
-            scroll,
-            scrollbar_drag_state,
-            kind: ScrollbarKind::Vertical,
-            parent_id,
-        }
-    }
-
-    pub(crate) fn horizontal(
-        thumb: Range<f32>,
-        scroll: UniformListScrollHandle,
-        scrollbar_drag_state: Rc<Cell<Option<f32>>>,
-        parent_id: EntityId,
-    ) -> Self {
-        Self {
-            thumb,
-            scroll,
-            scrollbar_drag_state,
-            kind: ScrollbarKind::Horizontal,
-            parent_id,
-        }
-    }
-}
-
-impl gpui::Element for ProjectPanelScrollbar {
-    type RequestLayoutState = ();
-
-    type PrepaintState = Hitbox;
-
-    fn id(&self) -> Option<ui::ElementId> {
-        None
-    }
-
-    fn request_layout(
-        &mut self,
-        _id: Option<&gpui::GlobalElementId>,
-        cx: &mut ui::WindowContext,
-    ) -> (gpui::LayoutId, Self::RequestLayoutState) {
-        let mut style = Style::default();
-        style.flex_grow = 1.;
-        style.flex_shrink = 1.;
-        if self.kind == ScrollbarKind::Vertical {
-            style.size.width = px(12.).into();
-            style.size.height = relative(1.).into();
-        } else {
-            style.size.width = relative(1.).into();
-            style.size.height = px(12.).into();
-        }
-
-        (cx.request_layout(style, None), ())
-    }
-
-    fn prepaint(
-        &mut self,
-        _id: Option<&gpui::GlobalElementId>,
-        bounds: Bounds<ui::Pixels>,
-        _request_layout: &mut Self::RequestLayoutState,
-        cx: &mut ui::WindowContext,
-    ) -> Self::PrepaintState {
-        cx.with_content_mask(Some(ContentMask { bounds }), |cx| {
-            cx.insert_hitbox(bounds, false)
-        })
-    }
-
-    fn paint(
-        &mut self,
-        _id: Option<&gpui::GlobalElementId>,
-        bounds: Bounds<ui::Pixels>,
-        _request_layout: &mut Self::RequestLayoutState,
-        _prepaint: &mut Self::PrepaintState,
-        cx: &mut ui::WindowContext,
-    ) {
-        cx.with_content_mask(Some(ContentMask { bounds }), |cx| {
-            let colors = cx.theme().colors();
-            let thumb_background = colors.scrollbar_thumb_background;
-            let is_vertical = self.kind == ScrollbarKind::Vertical;
-            let extra_padding = px(5.0);
-            let padded_bounds = if is_vertical {
-                Bounds::from_corners(
-                    bounds.origin + point(Pixels::ZERO, extra_padding),
-                    bounds.lower_right() - point(Pixels::ZERO, extra_padding * 3),
-                )
-            } else {
-                Bounds::from_corners(
-                    bounds.origin + point(extra_padding, Pixels::ZERO),
-                    bounds.lower_right() - point(extra_padding * 3, Pixels::ZERO),
-                )
-            };
-
-            let mut thumb_bounds = if is_vertical {
-                let thumb_offset = self.thumb.start * padded_bounds.size.height;
-                let thumb_end = self.thumb.end * padded_bounds.size.height;
-                let thumb_upper_left = point(
-                    padded_bounds.origin.x,
-                    padded_bounds.origin.y + thumb_offset,
-                );
-                let thumb_lower_right = point(
-                    padded_bounds.origin.x + padded_bounds.size.width,
-                    padded_bounds.origin.y + thumb_end,
-                );
-                Bounds::from_corners(thumb_upper_left, thumb_lower_right)
-            } else {
-                let thumb_offset = self.thumb.start * padded_bounds.size.width;
-                let thumb_end = self.thumb.end * padded_bounds.size.width;
-                let thumb_upper_left = point(
-                    padded_bounds.origin.x + thumb_offset,
-                    padded_bounds.origin.y,
-                );
-                let thumb_lower_right = point(
-                    padded_bounds.origin.x + thumb_end,
-                    padded_bounds.origin.y + padded_bounds.size.height,
-                );
-                Bounds::from_corners(thumb_upper_left, thumb_lower_right)
-            };
-            let corners = if is_vertical {
-                thumb_bounds.size.width /= 1.5;
-                Corners::all(thumb_bounds.size.width / 2.0)
-            } else {
-                thumb_bounds.size.height /= 1.5;
-                Corners::all(thumb_bounds.size.height / 2.0)
-            };
-            cx.paint_quad(quad(
-                thumb_bounds,
-                corners,
-                thumb_background,
-                Edges::default(),
-                Hsla::transparent_black(),
-            ));
-
-            let scroll = self.scroll.clone();
-            let kind = self.kind;
-            let thumb_percentage_size = self.thumb.end - self.thumb.start;
-
-            cx.on_mouse_event({
-                let scroll = self.scroll.clone();
-                let is_dragging = self.scrollbar_drag_state.clone();
-                move |event: &MouseDownEvent, phase, _cx| {
-                    if phase.bubble() && bounds.contains(&event.position) {
-                        if !thumb_bounds.contains(&event.position) {
-                            let scroll = scroll.0.borrow();
-                            if let Some(item_size) = scroll.last_item_size {
-                                match kind {
-                                    ScrollbarKind::Horizontal => {
-                                        let percentage = (event.position.x - bounds.origin.x)
-                                            / bounds.size.width;
-                                        let max_offset = item_size.contents.width;
-                                        let percentage = percentage.min(1. - thumb_percentage_size);
-                                        scroll.base_handle.set_offset(point(
-                                            -max_offset * percentage,
-                                            scroll.base_handle.offset().y,
-                                        ));
-                                    }
-                                    ScrollbarKind::Vertical => {
-                                        let percentage = (event.position.y - bounds.origin.y)
-                                            / bounds.size.height;
-                                        let max_offset = item_size.contents.height;
-                                        let percentage = percentage.min(1. - thumb_percentage_size);
-                                        scroll.base_handle.set_offset(point(
-                                            scroll.base_handle.offset().x,
-                                            -max_offset * percentage,
-                                        ));
-                                    }
-                                }
-                            }
-                        } else {
-                            let thumb_offset = if is_vertical {
-                                (event.position.y - thumb_bounds.origin.y) / bounds.size.height
-                            } else {
-                                (event.position.x - thumb_bounds.origin.x) / bounds.size.width
-                            };
-                            is_dragging.set(Some(thumb_offset));
-                        }
-                    }
-                }
-            });
-            cx.on_mouse_event({
-                let scroll = self.scroll.clone();
-                move |event: &ScrollWheelEvent, phase, cx| {
-                    if phase.bubble() && bounds.contains(&event.position) {
-                        let scroll = scroll.0.borrow_mut();
-                        let current_offset = scroll.base_handle.offset();
-
-                        scroll
-                            .base_handle
-                            .set_offset(current_offset + event.delta.pixel_delta(cx.line_height()));
-                    }
-                }
-            });
-            let drag_state = self.scrollbar_drag_state.clone();
-            let view_id = self.parent_id;
-            let kind = self.kind;
-            cx.on_mouse_event(move |event: &MouseMoveEvent, _, cx| {
-                if let Some(drag_state) = drag_state.get().filter(|_| event.dragging()) {
-                    let scroll = scroll.0.borrow();
-                    if let Some(item_size) = scroll.last_item_size {
-                        match kind {
-                            ScrollbarKind::Horizontal => {
-                                let max_offset = item_size.contents.width;
-                                let percentage = (event.position.x - bounds.origin.x)
-                                    / bounds.size.width
-                                    - drag_state;
-
-                                let percentage = percentage.min(1. - thumb_percentage_size);
-                                scroll.base_handle.set_offset(point(
-                                    -max_offset * percentage,
-                                    scroll.base_handle.offset().y,
-                                ));
-                            }
-                            ScrollbarKind::Vertical => {
-                                let max_offset = item_size.contents.height;
-                                let percentage = (event.position.y - bounds.origin.y)
-                                    / bounds.size.height
-                                    - drag_state;
-
-                                let percentage = percentage.min(1. - thumb_percentage_size);
-                                scroll.base_handle.set_offset(point(
-                                    scroll.base_handle.offset().x,
-                                    -max_offset * percentage,
-                                ));
-                            }
-                        };
-
-                        cx.notify(view_id);
-                    }
-                } else {
-                    drag_state.set(None);
-                }
-            });
-            let is_dragging = self.scrollbar_drag_state.clone();
-            cx.on_mouse_event(move |_event: &MouseUpEvent, phase, cx| {
-                if phase.bubble() {
-                    is_dragging.set(None);
-                    cx.notify(view_id);
-                }
-            });
-        })
-    }
-}
-
-impl IntoElement for ProjectPanelScrollbar {
-    type Element = Self;
-
-    fn into_element(self) -> Self::Element {
-        self
-    }
-}
diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 89772a1fe81f95..7c98500ea841e2 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -34,6 +34,8 @@ use task::HideStrategy;
 use task::RevealStrategy;
 use task::SpawnInTerminal;
 use terminal_view::terminal_panel::TerminalPanel;
+use ui::Scrollbar;
+use ui::ScrollbarState;
 use ui::Section;
 use ui::{prelude::*, IconButtonShape, List, ListItem, ListSeparator, Modal, ModalHeader, Tooltip};
 use util::ResultExt;
@@ -301,13 +303,19 @@ impl gpui::Render for ProjectPicker {
     }
 }
 enum Mode {
-    Default,
+    Default(ScrollbarState),
     ViewServerOptions(usize, SshConnection),
     EditNickname(EditNicknameState),
     ProjectPicker(View<ProjectPicker>),
     CreateDevServer(CreateDevServer),
 }
 
+impl Mode {
+    fn default_mode() -> Self {
+        let handle = ScrollHandle::new();
+        Self::Default(ScrollbarState::new(handle))
+    }
+}
 impl DevServerProjects {
     pub fn register(workspace: &mut Workspace, _: &mut ViewContext<Workspace>) {
         workspace.register_action(|workspace, _: &OpenRemote, cx| {
@@ -338,7 +346,7 @@ impl DevServerProjects {
         });
 
         Self {
-            mode: Mode::Default,
+            mode: Mode::default_mode(),
             focus_handle,
             scroll_handle: ScrollHandle::new(),
             dev_server_store,
@@ -349,13 +357,13 @@ impl DevServerProjects {
     }
 
     fn next_item(&mut self, _: &menu::SelectNext, cx: &mut ViewContext<Self>) {
-        if !matches!(self.mode, Mode::Default | Mode::ViewServerOptions(_, _)) {
+        if !matches!(self.mode, Mode::Default(_) | Mode::ViewServerOptions(_, _)) {
             return;
         }
         self.selectable_items.next(cx);
     }
     fn prev_item(&mut self, _: &menu::SelectPrev, cx: &mut ViewContext<Self>) {
-        if !matches!(self.mode, Mode::Default | Mode::ViewServerOptions(_, _)) {
+        if !matches!(self.mode, Mode::Default(_) | Mode::ViewServerOptions(_, _)) {
             return;
         }
         self.selectable_items.prev(cx);
@@ -431,7 +439,7 @@ impl DevServerProjects {
                         });
 
                         this.add_ssh_server(connection_options, cx);
-                        this.mode = Mode::Default;
+                        this.mode = Mode::default_mode();
                         this.selectable_items.reset_selection();
                         cx.notify()
                     })
@@ -535,7 +543,7 @@ impl DevServerProjects {
 
     fn confirm(&mut self, _: &menu::Confirm, cx: &mut ViewContext<Self>) {
         match &self.mode {
-            Mode::Default | Mode::ViewServerOptions(_, _) => {
+            Mode::Default(_) | Mode::ViewServerOptions(_, _) => {
                 let items = std::mem::take(&mut self.selectable_items);
                 items.confirm(self, cx);
                 self.selectable_items = items;
@@ -566,7 +574,7 @@ impl DevServerProjects {
                         }
                     }
                 });
-                self.mode = Mode::Default;
+                self.mode = Mode::default_mode();
                 self.selectable_items.reset_selection();
                 self.focus_handle.focus(cx);
             }
@@ -575,14 +583,14 @@ impl DevServerProjects {
 
     fn cancel(&mut self, _: &menu::Cancel, cx: &mut ViewContext<Self>) {
         match &self.mode {
-            Mode::Default => cx.emit(DismissEvent),
+            Mode::Default(_) => cx.emit(DismissEvent),
             Mode::CreateDevServer(state) if state.ssh_prompt.is_some() => {
                 self.mode = Mode::CreateDevServer(CreateDevServer::new(cx));
                 self.selectable_items.reset_selection();
                 cx.notify();
             }
             _ => {
-                self.mode = Mode::Default;
+                self.mode = Mode::default_mode();
                 self.selectable_items.reset_selection();
                 self.focus_handle(cx).focus(cx);
                 cx.notify();
@@ -1012,7 +1020,7 @@ impl DevServerProjects {
                                             move |cx| {
                                                 dev_servers.update(cx, |this, cx| {
                                                     this.delete_ssh_server(index, cx);
-                                                    this.mode = Mode::Default;
+                                                    this.mode = Mode::default_mode();
                                                     cx.notify();
                                                 })
                                             },
@@ -1055,7 +1063,7 @@ impl DevServerProjects {
                     .child({
                         self.selectable_items.add_item(Box::new({
                             move |this, cx| {
-                                this.mode = Mode::Default;
+                                this.mode = Mode::default_mode();
                                 cx.notify();
                             }
                         }));
@@ -1067,7 +1075,7 @@ impl DevServerProjects {
                             .start_slot(Icon::new(IconName::ArrowLeft).color(Color::Muted))
                             .child(Label::new("Go Back"))
                             .on_click(cx.listener(|this, _, cx| {
-                                this.mode = Mode::Default;
+                                this.mode = Mode::default_mode();
                                 cx.notify()
                             }))
                     }),
@@ -1099,7 +1107,12 @@ impl DevServerProjects {
             .child(h_flex().p_2().child(state.editor.clone()))
     }
 
-    fn render_default(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+    fn render_default(
+        &mut self,
+        scroll_state: ScrollbarState,
+        cx: &mut ViewContext<Self>,
+    ) -> impl IntoElement {
+        let scroll_state = scroll_state.parent_view(cx.view());
         let dev_servers = self.dev_server_store.read(cx).dev_servers();
         let ssh_connections = SshSettings::get_global(cx)
             .ssh_connections()
@@ -1124,27 +1137,37 @@ impl DevServerProjects {
                 cx.notify();
             }));
 
+        let ui::ScrollableHandle::NonUniform(scroll_handle) = scroll_state.scroll_handle() else {
+            unreachable!()
+        };
+
         let mut modal_section = v_flex()
             .id("ssh-server-list")
             .overflow_y_scroll()
+            .track_scroll(&scroll_handle)
             .size_full()
             .child(connect_button)
             .child(
-                List::new()
-                    .empty_message(
-                        v_flex()
-                            .child(ListSeparator)
-                            .child(div().px_3().child(
-                                Label::new("No dev servers registered yet.").color(Color::Muted),
-                            ))
-                            .into_any_element(),
-                    )
-                    .children(ssh_connections.iter().cloned().enumerate().map(
-                        |(ix, connection)| {
-                            self.render_ssh_connection(ix, connection, cx)
-                                .into_any_element()
-                        },
-                    )),
+                h_flex().child(
+                    List::new()
+                        .empty_message(
+                            v_flex()
+                                .child(ListSeparator)
+                                .child(
+                                    div().px_3().child(
+                                        Label::new("No dev servers registered yet.")
+                                            .color(Color::Muted),
+                                    ),
+                                )
+                                .into_any_element(),
+                        )
+                        .children(ssh_connections.iter().cloned().enumerate().map(
+                            |(ix, connection)| {
+                                self.render_ssh_connection(ix, connection, cx)
+                                    .into_any_element()
+                            },
+                        )),
+                ),
             )
             .into_any_element();
 
@@ -1162,26 +1185,37 @@ impl DevServerProjects {
             )
             .section(
                 Section::new().padded(false).child(
-                    v_flex()
+                    h_flex()
                         .min_h(rems(20.))
-                        .flex_1()
                         .size_full()
-                        .child(ListSeparator)
                         .child(
-                            canvas(
-                                |bounds, cx| {
-                                    modal_section.prepaint_as_root(
-                                        bounds.origin,
-                                        bounds.size.into(),
-                                        cx,
-                                    );
-                                    modal_section
-                                },
-                                |_, mut modal_section, cx| {
-                                    modal_section.paint(cx);
-                                },
-                            )
-                            .size_full(),
+                            v_flex().size_full().child(ListSeparator).child(
+                                canvas(
+                                    |bounds, cx| {
+                                        modal_section.prepaint_as_root(
+                                            bounds.origin,
+                                            bounds.size.into(),
+                                            cx,
+                                        );
+                                        modal_section
+                                    },
+                                    |_, mut modal_section, cx| {
+                                        modal_section.paint(cx);
+                                    },
+                                )
+                                .size_full(),
+                            ),
+                        )
+                        .child(
+                            div()
+                                .occlude()
+                                .h_full()
+                                .absolute()
+                                .right_1()
+                                .top_1()
+                                .bottom_1()
+                                .w(px(12.))
+                                .children(Scrollbar::vertical(scroll_state)),
                         ),
                 ),
             )
@@ -1217,13 +1251,13 @@ impl Render for DevServerProjects {
                 this.focus_handle(cx).focus(cx);
             }))
             .on_mouse_down_out(cx.listener(|this, _, cx| {
-                if matches!(this.mode, Mode::Default) {
+                if matches!(this.mode, Mode::Default(_)) {
                     cx.emit(DismissEvent)
                 }
             }))
             .w(rems(34.))
             .child(match &self.mode {
-                Mode::Default => self.render_default(cx).into_any_element(),
+                Mode::Default(state) => self.render_default(state.clone(), cx).into_any_element(),
                 Mode::ViewServerOptions(index, connection) => self
                     .render_view_options(*index, connection.clone(), cx)
                     .into_any_element(),
diff --git a/crates/ui/src/components.rs b/crates/ui/src/components.rs
index fe63b035027afb..98d103e163b45b 100644
--- a/crates/ui/src/components.rs
+++ b/crates/ui/src/components.rs
@@ -18,6 +18,7 @@ mod popover;
 mod popover_menu;
 mod radio;
 mod right_click_menu;
+mod scrollbar;
 mod settings_container;
 mod settings_group;
 mod stack;
@@ -49,6 +50,7 @@ pub use popover::*;
 pub use popover_menu::*;
 pub use radio::*;
 pub use right_click_menu::*;
+pub use scrollbar::*;
 pub use settings_container::*;
 pub use settings_group::*;
 pub use stack::*;
diff --git a/crates/ui/src/components/scrollbar.rs b/crates/ui/src/components/scrollbar.rs
new file mode 100644
index 00000000000000..5f25547b432fc1
--- /dev/null
+++ b/crates/ui/src/components/scrollbar.rs
@@ -0,0 +1,396 @@
+#![allow(missing_docs)]
+use std::{cell::Cell, ops::Range, rc::Rc};
+
+use crate::{prelude::*, px, relative, IntoElement};
+use gpui::{
+    point, quad, Along, Axis as ScrollbarAxis, Bounds, ContentMask, Corners, Edges, Element,
+    ElementId, Entity, EntityId, GlobalElementId, Hitbox, Hsla, LayoutId, MouseDownEvent,
+    MouseMoveEvent, MouseUpEvent, Pixels, Point, ScrollHandle, ScrollWheelEvent, Size, Style,
+    UniformListScrollHandle, View, WindowContext,
+};
+
+pub struct Scrollbar {
+    thumb: Range<f32>,
+    state: ScrollbarState,
+    kind: ScrollbarAxis,
+}
+
+/// Wrapper around scroll handles.
+#[derive(Clone)]
+pub enum ScrollableHandle {
+    Uniform(UniformListScrollHandle),
+    NonUniform(ScrollHandle),
+}
+
+#[derive(Debug)]
+struct ContentSize {
+    size: Size<Pixels>,
+    scroll_adjustment: Option<Point<Pixels>>,
+}
+
+impl ScrollableHandle {
+    fn content_size(&self) -> Option<ContentSize> {
+        match self {
+            ScrollableHandle::Uniform(handle) => Some(ContentSize {
+                size: handle.0.borrow().last_item_size.map(|size| size.contents)?,
+                scroll_adjustment: None,
+            }),
+            ScrollableHandle::NonUniform(handle) => {
+                let last_children_index = handle.children_count().checked_sub(1)?;
+                // todo: PO: this is slightly wrong for horizontal scrollbar, as the last item is not necessarily the longest one.
+                let mut last_item = handle.bounds_for_item(last_children_index)?;
+                last_item.size.height += last_item.origin.y;
+                last_item.size.width += last_item.origin.x;
+                let mut scroll_adjustment = None;
+                if last_children_index != 0 {
+                    let first_item = handle.bounds_for_item(0)?;
+
+                    scroll_adjustment = Some(first_item.origin);
+                    last_item.size.height -= first_item.origin.y;
+                    last_item.size.width -= first_item.origin.x;
+                }
+                Some(ContentSize {
+                    size: last_item.size,
+                    scroll_adjustment,
+                })
+            }
+        }
+    }
+    fn set_offset(&self, point: Point<Pixels>) {
+        let base_handle = match self {
+            ScrollableHandle::Uniform(handle) => &handle.0.borrow().base_handle,
+            ScrollableHandle::NonUniform(handle) => &handle,
+        };
+        base_handle.set_offset(point);
+    }
+    fn offset(&self) -> Point<Pixels> {
+        let base_handle = match self {
+            ScrollableHandle::Uniform(handle) => &handle.0.borrow().base_handle,
+            ScrollableHandle::NonUniform(handle) => &handle,
+        };
+        base_handle.offset()
+    }
+    fn viewport(&self) -> Bounds<Pixels> {
+        let base_handle = match self {
+            ScrollableHandle::Uniform(handle) => &handle.0.borrow().base_handle,
+            ScrollableHandle::NonUniform(handle) => &handle,
+        };
+        base_handle.bounds()
+    }
+}
+impl From<UniformListScrollHandle> for ScrollableHandle {
+    fn from(value: UniformListScrollHandle) -> Self {
+        Self::Uniform(value)
+    }
+}
+
+impl From<ScrollHandle> for ScrollableHandle {
+    fn from(value: ScrollHandle) -> Self {
+        Self::NonUniform(value)
+    }
+}
+
+/// A scrollbar state that should be persisted across frames.
+#[derive(Clone)]
+pub struct ScrollbarState {
+    // If Some(), there's an active drag, offset by percentage from the origin of a thumb.
+    drag: Rc<Cell<Option<f32>>>,
+    parent_id: Option<EntityId>,
+    scroll_handle: ScrollableHandle,
+}
+
+impl ScrollbarState {
+    pub fn new(scroll: impl Into<ScrollableHandle>) -> Self {
+        Self {
+            drag: Default::default(),
+            parent_id: None,
+            scroll_handle: scroll.into(),
+        }
+    }
+
+    /// Set a parent view which should be notified whenever this Scrollbar gets a scroll event.
+    pub fn parent_view<V: 'static>(mut self, v: &View<V>) -> Self {
+        self.parent_id = Some(v.entity_id());
+        self
+    }
+
+    pub fn scroll_handle(&self) -> ScrollableHandle {
+        self.scroll_handle.clone()
+    }
+
+    pub fn is_dragging(&self) -> bool {
+        self.drag.get().is_some()
+    }
+
+    fn thumb_range(&self, axis: ScrollbarAxis) -> Option<Range<f32>> {
+        const MINIMUM_SCROLLBAR_PERCENTAGE_SIZE: f32 = 0.005;
+        let ContentSize {
+            size: main_dimension_size,
+            scroll_adjustment,
+        } = self.scroll_handle.content_size()?;
+        let main_dimension_size = main_dimension_size.along(axis).0;
+        let mut current_offset = self.scroll_handle.offset().along(axis).min(px(0.)).abs().0;
+        if let Some(adjustment) = scroll_adjustment.and_then(|adjustment| {
+            let adjust = adjustment.along(axis).0;
+            if adjust < 0.0 {
+                Some(adjust)
+            } else {
+                None
+            }
+        }) {
+            current_offset -= adjustment;
+        }
+        let mut percentage = current_offset / main_dimension_size;
+        let viewport_size = self.scroll_handle.viewport().size;
+
+        let end_offset = (current_offset + viewport_size.along(axis).0) / main_dimension_size;
+        // Scroll handle might briefly report an offset greater than the length of a list;
+        // in such case we'll adjust the starting offset as well to keep the scrollbar thumb length stable.
+        let overshoot = (end_offset - 1.).clamp(0., 1.);
+        if overshoot > 0. {
+            percentage -= overshoot;
+        }
+        if percentage + MINIMUM_SCROLLBAR_PERCENTAGE_SIZE > 1.0 || end_offset > main_dimension_size
+        {
+            return None;
+        }
+        if main_dimension_size < viewport_size.along(axis).0 {
+            return None;
+        }
+        let end_offset = end_offset.clamp(percentage + MINIMUM_SCROLLBAR_PERCENTAGE_SIZE, 1.);
+        Some(percentage..end_offset)
+    }
+}
+
+impl Scrollbar {
+    pub fn vertical(state: ScrollbarState) -> Option<Self> {
+        Self::new(state, ScrollbarAxis::Vertical)
+    }
+
+    pub fn horizontal(state: ScrollbarState) -> Option<Self> {
+        Self::new(state, ScrollbarAxis::Horizontal)
+    }
+    fn new(state: ScrollbarState, kind: ScrollbarAxis) -> Option<Self> {
+        let thumb = state.thumb_range(kind)?;
+        Some(Self { thumb, state, kind })
+    }
+}
+
+impl Element for Scrollbar {
+    type RequestLayoutState = ();
+
+    type PrepaintState = Hitbox;
+
+    fn id(&self) -> Option<ElementId> {
+        None
+    }
+
+    fn request_layout(
+        &mut self,
+        _id: Option<&GlobalElementId>,
+        cx: &mut WindowContext,
+    ) -> (LayoutId, Self::RequestLayoutState) {
+        let mut style = Style::default();
+        style.flex_grow = 1.;
+        style.flex_shrink = 1.;
+
+        if self.kind == ScrollbarAxis::Vertical {
+            style.size.width = px(12.).into();
+            style.size.height = relative(1.).into();
+        } else {
+            style.size.width = relative(1.).into();
+            style.size.height = px(12.).into();
+        }
+
+        (cx.request_layout(style, None), ())
+    }
+
+    fn prepaint(
+        &mut self,
+        _id: Option<&GlobalElementId>,
+        bounds: Bounds<Pixels>,
+        _request_layout: &mut Self::RequestLayoutState,
+        cx: &mut WindowContext,
+    ) -> Self::PrepaintState {
+        cx.with_content_mask(Some(ContentMask { bounds }), |cx| {
+            cx.insert_hitbox(bounds, false)
+        })
+    }
+
+    fn paint(
+        &mut self,
+        _id: Option<&GlobalElementId>,
+        bounds: Bounds<Pixels>,
+        _request_layout: &mut Self::RequestLayoutState,
+        _prepaint: &mut Self::PrepaintState,
+        cx: &mut WindowContext,
+    ) {
+        cx.with_content_mask(Some(ContentMask { bounds }), |cx| {
+            let colors = cx.theme().colors();
+            let thumb_background = colors.scrollbar_thumb_background;
+            let is_vertical = self.kind == ScrollbarAxis::Vertical;
+            let extra_padding = px(5.0);
+            let padded_bounds = if is_vertical {
+                Bounds::from_corners(
+                    bounds.origin + point(Pixels::ZERO, extra_padding),
+                    bounds.lower_right() - point(Pixels::ZERO, extra_padding * 3),
+                )
+            } else {
+                Bounds::from_corners(
+                    bounds.origin + point(extra_padding, Pixels::ZERO),
+                    bounds.lower_right() - point(extra_padding * 3, Pixels::ZERO),
+                )
+            };
+
+            let mut thumb_bounds = if is_vertical {
+                let thumb_offset = self.thumb.start * padded_bounds.size.height;
+                let thumb_end = self.thumb.end * padded_bounds.size.height;
+                let thumb_upper_left = point(
+                    padded_bounds.origin.x,
+                    padded_bounds.origin.y + thumb_offset,
+                );
+                let thumb_lower_right = point(
+                    padded_bounds.origin.x + padded_bounds.size.width,
+                    padded_bounds.origin.y + thumb_end,
+                );
+                Bounds::from_corners(thumb_upper_left, thumb_lower_right)
+            } else {
+                let thumb_offset = self.thumb.start * padded_bounds.size.width;
+                let thumb_end = self.thumb.end * padded_bounds.size.width;
+                let thumb_upper_left = point(
+                    padded_bounds.origin.x + thumb_offset,
+                    padded_bounds.origin.y,
+                );
+                let thumb_lower_right = point(
+                    padded_bounds.origin.x + thumb_end,
+                    padded_bounds.origin.y + padded_bounds.size.height,
+                );
+                Bounds::from_corners(thumb_upper_left, thumb_lower_right)
+            };
+            let corners = if is_vertical {
+                thumb_bounds.size.width /= 1.5;
+                Corners::all(thumb_bounds.size.width / 2.0)
+            } else {
+                thumb_bounds.size.height /= 1.5;
+                Corners::all(thumb_bounds.size.height / 2.0)
+            };
+            cx.paint_quad(quad(
+                thumb_bounds,
+                corners,
+                thumb_background,
+                Edges::default(),
+                Hsla::transparent_black(),
+            ));
+
+            let scroll = self.state.scroll_handle.clone();
+            let kind = self.kind;
+            let thumb_percentage_size = self.thumb.end - self.thumb.start;
+
+            cx.on_mouse_event({
+                let scroll = scroll.clone();
+                let state = self.state.clone();
+                let axis = self.kind;
+                move |event: &MouseDownEvent, phase, _cx| {
+                    if !(phase.bubble() && bounds.contains(&event.position)) {
+                        return;
+                    }
+
+                    if thumb_bounds.contains(&event.position) {
+                        let thumb_offset = (event.position.along(axis)
+                            - thumb_bounds.origin.along(axis))
+                            / bounds.size.along(axis);
+                        state.drag.set(Some(thumb_offset));
+                    } else if let Some(ContentSize {
+                        size: item_size, ..
+                    }) = scroll.content_size()
+                    {
+                        match kind {
+                            ScrollbarAxis::Horizontal => {
+                                let percentage =
+                                    (event.position.x - bounds.origin.x) / bounds.size.width;
+                                let max_offset = item_size.width;
+                                let percentage = percentage.min(1. - thumb_percentage_size);
+                                scroll
+                                    .set_offset(point(-max_offset * percentage, scroll.offset().y));
+                            }
+                            ScrollbarAxis::Vertical => {
+                                let percentage =
+                                    (event.position.y - bounds.origin.y) / bounds.size.height;
+                                let max_offset = item_size.height;
+                                let percentage = percentage.min(1. - thumb_percentage_size);
+                                scroll
+                                    .set_offset(point(scroll.offset().x, -max_offset * percentage));
+                            }
+                        }
+                    }
+                }
+            });
+            cx.on_mouse_event({
+                let scroll = scroll.clone();
+                move |event: &ScrollWheelEvent, phase, cx| {
+                    if phase.bubble() && bounds.contains(&event.position) {
+                        let current_offset = scroll.offset();
+                        scroll
+                            .set_offset(current_offset + event.delta.pixel_delta(cx.line_height()));
+                    }
+                }
+            });
+            let state = self.state.clone();
+            let kind = self.kind;
+            cx.on_mouse_event(move |event: &MouseMoveEvent, _, cx| {
+                if let Some(drag_state) = state.drag.get().filter(|_| event.dragging()) {
+                    if let Some(ContentSize {
+                        size: item_size, ..
+                    }) = scroll.content_size()
+                    {
+                        match kind {
+                            ScrollbarAxis::Horizontal => {
+                                let max_offset = item_size.width;
+                                let percentage = (event.position.x - bounds.origin.x)
+                                    / bounds.size.width
+                                    - drag_state;
+
+                                let percentage = percentage.min(1. - thumb_percentage_size);
+                                scroll
+                                    .set_offset(point(-max_offset * percentage, scroll.offset().y));
+                            }
+                            ScrollbarAxis::Vertical => {
+                                let max_offset = item_size.height;
+                                let percentage = (event.position.y - bounds.origin.y)
+                                    / bounds.size.height
+                                    - drag_state;
+
+                                let percentage = percentage.min(1. - thumb_percentage_size);
+                                scroll
+                                    .set_offset(point(scroll.offset().x, -max_offset * percentage));
+                            }
+                        };
+
+                        if let Some(id) = state.parent_id {
+                            cx.notify(id);
+                        }
+                    }
+                } else {
+                    state.drag.set(None);
+                }
+            });
+            let state = self.state.clone();
+            cx.on_mouse_event(move |_event: &MouseUpEvent, phase, cx| {
+                if phase.bubble() {
+                    state.drag.take();
+                    if let Some(id) = state.parent_id {
+                        cx.notify(id);
+                    }
+                }
+            });
+        })
+    }
+}
+
+impl IntoElement for Scrollbar {
+    type Element = Self;
+
+    fn into_element(self) -> Self::Element {
+        self
+    }
+}

From 2f960c4aba999b5ac069b5d20cbab9a06eb4dadd Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 16 Oct 2024 14:12:45 +0200
Subject: [PATCH 675/762] project environment: Log when which env is used
 (#19270)

This adds more logging for debugging purposes.

Release Notes:

- N/A
---
 crates/project/src/environment.rs | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/crates/project/src/environment.rs b/crates/project/src/environment.rs
index 69aba235a77299..6153f41233757c 100644
--- a/crates/project/src/environment.rs
+++ b/crates/project/src/environment.rs
@@ -112,8 +112,18 @@ impl ProjectEnvironment {
         let worktree = worktree_id.zip(worktree_abs_path);
 
         let cli_environment = self.get_cli_environment();
-        if cli_environment.is_some() {
-            Task::ready(cli_environment)
+        if let Some(environment) = cli_environment {
+            cx.spawn(|_, _| async move {
+                let path = environment
+                    .get("PATH")
+                    .map(|path| path.as_str())
+                    .unwrap_or_default();
+                log::info!(
+                    "using project environment variables from CLI. PATH={:?}",
+                    path
+                );
+                Some(environment)
+            })
         } else if let Some((worktree_id, worktree_abs_path)) = worktree {
             self.get_worktree_env(worktree_id, worktree_abs_path, cx)
         } else {
@@ -143,6 +153,15 @@ impl ProjectEnvironment {
                     .await;
 
                 if let Some(shell_env) = shell_env.as_mut() {
+                    let path = shell_env
+                        .get("PATH")
+                        .map(|path| path.as_str())
+                        .unwrap_or_default();
+                    log::info!(
+                        "using project environment variables shell launched in {:?}. PATH={:?}",
+                        worktree_abs_path,
+                        path
+                    );
                     this.update(&mut cx, |this, _| {
                         this.cached_shell_environments
                             .insert(worktree_id, shell_env.clone());

From 103665ee28059c3240a872899ef01730c3f5af09 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 16 Oct 2024 08:41:45 -0400
Subject: [PATCH 676/762] astro: Bump to v0.1.1 (#19249)

Includes:
- https://github.com/zed-industries/zed/pull/18024
---
 Cargo.lock                      | 2 +-
 extensions/astro/Cargo.toml     | 2 +-
 extensions/astro/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6f1d7b2c9ca06d..22ba1c3ccbe544 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14698,7 +14698,7 @@ dependencies = [
 
 [[package]]
 name = "zed_astro"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "serde",
  "zed_extension_api 0.1.0",
diff --git a/extensions/astro/Cargo.toml b/extensions/astro/Cargo.toml
index 11de7b22c57f13..755896125c8010 100644
--- a/extensions/astro/Cargo.toml
+++ b/extensions/astro/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_astro"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/astro/extension.toml b/extensions/astro/extension.toml
index 44f0036bd6ebe1..03183e51e83477 100644
--- a/extensions/astro/extension.toml
+++ b/extensions/astro/extension.toml
@@ -1,7 +1,7 @@
 id = "astro"
 name = "Astro"
 description = "Astro support."
-version = "0.1.0"
+version = "0.1.1"
 schema_version = 1
 authors = ["Alvaro Gaona <alvgaona@gmail.com>", "0xk1f0 <dev@k1f0.dev>"]
 repository = "https://github.com/zed-industries/zed"

From a4357c429afa2dd11ec4c4f74906eff30269b40b Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 16 Oct 2024 08:42:07 -0400
Subject: [PATCH 677/762] elixir: Bump to v0.1.0 (#19250)

Includes:
- https://github.com/zed-industries/zed/pull/18024
- https://github.com/zed-industries/zed/pull/17488
- https://github.com/zed-industries/zed/pull/16985
---
 Cargo.lock                       | 2 +-
 extensions/elixir/Cargo.toml     | 2 +-
 extensions/elixir/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 22ba1c3ccbe544..a2d4279cdca171 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14734,7 +14734,7 @@ dependencies = [
 
 [[package]]
 name = "zed_elixir"
-version = "0.0.9"
+version = "0.1.0"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/elixir/Cargo.toml b/extensions/elixir/Cargo.toml
index 6e132ba6aaef0c..174711b1ba1931 100644
--- a/extensions/elixir/Cargo.toml
+++ b/extensions/elixir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_elixir"
-version = "0.0.9"
+version = "0.1.0"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/elixir/extension.toml b/extensions/elixir/extension.toml
index a21e01c4700998..6f00c29a79650d 100644
--- a/extensions/elixir/extension.toml
+++ b/extensions/elixir/extension.toml
@@ -1,7 +1,7 @@
 id = "elixir"
 name = "Elixir"
 description = "Elixir support."
-version = "0.0.9"
+version = "0.1.0"
 schema_version = 1
 authors = ["Marshall Bowers <elliott.codes@gmail.com>"]
 repository = "https://github.com/zed-industries/zed"

From 57c55b32e13414652db0a47d235ae25d7537630e Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 16 Oct 2024 08:42:27 -0400
Subject: [PATCH 678/762] html: Bump to v0.1.3 (#19251)

Includes:
- https://github.com/zed-industries/zed/pull/18024
---
 Cargo.lock                     | 2 +-
 extensions/html/Cargo.toml     | 2 +-
 extensions/html/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a2d4279cdca171..2476bfd26d68e3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14796,7 +14796,7 @@ dependencies = [
 
 [[package]]
 name = "zed_html"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/html/Cargo.toml b/extensions/html/Cargo.toml
index 084be13a70b3aa..1182356015db29 100644
--- a/extensions/html/Cargo.toml
+++ b/extensions/html/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_html"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/html/extension.toml b/extensions/html/extension.toml
index 9add7f8289d240..12b1020e3bad14 100644
--- a/extensions/html/extension.toml
+++ b/extensions/html/extension.toml
@@ -1,7 +1,7 @@
 id = "html"
 name = "HTML"
 description = "HTML support."
-version = "0.1.2"
+version = "0.1.3"
 schema_version = 1
 authors = ["Isaac Clayton <slightknack@gmail.com>"]
 repository = "https://github.com/zed-industries/zed"

From 84018d7a2d1def88c12f28ecc4cd54dc96c3110d Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 16 Oct 2024 08:42:45 -0400
Subject: [PATCH 679/762] zig: Bump to v0.3.1 (#19252)

Includes:
- https://github.com/zed-industries/zed/pull/18323
- https://github.com/zed-industries/zed/pull/17488
---
 Cargo.lock                    | 2 +-
 extensions/zig/Cargo.toml     | 2 +-
 extensions/zig/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2476bfd26d68e3..1627d39dd66410 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14903,7 +14903,7 @@ dependencies = [
 
 [[package]]
 name = "zed_zig"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/zig/Cargo.toml b/extensions/zig/Cargo.toml
index f98f1f871c6eb0..63f3c5c0076833 100644
--- a/extensions/zig/Cargo.toml
+++ b/extensions/zig/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_zig"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/zig/extension.toml b/extensions/zig/extension.toml
index 7a402b59d46bab..16210c5ba2441a 100644
--- a/extensions/zig/extension.toml
+++ b/extensions/zig/extension.toml
@@ -1,7 +1,7 @@
 id = "zig"
 name = "Zig"
 description = "Zig support."
-version = "0.3.0"
+version = "0.3.1"
 schema_version = 1
 authors = ["Allan Calix <contact@acx.dev>"]
 repository = "https://github.com/zed-industries/zed"

From eb76065ad3068cc3002264b43800f8f4f30afeca Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 16 Oct 2024 15:57:58 +0200
Subject: [PATCH 680/762] ssh remoting: Fix hang when activity channel gets
 dropped (#19275)

When the SSH command dies or the server, the channel gets dropped and
the heartbeat method went into an infinite loop causing a hang.

Oversight from yesterday. Fixed now.

Release Notes:

- N/A
---
 crates/remote/src/ssh_session.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 4d131425492da8..ed4bbbefaed2f4 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -743,7 +743,11 @@ impl SshRemoteClient {
 
                 loop {
                     select_biased! {
-                        _ = connection_activity_rx.next().fuse() => {
+                        result = connection_activity_rx.next().fuse() => {
+                            if result.is_none() {
+                                log::warn!("ssh heartbeat: connection activity channel has been dropped. stopping.");
+                                return Ok(());
+                            }
                             keepalive_timer.set(cx.background_executor().timer(HEARTBEAT_INTERVAL).fuse());
                         }
                         _ = keepalive_timer => {

From 84df3a0cad5f85dd76bd69a09b22bc659ecfe5d0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ihnat=20A=C5=ADtu=C5=A1ka?= <autushka.ihnat@gmail.com>
Date: Wed, 16 Oct 2024 16:58:37 +0300
Subject: [PATCH 681/762] Allow formatting selections via LSP (#18752)

Release Notes:

- Added a new `editor: format selections` action that allows formatting
only the currently selected text via the primary language server.

---------

Co-authored-by: Thorsten Ball <mrnugget@gmail.com>
---
 crates/collab/src/tests/integration_tests.rs |   5 +
 crates/editor/src/actions.rs                 |   1 +
 crates/editor/src/editor.rs                  |  34 +-
 crates/editor/src/editor_tests.rs            |  23 +-
 crates/editor/src/element.rs                 |   7 +
 crates/editor/src/items.rs                   |   8 +-
 crates/editor/src/mouse_context_menu.rs      |  14 +-
 crates/project/src/lsp_store.rs              | 388 ++++++++++++-------
 crates/project/src/project.rs                |   3 +-
 9 files changed, 323 insertions(+), 160 deletions(-)

diff --git a/crates/collab/src/tests/integration_tests.rs b/crates/collab/src/tests/integration_tests.rs
index cc8c35fbc3cf7b..e124fd6a7e3ffc 100644
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -27,6 +27,7 @@ use language::{
 use live_kit_client::MacOSDisplay;
 use lsp::LanguageServerId;
 use parking_lot::Mutex;
+use project::lsp_store::FormatTarget;
 use project::{
     lsp_store::FormatTrigger, search::SearchQuery, search::SearchResult, DiagnosticSummary,
     HoverBlockKind, Project, ProjectPath,
@@ -4417,6 +4418,7 @@ async fn test_formatting_buffer(
                 HashSet::from_iter([buffer_b.clone()]),
                 true,
                 FormatTrigger::Save,
+                FormatTarget::Buffer,
                 cx,
             )
         })
@@ -4450,6 +4452,7 @@ async fn test_formatting_buffer(
                 HashSet::from_iter([buffer_b.clone()]),
                 true,
                 FormatTrigger::Save,
+                FormatTarget::Buffer,
                 cx,
             )
         })
@@ -4555,6 +4558,7 @@ async fn test_prettier_formatting_buffer(
                 HashSet::from_iter([buffer_b.clone()]),
                 true,
                 FormatTrigger::Save,
+                FormatTarget::Buffer,
                 cx,
             )
         })
@@ -4574,6 +4578,7 @@ async fn test_prettier_formatting_buffer(
                 HashSet::from_iter([buffer_a.clone()]),
                 true,
                 FormatTrigger::Manual,
+                FormatTarget::Buffer,
                 cx,
             )
         })
diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs
index b0c7877979f39b..4955f00c382334 100644
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -237,6 +237,7 @@ gpui::actions!(
         ToggleFold,
         ToggleFoldRecursive,
         Format,
+        FormatSelections,
         GoToDeclaration,
         GoToDeclarationSplit,
         GoToDefinition,
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index d07002040c555d..5e33b38dacf26e 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -122,7 +122,7 @@ use multi_buffer::{
 use ordered_float::OrderedFloat;
 use parking_lot::{Mutex, RwLock};
 use project::{
-    lsp_store::FormatTrigger,
+    lsp_store::{FormatTarget, FormatTrigger},
     project_settings::{GitGutterSetting, ProjectSettings},
     CodeAction, Completion, CompletionIntent, DocumentHighlight, InlayHint, Item, Location,
     LocationLink, Project, ProjectPath, ProjectTransaction, TaskSourceKind,
@@ -10386,13 +10386,39 @@ impl Editor {
             None => return None,
         };
 
-        Some(self.perform_format(project, FormatTrigger::Manual, cx))
+        Some(self.perform_format(project, FormatTrigger::Manual, FormatTarget::Buffer, cx))
+    }
+
+    fn format_selections(
+        &mut self,
+        _: &FormatSelections,
+        cx: &mut ViewContext<Self>,
+    ) -> Option<Task<Result<()>>> {
+        let project = match &self.project {
+            Some(project) => project.clone(),
+            None => return None,
+        };
+
+        let selections = self
+            .selections
+            .all_adjusted(cx)
+            .into_iter()
+            .filter(|s| !s.is_empty())
+            .collect_vec();
+
+        Some(self.perform_format(
+            project,
+            FormatTrigger::Manual,
+            FormatTarget::Ranges(selections),
+            cx,
+        ))
     }
 
     fn perform_format(
         &mut self,
         project: Model<Project>,
         trigger: FormatTrigger,
+        target: FormatTarget,
         cx: &mut ViewContext<Self>,
     ) -> Task<Result<()>> {
         let buffer = self.buffer().clone();
@@ -10402,7 +10428,9 @@ impl Editor {
         }
 
         let mut timeout = cx.background_executor().timer(FORMAT_TIMEOUT).fuse();
-        let format = project.update(cx, |project, cx| project.format(buffers, true, trigger, cx));
+        let format = project.update(cx, |project, cx| {
+            project.format(buffers, true, trigger, target, cx)
+        });
 
         cx.spawn(|_, mut cx| async move {
             let transaction = futures::select_biased! {
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 092afb394e42fb..fdcfaab82fb33b 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -7076,7 +7076,12 @@ async fn test_document_format_manual_trigger(cx: &mut gpui::TestAppContext) {
 
     let format = editor
         .update(cx, |editor, cx| {
-            editor.perform_format(project.clone(), FormatTrigger::Manual, cx)
+            editor.perform_format(
+                project.clone(),
+                FormatTrigger::Manual,
+                FormatTarget::Buffer,
+                cx,
+            )
         })
         .unwrap();
     fake_server
@@ -7112,7 +7117,7 @@ async fn test_document_format_manual_trigger(cx: &mut gpui::TestAppContext) {
     });
     let format = editor
         .update(cx, |editor, cx| {
-            editor.perform_format(project, FormatTrigger::Manual, cx)
+            editor.perform_format(project, FormatTrigger::Manual, FormatTarget::Buffer, cx)
         })
         .unwrap();
     cx.executor().advance_clock(super::FORMAT_TIMEOUT);
@@ -10309,7 +10314,12 @@ async fn test_document_format_with_prettier(cx: &mut gpui::TestAppContext) {
 
     editor
         .update(cx, |editor, cx| {
-            editor.perform_format(project.clone(), FormatTrigger::Manual, cx)
+            editor.perform_format(
+                project.clone(),
+                FormatTrigger::Manual,
+                FormatTarget::Buffer,
+                cx,
+            )
         })
         .unwrap()
         .await;
@@ -10323,7 +10333,12 @@ async fn test_document_format_with_prettier(cx: &mut gpui::TestAppContext) {
         settings.defaults.formatter = Some(language_settings::SelectedFormatter::Auto)
     });
     let format = editor.update(cx, |editor, cx| {
-        editor.perform_format(project.clone(), FormatTrigger::Manual, cx)
+        editor.perform_format(
+            project.clone(),
+            FormatTrigger::Manual,
+            FormatTarget::Buffer,
+            cx,
+        )
     });
     format.await.unwrap();
     assert_eq!(
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 49bb9d7b925087..a9dfe7e435df8e 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -376,6 +376,13 @@ impl EditorElement {
                 cx.propagate();
             }
         });
+        register_action(view, cx, |editor, action, cx| {
+            if let Some(task) = editor.format_selections(action, cx) {
+                task.detach_and_log_err(cx);
+            } else {
+                cx.propagate();
+            }
+        });
         register_action(view, cx, Editor::restart_language_server);
         register_action(view, cx, Editor::cancel_language_server_work);
         register_action(view, cx, Editor::show_character_palette);
diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index b3f4cc813fe8ad..e84476fb08c728 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -27,6 +27,7 @@ use rpc::proto::{self, update_view, PeerId};
 use settings::Settings;
 use workspace::item::{Dedup, ItemSettings, SerializableItem, TabContentParams};
 
+use project::lsp_store::FormatTarget;
 use std::{
     any::TypeId,
     borrow::Cow,
@@ -722,7 +723,12 @@ impl Item for Editor {
         cx.spawn(|this, mut cx| async move {
             if format {
                 this.update(&mut cx, |editor, cx| {
-                    editor.perform_format(project.clone(), FormatTrigger::Save, cx)
+                    editor.perform_format(
+                        project.clone(),
+                        FormatTrigger::Save,
+                        FormatTarget::Buffer,
+                        cx,
+                    )
                 })?
                 .await?;
             }
diff --git a/crates/editor/src/mouse_context_menu.rs b/crates/editor/src/mouse_context_menu.rs
index 936d95dccbf8c2..9abf4d990cd7a0 100644
--- a/crates/editor/src/mouse_context_menu.rs
+++ b/crates/editor/src/mouse_context_menu.rs
@@ -1,5 +1,4 @@
-use std::ops::Range;
-
+use crate::actions::FormatSelections;
 use crate::{
     actions::Format, selections_collection::SelectionsCollection, Copy, CopyPermalinkToLine, Cut,
     DisplayPoint, DisplaySnapshot, Editor, EditorMode, FindAllReferences, GoToDeclaration,
@@ -8,6 +7,8 @@ use crate::{
 };
 use gpui::prelude::FluentBuilder;
 use gpui::{DismissEvent, Pixels, Point, Subscription, View, ViewContext};
+use std::ops::Range;
+use text::PointUtf16;
 use workspace::OpenInTerminal;
 
 #[derive(Debug)]
@@ -164,6 +165,12 @@ pub fn deploy_context_menu(
         } else {
             "Reveal in File Manager"
         };
+        let has_selections = editor
+            .selections
+            .all::<PointUtf16>(cx)
+            .into_iter()
+            .any(|s| !s.is_empty());
+
         ui::ContextMenu::build(cx, |menu, _cx| {
             let builder = menu
                 .on_blur_subscription(Subscription::new(|| {}))
@@ -175,6 +182,9 @@ pub fn deploy_context_menu(
                 .separator()
                 .action("Rename Symbol", Box::new(Rename))
                 .action("Format Buffer", Box::new(Format))
+                .when(has_selections, |cx| {
+                    cx.action("Format Selections", Box::new(FormatSelections))
+                })
                 .action(
                     "Code Actions",
                     Box::new(ToggleCodeActions {
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 8c4fb1f349b47f..41da302e469329 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -72,7 +72,7 @@ use std::{
     sync::Arc,
     time::{Duration, Instant},
 };
-use text::{Anchor, BufferId, LineEnding};
+use text::{Anchor, BufferId, LineEnding, Point, Selection};
 use util::{
     debug_panic, defer, maybe, merge_json_value_into, post_inc, ResultExt, TryFutureExt as _,
 };
@@ -96,6 +96,20 @@ pub enum FormatTrigger {
     Manual,
 }
 
+pub enum FormatTarget {
+    Buffer,
+    Ranges(Vec<Selection<Point>>),
+}
+
+impl FormatTarget {
+    pub fn as_selections(&self) -> Option<&[Selection<Point>]> {
+        match self {
+            FormatTarget::Buffer => None,
+            FormatTarget::Ranges(selections) => Some(selections.as_slice()),
+        }
+    }
+}
+
 // Currently, formatting operations are represented differently depending on
 // whether they come from a language server or an external command.
 #[derive(Debug)]
@@ -161,6 +175,7 @@ impl LocalLspStore {
         mut buffers: Vec<FormattableBuffer>,
         push_to_history: bool,
         trigger: FormatTrigger,
+        target: FormatTarget,
         mut cx: AsyncAppContext,
     ) -> anyhow::Result<ProjectTransaction> {
         // Do not allow multiple concurrent formatting requests for the
@@ -286,6 +301,7 @@ impl LocalLspStore {
                                             if prettier_settings.allowed {
                                                 Self::perform_format(
                                                     &Formatter::Prettier,
+                                                    &target,
                                                     server_and_buffer,
                                                     lsp_store.clone(),
                                                     buffer,
@@ -299,6 +315,7 @@ impl LocalLspStore {
                                             } else {
                                                 Self::perform_format(
                                                     &Formatter::LanguageServer { name: None },
+                                                    &target,
                                                     server_and_buffer,
                                                     lsp_store.clone(),
                                                     buffer,
@@ -310,9 +327,8 @@ impl LocalLspStore {
                                                 )
                                                 .await
                                             }
-                                        }
-                                        .log_err()
-                                        .flatten();
+                                        }?;
+
                                         if let Some(op) = diff {
                                             format_operations.push(op);
                                         }
@@ -321,6 +337,7 @@ impl LocalLspStore {
                                         for formatter in formatters.as_ref() {
                                             let diff = Self::perform_format(
                                                 formatter,
+                                                &target,
                                                 server_and_buffer,
                                                 lsp_store.clone(),
                                                 buffer,
@@ -330,9 +347,7 @@ impl LocalLspStore {
                                                 &mut project_transaction,
                                                 &mut cx,
                                             )
-                                            .await
-                                            .log_err()
-                                            .flatten();
+                                            .await?;
                                             if let Some(op) = diff {
                                                 format_operations.push(op);
                                             }
@@ -346,6 +361,7 @@ impl LocalLspStore {
                                 for formatter in formatters.as_ref() {
                                     let diff = Self::perform_format(
                                         formatter,
+                                        &target,
                                         server_and_buffer,
                                         lsp_store.clone(),
                                         buffer,
@@ -355,9 +371,7 @@ impl LocalLspStore {
                                         &mut project_transaction,
                                         &mut cx,
                                     )
-                                    .await
-                                    .log_err()
-                                    .flatten();
+                                    .await?;
                                     if let Some(op) = diff {
                                         format_operations.push(op);
                                     }
@@ -373,6 +387,7 @@ impl LocalLspStore {
                                     if prettier_settings.allowed {
                                         Self::perform_format(
                                             &Formatter::Prettier,
+                                            &target,
                                             server_and_buffer,
                                             lsp_store.clone(),
                                             buffer,
@@ -384,8 +399,14 @@ impl LocalLspStore {
                                         )
                                         .await
                                     } else {
+                                        let formatter = Formatter::LanguageServer {
+                                            name: primary_language_server
+                                                .as_ref()
+                                                .map(|server| server.name().to_string()),
+                                        };
                                         Self::perform_format(
-                                            &Formatter::LanguageServer { name: None },
+                                            &formatter,
+                                            &target,
                                             server_and_buffer,
                                             lsp_store.clone(),
                                             buffer,
@@ -397,9 +418,7 @@ impl LocalLspStore {
                                         )
                                         .await
                                     }
-                                }
-                                .log_err()
-                                .flatten();
+                                }?;
 
                                 if let Some(op) = diff {
                                     format_operations.push(op)
@@ -410,6 +429,7 @@ impl LocalLspStore {
                                     // format with formatter
                                     let diff = Self::perform_format(
                                         formatter,
+                                        &target,
                                         server_and_buffer,
                                         lsp_store.clone(),
                                         buffer,
@@ -419,9 +439,7 @@ impl LocalLspStore {
                                         &mut project_transaction,
                                         &mut cx,
                                     )
-                                    .await
-                                    .log_err()
-                                    .flatten();
+                                    .await?;
                                     if let Some(op) = diff {
                                         format_operations.push(op);
                                     }
@@ -483,6 +501,7 @@ impl LocalLspStore {
     #[allow(clippy::too_many_arguments)]
     async fn perform_format(
         formatter: &Formatter,
+        format_target: &FormatTarget,
         primary_server_and_buffer: Option<(&Arc<LanguageServer>, &PathBuf)>,
         lsp_store: WeakModel<LspStore>,
         buffer: &FormattableBuffer,
@@ -506,18 +525,33 @@ impl LocalLspStore {
                         language_server
                     };
 
-                    Some(FormatOperation::Lsp(
-                        LspStore::format_via_lsp(
-                            &lsp_store,
-                            &buffer.handle,
-                            buffer_abs_path,
-                            language_server,
-                            settings,
-                            cx,
-                        )
-                        .await
-                        .context("failed to format via language server")?,
-                    ))
+                    match format_target {
+                        FormatTarget::Buffer => Some(FormatOperation::Lsp(
+                            LspStore::format_via_lsp(
+                                &lsp_store,
+                                &buffer.handle,
+                                buffer_abs_path,
+                                language_server,
+                                settings,
+                                cx,
+                            )
+                            .await
+                            .context("failed to format via language server")?,
+                        )),
+                        FormatTarget::Ranges(selections) => Some(FormatOperation::Lsp(
+                            LspStore::format_range_via_lsp(
+                                &lsp_store,
+                                &buffer.handle,
+                                selections.as_slice(),
+                                buffer_abs_path,
+                                language_server,
+                                settings,
+                                cx,
+                            )
+                            .await
+                            .context("failed to format ranges via language server")?,
+                        )),
+                    }
                 } else {
                     None
                 }
@@ -1859,10 +1893,9 @@ impl LspStore {
         } else if matches!(range_formatting_provider, Some(p) if *p != OneOf::Left(false)) {
             let buffer_start = lsp::Position::new(0, 0);
             let buffer_end = buffer.update(cx, |b, _| point_to_lsp(b.max_point_utf16()))?;
-
             language_server
                 .request::<lsp::request::RangeFormatting>(lsp::DocumentRangeFormattingParams {
-                    text_document,
+                    text_document: text_document.clone(),
                     range: lsp::Range::new(buffer_start, buffer_end),
                     options: lsp_command::lsp_formatting_options(settings),
                     work_done_progress_params: Default::default(),
@@ -1878,7 +1911,62 @@ impl LspStore {
             })?
             .await
         } else {
-            Ok(Vec::new())
+            Ok(Vec::with_capacity(0))
+        }
+    }
+    pub async fn format_range_via_lsp(
+        this: &WeakModel<Self>,
+        buffer: &Model<Buffer>,
+        selections: &[Selection<Point>],
+        abs_path: &Path,
+        language_server: &Arc<LanguageServer>,
+        settings: &LanguageSettings,
+        cx: &mut AsyncAppContext,
+    ) -> Result<Vec<(Range<Anchor>, String)>> {
+        let capabilities = &language_server.capabilities();
+        let range_formatting_provider = capabilities.document_range_formatting_provider.as_ref();
+        if range_formatting_provider.map_or(false, |provider| provider == &OneOf::Left(false)) {
+            return Err(anyhow!(
+                "{} language server does not support range formatting",
+                language_server.name()
+            ));
+        }
+
+        let uri = lsp::Url::from_file_path(abs_path)
+            .map_err(|_| anyhow!("failed to convert abs path to uri"))?;
+        let text_document = lsp::TextDocumentIdentifier::new(uri);
+
+        let lsp_edits = {
+            let ranges = selections.into_iter().map(|s| {
+                let start = lsp::Position::new(s.start.row, s.start.column);
+                let end = lsp::Position::new(s.end.row, s.end.column);
+                lsp::Range::new(start, end)
+            });
+
+            let mut edits = None;
+            for range in ranges {
+                if let Some(mut edit) = language_server
+                    .request::<lsp::request::RangeFormatting>(lsp::DocumentRangeFormattingParams {
+                        text_document: text_document.clone(),
+                        range,
+                        options: lsp_command::lsp_formatting_options(settings),
+                        work_done_progress_params: Default::default(),
+                    })
+                    .await?
+                {
+                    edits.get_or_insert_with(Vec::new).append(&mut edit);
+                }
+            }
+            edits
+        };
+
+        if let Some(lsp_edits) = lsp_edits {
+            this.update(cx, |this, cx| {
+                this.edits_from_lsp(buffer, lsp_edits, language_server.server_id(), None, cx)
+            })?
+            .await
+        } else {
+            Ok(Vec::with_capacity(0))
         }
     }
 
@@ -2648,44 +2736,44 @@ impl LspStore {
                     };
 
                 requests.push(
-                    server
-                        .request::<lsp::request::WorkspaceSymbolRequest>(
-                            lsp::WorkspaceSymbolParams {
-                                query: query.to_string(),
-                                ..Default::default()
-                            },
-                        )
-                        .log_err()
-                        .map(move |response| {
-                            let lsp_symbols = response.flatten().map(|symbol_response| match symbol_response {
-                                lsp::WorkspaceSymbolResponse::Flat(flat_responses) => {
-                                    flat_responses.into_iter().map(|lsp_symbol| {
-                                        (lsp_symbol.name, lsp_symbol.kind, lsp_symbol.location)
-                                    }).collect::<Vec<_>>()
-                                }
-                                lsp::WorkspaceSymbolResponse::Nested(nested_responses) => {
-                                    nested_responses.into_iter().filter_map(|lsp_symbol| {
-                                        let location = match lsp_symbol.location {
-                                            OneOf::Left(location) => location,
-                                            OneOf::Right(_) => {
-                                                log::error!("Unexpected: client capabilities forbid symbol resolutions in workspace.symbol.resolveSupport");
-                                                return None
-                                            }
-                                        };
-                                        Some((lsp_symbol.name, lsp_symbol.kind, location))
-                                    }).collect::<Vec<_>>()
+                        server
+                            .request::<lsp::request::WorkspaceSymbolRequest>(
+                                lsp::WorkspaceSymbolParams {
+                                    query: query.to_string(),
+                                    ..Default::default()
+                                },
+                            )
+                            .log_err()
+                            .map(move |response| {
+                                let lsp_symbols = response.flatten().map(|symbol_response| match symbol_response {
+                                    lsp::WorkspaceSymbolResponse::Flat(flat_responses) => {
+                                        flat_responses.into_iter().map(|lsp_symbol| {
+                                            (lsp_symbol.name, lsp_symbol.kind, lsp_symbol.location)
+                                        }).collect::<Vec<_>>()
+                                    }
+                                    lsp::WorkspaceSymbolResponse::Nested(nested_responses) => {
+                                        nested_responses.into_iter().filter_map(|lsp_symbol| {
+                                            let location = match lsp_symbol.location {
+                                                OneOf::Left(location) => location,
+                                                OneOf::Right(_) => {
+                                                    log::error!("Unexpected: client capabilities forbid symbol resolutions in workspace.symbol.resolveSupport");
+                                                    return None
+                                                }
+                                            };
+                                            Some((lsp_symbol.name, lsp_symbol.kind, location))
+                                        }).collect::<Vec<_>>()
+                                    }
+                                }).unwrap_or_default();
+
+                                WorkspaceSymbolsResult {
+                                    lsp_adapter,
+                                    language,
+                                    worktree: worktree_handle.downgrade(),
+                                    worktree_abs_path,
+                                    lsp_symbols,
                                 }
-                            }).unwrap_or_default();
-
-                            WorkspaceSymbolsResult {
-                                lsp_adapter,
-                                language,
-                                worktree: worktree_handle.downgrade(),
-                                worktree_abs_path,
-                                lsp_symbols,
-                            }
-                        }),
-                );
+                            }),
+                    );
             }
 
             cx.spawn(move |this, mut cx| async move {
@@ -4579,16 +4667,16 @@ impl LspStore {
 
             if registrations.remove(registration_id).is_some() {
                 log::info!(
-                "language server {}: unregistered workspace/DidChangeWatchedFiles capability with id {}",
-                language_server_id,
-                registration_id
-            );
+                    "language server {}: unregistered workspace/DidChangeWatchedFiles capability with id {}",
+                    language_server_id,
+                    registration_id
+                );
             } else {
                 log::warn!(
-                "language server {}: failed to unregister workspace/DidChangeWatchedFiles capability with id {}. not registered.",
-                language_server_id,
-                registration_id
-            );
+                    "language server {}: failed to unregister workspace/DidChangeWatchedFiles capability with id {}. not registered.",
+                    language_server_id,
+                    registration_id
+                );
             }
 
             self.rebuild_watched_paths(language_server_id, cx);
@@ -5078,6 +5166,7 @@ impl LspStore {
         buffers: HashSet<Model<Buffer>>,
         push_to_history: bool,
         trigger: FormatTrigger,
+        target: FormatTarget,
         cx: &mut ModelContext<Self>,
     ) -> Task<anyhow::Result<ProjectTransaction>> {
         if let Some(_) = self.as_local() {
@@ -5114,6 +5203,7 @@ impl LspStore {
                     formattable_buffers,
                     push_to_history,
                     trigger,
+                    target,
                     cx.clone(),
                 )
                 .await;
@@ -5172,7 +5262,7 @@ impl LspStore {
                 buffers.insert(this.buffer_store.read(cx).get_existing(buffer_id)?);
             }
             let trigger = FormatTrigger::from_proto(envelope.payload.trigger);
-            Ok::<_, anyhow::Error>(this.format(buffers, false, trigger, cx))
+            Ok::<_, anyhow::Error>(this.format(buffers, false, trigger, FormatTarget::Buffer, cx))
         })??;
 
         let project_transaction = format.await?;
@@ -6485,11 +6575,11 @@ impl LspStore {
                 })?;
 
             let found_snapshot = snapshots
-                .binary_search_by_key(&version, |e| e.version)
-                .map(|ix| snapshots[ix].snapshot.clone())
-                .map_err(|_| {
-                    anyhow!("snapshot not found for buffer {buffer_id} server {server_id} at version {version}")
-                })?;
+                    .binary_search_by_key(&version, |e| e.version)
+                    .map(|ix| snapshots[ix].snapshot.clone())
+                    .map_err(|_| {
+                        anyhow!("snapshot not found for buffer {buffer_id} server {server_id} at version {version}")
+                    })?;
 
             snapshots.retain(|snapshot| snapshot.version + OLD_VERSIONS_TO_RETAIN >= version);
             Ok(found_snapshot)
@@ -7203,74 +7293,74 @@ impl LanguageServerWatchedPathsBuilder {
         let project = cx.weak_model();
 
         cx.new_model(|cx| {
-            let this_id = cx.entity_id();
-            const LSP_ABS_PATH_OBSERVE: Duration = Duration::from_millis(100);
-            let abs_paths = self
-                .abs_paths
-                .into_iter()
-                .map(|(abs_path, globset)| {
-                    let task = cx.spawn({
-                        let abs_path = abs_path.clone();
-                        let fs = fs.clone();
-
-                        let lsp_store = project.clone();
-                        |_, mut cx| async move {
-                            maybe!(async move {
-                                let mut push_updates =
-                                    fs.watch(&abs_path, LSP_ABS_PATH_OBSERVE).await;
-                                while let Some(update) = push_updates.0.next().await {
-                                    let action = lsp_store
-                                        .update(&mut cx, |this, cx| {
-                                            let Some(local) = this.as_local() else {
-                                                return ControlFlow::Break(());
-                                            };
-                                            let Some(watcher) = local
-                                                .language_server_watched_paths
-                                                .get(&language_server_id)
-                                            else {
-                                                return ControlFlow::Break(());
-                                            };
-                                            if watcher.entity_id() != this_id {
-                                                // This watcher is no longer registered on the project, which means that we should
-                                                // cease operations.
-                                                return ControlFlow::Break(());
-                                            }
-                                            let (globs, _) = watcher
-                                                .read(cx)
-                                                .abs_paths
-                                                .get(&abs_path)
-                                                .expect(
-                                                "Watched abs path is not registered with a watcher",
-                                            );
-                                            let matching_entries = update
-                                                .into_iter()
-                                                .filter(|event| globs.is_match(&event.path))
-                                                .collect::<Vec<_>>();
-                                            this.lsp_notify_abs_paths_changed(
-                                                language_server_id,
-                                                matching_entries,
-                                            );
-                                            ControlFlow::Continue(())
-                                        })
-                                        .ok()?;
+                let this_id = cx.entity_id();
+                const LSP_ABS_PATH_OBSERVE: Duration = Duration::from_millis(100);
+                let abs_paths = self
+                    .abs_paths
+                    .into_iter()
+                    .map(|(abs_path, globset)| {
+                        let task = cx.spawn({
+                            let abs_path = abs_path.clone();
+                            let fs = fs.clone();
+
+                            let lsp_store = project.clone();
+                            |_, mut cx| async move {
+                                maybe!(async move {
+                                    let mut push_updates =
+                                        fs.watch(&abs_path, LSP_ABS_PATH_OBSERVE).await;
+                                    while let Some(update) = push_updates.0.next().await {
+                                        let action = lsp_store
+                                            .update(&mut cx, |this, cx| {
+                                                let Some(local) = this.as_local() else {
+                                                    return ControlFlow::Break(());
+                                                };
+                                                let Some(watcher) = local
+                                                    .language_server_watched_paths
+                                                    .get(&language_server_id)
+                                                else {
+                                                    return ControlFlow::Break(());
+                                                };
+                                                if watcher.entity_id() != this_id {
+                                                    // This watcher is no longer registered on the project, which means that we should
+                                                    // cease operations.
+                                                    return ControlFlow::Break(());
+                                                }
+                                                let (globs, _) = watcher
+                                                    .read(cx)
+                                                    .abs_paths
+                                                    .get(&abs_path)
+                                                    .expect(
+                                                    "Watched abs path is not registered with a watcher",
+                                                );
+                                                let matching_entries = update
+                                                    .into_iter()
+                                                    .filter(|event| globs.is_match(&event.path))
+                                                    .collect::<Vec<_>>();
+                                                this.lsp_notify_abs_paths_changed(
+                                                    language_server_id,
+                                                    matching_entries,
+                                                );
+                                                ControlFlow::Continue(())
+                                            })
+                                            .ok()?;
 
-                                    if action.is_break() {
-                                        break;
+                                        if action.is_break() {
+                                            break;
+                                        }
                                     }
-                                }
-                                Some(())
-                            })
-                            .await;
-                        }
-                    });
-                    (abs_path, (globset, task))
-                })
-                .collect();
-            LanguageServerWatchedPaths {
-                worktree_paths: self.worktree_paths,
-                abs_paths,
-            }
-        })
+                                    Some(())
+                                })
+                                    .await;
+                            }
+                        });
+                        (abs_path, (globset, task))
+                    })
+                    .collect();
+                LanguageServerWatchedPaths {
+                    worktree_paths: self.worktree_paths,
+                    abs_paths,
+                }
+            })
     }
 }
 
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 6e731e9cbadd01..d26ee3a211cbc9 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -2505,10 +2505,11 @@ impl Project {
         buffers: HashSet<Model<Buffer>>,
         push_to_history: bool,
         trigger: lsp_store::FormatTrigger,
+        target: lsp_store::FormatTarget,
         cx: &mut ModelContext<Project>,
     ) -> Task<anyhow::Result<ProjectTransaction>> {
         self.lsp_store.update(cx, |lsp_store, cx| {
-            lsp_store.format(buffers, push_to_history, trigger, cx)
+            lsp_store.format(buffers, push_to_history, trigger, target, cx)
         })
     }
 

From 7d2628e8058a2636d0cf39c9de941d6e6e839527 Mon Sep 17 00:00:00 2001
From: Tilman Roeder <dyed.green.info@gmail.com>
Date: Wed, 16 Oct 2024 15:00:22 +0100
Subject: [PATCH 682/762] Make the divider rule color more muted (#19255)

I've been a bit annoyed by the hover divider rule being extremely bright
compared to other divider rules in the UI. This PR updates their color
to use the regular border color from the current theme instead of the
muted (but still pretty bright) text color.

Apologies for the unsolicited PR (and please feel free to close if it
goes against some other plans / designs you already have in place :).

#### Example screenshot before:
<img width="302" alt="Screenshot 2024-10-15 at 23 29 18"
src="https://github.com/user-attachments/assets/7ea22808-8135-4a46-9457-e670225aebaa">

#### Example screenshot after:
<img width="312" alt="Screenshot 2024-10-15 at 23 28 16"
src="https://github.com/user-attachments/assets/63ac0d02-ae6d-4962-84a2-1fdb95519b15">

***

Release Notes:

- Make the divider rule in LSP hovers more muted
---
 crates/editor/src/hover_popover.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/editor/src/hover_popover.rs b/crates/editor/src/hover_popover.rs
index 269e9e9e03e061..9200dd7b8c697c 100644
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -525,7 +525,7 @@ async fn parse_blocks(
                     font_family: Some(buffer_font_family),
                     ..Default::default()
                 },
-                rule_color: Color::Muted.color(cx),
+                rule_color: cx.theme().colors().border,
                 block_quote_border_color: Color::Muted.color(cx),
                 block_quote: TextStyleRefinement {
                     color: Some(Color::Muted.color(cx)),

From 9d944d0662eb4b0b769ef64a63310332b03ef050 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 16 Oct 2024 16:13:31 +0200
Subject: [PATCH 683/762] ssh remote: Restore ControlPersist=no (#19277)

This restores the change from #19193 that I erroneously reverted in
#19234.

I think the bug in #19275 got in my way when testing.

With that bug fixed, the changes in here also work fine.


Release Notes:

- N/A
---
 crates/remote/src/ssh_session.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index ed4bbbefaed2f4..2bb4cc7fb2c6ec 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -1186,7 +1186,14 @@ impl SshRemoteConnection {
             .stderr(Stdio::piped())
             .env("SSH_ASKPASS_REQUIRE", "force")
             .env("SSH_ASKPASS", &askpass_script_path)
-            .args(["-N", "-o", "ControlMaster=yes", "-o"])
+            .args([
+                "-N",
+                "-o",
+                "ControlPersist=no",
+                "-o",
+                "ControlMaster=yes",
+                "-o",
+            ])
             .arg(format!("ControlPath={}", socket_path.display()))
             .arg(&url)
             .spawn()?;

From 598939d186f38f850f68b2e5a974d15f9103862f Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 16 Oct 2024 10:58:28 -0400
Subject: [PATCH 684/762] collab: Refresh the user's LLM token when their
 subscription changes (#19281)

This PR makes it so collab will trigger a refresh for a user's LLM token
whenever their subscription changes.

This allows us to proactively push down changes to their subscription.

In order to facilitate this, the Stripe event processing has been moved
from the `api` service to the `collab` service in order to access the
RPC server.

Release Notes:

- N/A
---
 crates/collab/src/api/billing.rs | 18 ++++++++++++++----
 crates/collab/src/main.rs        |  3 ++-
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index 0e46e8453d95f0..6db40dd187788d 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -20,7 +20,7 @@ use stripe::{
 use util::ResultExt;
 
 use crate::llm::DEFAULT_MAX_MONTHLY_SPEND;
-use crate::rpc::ResultExt as _;
+use crate::rpc::{ResultExt as _, Server};
 use crate::{
     db::{
         billing_customer, BillingSubscriptionId, CreateBillingCustomerParams,
@@ -404,7 +404,7 @@ const NUMBER_OF_ALREADY_PROCESSED_PAGES_BEFORE_WE_STOP: usize = 4;
 
 /// Polls the Stripe events API periodically to reconcile the records in our
 /// database with the data in Stripe.
-pub fn poll_stripe_events_periodically(app: Arc<AppState>) {
+pub fn poll_stripe_events_periodically(app: Arc<AppState>, rpc_server: Arc<Server>) {
     let Some(stripe_client) = app.stripe_client.clone() else {
         log::warn!("failed to retrieve Stripe client");
         return;
@@ -415,7 +415,9 @@ pub fn poll_stripe_events_periodically(app: Arc<AppState>) {
         let executor = executor.clone();
         async move {
             loop {
-                poll_stripe_events(&app, &stripe_client).await.log_err();
+                poll_stripe_events(&app, &rpc_server, &stripe_client)
+                    .await
+                    .log_err();
 
                 executor.sleep(POLL_EVENTS_INTERVAL).await;
             }
@@ -425,6 +427,7 @@ pub fn poll_stripe_events_periodically(app: Arc<AppState>) {
 
 async fn poll_stripe_events(
     app: &Arc<AppState>,
+    rpc_server: &Arc<Server>,
     stripe_client: &stripe::Client,
 ) -> anyhow::Result<()> {
     fn event_type_to_string(event_type: EventType) -> String {
@@ -541,7 +544,7 @@ async fn poll_stripe_events(
             | EventType::CustomerSubscriptionPaused
             | EventType::CustomerSubscriptionResumed
             | EventType::CustomerSubscriptionDeleted => {
-                handle_customer_subscription_event(app, stripe_client, event).await
+                handle_customer_subscription_event(app, rpc_server, stripe_client, event).await
             }
             _ => Ok(()),
         };
@@ -609,6 +612,7 @@ async fn handle_customer_event(
 
 async fn handle_customer_subscription_event(
     app: &Arc<AppState>,
+    rpc_server: &Arc<Server>,
     stripe_client: &stripe::Client,
     event: stripe::Event,
 ) -> anyhow::Result<()> {
@@ -654,6 +658,12 @@ async fn handle_customer_subscription_event(
             .await?;
     }
 
+    // When the user's subscription changes, we want to refresh their LLM tokens
+    // to either grant/revoke access.
+    rpc_server
+        .refresh_llm_tokens_for_user(billing_customer.user_id)
+        .await;
+
     Ok(())
 }
 
diff --git a/crates/collab/src/main.rs b/crates/collab/src/main.rs
index de77be21eb4e01..ee95b6d41f5350 100644
--- a/crates/collab/src/main.rs
+++ b/crates/collab/src/main.rs
@@ -132,6 +132,8 @@ async fn main() -> Result<()> {
                     let rpc_server = collab::rpc::Server::new(epoch, state.clone());
                     rpc_server.start().await?;
 
+                    poll_stripe_events_periodically(state.clone(), rpc_server.clone());
+
                     app = app
                         .merge(collab::api::routes(rpc_server.clone()))
                         .merge(collab::rpc::routes(rpc_server.clone()));
@@ -140,7 +142,6 @@ async fn main() -> Result<()> {
                 }
 
                 if mode.is_api() {
-                    poll_stripe_events_periodically(state.clone());
                     fetch_extensions_from_blob_store_periodically(state.clone());
                     spawn_user_backfiller(state.clone());
 

From bcdb10b3cb399e72c6d1973c22cfc5f27cbe2cbe Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 16 Oct 2024 18:10:05 +0300
Subject: [PATCH 685/762] Do not attempt to install prettier if the language
 change is unrelated (#19283)

Release Notes:

- Fix prettier install being attempted too much
---
 crates/project/src/lsp_store.rs      | 23 +++++++++++++----------
 crates/project/src/prettier_store.rs | 12 +++++++-----
 2 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 41da302e469329..d72f631bdcfb47 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -1237,16 +1237,19 @@ impl LspStore {
             None
         };
 
-        if let Some(prettier_plugins) = prettier_store::prettier_plugins_for_language(&settings) {
-            let prettier_store = self.as_local().map(|s| s.prettier_store.clone());
-            if let Some(prettier_store) = prettier_store {
-                prettier_store.update(cx, |prettier_store, cx| {
-                    prettier_store.install_default_prettier(
-                        worktree_id,
-                        prettier_plugins.iter().map(|s| Arc::from(s.as_str())),
-                        cx,
-                    )
-                })
+        if settings.prettier.allowed {
+            if let Some(prettier_plugins) = prettier_store::prettier_plugins_for_language(&settings)
+            {
+                let prettier_store = self.as_local().map(|s| s.prettier_store.clone());
+                if let Some(prettier_store) = prettier_store {
+                    prettier_store.update(cx, |prettier_store, cx| {
+                        prettier_store.install_default_prettier(
+                            worktree_id,
+                            prettier_plugins.iter().map(|s| Arc::from(s.as_str())),
+                            cx,
+                        )
+                    })
+                }
             }
         }
 
diff --git a/crates/project/src/prettier_store.rs b/crates/project/src/prettier_store.rs
index 65e2aa2e7673e8..b6c99e4a1eba4b 100644
--- a/crates/project/src/prettier_store.rs
+++ b/crates/project/src/prettier_store.rs
@@ -610,11 +610,13 @@ impl PrettierStore {
     ) {
         let mut prettier_plugins_by_worktree = HashMap::default();
         for (worktree, language_settings) in language_formatters_to_check {
-            if let Some(plugins) = prettier_plugins_for_language(&language_settings) {
-                prettier_plugins_by_worktree
-                    .entry(worktree)
-                    .or_insert_with(HashSet::default)
-                    .extend(plugins.iter().cloned());
+            if language_settings.prettier.allowed {
+                if let Some(plugins) = prettier_plugins_for_language(&language_settings) {
+                    prettier_plugins_by_worktree
+                        .entry(worktree)
+                        .or_insert_with(HashSet::default)
+                        .extend(plugins.iter().cloned());
+                }
             }
         }
         for (worktree, prettier_plugins) in prettier_plugins_by_worktree {

From 834d50f0db0b6427c5c8fae61e4b903b136b112e Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 16 Oct 2024 18:12:36 +0300
Subject: [PATCH 686/762] Properly open worktrees when cmd-clicking in terminal
 or on inlay hints (#19280)

* uses the state that's synced, to fetch the language server name
* uses proper, canonicalized path when creating a remote ssh worktree,
otherwise `~/foo/something` stays unexpanded

Release Notes:

- N/A
---
 crates/editor/src/editor.rs                  | 18 +++----
 crates/project/src/lsp_store.rs              | 55 +++++++++++---------
 crates/project/src/project.rs                | 11 ----
 crates/project/src/worktree_store.rs         |  2 +-
 crates/proto/proto/zed.proto                 |  1 +
 crates/remote_server/src/headless_project.rs |  3 +-
 6 files changed, 43 insertions(+), 47 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 5e33b38dacf26e..378ccb905d9507 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -96,7 +96,9 @@ use language::{
     CursorShape, Diagnostic, Documentation, IndentKind, IndentSize, Language, OffsetRangeExt,
     Point, Selection, SelectionGoal, TransactionId,
 };
-use language::{point_to_lsp, BufferRow, CharClassifier, Runnable, RunnableRange};
+use language::{
+    point_to_lsp, BufferRow, CharClassifier, LanguageServerName, Runnable, RunnableRange,
+};
 use linked_editing_ranges::refresh_linked_ranges;
 pub use proposed_changes_editor::{
     ProposedChangesBuffer, ProposedChangesEditor, ProposedChangesEditorToolbar,
@@ -9893,21 +9895,19 @@ impl Editor {
         &self,
         lsp_location: lsp::Location,
         server_id: LanguageServerId,
-        cx: &mut ViewContext<Editor>,
+        cx: &mut ViewContext<Self>,
     ) -> Task<anyhow::Result<Option<Location>>> {
         let Some(project) = self.project.clone() else {
             return Task::Ready(Some(Ok(None)));
         };
 
         cx.spawn(move |editor, mut cx| async move {
-            let location_task = editor.update(&mut cx, |editor, cx| {
+            let location_task = editor.update(&mut cx, |_, cx| {
                 project.update(cx, |project, cx| {
-                    let language_server_name =
-                        editor.buffer.read(cx).as_singleton().and_then(|buffer| {
-                            project
-                                .language_server_for_buffer(buffer.read(cx), server_id, cx)
-                                .map(|(lsp_adapter, _)| lsp_adapter.name.clone())
-                        });
+                    let language_server_name = project
+                        .language_server_statuses(cx)
+                        .find(|(id, _)| server_id == *id)
+                        .map(|(_, status)| LanguageServerName::from(status.name.as_str()));
                     language_server_name.map(|language_server_name| {
                         project.open_local_buffer_via_lsp(
                             lsp_location.uri.clone(),
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index d72f631bdcfb47..61f959259d5ab8 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -3503,7 +3503,7 @@ impl LspStore {
         language_server_name: LanguageServerName,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Model<Buffer>>> {
-        cx.spawn(move |this, mut cx| async move {
+        cx.spawn(move |lsp_store, mut cx| async move {
             // Escape percent-encoded string.
             let current_scheme = abs_path.scheme().to_owned();
             let _ = abs_path.set_scheme("file");
@@ -3512,9 +3512,9 @@ impl LspStore {
                 .to_file_path()
                 .map_err(|_| anyhow!("can't convert URI to path"))?;
             let p = abs_path.clone();
-            let yarn_worktree = this
-                .update(&mut cx, move |this, cx| {
-                    this.as_local().unwrap().yarn.update(cx, |_, cx| {
+            let yarn_worktree = lsp_store
+                .update(&mut cx, move |lsp_store, cx| match lsp_store.as_local() {
+                    Some(local_lsp_store) => local_lsp_store.yarn.update(cx, |_, cx| {
                         cx.spawn(|this, mut cx| async move {
                             let t = this
                                 .update(&mut cx, |this, cx| {
@@ -3523,7 +3523,8 @@ impl LspStore {
                                 .ok()?;
                             t.await
                         })
-                    })
+                    }),
+                    None => Task::ready(None),
                 })?
                 .await;
             let (worktree_root_target, known_relative_path) =
@@ -3533,8 +3534,8 @@ impl LspStore {
                     (Arc::<Path>::from(abs_path.as_path()), None)
                 };
             let (worktree, relative_path) = if let Some(result) =
-                this.update(&mut cx, |this, cx| {
-                    this.worktree_store.update(cx, |worktree_store, cx| {
+                lsp_store.update(&mut cx, |lsp_store, cx| {
+                    lsp_store.worktree_store.update(cx, |worktree_store, cx| {
                         worktree_store.find_worktree(&worktree_root_target, cx)
                     })
                 })? {
@@ -3542,22 +3543,25 @@ impl LspStore {
                     known_relative_path.unwrap_or_else(|| Arc::<Path>::from(result.1));
                 (result.0, relative_path)
             } else {
-                let worktree = this
-                    .update(&mut cx, |this, cx| {
-                        this.worktree_store.update(cx, |worktree_store, cx| {
+                let worktree = lsp_store
+                    .update(&mut cx, |lsp_store, cx| {
+                        lsp_store.worktree_store.update(cx, |worktree_store, cx| {
                             worktree_store.create_worktree(&worktree_root_target, false, cx)
                         })
                     })?
                     .await?;
-                this.update(&mut cx, |this, cx| {
-                    this.register_language_server(
-                        worktree.read(cx).id(),
-                        language_server_name,
-                        language_server_id,
-                    )
-                })
-                .ok();
-                let worktree_root = worktree.update(&mut cx, |this, _| this.abs_path())?;
+                if worktree.update(&mut cx, |worktree, _| worktree.is_local())? {
+                    lsp_store
+                        .update(&mut cx, |lsp_store, cx| {
+                            lsp_store.register_language_server(
+                                worktree.read(cx).id(),
+                                language_server_name,
+                                language_server_id,
+                            )
+                        })
+                        .ok();
+                }
+                let worktree_root = worktree.update(&mut cx, |worktree, _| worktree.abs_path())?;
                 let relative_path = if let Some(known_path) = known_relative_path {
                     known_path
                 } else {
@@ -3569,12 +3573,13 @@ impl LspStore {
                 worktree_id: worktree.update(&mut cx, |worktree, _| worktree.id())?,
                 path: relative_path,
             };
-            this.update(&mut cx, |this, cx| {
-                this.buffer_store().update(cx, |buffer_store, cx| {
-                    buffer_store.open_buffer(project_path, cx)
-                })
-            })?
-            .await
+            lsp_store
+                .update(&mut cx, |lsp_store, cx| {
+                    lsp_store.buffer_store().update(cx, |buffer_store, cx| {
+                        buffer_store.open_buffer(project_path, cx)
+                    })
+                })?
+                .await
         })
     }
 
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index d26ee3a211cbc9..03074fb6a6579e 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -3979,17 +3979,6 @@ impl Project {
             .read(cx)
             .language_servers_for_buffer(buffer, cx)
     }
-
-    pub fn language_server_for_buffer<'a>(
-        &'a self,
-        buffer: &'a Buffer,
-        server_id: LanguageServerId,
-        cx: &'a AppContext,
-    ) -> Option<(&'a Arc<CachedLspAdapter>, &'a Arc<LanguageServer>)> {
-        self.lsp_store
-            .read(cx)
-            .language_server_for_buffer(buffer, server_id, cx)
-    }
 }
 
 fn deserialize_code_actions(code_actions: &HashMap<String, bool>) -> Vec<lsp::CodeActionKind> {
diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index 55eb0108e2109b..c49d3b062ee975 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -280,7 +280,7 @@ impl WorktreeStore {
                         id: response.worktree_id,
                         root_name,
                         visible,
-                        abs_path,
+                        abs_path: response.canonicalized_path,
                     },
                     client,
                     cx,
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index fbd1cf42151348..750aa924b4fc9b 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -2464,6 +2464,7 @@ message AddWorktree {
 
 message AddWorktreeResponse {
     uint64 worktree_id = 1;
+    string canonicalized_path = 2;
 }
 
 message UpdateUserSettings {
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index f17c27a03cad43..e6eddac1d0eb5b 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -275,7 +275,7 @@ impl HeadlessProject {
         let worktree = this
             .update(&mut cx.clone(), |this, _| {
                 Worktree::local(
-                    Arc::from(canonicalized),
+                    Arc::from(canonicalized.as_path()),
                     message.payload.visible,
                     this.fs.clone(),
                     this.next_entry_id.clone(),
@@ -287,6 +287,7 @@ impl HeadlessProject {
         let response = this.update(&mut cx, |_, cx| {
             worktree.update(cx, |worktree, _| proto::AddWorktreeResponse {
                 worktree_id: worktree.id().to_proto(),
+                canonicalized_path: canonicalized.to_string_lossy().to_string(),
             })
         })?;
 

From 9c3d80d6e8d1a936e243005871e179fbf23ca526 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 16 Oct 2024 11:40:56 -0400
Subject: [PATCH 687/762] collab: Fetch more meters and prices when
 initializing `StripeBilling` (#19288)

This PR makes it so we fetch more meters and prices when initializing
`StripeBilling`, as we have more than 10 meters defined.

Release Notes:

- N/A
---
 crates/collab/src/stripe_billing.rs | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/crates/collab/src/stripe_billing.rs b/crates/collab/src/stripe_billing.rs
index c121d8e8fddb32..f7cce28a3ad439 100644
--- a/crates/collab/src/stripe_billing.rs
+++ b/crates/collab/src/stripe_billing.rs
@@ -45,7 +45,13 @@ impl StripeBilling {
 
         let (meters, prices) = futures::try_join!(
             StripeMeter::list(&self.client),
-            stripe::Price::list(&self.client, &stripe::ListPrices::default())
+            stripe::Price::list(
+                &self.client,
+                &stripe::ListPrices {
+                    limit: Some(100),
+                    ..Default::default()
+                }
+            )
         )?;
 
         for meter in meters.data {
@@ -396,9 +402,12 @@ impl StripeMeter {
 
     pub fn list(client: &stripe::Client) -> stripe::Response<stripe::List<Self>> {
         #[derive(Serialize)]
-        struct Params {}
+        struct Params {
+            #[serde(skip_serializing_if = "Option::is_none")]
+            limit: Option<u64>,
+        }
 
-        client.get_query("/billing/meters", Params {})
+        client.get_query("/billing/meters", Params { limit: Some(100) })
     }
 }
 

From 69abe71bf74f9591b543e716940aca6e9fb5b727 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Wed, 16 Oct 2024 18:05:52 +0200
Subject: [PATCH 688/762] ssh remoting: Treat closed stderr as error (#19289)

Before this change we had a race condition bug: if stderr was closed
before the other two sockets, we wouldn't properly detect when the
server died, and not report or retry anything.

That's because we treated a closed stderr as a non-error.

Technically, it isn't an error (closing a connection is okay!), but
until we have a proper shutdown ceremony between all three processes, we
can treat it as an error, because that lets us to detect when the server
is gone.

On the client-side, we also always react to these errors by
reconnecting. Except when we shutdown: there we do a proper shutdown and
won't error on the proxy exit code.

So, this works, even if I wish there was a better way for the server to
communicate to the proxy that it shutdown properly. But I don't want a
fourth socket.

Release Notes:

- N/A
---
 crates/remote_server/src/unix.rs | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs
index 2972991b7bc64a..74198b18918ae9 100644
--- a/crates/remote_server/src/unix.rs
+++ b/crates/remote_server/src/unix.rs
@@ -186,7 +186,6 @@ fn start_server(
             log::info!("accepting new connections");
             let result = select! {
                 streams = streams.fuse() => {
-                    log::warn!("stdin {:?}, stdout: {:?}, stderr: {:?}", streams.0, streams.1, streams.2);
                     let (Some(Ok(stdin_stream)), Some(Ok(stdout_stream)), Some(Ok(stderr_stream))) = streams else {
                         break;
                     };
@@ -211,8 +210,6 @@ fn start_server(
                 break;
             };
 
-            log::info!("yep! we got connections");
-
             let mut input_buffer = Vec::new();
             let mut output_buffer = Vec::new();
             loop {
@@ -253,7 +250,6 @@ fn start_server(
                         }
                     }
 
-                    // // TODO: How do we handle backpressure?
                     log_message = log_rx.next().fuse() => {
                         if let Some(log_message) = log_message {
                             if let Err(error) = stderr_stream.write_all(&log_message).await {
@@ -316,7 +312,7 @@ pub fn execute_run(
 
     let listeners = ServerListeners::new(stdin_socket, stdout_socket, stderr_socket)?;
 
-    log::debug!("starting gpui app");
+    log::info!("starting headless gpui app");
     gpui::App::headless().run(move |cx| {
         settings::init(cx);
         HeadlessProject::init(cx);
@@ -404,7 +400,7 @@ pub fn execute_proxy(identifier: String, is_reconnecting: bool) -> Result<()> {
     init_logging_proxy();
     init_panic_hook();
 
-    log::debug!("starting up. PID: {}", std::process::id());
+    log::info!("starting proxy process. PID: {}", std::process::id());
 
     let server_paths = ServerPaths::new(&identifier)?;
 
@@ -417,7 +413,7 @@ pub fn execute_proxy(identifier: String, is_reconnecting: bool) -> Result<()> {
         }
     } else {
         if let Some(pid) = server_pid {
-            log::debug!("found server already running with PID {}. Killing process and cleaning up files...", pid);
+            log::info!("proxy found server already running with PID {}. Killing process and cleaning up files...", pid);
             kill_running_server(pid, &server_paths)?;
         }
 
@@ -443,7 +439,9 @@ pub fn execute_proxy(identifier: String, is_reconnecting: bool) -> Result<()> {
         loop {
             match stream.read(&mut stderr_buffer).await {
                 Ok(0) => {
-                    return anyhow::Ok(());
+                    let error =
+                        std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "stderr closed");
+                    Err(anyhow!(error))?;
                 }
                 Ok(n) => {
                     stderr.write_all(&mut stderr_buffer[..n]).await?;
@@ -463,6 +461,12 @@ pub fn execute_proxy(identifier: String, is_reconnecting: bool) -> Result<()> {
             result = stderr_task.fuse() => result,
         }
     }) {
+        if let Some(error) = forwarding_result.downcast_ref::<std::io::Error>() {
+            if error.kind() == std::io::ErrorKind::UnexpectedEof {
+                log::error!("connection to server closed due to unexpected EOF");
+                return Err(anyhow!("connection to server closed"));
+            }
+        }
         log::error!(
             "failed to forward messages: {:?}, terminating...",
             forwarding_result
@@ -518,7 +522,10 @@ fn spawn_server(paths: &ServerPaths) -> Result<()> {
         .arg(&paths.stderr_socket)
         .spawn()?;
 
-    log::debug!("server started. PID: {:?}", server_process.id());
+    log::info!(
+        "proxy spawned server process. PID: {:?}",
+        server_process.id()
+    );
 
     let mut total_time_waited = std::time::Duration::from_secs(0);
     let wait_duration = std::time::Duration::from_millis(20);

From fe0bcc063c9cbcde8396b4dcd21bd7c28d71f847 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 16 Oct 2024 12:10:39 -0400
Subject: [PATCH 689/762] collab: Add Stripe API key to Kubernetes template
 (#19292)

This PR adds the Stripe API key to the Kubernetes template.

It's optional right now, so we can set the API key when we're ready.

Release Notes:

- N/A
---
 crates/collab/k8s/collab.template.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/collab/k8s/collab.template.yml b/crates/collab/k8s/collab.template.yml
index 7d4ea6eb9a3cb2..a28c685f5e8cbc 100644
--- a/crates/collab/k8s/collab.template.yml
+++ b/crates/collab/k8s/collab.template.yml
@@ -199,6 +199,12 @@ spec:
                 secretKeyRef:
                   name: slack
                   key: panics_webhook
+            - name: STRIPE_API_KEY
+              valueFrom:
+                secretKeyRef:
+                  name: stripe
+                  key: api_key
+                  optional: true
             - name: COMPLETE_WITH_LANGUAGE_MODEL_RATE_LIMIT_PER_HOUR
               value: "1000"
             - name: SUPERMAVEN_ADMIN_API_KEY

From 474e670bbd2acb00ddb70cb350675023d9af5958 Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Wed, 16 Oct 2024 18:22:24 +0200
Subject: [PATCH 690/762] Increase monthly free tier spend from 5 dollars to 10
 dollars (#19291)

Release Notes:

- N/A

Co-authored-by: Marshall <marshall@zed.dev>
Co-authored-by: Richard <richard@zed.dev>
---
 crates/collab/src/llm.rs                      |  2 +-
 .../collab/src/llm/db/tests/billing_tests.rs  | 23 +++++++------------
 2 files changed, 9 insertions(+), 16 deletions(-)

diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index a94aa5afe94af9..1facfa20eac4fa 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -435,7 +435,7 @@ fn normalize_model_name(known_models: Vec<String>, name: String) -> String {
 
 /// The maximum monthly spending an individual user can reach on the free tier
 /// before they have to pay.
-pub const FREE_TIER_MONTHLY_SPENDING_LIMIT: Cents = Cents::from_dollars(5);
+pub const FREE_TIER_MONTHLY_SPENDING_LIMIT: Cents = Cents::from_dollars(10);
 
 /// The default value to use for maximum spend per month if the user did not
 /// explicitly set a maximum spend.
diff --git a/crates/collab/src/llm/db/tests/billing_tests.rs b/crates/collab/src/llm/db/tests/billing_tests.rs
index 241a705db4b6a1..2e71df5129764a 100644
--- a/crates/collab/src/llm/db/tests/billing_tests.rs
+++ b/crates/collab/src/llm/db/tests/billing_tests.rs
@@ -45,24 +45,17 @@ async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
 
     let user_id = UserId::from_proto(123);
 
-    let max_monthly_spend = Cents::from_dollars(10);
+    let max_monthly_spend = Cents::from_dollars(11);
 
     // Record usage that brings us close to the limit but doesn't exceed it
-    // Let's say we use $9.50 worth of tokens
-    let tokens_to_use = 190_000_000; // This will cost $9.50 at $0.05 per 1 million tokens
+    // Let's say we use $10.50 worth of tokens
+    let tokens_to_use = 210_000_000; // This will cost $10.50 at $0.05 per 1 million tokens
     let usage = TokenUsage {
         input: tokens_to_use,
         input_cache_creation: 0,
         input_cache_read: 0,
         output: 0,
     };
-    let cost = Cents::new(tokens_to_use as u32 / 1_000_000 * PRICE_PER_MILLION_INPUT_TOKENS as u32);
-
-    assert_eq!(
-        cost,
-        Cents::new(950),
-        "expected the cost to be $9.50, based on the inputs, but it wasn't"
-    );
 
     // Verify that before we record any usage, there are 0 billing events
     let billing_events = db.get_billing_events().await.unwrap();
@@ -102,8 +95,8 @@ async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
                 input_cache_read: 0,
                 output: 0,
             },
-            spending_this_month: Cents::new(950),
-            lifetime_spending: Cents::new(950),
+            spending_this_month: Cents::new(1050),
+            lifetime_spending: Cents::new(1050),
         }
     );
 
@@ -118,7 +111,7 @@ async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
     assert_eq!(billing_event.input_cache_read_tokens, 0);
     assert_eq!(billing_event.output_tokens, 0);
 
-    let tokens_to_exceed = 20_000_000; // This will cost $1.00 more, pushing us from $9.50 to $10.50, which is over the $10 monthly maximum limit
+    let tokens_to_exceed = 20_000_000; // This will cost $1.00 more, pushing us from $10.50 to $11.50, which is over the $11 monthly maximum limit
     let usage_exceeding = TokenUsage {
         input: tokens_to_exceed,
         input_cache_creation: 0,
@@ -158,8 +151,8 @@ async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
                 input_cache_read: 0,
                 output: 0,
             },
-            spending_this_month: Cents::new(1050),
-            lifetime_spending: Cents::new(1050),
+            spending_this_month: Cents::new(1150),
+            lifetime_spending: Cents::new(1150),
         }
     );
 }

From f8f3f369f69ce800a15e50d651ba9d502639c178 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Wed, 16 Oct 2024 12:47:57 -0400
Subject: [PATCH 691/762] v0.159.x dev

---
 Cargo.lock            | 2 +-
 crates/zed/Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1627d39dd66410..cb246160081463 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14577,7 +14577,7 @@ dependencies = [
 
 [[package]]
 name = "zed"
-version = "0.158.0"
+version = "0.159.0"
 dependencies = [
  "activity_indicator",
  "anyhow",
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index 69ca3aa98d2662..2feb110be4bcb4 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -2,7 +2,7 @@
 description = "The fast, collaborative code editor."
 edition = "2021"
 name = "zed"
-version = "0.158.0"
+version = "0.159.0"
 publish = false
 license = "GPL-3.0-or-later"
 authors = ["Zed Team <hi@zed.dev>"]

From 7a5003bea2e3c6feb783c705ef3da2d2aab09150 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Wed, 16 Oct 2024 18:53:05 +0200
Subject: [PATCH 692/762] ssh: Do not look up dev servers when rendering the
 default mode (#19295)

This should help with the bug where there's a mismatch between
connection count and the list showing empty state.

Closes #ISSUE

Release Notes:

- N/A
---
 crates/recent_projects/src/dev_servers.rs | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 7c98500ea841e2..0ec06ef0641a00 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -16,7 +16,6 @@ use gpui::canvas;
 use gpui::pulsating_between;
 use gpui::AsyncWindowContext;
 use gpui::ClipboardItem;
-use gpui::Subscription;
 use gpui::Task;
 use gpui::WeakView;
 use gpui::{
@@ -60,9 +59,7 @@ pub struct DevServerProjects {
     mode: Mode,
     focus_handle: FocusHandle,
     scroll_handle: ScrollHandle,
-    dev_server_store: Model<dev_server_projects::Store>,
     workspace: WeakView<Workspace>,
-    _dev_server_subscription: Subscription,
     selectable_items: SelectableItemList,
 }
 
@@ -333,11 +330,6 @@ impl DevServerProjects {
 
     pub fn new(cx: &mut ViewContext<Self>, workspace: WeakView<Workspace>) -> Self {
         let focus_handle = cx.focus_handle();
-        let dev_server_store = dev_server_projects::Store::global(cx);
-
-        let subscription = cx.observe(&dev_server_store, |_, _, cx| {
-            cx.notify();
-        });
 
         let mut base_style = cx.text_style();
         base_style.refine(&gpui::TextStyleRefinement {
@@ -349,9 +341,7 @@ impl DevServerProjects {
             mode: Mode::default_mode(),
             focus_handle,
             scroll_handle: ScrollHandle::new(),
-            dev_server_store,
             workspace,
-            _dev_server_subscription: subscription,
             selectable_items: Default::default(),
         }
     }
@@ -1113,7 +1103,6 @@ impl DevServerProjects {
         cx: &mut ViewContext<Self>,
     ) -> impl IntoElement {
         let scroll_state = scroll_state.parent_view(cx.view());
-        let dev_servers = self.dev_server_store.read(cx).dev_servers();
         let ssh_connections = SshSettings::get_global(cx)
             .ssh_connections()
             .collect::<Vec<_>>();
@@ -1171,7 +1160,7 @@ impl DevServerProjects {
             )
             .into_any_element();
 
-        let server_count = format!("Servers: {}", ssh_connections.len() + dev_servers.len());
+        let server_count = format!("Servers: {}", ssh_connections.len());
 
         Modal::new("remote-projects", Some(self.scroll_handle.clone()))
             .header(

From 879a2ea06f4144f9850db098c6a1a8a2b4f6afd6 Mon Sep 17 00:00:00 2001
From: Matin Aniss <76515905+MatinAniss@users.noreply.github.com>
Date: Thu, 17 Oct 2024 04:26:26 +1100
Subject: [PATCH 693/762] gpui: Replace redundant code in animation (#19273)

Just a small change to replace some redundant code in the animation
element.

Release Notes:

- N/A
---
 crates/gpui/src/elements/animation.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/crates/gpui/src/elements/animation.rs b/crates/gpui/src/elements/animation.rs
index daa119849655ee..bffa52cfbafb74 100644
--- a/crates/gpui/src/elements/animation.rs
+++ b/crates/gpui/src/elements/animation.rs
@@ -133,14 +133,7 @@ impl<E: IntoElement + 'static> Element for AnimationElement<E> {
             let mut element = (self.animator)(element, delta).into_any_element();
 
             if !done {
-                let parent_id = cx.parent_view_id();
-                cx.on_next_frame(move |cx| {
-                    if let Some(parent_id) = parent_id {
-                        cx.notify(parent_id)
-                    } else {
-                        cx.refresh()
-                    }
-                })
+                cx.request_animation_frame();
             }
 
             ((element.request_layout(cx), element), state)

From 338bf3fd282bf467dbd2f76c08b70fb4160cd1d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E5=B0=8F=E7=99=BD?= <364772080@qq.com>
Date: Thu, 17 Oct 2024 01:29:42 +0800
Subject: [PATCH 694/762] windows: Fix window not displaying correctly on
 launch (#19124)

Closes #18705 (comment)

This PR fixes the issue where the Zed window was not displaying
correctly on launch. Now, when Zed is closed in a maximized state, it
will reopen in a maximized state.

On macOS, when a window is created but not yet visible, calling `zoom`
or `toggle_fullscreen` will still affect the hidden window. However,
this behavior is different on Windows, so special handling is required.

Also, since #18705 hasn't been reviewed yet, I'm not sure if this PR
should be merged now or if it should wait until #18705 is reviewed
first.


Release Notes:

- N/A
---
 crates/gpui/src/platform/windows/window.rs | 174 +++++++++++++--------
 1 file changed, 109 insertions(+), 65 deletions(-)

diff --git a/crates/gpui/src/platform/windows/window.rs b/crates/gpui/src/platform/windows/window.rs
index 3faaa6a8d2472b..a363745f9baf0a 100644
--- a/crates/gpui/src/platform/windows/window.rs
+++ b/crates/gpui/src/platform/windows/window.rs
@@ -52,12 +52,13 @@ pub struct WindowsWindowState {
 
     pub display: WindowsDisplay,
     fullscreen: Option<StyleAndBounds>,
-    initial_placement: Option<WINDOWPLACEMENT>,
+    initial_placement: Option<WindowOpenStatus>,
     hwnd: HWND,
 }
 
 pub(crate) struct WindowsWindowStatePtr {
     hwnd: HWND,
+    this: Weak<Self>,
     pub(crate) state: RefCell<WindowsWindowState>,
     pub(crate) handle: AnyWindowHandle,
     pub(crate) hide_title_bar: bool,
@@ -222,9 +223,10 @@ impl WindowsWindowStatePtr {
             context.display,
         )?);
 
-        Ok(Rc::new(Self {
-            state,
+        Ok(Rc::new_cyclic(|this| Self {
             hwnd,
+            this: this.clone(),
+            state,
             handle: context.handle,
             hide_title_bar: context.hide_title_bar,
             is_movable: context.is_movable,
@@ -235,11 +237,86 @@ impl WindowsWindowStatePtr {
         }))
     }
 
+    fn toggle_fullscreen(&self) {
+        let Some(state_ptr) = self.this.upgrade() else {
+            log::error!("Unable to toggle fullscreen: window has been dropped");
+            return;
+        };
+        self.executor
+            .spawn(async move {
+                let mut lock = state_ptr.state.borrow_mut();
+                let StyleAndBounds {
+                    style,
+                    x,
+                    y,
+                    cx,
+                    cy,
+                } = if let Some(state) = lock.fullscreen.take() {
+                    state
+                } else {
+                    let (window_bounds, _) = lock.calculate_window_bounds();
+                    lock.fullscreen_restore_bounds = window_bounds;
+                    let style =
+                        WINDOW_STYLE(unsafe { get_window_long(state_ptr.hwnd, GWL_STYLE) } as _);
+                    let mut rc = RECT::default();
+                    unsafe { GetWindowRect(state_ptr.hwnd, &mut rc) }.log_err();
+                    let _ = lock.fullscreen.insert(StyleAndBounds {
+                        style,
+                        x: rc.left,
+                        y: rc.top,
+                        cx: rc.right - rc.left,
+                        cy: rc.bottom - rc.top,
+                    });
+                    let style = style
+                        & !(WS_THICKFRAME
+                            | WS_SYSMENU
+                            | WS_MAXIMIZEBOX
+                            | WS_MINIMIZEBOX
+                            | WS_CAPTION);
+                    let physical_bounds = lock.display.physical_bounds();
+                    StyleAndBounds {
+                        style,
+                        x: physical_bounds.left().0,
+                        y: physical_bounds.top().0,
+                        cx: physical_bounds.size.width.0,
+                        cy: physical_bounds.size.height.0,
+                    }
+                };
+                drop(lock);
+                unsafe { set_window_long(state_ptr.hwnd, GWL_STYLE, style.0 as isize) };
+                unsafe {
+                    SetWindowPos(
+                        state_ptr.hwnd,
+                        HWND::default(),
+                        x,
+                        y,
+                        cx,
+                        cy,
+                        SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOZORDER,
+                    )
+                }
+                .log_err();
+            })
+            .detach();
+    }
+
     fn set_window_placement(&self) -> Result<()> {
-        let Some(placement) = self.state.borrow_mut().initial_placement.take() else {
+        let Some(open_status) = self.state.borrow_mut().initial_placement.take() else {
             return Ok(());
         };
-        unsafe { SetWindowPlacement(self.hwnd, &placement)? };
+        match open_status.state {
+            WindowOpenState::Maximized => unsafe {
+                SetWindowPlacement(self.hwnd, &open_status.placement)?;
+                ShowWindowAsync(self.hwnd, SW_MAXIMIZE).ok()?;
+            },
+            WindowOpenState::Fullscreen => {
+                unsafe { SetWindowPlacement(self.hwnd, &open_status.placement)? };
+                self.toggle_fullscreen();
+            }
+            WindowOpenState::Windowed => unsafe {
+                SetWindowPlacement(self.hwnd, &open_status.placement)?;
+            },
+        }
         Ok(())
     }
 }
@@ -361,7 +438,10 @@ impl WindowsWindow {
         if params.show {
             unsafe { SetWindowPlacement(hwnd, &placement)? };
         } else {
-            state_ptr.state.borrow_mut().initial_placement = Some(placement);
+            state_ptr.state.borrow_mut().initial_placement = Some(WindowOpenStatus {
+                placement,
+                state: WindowOpenState::Windowed,
+            });
         }
 
         Ok(Self(state_ptr))
@@ -579,68 +659,21 @@ impl PlatformWindow for WindowsWindow {
     }
 
     fn zoom(&self) {
-        unsafe { ShowWindowAsync(self.0.hwnd, SW_MAXIMIZE).ok().log_err() };
+        unsafe {
+            if IsWindowVisible(self.0.hwnd).as_bool() {
+                ShowWindowAsync(self.0.hwnd, SW_MAXIMIZE).ok().log_err();
+            } else if let Some(status) = self.0.state.borrow_mut().initial_placement.as_mut() {
+                status.state = WindowOpenState::Maximized;
+            }
+        }
     }
 
     fn toggle_fullscreen(&self) {
-        let state_ptr = self.0.clone();
-        self.0
-            .executor
-            .spawn(async move {
-                let mut lock = state_ptr.state.borrow_mut();
-                let StyleAndBounds {
-                    style,
-                    x,
-                    y,
-                    cx,
-                    cy,
-                } = if let Some(state) = lock.fullscreen.take() {
-                    state
-                } else {
-                    let (window_bounds, _) = lock.calculate_window_bounds();
-                    lock.fullscreen_restore_bounds = window_bounds;
-                    let style =
-                        WINDOW_STYLE(unsafe { get_window_long(state_ptr.hwnd, GWL_STYLE) } as _);
-                    let mut rc = RECT::default();
-                    unsafe { GetWindowRect(state_ptr.hwnd, &mut rc) }.log_err();
-                    let _ = lock.fullscreen.insert(StyleAndBounds {
-                        style,
-                        x: rc.left,
-                        y: rc.top,
-                        cx: rc.right - rc.left,
-                        cy: rc.bottom - rc.top,
-                    });
-                    let style = style
-                        & !(WS_THICKFRAME
-                            | WS_SYSMENU
-                            | WS_MAXIMIZEBOX
-                            | WS_MINIMIZEBOX
-                            | WS_CAPTION);
-                    let physical_bounds = lock.display.physical_bounds();
-                    StyleAndBounds {
-                        style,
-                        x: physical_bounds.left().0,
-                        y: physical_bounds.top().0,
-                        cx: physical_bounds.size.width.0,
-                        cy: physical_bounds.size.height.0,
-                    }
-                };
-                drop(lock);
-                unsafe { set_window_long(state_ptr.hwnd, GWL_STYLE, style.0 as isize) };
-                unsafe {
-                    SetWindowPos(
-                        state_ptr.hwnd,
-                        HWND::default(),
-                        x,
-                        y,
-                        cx,
-                        cy,
-                        SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOZORDER,
-                    )
-                }
-                .log_err();
-            })
-            .detach();
+        if unsafe { IsWindowVisible(self.0.hwnd).as_bool() } {
+            self.0.toggle_fullscreen();
+        } else if let Some(status) = self.0.state.borrow_mut().initial_placement.as_mut() {
+            status.state = WindowOpenState::Fullscreen;
+        }
     }
 
     fn is_fullscreen(&self) -> bool {
@@ -925,6 +958,17 @@ impl WindowBorderOffset {
     }
 }
 
+struct WindowOpenStatus {
+    placement: WINDOWPLACEMENT,
+    state: WindowOpenState,
+}
+
+enum WindowOpenState {
+    Maximized,
+    Fullscreen,
+    Windowed,
+}
+
 fn register_wnd_class(icon_handle: HICON) -> PCWSTR {
     const CLASS_NAME: PCWSTR = w!("Zed::Window");
 

From d35b646dbba542e5ec530273fd25ce31fb9039eb Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 16 Oct 2024 14:03:42 -0400
Subject: [PATCH 695/762] assistant: Direct user to account page to subscribe
 for more LLM usage (#19300)

This PR updates the location where we send the user to subscribe for
more LLM usage to the account page.

Release Notes:

- Updated the URL to the account page when subscribing to LLM usage.
---
 crates/assistant/src/assistant_panel.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 943cbbb29ff015..a3e189287f4564 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -4347,7 +4347,7 @@ impl ContextEditor {
 
     fn render_payment_required_error(&self, cx: &mut ViewContext<Self>) -> AnyElement {
         const ERROR_MESSAGE: &str = "Free tier exceeded. Subscribe and add payment to continue using Zed LLMs. You'll be billed at cost for tokens used.";
-        const SUBSCRIBE_URL: &str = "https://zed.dev/api/billing/initiate_checkout";
+        const ACCOUNT_URL: &str = "https://zed.dev/account";
 
         v_flex()
             .gap_0p5()
@@ -4372,7 +4372,7 @@ impl ContextEditor {
                     .child(Button::new("subscribe", "Subscribe").on_click(cx.listener(
                         |this, _, cx| {
                             this.last_error = None;
-                            cx.open_url(SUBSCRIBE_URL);
+                            cx.open_url(ACCOUNT_URL);
                             cx.notify();
                         },
                     )))

From 3dcc638537f1ad323c305f3e4d020bfd5d8e3c2b Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 16 Oct 2024 21:49:54 +0300
Subject: [PATCH 696/762] Better handle shell for remote ssh projects (#19297)

Release Notes:

- N/A

Co-authored-by: Conrad Irwin <conrad@zed.dev>
---
 crates/project/src/terminals.rs            | 12 +++++-------
 crates/terminal_view/src/terminal_panel.rs | 16 +++++++++++++++-
 2 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/crates/project/src/terminals.rs b/crates/project/src/terminals.rs
index ac4e890aaddfa6..37b29c2a1d951b 100644
--- a/crates/project/src/terminals.rs
+++ b/crates/project/src/terminals.rs
@@ -6,6 +6,7 @@ use itertools::Itertools;
 use settings::{Settings, SettingsLocation};
 use smol::channel::bounded;
 use std::{
+    borrow::Cow,
     env::{self},
     iter,
     path::{Path, PathBuf},
@@ -341,10 +342,9 @@ pub fn wrap_for_ssh(
     venv_directory: Option<PathBuf>,
 ) -> (String, Vec<String>) {
     let to_run = if let Some((command, args)) = command {
-        iter::once(command)
-            .chain(args)
-            .filter_map(|arg| shlex::try_quote(arg).ok())
-            .join(" ")
+        let command = Cow::Borrowed(command.as_str());
+        let args = args.iter().filter_map(|arg| shlex::try_quote(arg).ok());
+        iter::once(command).chain(args).join(" ")
     } else {
         "exec ${SHELL:-sh} -l".to_string()
     };
@@ -390,9 +390,7 @@ pub fn wrap_for_ssh(
         SshCommand::Direct(ssh_args) => ("ssh".to_string(), ssh_args.clone()),
     };
 
-    if command.is_none() {
-        args.push("-t".to_string())
-    }
+    args.push("-t".to_string());
     args.push(shell_invocation);
     (program, args)
 }
diff --git a/crates/terminal_view/src/terminal_panel.rs b/crates/terminal_view/src/terminal_panel.rs
index 7d95613804414c..5097cbc28a4ae3 100644
--- a/crates/terminal_view/src/terminal_panel.rs
+++ b/crates/terminal_view/src/terminal_panel.rs
@@ -395,7 +395,21 @@ impl TerminalPanel {
         let mut spawn_task = spawn_in_terminal.clone();
         // Set up shell args unconditionally, as tasks are always spawned inside of a shell.
         let Some((shell, mut user_args)) = (match spawn_in_terminal.shell.clone() {
-            Shell::System => retrieve_system_shell().map(|shell| (shell, Vec::new())),
+            Shell::System => {
+                match self
+                    .workspace
+                    .update(cx, |workspace, cx| workspace.project().read(cx).is_local())
+                {
+                    Ok(local) => {
+                        if local {
+                            retrieve_system_shell().map(|shell| (shell, Vec::new()))
+                        } else {
+                            Some(("\"${SHELL:-sh}\"".to_string(), Vec::new()))
+                        }
+                    }
+                    Err(_no_window_e) => return,
+                }
+            }
             Shell::Program(shell) => Some((shell, Vec::new())),
             Shell::WithArguments { program, args } => Some((program, args)),
         }) else {

From 02f63e49ed1fb9a890f736fdc8f00540ccf46eb6 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 16 Oct 2024 21:50:51 +0300
Subject: [PATCH 697/762] Resolve proto hints with empty resolve data (#19274)

Fixed ssh remoting not showing a lot of hints


Release Notes:

- N/A
---
 crates/project/src/lsp_command.rs | 18 +++++++++---------
 crates/proto/proto/zed.proto      |  2 +-
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/crates/project/src/lsp_command.rs b/crates/project/src/lsp_command.rs
index 96eb327e8c4344..4a80180d7cd888 100644
--- a/crates/project/src/lsp_command.rs
+++ b/crates/project/src/lsp_command.rs
@@ -2439,15 +2439,13 @@ impl InlayHints {
             ResolveState::Resolved => (0, None),
             ResolveState::CanResolve(server_id, resolve_data) => (
                 1,
-                resolve_data
-                    .map(|json_data| {
+                Some(proto::resolve_state::LspResolveState {
+                    server_id: server_id.0 as u64,
+                    value: resolve_data.map(|json_data| {
                         serde_json::to_string(&json_data)
                             .expect("failed to serialize resolve json data")
-                    })
-                    .map(|value| proto::resolve_state::LspResolveState {
-                        server_id: server_id.0 as u64,
-                        value,
                     }),
+                }),
             ),
             ResolveState::Resolving => (2, None),
         };
@@ -2515,9 +2513,11 @@ impl InlayHints {
         let resolve_state_data = resolve_state
             .lsp_resolve_state.as_ref()
             .map(|lsp_resolve_state| {
-                serde_json::from_str::<Option<lsp::LSPAny>>(&lsp_resolve_state.value)
-                    .with_context(|| format!("incorrect proto inlay hint message: non-json resolve state {lsp_resolve_state:?}"))
-                    .map(|state| (LanguageServerId(lsp_resolve_state.server_id as usize), state))
+                let value = lsp_resolve_state.value.as_deref().map(|value| {
+                    serde_json::from_str::<Option<lsp::LSPAny>>(value)
+                        .with_context(|| format!("incorrect proto inlay hint message: non-json resolve state {lsp_resolve_state:?}"))
+                }).transpose()?.flatten();
+                anyhow::Ok((LanguageServerId(lsp_resolve_state.server_id as usize), value))
             })
             .transpose()?;
         let resolve_state = match resolve_state.state {
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index 750aa924b4fc9b..822ccf6cf7112b 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -1207,7 +1207,7 @@ message ResolveState {
     }
 
     message LspResolveState {
-        string value = 1;
+        optional string value = 1;
         uint64 server_id = 2;
     }
 }

From 56f69be2e772a39a0489bc736b35e08d04b79299 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Wed, 16 Oct 2024 22:57:39 +0300
Subject: [PATCH 698/762] Do not allow [re]running ssh tasks when not connected
 to the server (#19306)

Release Notes:

- N/A
---
 crates/tasks_ui/src/modal.rs  |  7 -------
 crates/workspace/src/tasks.rs | 14 ++++++++++++++
 2 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/crates/tasks_ui/src/modal.rs b/crates/tasks_ui/src/modal.rs
index f11f58e010cdc9..c18a0e6ba62741 100644
--- a/crates/tasks_ui/src/modal.rs
+++ b/crates/tasks_ui/src/modal.rs
@@ -384,13 +384,6 @@ impl PickerDelegate for TasksModalDelegate {
                 .start_slot::<Icon>(icon)
                 .end_slot::<AnyElement>(history_run_icon)
                 .spacing(ListItemSpacing::Sparse)
-                // .map(|this| {
-                //     if Some(ix) <= self.divider_index {
-                //         this.start_slot(Icon::new(IconName::HistoryRerun).size(IconSize::Small))
-                //     } else {
-                //         this.start_slot(v_flex().flex_none().size(IconSize::Small.rems()))
-                //     }
-                // })
                 .when_some(tooltip_label, |list_item, item_label| {
                     list_item.tooltip(move |_| item_label.clone())
                 })
diff --git a/crates/workspace/src/tasks.rs b/crates/workspace/src/tasks.rs
index 377875ee1b2a4a..c2b6e51acd2173 100644
--- a/crates/workspace/src/tasks.rs
+++ b/crates/workspace/src/tasks.rs
@@ -1,4 +1,5 @@
 use project::TaskSourceKind;
+use remote::ConnectionState;
 use task::{ResolvedTask, TaskContext, TaskTemplate};
 use ui::ViewContext;
 
@@ -12,6 +13,19 @@ pub fn schedule_task(
     omit_history: bool,
     cx: &mut ViewContext<'_, Workspace>,
 ) {
+    match workspace.project.read(cx).ssh_connection_state(cx) {
+        None | Some(ConnectionState::Connected) => {}
+        Some(
+            ConnectionState::Connecting
+            | ConnectionState::Disconnected
+            | ConnectionState::HeartbeatMissed
+            | ConnectionState::Reconnecting,
+        ) => {
+            log::warn!("Cannot schedule tasks when disconnected from a remote host");
+            return;
+        }
+    }
+
     if let Some(spawn_in_terminal) =
         task_to_resolve.resolve_task(&task_source_kind.to_id_base(), task_cx)
     {

From 0e22c9f275a4b99b799ec3bbaa379c9dfe91e49c Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Wed, 16 Oct 2024 16:07:05 -0400
Subject: [PATCH 699/762] docs: Add C++ clangd example arguments (#19308)

---
 docs/src/languages/cpp.md | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/docs/src/languages/cpp.md b/docs/src/languages/cpp.md
index 127330dd940dc5..dac1f210d48c29 100644
--- a/docs/src/languages/cpp.md
+++ b/docs/src/languages/cpp.md
@@ -38,6 +38,23 @@ If you want to disable Zed looking for a `clangd` binary, you can set `ignore_sy
 }
 ```
 
+## Arguments
+
+You can pass any number of arguments to clangd. To see a full set of available options, run `clangd --help` from the command line. For example with `--function-arg-placeholders=0` completions contain only parentheses for function calls, while the default (`--function-arg-placeholders=1`) completions also contain placeholders for method parameters.
+
+```json
+{
+  "lsp": {
+    "clangd": {
+      "binary": {
+        "path": "/path/to/clangd",
+        "arguments": ["--function-arg-placeholders=0"]
+      }
+    }
+  }
+}
+```
+
 ## More server configuration
 
 In the root of your project, it is generally common to create a `.clangd` file to set extra configuration.

From c8b6ad96663b18d502c6b50aff4805dbfdf69d2c Mon Sep 17 00:00:00 2001
From: David Soria Parra <167242713+dsp-ant@users.noreply.github.com>
Date: Wed, 16 Oct 2024 21:07:15 +0100
Subject: [PATCH 700/762] Context Servers: Protocol fixes and UI improvements
 (#19087)

This PR does two things. It fixes some minor inconsistencies in the
protocol. This is mostly about handling JSON RPC notifications correctly
and skipping fields when set to None.

Second part is about improving the rendering of context server commands,
by passing on the description
of the command to the slash command UI and showing the name of the
argument as a CodeLabel.

Release Notes:

- N/A
---
 .../slash_command/context_server_command.rs   |  35 +++--
 crates/context_servers/src/client.rs          |  16 +--
 crates/context_servers/src/manager.rs         |   2 +-
 crates/context_servers/src/protocol.rs        |  18 ++-
 crates/context_servers/src/types.rs           | 135 ++++++++++++++----
 5 files changed, 152 insertions(+), 54 deletions(-)

diff --git a/crates/assistant/src/slash_command/context_server_command.rs b/crates/assistant/src/slash_command/context_server_command.rs
index 6b1ae39186d28f..3db057d07494cd 100644
--- a/crates/assistant/src/slash_command/context_server_command.rs
+++ b/crates/assistant/src/slash_command/context_server_command.rs
@@ -1,3 +1,4 @@
+use super::create_label_for_command;
 use anyhow::{anyhow, Result};
 use assistant_slash_command::{
     AfterCompletion, ArgumentCompletion, SlashCommand, SlashCommandOutput,
@@ -6,9 +7,9 @@ use assistant_slash_command::{
 use collections::HashMap;
 use context_servers::{
     manager::{ContextServer, ContextServerManager},
-    protocol::PromptInfo,
+    types::Prompt,
 };
-use gpui::{Task, WeakView, WindowContext};
+use gpui::{AppContext, Task, WeakView, WindowContext};
 use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate};
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
@@ -18,11 +19,11 @@ use workspace::Workspace;
 
 pub struct ContextServerSlashCommand {
     server_id: String,
-    prompt: PromptInfo,
+    prompt: Prompt,
 }
 
 impl ContextServerSlashCommand {
-    pub fn new(server: &Arc<ContextServer>, prompt: PromptInfo) -> Self {
+    pub fn new(server: &Arc<ContextServer>, prompt: Prompt) -> Self {
         Self {
             server_id: server.id.clone(),
             prompt,
@@ -35,12 +36,28 @@ impl SlashCommand for ContextServerSlashCommand {
         self.prompt.name.clone()
     }
 
+    fn label(&self, cx: &AppContext) -> language::CodeLabel {
+        let mut parts = vec![self.prompt.name.as_str()];
+        if let Some(args) = &self.prompt.arguments {
+            if let Some(arg) = args.first() {
+                parts.push(arg.name.as_str());
+            }
+        }
+        create_label_for_command(&parts[0], &parts[1..], cx)
+    }
+
     fn description(&self) -> String {
-        format!("Run context server command: {}", self.prompt.name)
+        match &self.prompt.description {
+            Some(desc) => desc.clone(),
+            None => format!("Run '{}' from {}", self.prompt.name, self.server_id),
+        }
     }
 
     fn menu_text(&self) -> String {
-        format!("Run '{}' from {}", self.prompt.name, self.server_id)
+        match &self.prompt.description {
+            Some(desc) => desc.clone(),
+            None => format!("Run '{}' from {}", self.prompt.name, self.server_id),
+        }
     }
 
     fn requires_argument(&self) -> bool {
@@ -154,7 +171,7 @@ impl SlashCommand for ContextServerSlashCommand {
     }
 }
 
-fn completion_argument(prompt: &PromptInfo, arguments: &[String]) -> Result<(String, String)> {
+fn completion_argument(prompt: &Prompt, arguments: &[String]) -> Result<(String, String)> {
     if arguments.is_empty() {
         return Err(anyhow!("No arguments given"));
     }
@@ -170,7 +187,7 @@ fn completion_argument(prompt: &PromptInfo, arguments: &[String]) -> Result<(Str
     }
 }
 
-fn prompt_arguments(prompt: &PromptInfo, arguments: &[String]) -> Result<HashMap<String, String>> {
+fn prompt_arguments(prompt: &Prompt, arguments: &[String]) -> Result<HashMap<String, String>> {
     match &prompt.arguments {
         Some(args) if args.len() > 1 => Err(anyhow!(
             "Prompt has more than one argument, which is not supported"
@@ -199,7 +216,7 @@ fn prompt_arguments(prompt: &PromptInfo, arguments: &[String]) -> Result<HashMap
 /// MCP servers can return prompts with multiple arguments. Since we only
 /// support one argument, we ignore all others. This is the necessary predicate
 /// for this.
-pub fn acceptable_prompt(prompt: &PromptInfo) -> bool {
+pub fn acceptable_prompt(prompt: &Prompt) -> bool {
     match &prompt.arguments {
         None => true,
         Some(args) if args.len() <= 1 => true,
diff --git a/crates/context_servers/src/client.rs b/crates/context_servers/src/client.rs
index aff186b115672b..6681023c008711 100644
--- a/crates/context_servers/src/client.rs
+++ b/crates/context_servers/src/client.rs
@@ -26,7 +26,7 @@ const JSON_RPC_VERSION: &str = "2.0";
 const REQUEST_TIMEOUT: Duration = Duration::from_secs(60);
 
 type ResponseHandler = Box<dyn Send + FnOnce(Result<String, Error>)>;
-type NotificationHandler = Box<dyn Send + FnMut(RequestId, Value, AsyncAppContext)>;
+type NotificationHandler = Box<dyn Send + FnMut(Value, AsyncAppContext)>;
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
 #[serde(untagged)]
@@ -94,7 +94,6 @@ enum CspResult<T> {
 #[derive(Serialize, Deserialize)]
 struct Notification<'a, T> {
     jsonrpc: &'static str,
-    id: RequestId,
     #[serde(borrow)]
     method: &'a str,
     params: T,
@@ -103,7 +102,6 @@ struct Notification<'a, T> {
 #[derive(Debug, Clone, Deserialize)]
 struct AnyNotification<'a> {
     jsonrpc: &'a str,
-    id: RequestId,
     method: String,
     #[serde(default)]
     params: Option<Value>,
@@ -246,11 +244,7 @@ impl Client {
                     if let Some(handler) =
                         notification_handlers.get_mut(notification.method.as_str())
                     {
-                        handler(
-                            notification.id,
-                            notification.params.unwrap_or(Value::Null),
-                            cx.clone(),
-                        );
+                        handler(notification.params.unwrap_or(Value::Null), cx.clone());
                     }
                 }
             }
@@ -378,10 +372,8 @@ impl Client {
     /// Sends a notification to the context server without expecting a response.
     /// This function serializes the notification and sends it through the outbound channel.
     pub fn notify(&self, method: &str, params: impl Serialize) -> Result<()> {
-        let id = self.next_id.fetch_add(1, SeqCst);
         let notification = serde_json::to_string(&Notification {
             jsonrpc: JSON_RPC_VERSION,
-            id: RequestId::Int(id),
             method,
             params,
         })
@@ -390,13 +382,13 @@ impl Client {
         Ok(())
     }
 
-    pub fn on_notification<F>(&self, method: &'static str, mut f: F)
+    pub fn on_notification<F>(&self, method: &'static str, f: F)
     where
         F: 'static + Send + FnMut(Value, AsyncAppContext),
     {
         self.notification_handlers
             .lock()
-            .insert(method, Box::new(move |_, params, cx| f(params, cx)));
+            .insert(method, Box::new(f));
     }
 
     pub fn name(&self) -> &str {
diff --git a/crates/context_servers/src/manager.rs b/crates/context_servers/src/manager.rs
index 08e403a43442ea..3c21fd53fb5824 100644
--- a/crates/context_servers/src/manager.rs
+++ b/crates/context_servers/src/manager.rs
@@ -85,7 +85,7 @@ impl ContextServer {
         )?;
 
         let protocol = crate::protocol::ModelContextProtocol::new(client);
-        let client_info = types::EntityInfo {
+        let client_info = types::Implementation {
             name: "Zed".to_string(),
             version: env!("CARGO_PKG_VERSION").to_string(),
         };
diff --git a/crates/context_servers/src/protocol.rs b/crates/context_servers/src/protocol.rs
index 87da217f7d1936..451db56ef31df0 100644
--- a/crates/context_servers/src/protocol.rs
+++ b/crates/context_servers/src/protocol.rs
@@ -11,8 +11,6 @@ use collections::HashMap;
 use crate::client::Client;
 use crate::types;
 
-pub use types::PromptInfo;
-
 const PROTOCOL_VERSION: u32 = 1;
 
 pub struct ModelContextProtocol {
@@ -26,7 +24,7 @@ impl ModelContextProtocol {
 
     pub async fn initialize(
         self,
-        client_info: types::EntityInfo,
+        client_info: types::Implementation,
     ) -> Result<InitializedContextServerProtocol> {
         let params = types::InitializeParams {
             protocol_version: PROTOCOL_VERSION,
@@ -96,7 +94,7 @@ impl InitializedContextServerProtocol {
     }
 
     /// List the MCP prompts.
-    pub async fn list_prompts(&self) -> Result<Vec<types::PromptInfo>> {
+    pub async fn list_prompts(&self) -> Result<Vec<types::Prompt>> {
         self.check_capability(ServerCapability::Prompts)?;
 
         let response: types::PromptsListResponse = self
@@ -107,6 +105,18 @@ impl InitializedContextServerProtocol {
         Ok(response.prompts)
     }
 
+    /// List the MCP resources.
+    pub async fn list_resources(&self) -> Result<types::ResourcesListResponse> {
+        self.check_capability(ServerCapability::Resources)?;
+
+        let response: types::ResourcesListResponse = self
+            .inner
+            .request(types::RequestType::ResourcesList.as_str(), ())
+            .await?;
+
+        Ok(response)
+    }
+
     /// Executes a prompt with the given arguments and returns the result.
     pub async fn run_prompt<P: AsRef<str>>(
         &self,
diff --git a/crates/context_servers/src/types.rs b/crates/context_servers/src/types.rs
index cd95ecd7adb368..04ac87c704d06c 100644
--- a/crates/context_servers/src/types.rs
+++ b/crates/context_servers/src/types.rs
@@ -15,6 +15,7 @@ pub enum RequestType {
     PromptsGet,
     PromptsList,
     CompletionComplete,
+    Ping,
 }
 
 impl RequestType {
@@ -30,6 +31,7 @@ impl RequestType {
             RequestType::PromptsGet => "prompts/get",
             RequestType::PromptsList => "prompts/list",
             RequestType::CompletionComplete => "completion/complete",
+            RequestType::Ping => "ping",
         }
     }
 }
@@ -39,14 +41,15 @@ impl RequestType {
 pub struct InitializeParams {
     pub protocol_version: u32,
     pub capabilities: ClientCapabilities,
-    pub client_info: EntityInfo,
+    pub client_info: Implementation,
 }
 
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CallToolParams {
     pub name: String,
-    pub arguments: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub arguments: Option<HashMap<String, serde_json::Value>>,
 }
 
 #[derive(Debug, Serialize)]
@@ -77,6 +80,7 @@ pub struct LoggingSetLevelParams {
 #[serde(rename_all = "camelCase")]
 pub struct PromptsGetParams {
     pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub arguments: Option<HashMap<String, String>>,
 }
 
@@ -101,6 +105,13 @@ pub struct PromptReference {
     pub name: String,
 }
 
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ResourceReference {
+    pub r#type: PromptReferenceType,
+    pub uri: Url,
+}
+
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PromptReferenceType {
@@ -110,13 +121,6 @@ pub enum PromptReferenceType {
     Resource,
 }
 
-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ResourceReference {
-    pub r#type: String,
-    pub uri: String,
-}
-
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionArgument {
@@ -129,7 +133,7 @@ pub struct CompletionArgument {
 pub struct InitializeResponse {
     pub protocol_version: u32,
     pub capabilities: ServerCapabilities,
-    pub server_info: EntityInfo,
+    pub server_info: Implementation,
 }
 
 #[derive(Debug, Deserialize)]
@@ -141,13 +145,39 @@ pub struct ResourcesReadResponse {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesListResponse {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub resource_templates: Option<Vec<ResourceTemplate>>,
-    pub resources: Vec<Resource>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub resources: Option<Vec<Resource>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SamplingMessage {
+    pub role: SamplingRole,
+    pub content: SamplingContent,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum SamplingRole {
+    User,
+    Assistant,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum SamplingContent {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "image")]
+    Image { data: String, mime_type: String },
 }
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptsGetResponse {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
     pub prompt: String,
 }
@@ -155,7 +185,7 @@ pub struct PromptsGetResponse {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptsListResponse {
-    pub prompts: Vec<PromptInfo>,
+    pub prompts: Vec<Prompt>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -168,61 +198,91 @@ pub struct CompletionCompleteResponse {
 #[serde(rename_all = "camelCase")]
 pub struct CompletionResult {
     pub values: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub total: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub has_more: Option<bool>,
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct PromptInfo {
+pub struct Prompt {
     pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub arguments: Option<Vec<PromptArgument>>,
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptArgument {
     pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub required: Option<bool>,
 }
 
-// Shared Types
-
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ClientCapabilities {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub experimental: Option<HashMap<String, serde_json::Value>>,
-    pub sampling: Option<HashMap<String, serde_json::Value>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sampling: Option<serde_json::Value>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ServerCapabilities {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub experimental: Option<HashMap<String, serde_json::Value>>,
-    pub logging: Option<HashMap<String, serde_json::Value>>,
-    pub prompts: Option<HashMap<String, serde_json::Value>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub logging: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub prompts: Option<PromptsCapabilities>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub resources: Option<ResourcesCapabilities>,
-    pub tools: Option<HashMap<String, serde_json::Value>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tools: Option<ToolsCapabilities>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PromptsCapabilities {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub list_changed: Option<bool>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesCapabilities {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub subscribe: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub list_changed: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ToolsCapabilities {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub list_changed: Option<bool>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Tool {
     pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
     pub input_schema: serde_json::Value,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct EntityInfo {
+pub struct Implementation {
     pub name: String,
     pub version: String,
 }
@@ -231,6 +291,10 @@ pub struct EntityInfo {
 #[serde(rename_all = "camelCase")]
 pub struct Resource {
     pub uri: Url,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub mime_type: Option<String>,
 }
 
@@ -238,17 +302,23 @@ pub struct Resource {
 #[serde(rename_all = "camelCase")]
 pub struct ResourceContent {
     pub uri: Url,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub mime_type: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub text: Option<String>,
-    pub data: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub blob: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourceTemplate {
     pub uri_template: String,
-    pub name: Option<String>,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mime_type: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -260,13 +330,16 @@ pub enum LoggingLevel {
     Error,
 }
 
-// Client Notifications
-
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub enum NotificationType {
     Initialized,
     Progress,
+    Message,
+    ResourcesUpdated,
+    ResourcesListChanged,
+    ToolsListChanged,
+    PromptsListChanged,
 }
 
 impl NotificationType {
@@ -274,6 +347,11 @@ impl NotificationType {
         match self {
             NotificationType::Initialized => "notifications/initialized",
             NotificationType::Progress => "notifications/progress",
+            NotificationType::Message => "notifications/message",
+            NotificationType::ResourcesUpdated => "notifications/resources/updated",
+            NotificationType::ResourcesListChanged => "notifications/resources/list_changed",
+            NotificationType::ToolsListChanged => "notifications/tools/list_changed",
+            NotificationType::PromptsListChanged => "notifications/prompts/list_changed",
         }
     }
 }
@@ -288,12 +366,13 @@ pub enum ClientNotification {
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProgressParams {
-    pub progress_token: String,
+    pub progress_token: ProgressToken,
     pub progress: f64,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub total: Option<f64>,
 }
 
-// Helper Types that don't map directly to the protocol
+pub type ProgressToken = String;
 
 pub enum CompletionTotal {
     Exact(u32),

From 256c31a5d9be749f9f8d8aa83f4c7c54f74aeffe Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 16 Oct 2024 23:19:10 +0300
Subject: [PATCH 701/762] Update Rust crate tree-sitter-c to v0.23.1 (#18958)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [tree-sitter-c](https://redirect.github.com/tree-sitter/tree-sitter-c)
| workspace.dependencies | patch | `0.23.0` -> `0.23.1` |

---

### Release Notes

<details>
<summary>tree-sitter/tree-sitter-c (tree-sitter-c)</summary>

###
[`v0.23.1`](https://redirect.github.com/tree-sitter/tree-sitter-c/compare/v0.23.0...v0.23.1)

[Compare
Source](https://redirect.github.com/tree-sitter/tree-sitter-c/compare/v0.23.0...v0.23.1)

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4xMTQuMCIsInVwZGF0ZWRJblZlciI6IjM4LjExNC4wIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6W119-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cb246160081463..14a876569a937c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12285,9 +12285,9 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-c"
-version = "0.23.0"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e795ad541f7ae6a80d22975296340a75a12a29afd3a7089f4368021613728e17"
+checksum = "c8b3fb515e498e258799a31d78e6603767cd6892770d9e2290ec00af5c3ad80b"
 dependencies = [
  "cc",
  "tree-sitter-language",

From 4288096ca16f23499fd6f748332f440de0416da1 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 16 Oct 2024 23:21:23 +0300
Subject: [PATCH 702/762] Update Rust crate tree-sitter-cpp to v0.23.1 (#18974)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
|
[tree-sitter-cpp](https://redirect.github.com/tree-sitter/tree-sitter-cpp)
| workspace.dependencies | patch | `0.23.0` -> `0.23.1` |

---

### Release Notes

<details>
<summary>tree-sitter/tree-sitter-cpp (tree-sitter-cpp)</summary>

###
[`v0.23.1`](https://redirect.github.com/tree-sitter/tree-sitter-cpp/compare/v0.23.0...v0.23.1)

[Compare
Source](https://redirect.github.com/tree-sitter/tree-sitter-cpp/compare/v0.23.0...v0.23.1)

</details>

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4xMTQuMCIsInVwZGF0ZWRJblZlciI6IjM4LjExNC4wIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6W119-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 14a876569a937c..84b6a3e471add6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12295,9 +12295,9 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-cpp"
-version = "0.23.0"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0a588a816017469b69f2e3544742e34a5a59dddfb4b9457b657a6052e2ea39c"
+checksum = "1d67e862242878d6ee50e1e5814f267ee3eea0168aea2cdbd700ccfb4c74b6d3"
 dependencies = [
  "cc",
  "tree-sitter-language",

From fedd177b0806441d85508fc12607c70e641243c2 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 16 Oct 2024 17:09:26 -0400
Subject: [PATCH 703/762] collab: Add context to errors syncing billing events
 to Stripe (#19315)

This PR adds context to errors that occur when trying to sync billing
events to Stripe.

Release Notes:

- N/A
---
 crates/collab/src/api/billing.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index 6db40dd187788d..02282b40c6d916 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -748,6 +748,7 @@ pub fn sync_llm_usage_with_stripe_periodically(app: Arc<AppState>) {
             loop {
                 sync_with_stripe(&app, &llm_db, &stripe_billing)
                     .await
+                    .context("failed to sync LLM usage to Stripe")
                     .trace_err();
                 executor.sleep(SYNC_LLM_USAGE_WITH_STRIPE_INTERVAL).await;
             }

From 08b1545c85d723645a3b143f3e2e3622e755f19a Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 16 Oct 2024 15:17:38 -0600
Subject: [PATCH 704/762] Show a user-visible error message if saving fails
 (#19311)

Release Notes:

- Added a user-visible error message when a manual save fails.
---
 crates/workspace/src/workspace.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index ec4079ba9f8af3..e07e25063cafc6 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -46,7 +46,9 @@ use itertools::Itertools;
 use language::{LanguageRegistry, Rope};
 pub use modal_layer::*;
 use node_runtime::NodeRuntime;
-use notifications::{simple_message_notification::MessageNotification, NotificationHandle};
+use notifications::{
+    simple_message_notification::MessageNotification, DetachAndPromptErr, NotificationHandle,
+};
 pub use pane::*;
 pub use pane_group::*;
 pub use persistence::{
@@ -4359,17 +4361,17 @@ impl Workspace {
             .on_action(cx.listener(|workspace, action: &Save, cx| {
                 workspace
                     .save_active_item(action.save_intent.unwrap_or(SaveIntent::Save), cx)
-                    .detach_and_log_err(cx);
+                    .detach_and_prompt_err("Failed to save", cx, |_, _| None);
             }))
             .on_action(cx.listener(|workspace, _: &SaveWithoutFormat, cx| {
                 workspace
                     .save_active_item(SaveIntent::SaveWithoutFormat, cx)
-                    .detach_and_log_err(cx);
+                    .detach_and_prompt_err("Failed to save", cx, |_, _| None);
             }))
             .on_action(cx.listener(|workspace, _: &SaveAs, cx| {
                 workspace
                     .save_active_item(SaveIntent::SaveAs, cx)
-                    .detach_and_log_err(cx);
+                    .detach_and_prompt_err("Failed to save", cx, |_, _| None);
             }))
             .on_action(cx.listener(|workspace, _: &ActivatePreviousPane, cx| {
                 workspace.activate_previous_pane(cx)

From 6614feff977bd56a74054a05c2deea143c193da5 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 16 Oct 2024 17:20:39 -0400
Subject: [PATCH 705/762] Pin astral-sh/setup-uv action to f3bcaeb (#19309)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [astral-sh/setup-uv](https://redirect.github.com/astral-sh/setup-uv) |
action | pinDigest | -> `f3bcaeb` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4xMjAuMSIsInVwZGF0ZWRJblZlciI6IjM4LjEyMC4xIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6W119-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 .github/workflows/update_all_top_ranking_issues.yml    | 2 +-
 .github/workflows/update_weekly_top_ranking_issues.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/update_all_top_ranking_issues.yml b/.github/workflows/update_all_top_ranking_issues.yml
index 8291ccf3fa7e4d..ecc7355511ccdc 100644
--- a/.github/workflows/update_all_top_ranking_issues.yml
+++ b/.github/workflows/update_all_top_ranking_issues.yml
@@ -12,7 +12,7 @@ jobs:
     steps:
       - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
       - name: Set up uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@f3bcaebff5eace81a1c062af9f9011aae482ca9d # v3
         with:
           version: "latest"
           enable-cache: true
diff --git a/.github/workflows/update_weekly_top_ranking_issues.yml b/.github/workflows/update_weekly_top_ranking_issues.yml
index f7eae61e264109..aab45740cdf7a8 100644
--- a/.github/workflows/update_weekly_top_ranking_issues.yml
+++ b/.github/workflows/update_weekly_top_ranking_issues.yml
@@ -12,7 +12,7 @@ jobs:
     steps:
       - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
       - name: Set up uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@f3bcaebff5eace81a1c062af9f9011aae482ca9d # v3
         with:
           version: "latest"
           enable-cache: true

From f6fad3b09ed52278fcba5747a094cd9f766da874 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Wed, 16 Oct 2024 18:14:07 -0400
Subject: [PATCH 706/762] collab: Remove lifetime spending limit in favor of
 LLM usage billing (#19321)

This PR removes the lifetime spending limit that was added in #16780.

We had previously added this as a way to prevent runaway usage, but now
that we have a cap on free usage per month with paid access after that,
we don't need this check anymore.

Release Notes:

- N/A
---
 crates/collab/src/llm.rs | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index 1facfa20eac4fa..e54c9e133e3fc0 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -443,9 +443,6 @@ pub const FREE_TIER_MONTHLY_SPENDING_LIMIT: Cents = Cents::from_dollars(10);
 /// Used to prevent surprise bills.
 pub const DEFAULT_MAX_MONTHLY_SPEND: Cents = Cents::from_dollars(10);
 
-/// The maximum lifetime spending an individual user can reach before being cut off.
-const LIFETIME_SPENDING_LIMIT: Cents = Cents::from_dollars(1_000);
-
 async fn check_usage_limit(
     state: &Arc<LlmState>,
     provider: LanguageModelProvider,
@@ -487,14 +484,6 @@ async fn check_usage_limit(
         }
     }
 
-    // TODO: Remove this once we've rolled out monthly spending limits.
-    if usage.lifetime_spending >= LIFETIME_SPENDING_LIMIT {
-        return Err(Error::http(
-            StatusCode::FORBIDDEN,
-            "Maximum spending limit reached.".to_string(),
-        ));
-    }
-
     let active_users = state.get_active_user_count(provider, model_name).await?;
 
     let users_in_recent_minutes = active_users.users_in_recent_minutes.max(1);

From 0c04fb9862e0dad87f715c5c2457a3efab462462 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 16 Oct 2024 17:16:56 -0600
Subject: [PATCH 707/762] SSH remoting: better error message for projects
 (#19320)

Before this, if no project paths were opened you were in a wierd UI
state where
most things didn't work because the project was ssh, but no
files/folders were open.

Release Notes:

- Fixed error handling when no project paths could be opened
---
 crates/remote/src/ssh_session.rs  | 29 ++++++++++++++++-------------
 crates/workspace/src/workspace.rs |  6 ++++++
 2 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 2bb4cc7fb2c6ec..b862ecf10f0631 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -979,16 +979,9 @@ impl SshRemoteClient {
             SshRemoteConnection::new(connection_options, delegate.clone(), cx).await?;
 
         let platform = ssh_connection.query_platform().await?;
-        let (local_binary_path, version) = delegate.get_server_binary(platform, cx).await??;
         let remote_binary_path = delegate.remote_server_binary_path(platform, cx)?;
         ssh_connection
-            .ensure_server_binary(
-                &delegate,
-                &local_binary_path,
-                &remote_binary_path,
-                version,
-                cx,
-            )
+            .ensure_server_binary(&delegate, &remote_binary_path, platform, cx)
             .await?;
 
         let socket = ssh_connection.socket.clone();
@@ -1252,11 +1245,19 @@ impl SshRemoteConnection {
     async fn ensure_server_binary(
         &self,
         delegate: &Arc<dyn SshClientDelegate>,
-        src_path: &Path,
         dst_path: &Path,
-        version: SemanticVersion,
+        platform: SshPlatform,
         cx: &mut AsyncAppContext,
     ) -> Result<()> {
+        if std::env::var("ZED_USE_CACHED_REMOTE_SERVER").is_ok() {
+            if let Ok(installed_version) =
+                run_cmd(self.socket.ssh_command(dst_path).arg("version")).await
+            {
+                log::info!("using cached server binary version {}", installed_version);
+                return Ok(());
+            }
+        }
+
         let mut dst_path_gz = dst_path.to_path_buf();
         dst_path_gz.set_extension("gz");
 
@@ -1264,8 +1265,10 @@ impl SshRemoteConnection {
             run_cmd(self.socket.ssh_command("mkdir").arg("-p").arg(parent)).await?;
         }
 
+        let (src_path, version) = delegate.get_server_binary(platform, cx).await??;
+
         let mut server_binary_exists = false;
-        if cfg!(not(debug_assertions)) {
+        if !server_binary_exists && cfg!(not(debug_assertions)) {
             if let Ok(installed_version) =
                 run_cmd(self.socket.ssh_command(dst_path).arg("version")).await
             {
@@ -1280,14 +1283,14 @@ impl SshRemoteConnection {
             return Ok(());
         }
 
-        let src_stat = fs::metadata(src_path).await?;
+        let src_stat = fs::metadata(&src_path).await?;
         let size = src_stat.len();
         let server_mode = 0o755;
 
         let t0 = Instant::now();
         delegate.set_status(Some("uploading remote development server"), cx);
         log::info!("uploading remote development server ({}kb)", size / 1024);
-        self.upload_file(src_path, &dst_path_gz)
+        self.upload_file(&src_path, &dst_path_gz)
             .await
             .context("failed to upload server binary")?;
         log::info!("uploaded remote development server in {:?}", t0.elapsed());
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index e07e25063cafc6..c50c3b9f126a7b 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -5568,6 +5568,12 @@ pub fn open_ssh_project(
             };
         }
 
+        if project_paths_to_open.is_empty() {
+            return Err(project_path_errors
+                .pop()
+                .unwrap_or_else(|| anyhow!("no paths given")));
+        }
+
         cx.update_window(window.into(), |_, cx| {
             cx.replace_root_view(|cx| {
                 let mut workspace =

From c888101e4b9b430a6ed71efee80345ef3e41bb69 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 16 Oct 2024 17:17:20 -0600
Subject: [PATCH 708/762] SSH remoting: Don't panic when opening root, open ~
 instead (#19322)

Release Notes:

- Fixed a panic when doing `zed ssh://server/`
---
 crates/project/src/worktree_store.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/crates/project/src/worktree_store.rs b/crates/project/src/worktree_store.rs
index c49d3b062ee975..df63415b18cf5b 100644
--- a/crates/project/src/worktree_store.rs
+++ b/crates/project/src/worktree_store.rs
@@ -247,14 +247,9 @@ impl WorktreeStore {
         if abs_path.starts_with("/~") {
             abs_path = abs_path[1..].to_string();
         }
-        if abs_path.is_empty() {
+        if abs_path.is_empty() || abs_path == "/" {
             abs_path = "~/".to_string();
         }
-        let root_name = PathBuf::from(abs_path.clone())
-            .file_name()
-            .unwrap()
-            .to_string_lossy()
-            .to_string();
         cx.spawn(|this, mut cx| async move {
             let this = this.upgrade().context("Dropped worktree store")?;
 
@@ -272,6 +267,11 @@ impl WorktreeStore {
                 return Ok(existing_worktree);
             }
 
+            let root_name = PathBuf::from(&response.canonicalized_path)
+                .file_name()
+                .map(|n| n.to_string_lossy().to_string())
+                .unwrap_or(response.canonicalized_path.to_string());
+
             let worktree = cx.update(|cx| {
                 Worktree::remote(
                     SSH_PROJECT_ID,

From 9a3d8733cebe2346a3d0d56e8539ba8f2eb63f9a Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 17 Oct 2024 03:25:03 +0200
Subject: [PATCH 709/762] ssh: Use system prompt for the server removal action
 (#19332)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR replaces a toast for the system prompt to confirm the action of
removing a server from the remote list. The alert dialog component is
the right choice here as we want to have a modal action that forces
choice. This should make it easier to convert to a nativa alert dialog
in the future, as well as for other platforms.

<img width="800" alt="Screenshot 2024-10-17 at 3 01 41 AM"
src="https://github.com/user-attachments/assets/7bb1210a-54bf-40da-a85a-f269484825a1">

Release Notes:

- N/A
---
 crates/recent_projects/src/dev_servers.rs | 63 ++++++++++-------------
 1 file changed, 27 insertions(+), 36 deletions(-)

diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 0ec06ef0641a00..1babc036271012 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -20,7 +20,7 @@ use gpui::Task;
 use gpui::WeakView;
 use gpui::{
     Animation, AnimationExt, AnyElement, AppContext, DismissEvent, EventEmitter, FocusHandle,
-    FocusableView, FontWeight, Model, ScrollHandle, View, ViewContext,
+    FocusableView, FontWeight, Model, PromptLevel, ScrollHandle, View, ViewContext,
 };
 use picker::Picker;
 use project::terminals::wrap_for_ssh;
@@ -986,46 +986,38 @@ impl DevServerProjects {
                     .child({
                         fn remove_ssh_server(
                             dev_servers: View<DevServerProjects>,
-                            workspace: WeakView<Workspace>,
                             index: usize,
                             connection_string: SharedString,
                             cx: &mut WindowContext<'_>,
                         ) {
-                            workspace
-                                .update(cx, |this, cx| {
-                                    struct SshServerRemoval;
-                                    let notification = format!(
-                                        "Do you really want to remove server `{}`?",
-                                        connection_string
-                                    );
-                                    this.show_toast(
-                                        Toast::new(
-                                            NotificationId::composite::<SshServerRemoval>(
-                                                connection_string.clone(),
-                                            ),
-                                            notification,
-                                        )
-                                        .on_click(
-                                            "Yes, delete it",
-                                            move |cx| {
-                                                dev_servers.update(cx, |this, cx| {
-                                                    this.delete_ssh_server(index, cx);
-                                                    this.mode = Mode::default_mode();
-                                                    cx.notify();
-                                                })
-                                            },
-                                        ),
-                                        cx,
-                                    );
-                                })
-                                .ok();
+                            let prompt_message = format!("Remove server `{}`?", connection_string);
+
+                            let confirmation = cx.prompt(
+                                PromptLevel::Warning,
+                                &prompt_message,
+                                None,
+                                &["Yes, remove it", "No, keep it"],
+                            );
+
+                            cx.spawn(|mut cx| async move {
+                                if confirmation.await.ok() == Some(0) {
+                                    dev_servers
+                                        .update(&mut cx, |this, cx| {
+                                            this.delete_ssh_server(index, cx);
+                                            this.mode = Mode::default_mode();
+                                            cx.notify();
+                                        })
+                                        .ok();
+                                }
+                                anyhow::Ok(())
+                            })
+                            .detach_and_log_err(cx);
                         }
                         self.selectable_items.add_item(Box::new({
                             let connection_string = connection_string.clone();
-                            move |this, cx| {
+                            move |_, cx| {
                                 remove_ssh_server(
                                     cx.view().clone(),
-                                    this.workspace.clone(),
                                     index,
                                     connection_string.clone(),
                                     cx,
@@ -1033,16 +1025,15 @@ impl DevServerProjects {
                             }
                         }));
                         let is_selected = self.selectable_items.is_selected();
-                        ListItem::new("delete-server")
+                        ListItem::new("remove-server")
                             .selected(is_selected)
                             .inset(true)
                             .spacing(ui::ListItemSpacing::Sparse)
                             .start_slot(Icon::new(IconName::Trash).color(Color::Error))
-                            .child(Label::new("Delete Server").color(Color::Error))
-                            .on_click(cx.listener(move |this, _, cx| {
+                            .child(Label::new("Remove Server").color(Color::Error))
+                            .on_click(cx.listener(move |_, _, cx| {
                                 remove_ssh_server(
                                     cx.view().clone(),
-                                    this.workspace.clone(),
                                     index,
                                     connection_string.clone(),
                                     cx,

From a41e97378204f8382a2d55e7fb633822376860c3 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 17 Oct 2024 03:25:15 +0200
Subject: [PATCH 710/762] ssh: Remove server count from modal header (#19329)

The server count was something that existed since the remote development
implementation and we just kept it there without a lot of critical
thinking. However, it doesn't feel like it's particularly useful yet,
which means that, at least for now, we could clean it up more and wait
for further feedback to add it back, if ever requested.

Release Notes:

- N/A
---
 crates/recent_projects/src/dev_servers.rs | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 1babc036271012..75b78f1654fc61 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -1151,17 +1151,10 @@ impl DevServerProjects {
             )
             .into_any_element();
 
-        let server_count = format!("Servers: {}", ssh_connections.len());
-
         Modal::new("remote-projects", Some(self.scroll_handle.clone()))
             .header(
-                ModalHeader::new().child(
-                    h_flex()
-                        .items_center()
-                        .justify_between()
-                        .child(Headline::new("Remote Projects (alpha)").size(HeadlineSize::XSmall))
-                        .child(Label::new(server_count).size(LabelSize::Small)),
-                ),
+                ModalHeader::new()
+                    .child(Headline::new("Remote Projects (alpha)").size(HeadlineSize::XSmall)),
             )
             .section(
                 Section::new().padded(false).child(

From 78093b8e76c9f4d244c749b29c42bcd0041caeda Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Thu, 17 Oct 2024 03:25:27 +0200
Subject: [PATCH 711/762] ssh: Clean up title bar indicator icon (#19328)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR cleans up the custom icon with indicator implementation in favor
of `IconWithIndicator`, which we already had. It seems like it isn't
super used still, but it's good to try to enforce some consistency
either way. I checked my changes against the REPL stuff (one instance
where its used) and everything's looking good so far. As far as SSH,
nothing has visually changed; we just have less code for this thing now.

<img width="800" alt="Screenshot 2024-10-17 at 2 15 47 AM"
src="https://github.com/user-attachments/assets/5c146757-501e-4242-b145-a576a8f289b5">

---

Release Notes:

- N/A
---
 crates/title_bar/src/title_bar.rs | 52 +++++++++----------------------
 crates/ui/src/components/icon.rs  |  7 ++---
 2 files changed, 18 insertions(+), 41 deletions(-)

diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index d0307d5625a5b8..8c708e619a0fd5 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -24,8 +24,8 @@ use smallvec::SmallVec;
 use std::sync::Arc;
 use theme::ActiveTheme;
 use ui::{
-    h_flex, prelude::*, Avatar, Button, ButtonLike, ButtonStyle, ContextMenu, Icon,
-    IconButtonShape, IconName, IconSize, Indicator, PopoverMenu, Tooltip,
+    h_flex, prelude::*, Avatar, Button, ButtonLike, ButtonStyle, ContextMenu, Icon, IconName,
+    IconSize, IconWithIndicator, Indicator, PopoverMenu, Tooltip,
 };
 use util::ResultExt;
 use vcs_menu::{BranchList, OpenRecent as ToggleVcsMenu};
@@ -281,8 +281,6 @@ impl TitleBar {
             }
         };
 
-        let indicator_border_color = cx.theme().colors().title_bar_background;
-
         let icon_color = match self.project.read(cx).ssh_connection_state(cx)? {
             remote::ConnectionState::Connecting => Color::Info,
             remote::ConnectionState::Connected => Color::Default,
@@ -293,42 +291,22 @@ impl TitleBar {
 
         let meta = SharedString::from(meta);
 
-        let indicator = h_flex()
-            // We're using the circle inside a circle approach because, otherwise, by using borders
-            // we'd get a very thin, leaking indicator color, which is not what we want.
-            .absolute()
-            .size_2p5()
-            .right_0()
-            .bottom_0()
-            .bg(indicator_border_color)
-            .size_2p5()
-            .rounded_full()
-            .items_center()
-            .justify_center()
-            .overflow_hidden()
-            .child(Indicator::dot().color(indicator_color));
-
         Some(
-            div()
-                .relative()
+            ButtonLike::new("ssh-server-icon")
                 .child(
-                    IconButton::new("ssh-server-icon", IconName::Server)
-                        .icon_size(IconSize::Small)
-                        .shape(IconButtonShape::Square)
-                        .icon_color(icon_color)
-                        .tooltip(move |cx| {
-                            Tooltip::with_meta(
-                                "Remote Project",
-                                Some(&OpenRemote),
-                                meta.clone(),
-                                cx,
-                            )
-                        })
-                        .on_click(|_, cx| {
-                            cx.dispatch_action(OpenRemote.boxed_clone());
-                        }),
+                    IconWithIndicator::new(
+                        Icon::new(IconName::Server).color(icon_color),
+                        Some(Indicator::dot().color(indicator_color)),
+                    )
+                    .indicator_border_color(Some(cx.theme().colors().title_bar_background))
+                    .into_any_element(),
                 )
-                .child(indicator)
+                .tooltip(move |cx| {
+                    Tooltip::with_meta("Remote Project", Some(&OpenRemote), meta.clone(), cx)
+                })
+                .on_click(|_, cx| {
+                    cx.dispatch_action(OpenRemote.boxed_clone());
+                })
                 .into_any_element(),
         )
     }
diff --git a/crates/ui/src/components/icon.rs b/crates/ui/src/components/icon.rs
index 8d374ef67ca410..683bcec5a8c3f4 100644
--- a/crates/ui/src/components/icon.rs
+++ b/crates/ui/src/components/icon.rs
@@ -473,13 +473,12 @@ impl RenderOnce for IconWithIndicator {
                 this.child(
                     div()
                         .absolute()
-                        .w_2()
-                        .h_2()
-                        .border_1()
+                        .size_2p5()
+                        .border_2()
                         .border_color(indicator_border_color)
                         .rounded_full()
                         .bottom_neg_0p5()
-                        .right_neg_1()
+                        .right_neg_0p5()
                         .child(indicator),
                 )
             })

From f1d01d59ac2d4041541ab178b602fdd961199c24 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 16 Oct 2024 20:22:08 -0600
Subject: [PATCH 712/762] Simplify PR template (#19337)

Release Notes:

- N/A
---
 .github/pull_request_template.md | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index bf1667643ed5aa..e107c14470ff29 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -2,14 +2,4 @@ Closes #ISSUE
 
 Release Notes:
 
-- Added/Fixed/Improved ...
-
-Optionally, include screenshots / media showcasing your addition that can be included in the release notes.
-
-### Or...
-
-Closes #ISSUE
-
-Release Notes:
-
-- N/A
+- N/A *or* Added/Fixed/Improved ...

From 378a2cf9d86c8b64b0e27fb16197c68f426825c2 Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Wed, 16 Oct 2024 21:09:31 -0600
Subject: [PATCH 713/762] Allow passing args to ssh (#19336)

This is useful for passing a custom identity file, jump hosts, etc.

Unlike with the v1 feature, we won't support `gh`/`gcloud` ssh wrappers
(yet?). I think the right way of supporting those would be to let
extensions provide remote projects.

Closes #19118

Release Notes:

- SSH remoting: restored ability to set arguments for SSH
---
 Cargo.lock                                    |   1 +
 crates/recent_projects/src/dev_servers.rs     | 122 ++++++++++--------
 crates/recent_projects/src/recent_projects.rs |   4 +-
 crates/recent_projects/src/ssh_connections.rs |  32 +++--
 crates/remote/Cargo.toml                      |   1 +
 crates/remote/src/ssh_session.rs              |  85 ++++++++++++
 crates/workspace/src/persistence/model.rs     |  11 +-
 crates/zed/src/main.rs                        |  21 ++-
 crates/zed/src/zed/open_listener.rs           |  28 +++-
 9 files changed, 216 insertions(+), 89 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 84b6a3e471add6..32b4ca22901201 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9126,6 +9126,7 @@ dependencies = [
  "rpc",
  "serde",
  "serde_json",
+ "shlex",
  "smol",
  "tempfile",
  "thiserror",
diff --git a/crates/recent_projects/src/dev_servers.rs b/crates/recent_projects/src/dev_servers.rs
index 75b78f1654fc61..eec007431e625f 100644
--- a/crates/recent_projects/src/dev_servers.rs
+++ b/crates/recent_projects/src/dev_servers.rs
@@ -13,19 +13,19 @@ use futures::channel::oneshot;
 use futures::future::Shared;
 use futures::FutureExt;
 use gpui::canvas;
-use gpui::pulsating_between;
 use gpui::AsyncWindowContext;
 use gpui::ClipboardItem;
 use gpui::Task;
 use gpui::WeakView;
 use gpui::{
-    Animation, AnimationExt, AnyElement, AppContext, DismissEvent, EventEmitter, FocusHandle,
-    FocusableView, FontWeight, Model, PromptLevel, ScrollHandle, View, ViewContext,
+    AnyElement, AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView, FontWeight,
+    Model, PromptLevel, ScrollHandle, View, ViewContext,
 };
 use picker::Picker;
 use project::terminals::wrap_for_ssh;
 use project::terminals::SshCommand;
 use project::Project;
+use remote::SshConnectionOptions;
 use rpc::proto::DevServerStatus;
 use settings::update_settings_file;
 use settings::Settings;
@@ -65,8 +65,9 @@ pub struct DevServerProjects {
 
 struct CreateDevServer {
     address_editor: View<Editor>,
-    creating: Option<Task<Option<()>>>,
+    address_error: Option<SharedString>,
     ssh_prompt: Option<View<SshPrompt>>,
+    _creating: Option<Task<Option<()>>>,
 }
 
 impl CreateDevServer {
@@ -77,8 +78,9 @@ impl CreateDevServer {
         });
         Self {
             address_editor,
-            creating: None,
+            address_error: None,
             ssh_prompt: None,
+            _creating: None,
         }
     }
 }
@@ -378,34 +380,22 @@ impl DevServerProjects {
     }
 
     fn create_ssh_server(&mut self, editor: View<Editor>, cx: &mut ViewContext<Self>) {
-        let host = get_text(&editor, cx);
-        if host.is_empty() {
+        let input = get_text(&editor, cx);
+        if input.is_empty() {
             return;
         }
 
-        let mut host = host.trim_start_matches("ssh ");
-        let mut username: Option<String> = None;
-        let mut port: Option<u16> = None;
-
-        if let Some((u, rest)) = host.split_once('@') {
-            host = rest;
-            username = Some(u.to_string());
-        }
-        if let Some((rest, p)) = host.split_once(':') {
-            host = rest;
-            port = p.parse().ok()
-        }
-
-        if let Some((rest, p)) = host.split_once(" -p") {
-            host = rest;
-            port = p.trim().parse().ok()
-        }
-
-        let connection_options = remote::SshConnectionOptions {
-            host: host.to_string(),
-            username: username.clone(),
-            port,
-            password: None,
+        let connection_options = match SshConnectionOptions::parse_command_line(&input) {
+            Ok(c) => c,
+            Err(e) => {
+                self.mode = Mode::CreateDevServer(CreateDevServer {
+                    address_editor: editor,
+                    address_error: Some(format!("could not parse: {:?}", e).into()),
+                    ssh_prompt: None,
+                    _creating: None,
+                });
+                return;
+            }
         };
         let ssh_prompt = cx.new_view(|cx| SshPrompt::new(&connection_options, cx));
 
@@ -417,6 +407,7 @@ impl DevServerProjects {
         )
         .prompt_err("Failed to connect", cx, |_, _| None);
 
+        let address_editor = editor.clone();
         let creating = cx.spawn(move |this, mut cx| async move {
             match connection.await {
                 Some(_) => this
@@ -436,18 +427,31 @@ impl DevServerProjects {
                     .log_err(),
                 None => this
                     .update(&mut cx, |this, cx| {
-                        this.mode = Mode::CreateDevServer(CreateDevServer::new(cx));
+                        address_editor.update(cx, |this, _| {
+                            this.set_read_only(false);
+                        });
+                        this.mode = Mode::CreateDevServer(CreateDevServer {
+                            address_editor,
+                            address_error: None,
+                            ssh_prompt: None,
+                            _creating: None,
+                        });
                         cx.notify()
                     })
                     .log_err(),
             };
             None
         });
-        let mut state = CreateDevServer::new(cx);
-        state.address_editor = editor;
-        state.ssh_prompt = Some(ssh_prompt.clone());
-        state.creating = Some(creating);
-        self.mode = Mode::CreateDevServer(state);
+
+        editor.update(cx, |this, _| {
+            this.set_read_only(true);
+        });
+        self.mode = Mode::CreateDevServer(CreateDevServer {
+            address_editor: editor,
+            address_error: None,
+            ssh_prompt: Some(ssh_prompt.clone()),
+            _creating: Some(creating),
+        });
     }
 
     fn view_server_options(
@@ -547,9 +551,6 @@ impl DevServerProjects {
                     return;
                 }
 
-                state.address_editor.update(cx, |this, _| {
-                    this.set_read_only(true);
-                });
                 self.create_ssh_server(state.address_editor.clone(), cx);
             }
             Mode::EditNickname(state) => {
@@ -812,6 +813,7 @@ impl DevServerProjects {
                     port: connection_options.port,
                     projects: vec![],
                     nickname: None,
+                    args: connection_options.args.unwrap_or_default(),
                 })
         });
     }
@@ -825,10 +827,7 @@ impl DevServerProjects {
 
         state.address_editor.update(cx, |editor, cx| {
             if editor.text(cx).is_empty() {
-                editor.set_placeholder_text(
-                    "Enter the command you use to SSH into this server: e.g., ssh me@my.server",
-                    cx,
-                );
+                editor.set_placeholder_text("ssh user@example -p 2222", cx);
             }
         });
 
@@ -854,27 +853,38 @@ impl DevServerProjects {
                     .map(|this| {
                         if let Some(ssh_prompt) = ssh_prompt {
                             this.child(h_flex().w_full().child(ssh_prompt))
+                        } else if let Some(address_error) = &state.address_error {
+                            this.child(
+                                h_flex().p_2().w_full().gap_2().child(
+                                    Label::new(address_error.clone())
+                                        .size(LabelSize::Small)
+                                        .color(Color::Error),
+                                ),
+                            )
                         } else {
-                            let color = Color::Muted.color(cx);
                             this.child(
                                 h_flex()
                                     .p_2()
                                     .w_full()
-                                    .items_center()
-                                    .justify_center()
-                                    .gap_2()
+                                    .gap_1()
                                     .child(
-                                        div().size_1p5().rounded_full().bg(color).with_animation(
-                                            "pulse-ssh-waiting-for-connection",
-                                            Animation::new(Duration::from_secs(2))
-                                                .repeat()
-                                                .with_easing(pulsating_between(0.2, 0.5)),
-                                            move |this, progress| this.bg(color.opacity(progress)),
-                                        ),
+                                        Label::new(
+                                            "Enter the command you use to SSH into this server.",
+                                        )
+                                        .color(Color::Muted)
+                                        .size(LabelSize::Small),
                                     )
                                     .child(
-                                        Label::new("Waiting for connection…")
-                                            .size(LabelSize::Small),
+                                        Button::new("learn-more", "Learn more…")
+                                            .label_size(LabelSize::Small)
+                                            .size(ButtonSize::None)
+                                            .color(Color::Accent)
+                                            .style(ButtonStyle::Transparent)
+                                            .on_click(|_, cx| {
+                                                cx.open_url(
+                                                    "https://zed.dev/docs/remote-development",
+                                                );
+                                            }),
                                     ),
                             )
                         }
diff --git a/crates/recent_projects/src/recent_projects.rs b/crates/recent_projects/src/recent_projects.rs
index d763d24234342e..5fea5d3a5c4ac6 100644
--- a/crates/recent_projects/src/recent_projects.rs
+++ b/crates/recent_projects/src/recent_projects.rs
@@ -21,7 +21,7 @@ use picker::{
 use rpc::proto::DevServerStatus;
 use serde::Deserialize;
 use settings::Settings;
-use ssh_connections::SshSettings;
+pub use ssh_connections::SshSettings;
 use std::{
     path::{Path, PathBuf},
     sync::Arc,
@@ -384,11 +384,13 @@ impl PickerDelegate for RecentProjectsDelegate {
                                 ..Default::default()
                             };
 
+                            let args = SshSettings::get_global(cx).args_for(&ssh_project.host, ssh_project.port, &ssh_project.user);
                             let connection_options = SshConnectionOptions {
                                 host: ssh_project.host.clone(),
                                 username: ssh_project.user.clone(),
                                 port: ssh_project.port,
                                 password: None,
+                                args,
                             };
 
                             let paths = ssh_project.paths.iter().map(PathBuf::from).collect();
diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index 06fb08b3fe493d..c8043acc48fd5e 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -32,6 +32,23 @@ impl SshSettings {
     pub fn ssh_connections(&self) -> impl Iterator<Item = SshConnection> {
         self.ssh_connections.clone().into_iter().flatten()
     }
+
+    pub fn args_for(
+        &self,
+        host: &str,
+        port: Option<u16>,
+        user: &Option<String>,
+    ) -> Option<Vec<String>> {
+        self.ssh_connections()
+            .filter_map(|conn| {
+                if conn.host == host && &conn.username == user && conn.port == port {
+                    Some(conn.args)
+                } else {
+                    None
+                }
+            })
+            .next()
+    }
 }
 
 #[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
@@ -45,6 +62,9 @@ pub struct SshConnection {
     /// Name to use for this server in UI.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub nickname: Option<SharedString>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    #[serde(default)]
+    pub args: Vec<String>,
 }
 impl From<SshConnection> for SshConnectionOptions {
     fn from(val: SshConnection) -> Self {
@@ -53,6 +73,7 @@ impl From<SshConnection> for SshConnectionOptions {
             username: val.username,
             port: val.port,
             password: None,
+            args: Some(val.args),
         }
     }
 }
@@ -151,11 +172,9 @@ impl Render for SshPrompt {
         v_flex()
             .key_context("PasswordPrompt")
             .size_full()
-            .justify_center()
             .child(
                 h_flex()
                     .p_2()
-                    .justify_center()
                     .flex_wrap()
                     .child(if self.error_message.is_some() {
                         Icon::new(IconName::XCircle)
@@ -174,24 +193,19 @@ impl Render for SshPrompt {
                             )
                             .into_any_element()
                     })
-                    .child(
-                        div()
-                            .ml_1()
-                            .child(Label::new("SSH Connection").size(LabelSize::Small)),
-                    )
                     .child(
                         div()
                             .text_ellipsis()
                             .overflow_x_hidden()
                             .when_some(self.error_message.as_ref(), |el, error| {
-                                el.child(Label::new(format!("－{}", error)).size(LabelSize::Small))
+                                el.child(Label::new(format!("{}", error)).size(LabelSize::Small))
                             })
                             .when(
                                 self.error_message.is_none() && self.status_message.is_some(),
                                 |el| {
                                     el.child(
                                         Label::new(format!(
-                                            "－{}",
+                                            "－{}…",
                                             self.status_message.clone().unwrap()
                                         ))
                                         .size(LabelSize::Small),
diff --git a/crates/remote/Cargo.toml b/crates/remote/Cargo.toml
index 63c12cf11704b3..b8c5f34cc5854a 100644
--- a/crates/remote/Cargo.toml
+++ b/crates/remote/Cargo.toml
@@ -29,6 +29,7 @@ prost.workspace = true
 rpc = { workspace = true, features = ["gpui"] }
 serde.workspace = true
 serde_json.workspace = true
+shlex.workspace = true
 smol.workspace = true
 tempfile.workspace = true
 thiserror.workspace = true
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index b862ecf10f0631..a09faf894cd4d7 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -61,9 +61,89 @@ pub struct SshConnectionOptions {
     pub username: Option<String>,
     pub port: Option<u16>,
     pub password: Option<String>,
+    pub args: Option<Vec<String>>,
 }
 
 impl SshConnectionOptions {
+    pub fn parse_command_line(input: &str) -> Result<Self> {
+        let input = input.trim_start_matches("ssh ");
+        let mut hostname: Option<String> = None;
+        let mut username: Option<String> = None;
+        let mut port: Option<u16> = None;
+        let mut args = Vec::new();
+
+        // disallowed: -E, -e, -F, -f, -G, -g, -M, -N, -n, -O, -q, -S, -s, -T, -t, -V, -v, -W
+        const ALLOWED_OPTS: &[&str] = &[
+            "-4", "-6", "-A", "-a", "-C", "-K", "-k", "-X", "-x", "-Y", "-y",
+        ];
+        const ALLOWED_ARGS: &[&str] = &[
+            "-B", "-b", "-c", "-D", "-I", "-i", "-J", "-L", "-l", "-m", "-o", "-P", "-p", "-R",
+            "-w",
+        ];
+
+        let mut tokens = shlex::split(input)
+            .ok_or_else(|| anyhow!("invalid input"))?
+            .into_iter();
+
+        'outer: while let Some(arg) = tokens.next() {
+            if ALLOWED_OPTS.contains(&(&arg as &str)) {
+                args.push(arg.to_string());
+                continue;
+            }
+            if arg == "-p" {
+                port = tokens.next().and_then(|arg| arg.parse().ok());
+                continue;
+            } else if let Some(p) = arg.strip_prefix("-p") {
+                port = p.parse().ok();
+                continue;
+            }
+            if arg == "-l" {
+                username = tokens.next();
+                continue;
+            } else if let Some(l) = arg.strip_prefix("-l") {
+                username = Some(l.to_string());
+                continue;
+            }
+            for a in ALLOWED_ARGS {
+                if arg == *a {
+                    args.push(arg);
+                    if let Some(next) = tokens.next() {
+                        args.push(next);
+                    }
+                    continue 'outer;
+                } else if arg.starts_with(a) {
+                    args.push(arg);
+                    continue 'outer;
+                }
+            }
+            if arg.starts_with("-") || hostname.is_some() {
+                anyhow::bail!("unsupported argument: {:?}", arg);
+            }
+            let mut input = &arg as &str;
+            if let Some((u, rest)) = input.split_once('@') {
+                input = rest;
+                username = Some(u.to_string());
+            }
+            if let Some((rest, p)) = input.split_once(':') {
+                input = rest;
+                port = p.parse().ok()
+            }
+            hostname = Some(input.to_string())
+        }
+
+        let Some(hostname) = hostname else {
+            anyhow::bail!("missing hostname");
+        };
+
+        Ok(Self {
+            host: hostname.to_string(),
+            username: username.clone(),
+            port,
+            password: None,
+            args: Some(args),
+        })
+    }
+
     pub fn ssh_url(&self) -> String {
         let mut result = String::from("ssh://");
         if let Some(username) = &self.username {
@@ -78,6 +158,10 @@ impl SshConnectionOptions {
         result
     }
 
+    pub fn additional_args(&self) -> Option<&Vec<String>> {
+        self.args.as_ref()
+    }
+
     fn scp_url(&self) -> String {
         if let Some(username) = &self.username {
             format!("{}@{}", username, self.host)
@@ -1179,6 +1263,7 @@ impl SshRemoteConnection {
             .stderr(Stdio::piped())
             .env("SSH_ASKPASS_REQUIRE", "force")
             .env("SSH_ASKPASS", &askpass_script_path)
+            .args(connection_options.additional_args().unwrap_or(&Vec::new()))
             .args([
                 "-N",
                 "-o",
diff --git a/crates/workspace/src/persistence/model.rs b/crates/workspace/src/persistence/model.rs
index 5efc77205c3469..7528e4c3934c57 100644
--- a/crates/workspace/src/persistence/model.rs
+++ b/crates/workspace/src/persistence/model.rs
@@ -11,7 +11,7 @@ use db::sqlez::{
 };
 use gpui::{AsyncWindowContext, Model, View, WeakView};
 use project::Project;
-use remote::{ssh_session::SshProjectId, SshConnectionOptions};
+use remote::ssh_session::SshProjectId;
 use serde::{Deserialize, Serialize};
 use std::{
     path::{Path, PathBuf},
@@ -50,15 +50,6 @@ impl SerializedSshProject {
             })
             .collect()
     }
-
-    pub fn connection_options(&self) -> SshConnectionOptions {
-        SshConnectionOptions {
-            host: self.host.clone(),
-            username: self.user.clone(),
-            port: self.port,
-            password: None,
-        }
-    }
 }
 
 impl StaticColumnCount for SerializedSshProject {
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 25baf74c68d894..9ddb2982ec37b9 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -33,7 +33,7 @@ use assets::Assets;
 use node_runtime::{NodeBinaryOptions, NodeRuntime};
 use parking_lot::Mutex;
 use project::project_settings::ProjectSettings;
-use recent_projects::open_ssh_project;
+use recent_projects::{open_ssh_project, SshSettings};
 use release_channel::{AppCommitSha, AppVersion};
 use session::{AppSession, Session};
 use settings::{
@@ -214,6 +214,7 @@ fn init_common(app_state: Arc<AppState>, cx: &mut AppContext) -> Arc<PromptBuild
         ThemeRegistry::global(cx),
         cx,
     );
+    recent_projects::init(cx);
     prompt_builder
 }
 
@@ -248,7 +249,6 @@ fn init_ui(
     audio::init(Assets, cx);
     workspace::init(app_state.clone(), cx);
 
-    recent_projects::init(cx);
     go_to_line::init(cx);
     file_finder::init(cx);
     tab_switcher::init(cx);
@@ -881,18 +881,25 @@ async fn restore_or_create_workspace(
                     })?;
                     task.await?;
                 }
-                SerializedWorkspaceLocation::Ssh(ssh_project) => {
+                SerializedWorkspaceLocation::Ssh(ssh) => {
+                    let args = cx
+                        .update(|cx| {
+                            SshSettings::get_global(cx).args_for(&ssh.host, ssh.port, &ssh.user)
+                        })
+                        .ok()
+                        .flatten();
                     let connection_options = SshConnectionOptions {
-                        host: ssh_project.host.clone(),
-                        username: ssh_project.user.clone(),
-                        port: ssh_project.port,
+                        args,
+                        host: ssh.host.clone(),
+                        username: ssh.user.clone(),
+                        port: ssh.port,
                         password: None,
                     };
                     let app_state = app_state.clone();
                     cx.spawn(move |mut cx| async move {
                         recent_projects::open_ssh_project(
                             connection_options,
-                            ssh_project.paths.into_iter().map(PathBuf::from).collect(),
+                            ssh.paths.into_iter().map(PathBuf::from).collect(),
                             app_state,
                             workspace::OpenOptions::default(),
                             &mut cx,
diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs
index 66d27888214ff0..64839f46251d75 100644
--- a/crates/zed/src/zed/open_listener.rs
+++ b/crates/zed/src/zed/open_listener.rs
@@ -16,8 +16,9 @@ use futures::future::join_all;
 use futures::{FutureExt, SinkExt, StreamExt};
 use gpui::{AppContext, AsyncAppContext, Global, WindowHandle};
 use language::{Bias, Point};
-use recent_projects::open_ssh_project;
+use recent_projects::{open_ssh_project, SshSettings};
 use remote::SshConnectionOptions;
+use settings::Settings;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
@@ -48,7 +49,7 @@ impl OpenRequest {
             } else if let Some(file) = url.strip_prefix("zed://file") {
                 this.parse_file_path(file)
             } else if url.starts_with("ssh://") {
-                this.parse_ssh_file_path(&url)?
+                this.parse_ssh_file_path(&url, cx)?
             } else if let Some(request_path) = parse_zed_link(&url, cx) {
                 this.parse_request_path(request_path).log_err();
             } else {
@@ -65,7 +66,7 @@ impl OpenRequest {
         }
     }
 
-    fn parse_ssh_file_path(&mut self, file: &str) -> Result<()> {
+    fn parse_ssh_file_path(&mut self, file: &str, cx: &AppContext) -> Result<()> {
         let url = url::Url::parse(file)?;
         let host = url
             .host()
@@ -77,11 +78,13 @@ impl OpenRequest {
         if !self.open_paths.is_empty() {
             return Err(anyhow!("cannot open both local and ssh paths"));
         }
+        let args = SshSettings::get_global(cx).args_for(&host, port, &username);
         let connection = SshConnectionOptions {
             username,
             password,
             host,
             port,
+            args,
         };
         if let Some(ssh_connection) = &self.ssh_connection {
             if *ssh_connection != connection {
@@ -419,12 +422,25 @@ async fn open_workspaces(
                         errored = true
                     }
                 }
-                SerializedWorkspaceLocation::Ssh(ssh_project) => {
+                SerializedWorkspaceLocation::Ssh(ssh) => {
                     let app_state = app_state.clone();
+                    let args = cx
+                        .update(|cx| {
+                            SshSettings::get_global(cx).args_for(&ssh.host, ssh.port, &ssh.user)
+                        })
+                        .ok()
+                        .flatten();
+                    let connection_options = SshConnectionOptions {
+                        args,
+                        host: ssh.host.clone(),
+                        username: ssh.user.clone(),
+                        port: ssh.port,
+                        password: None,
+                    };
                     cx.spawn(|mut cx| async move {
                         open_ssh_project(
-                            ssh_project.connection_options(),
-                            ssh_project.paths.into_iter().map(PathBuf::from).collect(),
+                            connection_options,
+                            ssh.paths.into_iter().map(PathBuf::from).collect(),
                             app_state,
                             OpenOptions::default(),
                             &mut cx,

From f9d4272e1336099568ec9cf3f13256856ee40250 Mon Sep 17 00:00:00 2001
From: Heavysnowjakarta <54460050+HeavySnowJakarta@users.noreply.github.com>
Date: Thu, 17 Oct 2024 12:04:59 +0800
Subject: [PATCH 714/762] docs: Java extension settings (#19113)

Co-authored-by: Peter Tripp <peter@zed.dev>
---
 docs/src/languages/java.md | 201 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 199 insertions(+), 2 deletions(-)

diff --git a/docs/src/languages/java.md b/docs/src/languages/java.md
index 0078947f822bdd..5d3cf771cf50a7 100644
--- a/docs/src/languages/java.md
+++ b/docs/src/languages/java.md
@@ -1,6 +1,203 @@
 # Java
 
-Java language support in Zed is provided the [zed Java extension](https://github.com/zed-extensions/java).
-Report issues to: [https://github.com/zed-extensions/java/issues](https://github.com/zed-extensions/java/issues)
+There are two extensions that provide Java language support for Zed:
+
+- Zed Java: [zed-extensions/java](https://github.com/zed-extensions/java) and
+- Java with Eclipse JDTLS: [zed-java-eclipse-jdtls](https://github.com/ABckh/zed-java-eclipse-jdtls).
+
+Both use:
 
 - Tree Sitter: [tree-sitter/tree-sitter-java](https://github.com/tree-sitter/tree-sitter-java)
+- Language Server: [eclipse-jdtls/eclipse.jdt.ls](https://github.com/eclipse-jdtls/eclipse.jdt.ls)
+
+## Pre-requisites
+
+You will need to install both a Java runtime (OpenJDK) and Eclipse JDT Language Server (`eclipse.jdt.ls`).
+
+### Install OpenJDK
+
+- MacOS: `brew install openjdk`
+- Ubuntu: `sudo add-apt-repository ppa:openjdk-23 && sudo apt-get install openjdk-23`
+- Windows: `choco install openjdk`
+- Arch Linux: `sudo pacman -S jre-openjdk-headless`
+
+Or manually download and install [OpenJDK 23](https://jdk.java.net/23/).
+
+### Install JDTLS
+
+- MacOS: `brew install jdtls`
+- Arch: [`jdtls` from AUR](https://aur.archlinux.org/packages/jdtls)
+
+Or manually download install:
+
+- [JDTLS Milestone Builds](http://download.eclipse.org/jdtls/milestones/) (updated every two weeks)
+- [JDTLS Snapshot Builds](https://download.eclipse.org/jdtls/snapshots/) (frequent updates)
+
+## Extension Install
+
+You can install either by opening {#action zed::Extensions}({#kb zed::Extensions}) and searching for `java`.
+We recommend you install one or the other and not both.
+
+## Settings / Initialization Options
+
+See [JDTLS Language Server Settings & Capabilities](https://github.com/eclipse-jdtls/eclipse.jdt.ls/wiki/Language-Server-Settings-&-Capabilities) for a complete list of options.
+
+Add the following to your Zed Settings by launching {#action zed::OpenSettings}({#kb zed::OpenSettings}).
+
+### Zed Java Settings
+
+```json
+{
+  "lsp": {
+    "jdtls": {
+      "settings": {},
+      "initialization_options": {}
+      }
+    }
+  }
+}
+```
+
+### Java with Eclipse JDTLS settings
+
+```json
+{
+  "lsp": {
+    "java": {
+      "settings": {},
+      "initialization_options": {}
+    }
+  }
+}
+```
+
+## See also
+
+- [Zed Java Readme](https://github.com/zed-extensions/java)
+- [Java with Eclipse JDTLS Readme](https://github.com/ABckh/zed-java-eclipse-jdtls)
+
+### Support
+
+If you have issues with either of these plugins, please open issues on their respective repositories:
+
+- [Zed Java Issues](https://github.com/zed-extensions/java/issues)
+- [Java with Eclipse JDTLS Issues](https://github.com/ABckh/zed-java-eclipse-jdtls/issues)
+
+## Example Configs
+
+### Zed Java Classpath
+
+You can optionally configure the class path that JDTLS uses with:
+
+```json
+{
+  "lsp": {
+    "jdtls": {
+      "settings": {
+        "classpath": "/path/to/classes.jar:/path/to/more/classes/"
+      }
+    }
+  }
+}
+```
+
+#### Zed Java Initialization Options
+
+There are also many more options you can pass directly to the language server, for example:
+
+```json
+{
+  "lsp": {
+    "jdtls": {
+      "initialization_options": {
+        "bundles": [],
+        "workspaceFolders": ["file:///home/snjeza/Project"],
+        "settings": {
+          "java": {
+            "home": "/usr/local/jdk-9.0.1",
+            "errors": {
+              "incompleteClasspath": {
+                "severity": "warning"
+              }
+            },
+            "configuration": {
+              "updateBuildConfiguration": "interactive",
+              "maven": {
+                "userSettings": null
+              }
+            },
+            "trace": {
+              "server": "verbose"
+            },
+            "import": {
+              "gradle": {
+                "enabled": true
+              },
+              "maven": {
+                "enabled": true
+              },
+              "exclusions": [
+                "**/node_modules/**",
+                "**/.metadata/**",
+                "**/archetype-resources/**",
+                "**/META-INF/maven/**",
+                "/**/test/**"
+              ]
+            },
+            "referencesCodeLens": {
+              "enabled": false
+            },
+            "signatureHelp": {
+              "enabled": false
+            },
+            "implementationsCodeLens": {
+              "enabled": false
+            },
+            "format": {
+              "enabled": true
+            },
+            "saveActions": {
+              "organizeImports": false
+            },
+            "contentProvider": {
+              "preferred": null
+            },
+            "autobuild": {
+              "enabled": false
+            },
+            "completion": {
+              "favoriteStaticMembers": [
+                "org.junit.Assert.*",
+                "org.junit.Assume.*",
+                "org.junit.jupiter.api.Assertions.*",
+                "org.junit.jupiter.api.Assumptions.*",
+                "org.junit.jupiter.api.DynamicContainer.*",
+                "org.junit.jupiter.api.DynamicTest.*"
+              ],
+              "importOrder": ["java", "javax", "com", "org"]
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+## Java with Eclipse JTDLS Configuration {#zed-java-eclipse-configuration}
+
+Configuration options match those provided in the [redhat-developer/vscode-java extension](https://github.com/redhat-developer/vscode-java#supported-vs-code-settings).
+
+For example, to enable [Lombok Support](https://github.com/redhat-developer/vscode-java/wiki/Lombok-support):
+
+```json
+{
+  "lsp": {
+    "java": {
+      "settings": {
+        "java.jdt.ls.lombokSupport.enabled:": true
+      }
+    }
+  }
+}
+```

From 57369b5a54660fe6129132bdc073b63c2cde07f7 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 17 Oct 2024 08:44:51 +0300
Subject: [PATCH 715/762] Update Rust crate tree-sitter-elixir to v0.3.1
 (#19335)

---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 32b4ca22901201..03d36c4445147b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12326,9 +12326,9 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-elixir"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6174acad8a059851f6f768d7893f4b25eedc80eb6643283d545dd71bbb38222a"
+checksum = "97bf0efa4be41120018f23305b105ad4dfd3be1b7f302dc4071d0e6c2dec3a32"
 dependencies = [
  "cc",
  "tree-sitter-language",

From 3216de7eb5c64c8696f3437a9dc8bbb32cd5dcbc Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 17 Oct 2024 09:41:16 +0200
Subject: [PATCH 716/762] ssh remoting: Do not print error backtrace on
 non-zero exit (#19290)

Closes #ISSUE


Release Notes:

- N/A
---
 crates/remote_server/src/main.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/crates/remote_server/src/main.rs b/crates/remote_server/src/main.rs
index a37ec2864e8be4..10b656cbdb1ce3 100644
--- a/crates/remote_server/src/main.rs
+++ b/crates/remote_server/src/main.rs
@@ -1,6 +1,5 @@
 #![cfg_attr(target_os = "windows", allow(unused, dead_code))]
 
-use anyhow::Result;
 use clap::{Parser, Subcommand};
 use std::path::PathBuf;
 
@@ -40,13 +39,13 @@ fn main() {
 }
 
 #[cfg(not(windows))]
-fn main() -> Result<()> {
+fn main() {
     use remote::proxy::ProxyLaunchError;
     use remote_server::unix::{execute_proxy, execute_run};
 
     let cli = Cli::parse();
 
-    match cli.command {
+    let result = match cli.command {
         Some(Commands::Run {
             log_file,
             pid_file,
@@ -74,11 +73,15 @@ fn main() -> Result<()> {
         },
         Some(Commands::Version) => {
             eprintln!("{}", env!("ZED_PKG_VERSION"));
-            Ok(())
+            std::process::exit(0);
         }
         None => {
             eprintln!("usage: remote <run|proxy|version>");
             std::process::exit(1);
         }
+    };
+    if let Err(error) = result {
+        log::error!("exiting due to error: {}", error);
+        std::process::exit(1);
     }
 }

From 498ecd6404a2e8f7729daf13c4f19a1a787c75e3 Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Thu, 17 Oct 2024 09:47:25 +0200
Subject: [PATCH 717/762] Fetch more than one page when polling stripe events
 (#19343)

This fixes a bug that was causing most users to be unable to use the
LLMs via Zed. It was caused by not using pagination and, instead, always
querying the very first page of stripe events.

Note that we're also allowing processing events generated in the last 24
hours (before, this was only 1 hour). I did this so that we can process
the backlog of events that the aforementioned bug was skipping.

Release Notes:

- N/A
---
 crates/collab/src/api/billing.rs | 63 +++++++++++++++++---------------
 1 file changed, 34 insertions(+), 29 deletions(-)

diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index 02282b40c6d916..36745820a0a435 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -452,29 +452,28 @@ async fn poll_stripe_events(
     let mut pages_of_already_processed_events = 0;
     let mut unprocessed_events = Vec::new();
 
-    loop {
-        if pages_of_already_processed_events >= NUMBER_OF_ALREADY_PROCESSED_PAGES_BEFORE_WE_STOP {
-            log::info!("saw {pages_of_already_processed_events} pages of already-processed events: stopping event retrieval");
-            break;
-        }
-
-        log::info!("retrieving events from Stripe: {}", event_types.join(", "));
-
-        let mut params = ListEvents::new();
-        params.types = Some(event_types.clone());
-        params.limit = Some(EVENTS_LIMIT_PER_PAGE);
+    log::info!(
+        "Stripe events: starting retrieval for {}",
+        event_types.join(", ")
+    );
+    let mut params = ListEvents::new();
+    params.types = Some(event_types.clone());
+    params.limit = Some(EVENTS_LIMIT_PER_PAGE);
 
-        let events = stripe::Event::list(stripe_client, &params).await?;
+    let mut event_pages = stripe::Event::list(&stripe_client, &params)
+        .await?
+        .paginate(params);
 
+    loop {
         let processed_event_ids = {
-            let event_ids = &events
+            let event_ids = event_pages
+                .page
                 .data
                 .iter()
                 .map(|event| event.id.as_str())
                 .collect::<Vec<_>>();
-
             app.db
-                .get_processed_stripe_events_by_event_ids(event_ids)
+                .get_processed_stripe_events_by_event_ids(&event_ids)
                 .await?
                 .into_iter()
                 .map(|event| event.stripe_event_id)
@@ -482,13 +481,13 @@ async fn poll_stripe_events(
         };
 
         let mut processed_events_in_page = 0;
-        let events_in_page = events.data.len();
-        for event in events.data {
+        let events_in_page = event_pages.page.data.len();
+        for event in &event_pages.page.data {
             if processed_event_ids.contains(&event.id.to_string()) {
                 processed_events_in_page += 1;
-                log::debug!("Stripe event {} already processed: skipping", event.id);
+                log::debug!("Stripe events: already processed '{}', skipping", event.id);
             } else {
-                unprocessed_events.push(event);
+                unprocessed_events.push(event.clone());
             }
         }
 
@@ -496,15 +495,21 @@ async fn poll_stripe_events(
             pages_of_already_processed_events += 1;
         }
 
-        if !events.has_more {
+        if event_pages.page.has_more {
+            if pages_of_already_processed_events >= NUMBER_OF_ALREADY_PROCESSED_PAGES_BEFORE_WE_STOP
+            {
+                log::info!("Stripe events: stopping, saw {pages_of_already_processed_events} pages of already-processed events");
+                break;
+            } else {
+                log::info!("Stripe events: retrieving next page");
+                event_pages = event_pages.next(&stripe_client).await?;
+            }
+        } else {
             break;
         }
     }
 
-    log::info!(
-        "unprocessed events from Stripe: {}",
-        unprocessed_events.len()
-    );
+    log::info!("Stripe events: unprocessed {}", unprocessed_events.len());
 
     // Sort all of the unprocessed events in ascending order, so we can handle them in the order they occurred.
     unprocessed_events.sort_by(|a, b| a.created.cmp(&b.created).then_with(|| a.id.cmp(&b.id)));
@@ -520,12 +525,12 @@ async fn poll_stripe_events(
         // If the event has happened too far in the past, we don't want to
         // process it and risk overwriting other more-recent updates.
         //
-        // 1 hour was chosen arbitrarily. This could be made longer or shorter.
-        let one_hour = Duration::from_secs(60 * 60);
-        let an_hour_ago = Utc::now() - one_hour;
-        if an_hour_ago.timestamp() > event.created {
+        // 1 day was chosen arbitrarily. This could be made longer or shorter.
+        let one_day = Duration::from_secs(24 * 60 * 60);
+        let a_day_ago = Utc::now() - one_day;
+        if a_day_ago.timestamp() > event.created {
             log::info!(
-                "Stripe event {} is more than {one_hour:?} old, marking as processed",
+                "Stripe events: event '{}' is more than {one_day:?} old, marking as processed",
                 event_id
             );
             app.db

From 455f241c6a296e79d52c9928643d9b6fba1a61c8 Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Thu, 17 Oct 2024 12:34:25 +0200
Subject: [PATCH 718/762] Introduce a new /billing/monthly_spend API (#19354)

Fixes https://github.com/zed-industries/zed/issues/19353

Release Notes:

- N/A
---
 crates/collab/src/api/billing.rs | 37 ++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index 36745820a0a435..82a6786ff0d7cf 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -50,6 +50,7 @@ pub fn router() -> Router {
             "/billing/subscriptions/manage",
             post(manage_billing_subscription),
         )
+        .route("/billing/monthly_spend", get(get_monthly_spend))
 }
 
 #[derive(Debug, Deserialize)]
@@ -672,6 +673,42 @@ async fn handle_customer_subscription_event(
     Ok(())
 }
 
+#[derive(Debug, Deserialize)]
+struct GetMonthlySpendParams {
+    github_user_id: i32,
+}
+
+#[derive(Debug, Serialize)]
+struct GetMonthlySpendResponse {
+    monthly_spend_in_cents: i32,
+}
+
+async fn get_monthly_spend(
+    Extension(app): Extension<Arc<AppState>>,
+    Query(params): Query<GetMonthlySpendParams>,
+) -> Result<Json<GetMonthlySpendResponse>> {
+    let user = app
+        .db
+        .get_user_by_github_user_id(params.github_user_id)
+        .await?
+        .ok_or_else(|| anyhow!("user not found"))?;
+
+    let Some(llm_db) = app.llm_db.clone() else {
+        return Err(Error::http(
+            StatusCode::NOT_IMPLEMENTED,
+            "LLM database not available".into(),
+        ));
+    };
+
+    let monthly_spend = llm_db
+        .get_user_spending_for_month(user.id, Utc::now())
+        .await?;
+
+    Ok(Json(GetMonthlySpendResponse {
+        monthly_spend_in_cents: monthly_spend.0 as i32,
+    }))
+}
+
 impl From<SubscriptionStatus> for StripeSubscriptionStatus {
     fn from(value: SubscriptionStatus) -> Self {
         match value {

From 8c910540edae12bd8e12ba89a3bcaf6abc87aa42 Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Thu, 17 Oct 2024 13:09:50 +0200
Subject: [PATCH 719/762] Subtract FREE_TIER_MONTHLY_SPENDING_LIMIT from
 reported monthly spend (#19358)

Release Notes:

- N/A
---
 crates/collab/src/api/billing.rs              |  5 +-
 crates/collab/src/cents.rs                    |  2 +
 crates/collab/src/llm.rs                      |  4 +-
 crates/collab/src/llm/db/queries/usages.rs    |  2 +-
 .../collab/src/llm/db/tests/billing_tests.rs  | 86 ++++++++-----------
 5 files changed, 47 insertions(+), 52 deletions(-)

diff --git a/crates/collab/src/api/billing.rs b/crates/collab/src/api/billing.rs
index 82a6786ff0d7cf..5e167a668c4f57 100644
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -19,7 +19,7 @@ use stripe::{
 };
 use util::ResultExt;
 
-use crate::llm::DEFAULT_MAX_MONTHLY_SPEND;
+use crate::llm::{DEFAULT_MAX_MONTHLY_SPEND, FREE_TIER_MONTHLY_SPENDING_LIMIT};
 use crate::rpc::{ResultExt as _, Server};
 use crate::{
     db::{
@@ -702,7 +702,8 @@ async fn get_monthly_spend(
 
     let monthly_spend = llm_db
         .get_user_spending_for_month(user.id, Utc::now())
-        .await?;
+        .await?
+        .saturating_sub(FREE_TIER_MONTHLY_SPENDING_LIMIT);
 
     Ok(Json(GetMonthlySpendResponse {
         monthly_spend_in_cents: monthly_spend.0 as i32,
diff --git a/crates/collab/src/cents.rs b/crates/collab/src/cents.rs
index 917177bc51219a..defbcea4e26d39 100644
--- a/crates/collab/src/cents.rs
+++ b/crates/collab/src/cents.rs
@@ -10,6 +10,8 @@
     Copy,
     derive_more::Add,
     derive_more::AddAssign,
+    derive_more::Sub,
+    derive_more::SubAssign,
 )]
 pub struct Cents(pub u32);
 
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index e54c9e133e3fc0..b782db58706dfa 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -469,7 +469,9 @@ async fn check_usage_limit(
                 ));
             }
 
-            if usage.spending_this_month >= Cents(claims.max_monthly_spend_in_cents) {
+            if (usage.spending_this_month - FREE_TIER_MONTHLY_SPENDING_LIMIT)
+                >= Cents(claims.max_monthly_spend_in_cents)
+            {
                 return Err(Error::Http(
                     StatusCode::FORBIDDEN,
                     "Maximum spending limit reached for this month.".to_string(),
diff --git a/crates/collab/src/llm/db/queries/usages.rs b/crates/collab/src/llm/db/queries/usages.rs
index 1e9204b02b21c8..5883bcef571321 100644
--- a/crates/collab/src/llm/db/queries/usages.rs
+++ b/crates/collab/src/llm/db/queries/usages.rs
@@ -412,7 +412,7 @@ impl LlmDatabase {
             if !is_staff
                 && spending_this_month > FREE_TIER_MONTHLY_SPENDING_LIMIT
                 && has_llm_subscription
-                && spending_this_month <= max_monthly_spend
+                && (spending_this_month - FREE_TIER_MONTHLY_SPENDING_LIMIT) <= max_monthly_spend
             {
                 billing_event::ActiveModel {
                     id: ActiveValue::not_set(),
diff --git a/crates/collab/src/llm/db/tests/billing_tests.rs b/crates/collab/src/llm/db/tests/billing_tests.rs
index 2e71df5129764a..88551dd5f85e9d 100644
--- a/crates/collab/src/llm/db/tests/billing_tests.rs
+++ b/crates/collab/src/llm/db/tests/billing_tests.rs
@@ -1,10 +1,7 @@
 use crate::{
     db::UserId,
     llm::{
-        db::{
-            queries::{providers::ModelParams, usages::Usage},
-            LlmDatabase, TokenUsage,
-        },
+        db::{queries::providers::ModelParams, LlmDatabase, TokenUsage},
         FREE_TIER_MONTHLY_SPENDING_LIMIT,
     },
     test_llm_db, Cents,
@@ -76,29 +73,9 @@ async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
 
     // Verify the recorded usage and spending
     let recorded_usage = db.get_usage(user_id, provider, model, now).await.unwrap();
-
     // Verify that we exceeded the free tier usage
-    assert!(
-        recorded_usage.spending_this_month > FREE_TIER_MONTHLY_SPENDING_LIMIT,
-        "Expected spending to exceed free tier limit"
-    );
-
-    assert_eq!(
-        recorded_usage,
-        Usage {
-            requests_this_minute: 1,
-            tokens_this_minute: tokens_to_use,
-            tokens_this_day: tokens_to_use,
-            tokens_this_month: TokenUsage {
-                input: tokens_to_use,
-                input_cache_creation: 0,
-                input_cache_read: 0,
-                output: 0,
-            },
-            spending_this_month: Cents::new(1050),
-            lifetime_spending: Cents::new(1050),
-        }
-    );
+    assert_eq!(recorded_usage.spending_this_month, Cents::new(1050));
+    assert!(recorded_usage.spending_this_month > FREE_TIER_MONTHLY_SPENDING_LIMIT);
 
     // Verify that there is one `billing_event` record
     let billing_events = db.get_billing_events().await.unwrap();
@@ -111,7 +88,35 @@ async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
     assert_eq!(billing_event.input_cache_read_tokens, 0);
     assert_eq!(billing_event.output_tokens, 0);
 
-    let tokens_to_exceed = 20_000_000; // This will cost $1.00 more, pushing us from $10.50 to $11.50, which is over the $11 monthly maximum limit
+    // Record usage that puts us at $20.50
+    let usage_2 = TokenUsage {
+        input: 200_000_000, // This will cost $10 more, pushing us from $10.50 to $20.50,
+        input_cache_creation: 0,
+        input_cache_read: 0,
+        output: 0,
+    };
+    db.record_usage(
+        user_id,
+        false,
+        provider,
+        model,
+        usage_2,
+        true,
+        max_monthly_spend,
+        now,
+    )
+    .await
+    .unwrap();
+
+    // Verify the updated usage and spending
+    let updated_usage = db.get_usage(user_id, provider, model, now).await.unwrap();
+    assert_eq!(updated_usage.spending_this_month, Cents::new(2050));
+
+    // Verify that there are now two billing events
+    let billing_events = db.get_billing_events().await.unwrap();
+    assert_eq!(billing_events.len(), 2);
+
+    let tokens_to_exceed = 20_000_000; // This will cost $1.00 more, pushing us from $20.50 to $21.50, which is over the $11 monthly maximum limit
     let usage_exceeding = TokenUsage {
         input: tokens_to_exceed,
         input_cache_creation: 0,
@@ -132,27 +137,12 @@ async fn test_billing_limit_exceeded(db: &mut LlmDatabase) {
     )
     .await
     .unwrap();
-
-    // Verify that there is still one billing record
-    let billing_events = db.get_billing_events().await.unwrap();
-    assert_eq!(billing_events.len(), 1);
-
     // Verify the updated usage and spending
     let updated_usage = db.get_usage(user_id, provider, model, now).await.unwrap();
-    assert_eq!(
-        updated_usage,
-        Usage {
-            requests_this_minute: 2,
-            tokens_this_minute: tokens_to_use + tokens_to_exceed,
-            tokens_this_day: tokens_to_use + tokens_to_exceed,
-            tokens_this_month: TokenUsage {
-                input: tokens_to_use + tokens_to_exceed,
-                input_cache_creation: 0,
-                input_cache_read: 0,
-                output: 0,
-            },
-            spending_this_month: Cents::new(1150),
-            lifetime_spending: Cents::new(1150),
-        }
-    );
+    assert_eq!(updated_usage.spending_this_month, Cents::new(2150));
+
+    // Verify that we never exceed the user max spending for the user
+    // and avoid charging them.
+    let billing_events = db.get_billing_events().await.unwrap();
+    assert_eq!(billing_events.len(), 2);
 }

From 5ad392035e5b8855c5a886e45302baf7d4c755cb Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Thu, 17 Oct 2024 08:48:18 -0400
Subject: [PATCH 720/762] Support uppercase extensions in image preview
 (#19304)

---
 crates/image_viewer/src/image_viewer.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/image_viewer/src/image_viewer.rs b/crates/image_viewer/src/image_viewer.rs
index a7ff1e732db4ed..5691119dea9726 100644
--- a/crates/image_viewer/src/image_viewer.rs
+++ b/crates/image_viewer/src/image_viewer.rs
@@ -36,7 +36,9 @@ impl project::Item for ImageItem {
             .path
             .extension()
             .and_then(OsStr::to_str)
+            .map(str::to_lowercase)
             .unwrap_or_default();
+        let ext = ext.as_str();
 
         // Only open the item if it's a binary image (no SVGs, etc.)
         // Since we do not have a way to toggle to an editor

From 17f2929b4c408f723c42e650564696ee96eb7860 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 17 Oct 2024 10:18:12 -0400
Subject: [PATCH 721/762] collab: Anchor new subscription's billing cycle to
 the first of the month (#19367)

This PR makes it so new subscriptions will have their billing cycle
anchored to the first of the month.

When someone signs up today, they will be billed starting on the first
of next month.

Release Notes:

- N/A

Co-authored-by: Antonio <antontio@zed.dev>
Co-authored-by: Richard <richard@zed.dev>
---
 crates/collab/src/stripe_billing.rs | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/crates/collab/src/stripe_billing.rs b/crates/collab/src/stripe_billing.rs
index f7cce28a3ad439..126db988a1ea8a 100644
--- a/crates/collab/src/stripe_billing.rs
+++ b/crates/collab/src/stripe_billing.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::{llm, Cents, Result};
 use anyhow::Context;
-use chrono::Utc;
+use chrono::{Datelike, Utc};
 use collections::HashMap;
 use serde::{Deserialize, Serialize};
 use tokio::sync::RwLock;
@@ -349,10 +349,20 @@ impl StripeBilling {
         model: &StripeModel,
         success_url: &str,
     ) -> Result<String> {
+        let first_of_next_month = Utc::now()
+            .checked_add_months(chrono::Months::new(1))
+            .unwrap()
+            .with_day(1)
+            .unwrap();
+
         let mut params = stripe::CreateCheckoutSession::new();
         params.mode = Some(stripe::CheckoutSessionMode::Subscription);
         params.customer = Some(customer_id);
         params.client_reference_id = Some(github_login);
+        params.subscription_data = Some(stripe::CreateCheckoutSessionSubscriptionData {
+            billing_cycle_anchor: Some(first_of_next_month.timestamp()),
+            ..Default::default()
+        });
         params.line_items = Some(
             [
                 &model.input_tokens_price.id,

From 4df882c29536e435cb3608a04f45e65a2c800f0f Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Thu, 17 Oct 2024 10:31:35 -0400
Subject: [PATCH 722/762] Make terminal.option_as_meta=false in default
 settings (#19364)

- This reverts the change I made in https://github.com/zed-industries/zed/pull/15535 which set `option_as_meta` to `true` in the default settings.
- `true` is a reasonable default for US Keyboards, but is terrible for many others which rely on `alt+<key>` for totally normal keystroke combinations.
---
 crates/terminal/src/terminal_settings.rs | 2 +-
 docs/src/configuring-zed.md              | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/terminal/src/terminal_settings.rs b/crates/terminal/src/terminal_settings.rs
index 51b8207f576d6e..e48e23b141c268 100644
--- a/crates/terminal/src/terminal_settings.rs
+++ b/crates/terminal/src/terminal_settings.rs
@@ -151,7 +151,7 @@ pub struct TerminalSettingsContent {
     pub alternate_scroll: Option<AlternateScroll>,
     /// Sets whether the option key behaves as the meta key.
     ///
-    /// Default: true
+    /// Default: false
     pub option_as_meta: Option<bool>,
     /// Whether or not selecting text in the terminal will automatically
     /// copy to the system clipboard.
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 37d86e6481978f..1a791bed012b87 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -1498,13 +1498,13 @@ List of `integer` column numbers
         "directories": [".env", "env", ".venv", "venv"],
         "activate_script": "default"
       }
-    }
+    },
     "env": {},
     "font_family": null,
     "font_features": null,
     "font_size": null,
     "line_height": "comfortable",
-    "option_as_meta": true,
+    "option_as_meta": false,
     "button": false,
     "shell": {},
     "toolbar": {

From c186e99a3d51d7cf496792c35c64338618e4a4ce Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 17 Oct 2024 17:07:34 +0200
Subject: [PATCH 723/762] ssh remote: Reset missed heartbeats on connection
 activity (#19368)

Ran into this this morning. At least I suspect I ran into it. In any
case: we need to reset the missed hearbeats to 0 in case we got any
connection activity.

Release Notes:

- N/A
---
 crates/remote/src/ssh_session.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index a09faf894cd4d7..6f9df8a4a34241 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -832,7 +832,15 @@ impl SshRemoteClient {
                                 log::warn!("ssh heartbeat: connection activity channel has been dropped. stopping.");
                                 return Ok(());
                             }
+
                             keepalive_timer.set(cx.background_executor().timer(HEARTBEAT_INTERVAL).fuse());
+
+                            if missed_heartbeats != 0 {
+                                missed_heartbeats = 0;
+                                this.update(&mut cx, |this, mut cx| {
+                                    this.handle_heartbeat_result(missed_heartbeats, &mut cx)
+                                })?;
+                            }
                         }
                         _ = keepalive_timer => {
                             log::debug!("Sending heartbeat to server...");
@@ -845,6 +853,7 @@ impl SshRemoteClient {
                                     ping_result
                                 }
                             };
+
                             if result.is_err() {
                                 missed_heartbeats += 1;
                                 log::warn!(

From 4be9da26413d02d5fae0c03e135cc288fd7ad265 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 17 Oct 2024 17:07:42 +0200
Subject: [PATCH 724/762] remote ssh: Make "get permalink to line" work
 (#19366)

This makes the `editor: copy permalink to line` and `editor: copy
permalink to line` actions work in SSH remote projects.

Previously it would only work in local projects.

Demo:


https://github.com/user-attachments/assets/a8012152-b631-4b34-9ff2-e4d033c97dee




Release Notes:

- N/A
---
 Cargo.lock                         |   3 +
 crates/editor/src/editor.rs        | 144 +++++++++++++++--------------
 crates/project/Cargo.toml          |   1 +
 crates/project/src/buffer_store.rs | 101 +++++++++++++++++++-
 crates/project/src/project.rs      |  11 +++
 crates/proto/proto/zed.proto       |  15 ++-
 crates/proto/src/proto.rs          |   7 +-
 crates/remote_server/Cargo.toml    |   2 +
 crates/remote_server/src/unix.rs   |   6 ++
 9 files changed, 215 insertions(+), 75 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 03d36c4445147b..aead615900ab7f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8472,6 +8472,7 @@ dependencies = [
  "terminal",
  "text",
  "unindent",
+ "url",
  "util",
  "which 6.0.3",
  "windows 0.58.0",
@@ -9147,6 +9148,8 @@ dependencies = [
  "env_logger",
  "fs",
  "futures 0.3.30",
+ "git",
+ "git_hosting_providers",
  "gpui",
  "http_client",
  "language",
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 378ccb905d9507..72205273f80702 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -48,7 +48,6 @@ mod signature_help;
 pub mod test;
 
 use ::git::diff::DiffHunkStatus;
-use ::git::{parse_git_remote_url, BuildPermalinkParams, GitHostingProviderRegistry};
 pub(crate) use actions::*;
 use aho_corasick::AhoCorasick;
 use anyhow::{anyhow, Context as _, Result};
@@ -11488,11 +11487,8 @@ impl Editor {
         snapshot.line_len(buffer_row) == 0
     }
 
-    fn get_permalink_to_line(&mut self, cx: &mut ViewContext<Self>) -> Result<url::Url> {
-        let (path, selection, repo) = maybe!({
-            let project_handle = self.project.as_ref()?.clone();
-            let project = project_handle.read(cx);
-
+    fn get_permalink_to_line(&mut self, cx: &mut ViewContext<Self>) -> Task<Result<url::Url>> {
+        let buffer_and_selection = maybe!({
             let selection = self.selections.newest::<Point>(cx);
             let selection_range = selection.range();
 
@@ -11516,64 +11512,58 @@ impl Editor {
                 (buffer.clone(), selection)
             };
 
-            let path = buffer
-                .read(cx)
-                .file()?
-                .as_local()?
-                .path()
-                .to_str()?
-                .to_string();
-            let repo = project.get_repo(&buffer.read(cx).project_path(cx)?, cx)?;
-            Some((path, selection, repo))
+            Some((buffer, selection))
+        });
+
+        let Some((buffer, selection)) = buffer_and_selection else {
+            return Task::ready(Err(anyhow!("failed to determine buffer and selection")));
+        };
+
+        let Some(project) = self.project.as_ref() else {
+            return Task::ready(Err(anyhow!("editor does not have project")));
+        };
+
+        project.update(cx, |project, cx| {
+            project.get_permalink_to_line(&buffer, selection, cx)
         })
-        .ok_or_else(|| anyhow!("unable to open git repository"))?;
-
-        const REMOTE_NAME: &str = "origin";
-        let origin_url = repo
-            .remote_url(REMOTE_NAME)
-            .ok_or_else(|| anyhow!("remote \"{REMOTE_NAME}\" not found"))?;
-        let sha = repo
-            .head_sha()
-            .ok_or_else(|| anyhow!("failed to read HEAD SHA"))?;
-
-        let (provider, remote) =
-            parse_git_remote_url(GitHostingProviderRegistry::default_global(cx), &origin_url)
-                .ok_or_else(|| anyhow!("failed to parse Git remote URL"))?;
-
-        Ok(provider.build_permalink(
-            remote,
-            BuildPermalinkParams {
-                sha: &sha,
-                path: &path,
-                selection: Some(selection),
-            },
-        ))
     }
 
     pub fn copy_permalink_to_line(&mut self, _: &CopyPermalinkToLine, cx: &mut ViewContext<Self>) {
-        let permalink = self.get_permalink_to_line(cx);
+        let permalink_task = self.get_permalink_to_line(cx);
+        let workspace = self.workspace();
 
-        match permalink {
-            Ok(permalink) => {
-                cx.write_to_clipboard(ClipboardItem::new_string(permalink.to_string()));
-            }
-            Err(err) => {
-                let message = format!("Failed to copy permalink: {err}");
+        cx.spawn(|_, mut cx| async move {
+            match permalink_task.await {
+                Ok(permalink) => {
+                    cx.update(|cx| {
+                        cx.write_to_clipboard(ClipboardItem::new_string(permalink.to_string()));
+                    })
+                    .ok();
+                }
+                Err(err) => {
+                    let message = format!("Failed to copy permalink: {err}");
 
-                Err::<(), anyhow::Error>(err).log_err();
+                    Err::<(), anyhow::Error>(err).log_err();
 
-                if let Some(workspace) = self.workspace() {
-                    workspace.update(cx, |workspace, cx| {
-                        struct CopyPermalinkToLine;
+                    if let Some(workspace) = workspace {
+                        workspace
+                            .update(&mut cx, |workspace, cx| {
+                                struct CopyPermalinkToLine;
 
-                        workspace.show_toast(
-                            Toast::new(NotificationId::unique::<CopyPermalinkToLine>(), message),
-                            cx,
-                        )
-                    })
+                                workspace.show_toast(
+                                    Toast::new(
+                                        NotificationId::unique::<CopyPermalinkToLine>(),
+                                        message,
+                                    ),
+                                    cx,
+                                )
+                            })
+                            .ok();
+                    }
                 }
             }
-        }
+        })
+        .detach();
     }
 
     pub fn copy_file_location(&mut self, _: &CopyFileLocation, cx: &mut ViewContext<Self>) {
@@ -11586,29 +11576,41 @@ impl Editor {
     }
 
     pub fn open_permalink_to_line(&mut self, _: &OpenPermalinkToLine, cx: &mut ViewContext<Self>) {
-        let permalink = self.get_permalink_to_line(cx);
+        let permalink_task = self.get_permalink_to_line(cx);
+        let workspace = self.workspace();
 
-        match permalink {
-            Ok(permalink) => {
-                cx.open_url(permalink.as_ref());
-            }
-            Err(err) => {
-                let message = format!("Failed to open permalink: {err}");
+        cx.spawn(|_, mut cx| async move {
+            match permalink_task.await {
+                Ok(permalink) => {
+                    cx.update(|cx| {
+                        cx.open_url(permalink.as_ref());
+                    })
+                    .ok();
+                }
+                Err(err) => {
+                    let message = format!("Failed to open permalink: {err}");
 
-                Err::<(), anyhow::Error>(err).log_err();
+                    Err::<(), anyhow::Error>(err).log_err();
 
-                if let Some(workspace) = self.workspace() {
-                    workspace.update(cx, |workspace, cx| {
-                        struct OpenPermalinkToLine;
+                    if let Some(workspace) = workspace {
+                        workspace
+                            .update(&mut cx, |workspace, cx| {
+                                struct OpenPermalinkToLine;
 
-                        workspace.show_toast(
-                            Toast::new(NotificationId::unique::<OpenPermalinkToLine>(), message),
-                            cx,
-                        )
-                    })
+                                workspace.show_toast(
+                                    Toast::new(
+                                        NotificationId::unique::<OpenPermalinkToLine>(),
+                                        message,
+                                    ),
+                                    cx,
+                                )
+                            })
+                            .ok();
+                    }
                 }
             }
-        }
+        })
+        .detach();
     }
 
     /// Adds a row highlight for the given range. If a row has multiple highlights, the
diff --git a/crates/project/Cargo.toml b/crates/project/Cargo.toml
index 1e7801e90888da..2a9bb82a353659 100644
--- a/crates/project/Cargo.toml
+++ b/crates/project/Cargo.toml
@@ -69,6 +69,7 @@ snippet_provider.workspace = true
 terminal.workspace = true
 text.workspace = true
 util.workspace = true
+url.workspace = true
 which.workspace = true
 
 [target.'cfg(target_os = "windows")'.dependencies]
diff --git a/crates/project/src/buffer_store.rs b/crates/project/src/buffer_store.rs
index aa86a8f7e256e8..9f9e624d221ba0 100644
--- a/crates/project/src/buffer_store.rs
+++ b/crates/project/src/buffer_store.rs
@@ -3,6 +3,7 @@ use crate::{
     worktree_store::{WorktreeStore, WorktreeStoreEvent},
     Item, NoRepositoryError, ProjectPath,
 };
+use ::git::{parse_git_remote_url, BuildPermalinkParams, GitHostingProviderRegistry};
 use anyhow::{anyhow, Context as _, Result};
 use client::Client;
 use collections::{hash_map, HashMap, HashSet};
@@ -23,7 +24,7 @@ use language::{
 };
 use rpc::{proto, AnyProtoClient, ErrorExt as _, TypedEnvelope};
 use smol::channel::Receiver;
-use std::{io, path::Path, str::FromStr as _, sync::Arc, time::Instant};
+use std::{io, ops::Range, path::Path, str::FromStr as _, sync::Arc, time::Instant};
 use text::BufferId;
 use util::{debug_panic, maybe, ResultExt as _, TryFutureExt};
 use worktree::{File, PathChange, ProjectEntryId, UpdatedGitRepositoriesSet, Worktree, WorktreeId};
@@ -971,6 +972,7 @@ impl BufferStore {
         client.add_model_request_handler(Self::handle_save_buffer);
         client.add_model_request_handler(Self::handle_blame_buffer);
         client.add_model_request_handler(Self::handle_reload_buffers);
+        client.add_model_request_handler(Self::handle_get_permalink_to_line);
     }
 
     /// Creates a buffer store, optionally retaining its buffers.
@@ -1170,6 +1172,78 @@ impl BufferStore {
         }
     }
 
+    pub fn get_permalink_to_line(
+        &self,
+        buffer: &Model<Buffer>,
+        selection: Range<u32>,
+        cx: &AppContext,
+    ) -> Task<Result<url::Url>> {
+        let buffer = buffer.read(cx);
+        let Some(file) = File::from_dyn(buffer.file()) else {
+            return Task::ready(Err(anyhow!("buffer has no file")));
+        };
+
+        match file.worktree.clone().read(cx) {
+            Worktree::Local(worktree) => {
+                let Some(repo) = worktree.local_git_repo(file.path()) else {
+                    return Task::ready(Err(anyhow!("no repository for buffer found")));
+                };
+
+                let path = file.path().clone();
+
+                cx.spawn(|cx| async move {
+                    const REMOTE_NAME: &str = "origin";
+                    let origin_url = repo
+                        .remote_url(REMOTE_NAME)
+                        .ok_or_else(|| anyhow!("remote \"{REMOTE_NAME}\" not found"))?;
+
+                    let sha = repo
+                        .head_sha()
+                        .ok_or_else(|| anyhow!("failed to read HEAD SHA"))?;
+
+                    let provider_registry =
+                        cx.update(GitHostingProviderRegistry::default_global)?;
+
+                    let (provider, remote) =
+                        parse_git_remote_url(provider_registry, &origin_url)
+                            .ok_or_else(|| anyhow!("failed to parse Git remote URL"))?;
+
+                    let path = path
+                        .to_str()
+                        .context("failed to convert buffer path to string")?;
+
+                    Ok(provider.build_permalink(
+                        remote,
+                        BuildPermalinkParams {
+                            sha: &sha,
+                            path,
+                            selection: Some(selection),
+                        },
+                    ))
+                })
+            }
+            Worktree::Remote(worktree) => {
+                let buffer_id = buffer.remote_id();
+                let project_id = worktree.project_id();
+                let client = worktree.client();
+                cx.spawn(|_| async move {
+                    let response = client
+                        .request(proto::GetPermalinkToLine {
+                            project_id,
+                            buffer_id: buffer_id.into(),
+                            selection: Some(proto::Range {
+                                start: selection.start as u64,
+                                end: selection.end as u64,
+                            }),
+                        })
+                        .await?;
+
+                    url::Url::parse(&response.permalink).context("failed to parse permalink")
+                })
+            }
+        }
+    }
+
     fn add_buffer(&mut self, buffer: Model<Buffer>, cx: &mut ModelContext<Self>) -> Result<()> {
         let remote_id = buffer.read(cx).remote_id();
         let is_remote = buffer.read(cx).replica_id() != 0;
@@ -1775,6 +1849,31 @@ impl BufferStore {
         Ok(serialize_blame_buffer_response(blame))
     }
 
+    pub async fn handle_get_permalink_to_line(
+        this: Model<Self>,
+        envelope: TypedEnvelope<proto::GetPermalinkToLine>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::GetPermalinkToLineResponse> {
+        let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
+        // let version = deserialize_version(&envelope.payload.version);
+        let selection = {
+            let proto_selection = envelope
+                .payload
+                .selection
+                .context("no selection to get permalink for defined")?;
+            proto_selection.start as u32..proto_selection.end as u32
+        };
+        let buffer = this.read_with(&cx, |this, _| this.get_existing(buffer_id))??;
+        let permalink = this
+            .update(&mut cx, |this, cx| {
+                this.get_permalink_to_line(&buffer, selection, cx)
+            })?
+            .await?;
+        Ok(proto::GetPermalinkToLineResponse {
+            permalink: permalink.to_string(),
+        })
+    }
+
     pub async fn wait_for_loading_buffer(
         mut receiver: postage::watch::Receiver<Option<Result<Model<Buffer>, Arc<anyhow::Error>>>>,
     ) -> Result<Model<Buffer>, Arc<anyhow::Error>> {
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 03074fb6a6579e..70d5962647c487 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -3463,6 +3463,17 @@ impl Project {
         self.buffer_store.read(cx).blame_buffer(buffer, version, cx)
     }
 
+    pub fn get_permalink_to_line(
+        &self,
+        buffer: &Model<Buffer>,
+        selection: Range<u32>,
+        cx: &AppContext,
+    ) -> Task<Result<url::Url>> {
+        self.buffer_store
+            .read(cx)
+            .get_permalink_to_line(buffer, selection, cx)
+    }
+
     // RPC message handlers
 
     async fn handle_unshare_project(
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index 822ccf6cf7112b..09891de6fecd3b 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -292,7 +292,10 @@ message Envelope {
         Toast toast = 261;
         HideToast hide_toast = 262;
 
-        OpenServerSettings open_server_settings = 263; // current max
+        OpenServerSettings open_server_settings = 263;
+
+        GetPermalinkToLine get_permalink_to_line = 264;
+        GetPermalinkToLineResponse get_permalink_to_line_response = 265;  // current max
     }
 
     reserved 87 to 88;
@@ -2508,3 +2511,13 @@ message HideToast {
 message OpenServerSettings {
     uint64 project_id = 1;
 }
+
+message GetPermalinkToLine {
+    uint64 project_id = 1;
+    uint64 buffer_id = 2;
+    Range selection = 3;
+}
+
+message GetPermalinkToLineResponse {
+    string permalink = 1;
+}
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 84554399801653..ffbbeb49c2b48a 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -370,6 +370,8 @@ messages!(
     (Toast, Background),
     (HideToast, Background),
     (OpenServerSettings, Foreground),
+    (GetPermalinkToLine, Foreground),
+    (GetPermalinkToLineResponse, Foreground),
 );
 
 request_messages!(
@@ -494,7 +496,8 @@ request_messages!(
     (CheckFileExists, CheckFileExistsResponse),
     (ShutdownRemoteServer, Ack),
     (RemoveWorktree, Ack),
-    (OpenServerSettings, OpenBufferResponse)
+    (OpenServerSettings, OpenBufferResponse),
+    (GetPermalinkToLine, GetPermalinkToLineResponse),
 );
 
 entity_messages!(
@@ -571,7 +574,7 @@ entity_messages!(
     Toast,
     HideToast,
     OpenServerSettings,
-
+    GetPermalinkToLine,
 );
 
 entity_messages!(
diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml
index 6ba2c5c7c97ca7..ffec42e5706d9a 100644
--- a/crates/remote_server/Cargo.toml
+++ b/crates/remote_server/Cargo.toml
@@ -30,6 +30,8 @@ client.workspace = true
 env_logger.workspace = true
 fs.workspace = true
 futures.workspace = true
+git.workspace = true
+git_hosting_providers.workspace = true
 gpui.workspace = true
 http_client.workspace = true
 language.workspace = true
diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs
index 74198b18918ae9..60b7fc458d0b43 100644
--- a/crates/remote_server/src/unix.rs
+++ b/crates/remote_server/src/unix.rs
@@ -5,6 +5,7 @@ use client::ProxySettings;
 use fs::{Fs, RealFs};
 use futures::channel::mpsc;
 use futures::{select, select_biased, AsyncRead, AsyncWrite, AsyncWriteExt, FutureExt, SinkExt};
+use git::GitHostingProviderRegistry;
 use gpui::{AppContext, Context as _, ModelContext, UpdateGlobal as _};
 use http_client::{read_proxy_from_env, Uri};
 use language::LanguageRegistry;
@@ -313,6 +314,8 @@ pub fn execute_run(
     let listeners = ServerListeners::new(stdin_socket, stdout_socket, stderr_socket)?;
 
     log::info!("starting headless gpui app");
+
+    let git_hosting_provider_registry = Arc::new(GitHostingProviderRegistry::new());
     gpui::App::headless().run(move |cx| {
         settings::init(cx);
         HeadlessProject::init(cx);
@@ -322,6 +325,9 @@ pub fn execute_run(
 
         client::init_settings(cx);
 
+        GitHostingProviderRegistry::set_global(git_hosting_provider_registry, cx);
+        git_hosting_providers::init(cx);
+
         let project = cx.new_model(|cx| {
             let fs = Arc::new(RealFs::new(Default::default(), None));
             let node_settings_rx = initialize_settings(session.clone(), fs.clone(), cx);

From e9e4c770ca843cb3201797330e9d89a32cc0073f Mon Sep 17 00:00:00 2001
From: Finn Evers <dev@bahn.sh>
Date: Thu, 17 Oct 2024 17:21:07 +0200
Subject: [PATCH 725/762] Update all occurrences of `option_as_meta` to new
 default value (#19369)

This PR is a quick follow-up to #19364 which updates some left-out
occurrences of `option_as_meta` to the new default value (`false`).
---
 assets/settings/default.json | 6 +++---
 docs/src/configuring-zed.md  | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 4bde5ee174f782..bde7239bc921fd 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -712,10 +712,10 @@
     // May take 2 values:
     //  1. Rely on default platform handling of option key, on macOS
     //     this means generating certain unicode characters
-    //         "option_to_meta": false,
+    //         "option_as_meta": false,
     //  2. Make the option keys behave as a 'meta' key, e.g. for emacs
-    //         "option_to_meta": true,
-    "option_as_meta": true,
+    //         "option_as_meta": true,
+    "option_as_meta": false,
     // Whether or not selecting text in the terminal will automatically
     // copy to the system clipboard.
     "copy_on_select": false,
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 1a791bed012b87..16f7fcf2d593d0 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -1732,7 +1732,7 @@ See Buffer Font Features
 
 - Description: Re-interprets the option keys to act like a 'meta' key, like in Emacs.
 - Setting: `option_as_meta`
-- Default: `true`
+- Default: `false`
 
 **Options**
 

From 398d0396b67ea3c8acc3f893e34d79b7054b3861 Mon Sep 17 00:00:00 2001
From: Elliot Thomas <eth0net@pm.me>
Date: Thu, 17 Oct 2024 16:38:28 +0100
Subject: [PATCH 726/762] workspace: Fix inconsistent paths order serialization
 (#19232)

Release Notes:

- Fixed inconsistent serialization of workspace paths order
---
 Cargo.lock                                    |   1 +
 crates/recent_projects/Cargo.toml             |   1 +
 crates/recent_projects/src/recent_projects.rs |  11 +-
 crates/workspace/src/persistence.rs           | 105 ++++++++++++++----
 crates/workspace/src/workspace.rs             |  22 ++--
 5 files changed, 107 insertions(+), 33 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index aead615900ab7f..b58716cd574394 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8974,6 +8974,7 @@ dependencies = [
  "futures 0.3.30",
  "fuzzy",
  "gpui",
+ "itertools 0.13.0",
  "language",
  "log",
  "menu",
diff --git a/crates/recent_projects/Cargo.toml b/crates/recent_projects/Cargo.toml
index 3dadcbef37509d..c954924711e327 100644
--- a/crates/recent_projects/Cargo.toml
+++ b/crates/recent_projects/Cargo.toml
@@ -22,6 +22,7 @@ file_finder.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
+itertools.workspace = true
 log.workspace = true
 menu.workspace = true
 ordered-float.workspace = true
diff --git a/crates/recent_projects/src/recent_projects.rs b/crates/recent_projects/src/recent_projects.rs
index 5fea5d3a5c4ac6..6add7a618ad84c 100644
--- a/crates/recent_projects/src/recent_projects.rs
+++ b/crates/recent_projects/src/recent_projects.rs
@@ -13,6 +13,7 @@ use gpui::{
     Action, AnyElement, AppContext, DismissEvent, EventEmitter, FocusHandle, FocusableView,
     Subscription, Task, View, ViewContext, WeakView,
 };
+use itertools::Itertools;
 use ordered_float::OrderedFloat;
 use picker::{
     highlighted_match_with_paths::{HighlightedMatchWithPaths, HighlightedText},
@@ -247,8 +248,9 @@ impl PickerDelegate for RecentProjectsDelegate {
                     SerializedWorkspaceLocation::Local(paths, order) => order
                         .order()
                         .iter()
-                        .filter_map(|i| paths.paths().get(*i))
-                        .map(|path| path.compact().to_string_lossy().into_owned())
+                        .zip(paths.paths().iter())
+                        .sorted_by_key(|(i, _)| *i)
+                        .map(|(_, path)| path.compact().to_string_lossy().into_owned())
                         .collect::<Vec<_>>()
                         .join(""),
                     SerializedWorkspaceLocation::DevServer(dev_server_project) => {
@@ -447,8 +449,9 @@ impl PickerDelegate for RecentProjectsDelegate {
                 order
                     .order()
                     .iter()
-                    .filter_map(|i| paths.paths().get(*i).cloned())
-                    .map(|path| path.compact())
+                    .zip(paths.paths().iter())
+                    .sorted_by_key(|(i, _)| **i)
+                    .map(|(_, path)| path.compact())
                     .collect(),
             ),
             SerializedWorkspaceLocation::Ssh(ssh_project) => Arc::new(ssh_project.ssh_urls()),
diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs
index 69217fcc457968..d0cb684b527400 100644
--- a/crates/workspace/src/persistence.rs
+++ b/crates/workspace/src/persistence.rs
@@ -380,6 +380,8 @@ impl WorkspaceDb {
         &self,
         worktree_roots: &[P],
     ) -> Option<SerializedWorkspace> {
+        // paths are sorted before db interactions to ensure that the order of the paths
+        // doesn't affect the workspace selection for existing workspaces
         let local_paths = LocalPaths::new(worktree_roots);
 
         // Note that we re-assign the workspace_id here in case it's empty
@@ -833,8 +835,8 @@ impl WorkspaceDb {
     }
 
     query! {
-        fn session_workspaces(session_id: String) -> Result<Vec<(LocalPaths, Option<u64>, Option<u64>)>> {
-            SELECT local_paths, window_id, ssh_project_id
+        fn session_workspaces(session_id: String) -> Result<Vec<(LocalPaths, LocalPathsOrder, Option<u64>, Option<u64>)>> {
+            SELECT local_paths, local_paths_order, window_id, ssh_project_id
             FROM workspaces
             WHERE session_id = ?1 AND dev_server_project_id IS NULL
             ORDER BY timestamp DESC
@@ -971,7 +973,7 @@ impl WorkspaceDb {
     ) -> Result<Vec<SerializedWorkspaceLocation>> {
         let mut workspaces = Vec::new();
 
-        for (location, window_id, ssh_project_id) in
+        for (location, order, window_id, ssh_project_id) in
             self.session_workspaces(last_session_id.to_owned())?
         {
             if let Some(ssh_project_id) = ssh_project_id {
@@ -980,8 +982,7 @@ impl WorkspaceDb {
             } else if location.paths().iter().all(|path| path.exists())
                 && location.paths().iter().any(|path| path.is_dir())
             {
-                let location =
-                    SerializedWorkspaceLocation::from_local_paths(location.paths().iter());
+                let location = SerializedWorkspaceLocation::Local(location, order);
                 workspaces.push((location, window_id.map(WindowId::from)));
             }
         }
@@ -1603,27 +1604,56 @@ mod tests {
             window_id: Some(50),
         };
 
+        let workspace_6 = SerializedWorkspace {
+            id: WorkspaceId(6),
+            location: SerializedWorkspaceLocation::Local(
+                LocalPaths::new(["/tmp6a", "/tmp6b", "/tmp6c"]),
+                LocalPathsOrder::new([2, 1, 0]),
+            ),
+            center_group: Default::default(),
+            window_bounds: Default::default(),
+            display: Default::default(),
+            docks: Default::default(),
+            centered_layout: false,
+            session_id: Some("session-id-3".to_owned()),
+            window_id: Some(60),
+        };
+
         db.save_workspace(workspace_1.clone()).await;
         db.save_workspace(workspace_2.clone()).await;
         db.save_workspace(workspace_3.clone()).await;
         db.save_workspace(workspace_4.clone()).await;
         db.save_workspace(workspace_5.clone()).await;
+        db.save_workspace(workspace_6.clone()).await;
 
         let locations = db.session_workspaces("session-id-1".to_owned()).unwrap();
         assert_eq!(locations.len(), 2);
         assert_eq!(locations[0].0, LocalPaths::new(["/tmp1"]));
-        assert_eq!(locations[0].1, Some(10));
+        assert_eq!(locations[0].1, LocalPathsOrder::new([0]));
+        assert_eq!(locations[0].2, Some(10));
         assert_eq!(locations[1].0, LocalPaths::new(["/tmp2"]));
-        assert_eq!(locations[1].1, Some(20));
+        assert_eq!(locations[1].1, LocalPathsOrder::new([0]));
+        assert_eq!(locations[1].2, Some(20));
 
         let locations = db.session_workspaces("session-id-2".to_owned()).unwrap();
         assert_eq!(locations.len(), 2);
         assert_eq!(locations[0].0, LocalPaths::new(["/tmp3"]));
-        assert_eq!(locations[0].1, Some(30));
+        assert_eq!(locations[0].1, LocalPathsOrder::new([0]));
+        assert_eq!(locations[0].2, Some(30));
         let empty_paths: Vec<&str> = Vec::new();
         assert_eq!(locations[1].0, LocalPaths::new(empty_paths.iter()));
-        assert_eq!(locations[1].1, Some(50));
-        assert_eq!(locations[1].2, Some(ssh_project.id.0));
+        assert_eq!(locations[1].1, LocalPathsOrder::new([]));
+        assert_eq!(locations[1].2, Some(50));
+        assert_eq!(locations[1].3, Some(ssh_project.id.0));
+
+        let locations = db.session_workspaces("session-id-3".to_owned()).unwrap();
+        assert_eq!(locations.len(), 1);
+        assert_eq!(
+            locations[0].0,
+            LocalPaths::new(["/tmp6a", "/tmp6b", "/tmp6c"]),
+        );
+        assert_eq!(locations[0].1, LocalPathsOrder::new([2, 1, 0]));
+        assert_eq!(locations[0].2, Some(60));
     }
 
     fn default_workspace<P: AsRef<Path>>(
@@ -1654,15 +1684,30 @@ mod tests {
             WorkspaceDb(open_test_db("test_serializing_workspaces_last_session_workspaces").await);
 
         let workspaces = [
-            (1, dir1.path().to_str().unwrap(), 9),
-            (2, dir2.path().to_str().unwrap(), 5),
-            (3, dir3.path().to_str().unwrap(), 8),
-            (4, dir4.path().to_str().unwrap(), 2),
+            (1, vec![dir1.path()], vec![0], 9),
+            (2, vec![dir2.path()], vec![0], 5),
+            (3, vec![dir3.path()], vec![0], 8),
+            (4, vec![dir4.path()], vec![0], 2),
+            (
+                5,
+                vec![dir1.path(), dir2.path(), dir3.path()],
+                vec![0, 1, 2],
+                3,
+            ),
+            (
+                6,
+                vec![dir2.path(), dir3.path(), dir4.path()],
+                vec![2, 1, 0],
+                4,
+            ),
         ]
         .into_iter()
-        .map(|(id, location, window_id)| SerializedWorkspace {
+        .map(|(id, locations, order, window_id)| SerializedWorkspace {
             id: WorkspaceId(id),
-            location: SerializedWorkspaceLocation::from_local_paths([location]),
+            location: SerializedWorkspaceLocation::Local(
+                LocalPaths::new(locations),
+                LocalPathsOrder::new(order),
+            ),
             center_group: Default::default(),
             window_bounds: Default::default(),
             display: Default::default(),
@@ -1681,28 +1726,44 @@ mod tests {
             WindowId::from(2), // Top
             WindowId::from(8),
             WindowId::from(5),
-            WindowId::from(9), // Bottom
+            WindowId::from(9),
+            WindowId::from(3),
+            WindowId::from(4), // Bottom
         ]));
 
         let have = db
             .last_session_workspace_locations("one-session", stack)
             .unwrap();
-        assert_eq!(have.len(), 4);
+        assert_eq!(have.len(), 6);
         assert_eq!(
             have[0],
-            SerializedWorkspaceLocation::from_local_paths(&[dir4.path().to_str().unwrap()])
+            SerializedWorkspaceLocation::from_local_paths(&[dir4.path()])
         );
         assert_eq!(
             have[1],
-            SerializedWorkspaceLocation::from_local_paths([dir3.path().to_str().unwrap()])
+            SerializedWorkspaceLocation::from_local_paths([dir3.path()])
         );
         assert_eq!(
             have[2],
-            SerializedWorkspaceLocation::from_local_paths([dir2.path().to_str().unwrap()])
+            SerializedWorkspaceLocation::from_local_paths([dir2.path()])
         );
         assert_eq!(
             have[3],
-            SerializedWorkspaceLocation::from_local_paths([dir1.path().to_str().unwrap()])
+            SerializedWorkspaceLocation::from_local_paths([dir1.path()])
+        );
+        assert_eq!(
+            have[4],
+            SerializedWorkspaceLocation::Local(
+                LocalPaths::new([dir1.path(), dir2.path(), dir3.path()]),
+                LocalPathsOrder::new([0, 1, 2]),
+            ),
+        );
+        assert_eq!(
+            have[5],
+            SerializedWorkspaceLocation::Local(
+                LocalPaths::new([dir2.path(), dir3.path(), dir4.path()]),
+                LocalPathsOrder::new([2, 1, 0]),
+            ),
         );
     }
 
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index c50c3b9f126a7b..626d4d9c1defa2 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -1103,20 +1103,28 @@ impl Workspace {
 
             let mut paths_to_open = abs_paths;
 
-            let paths_order = serialized_workspace
+            let workspace_location = serialized_workspace
                 .as_ref()
                 .map(|ws| &ws.location)
                 .and_then(|loc| match loc {
-                    SerializedWorkspaceLocation::Local(_, order) => Some(order.order()),
+                    SerializedWorkspaceLocation::Local(paths, order) => {
+                        Some((paths.paths(), order.order()))
+                    }
                     _ => None,
                 });
 
-            if let Some(paths_order) = paths_order {
-                paths_to_open = paths_order
+            if let Some((paths, order)) = workspace_location {
+                // todo: should probably move this logic to a method on the SerializedWorkspaceLocation
+                // it's only valid for Local and would be more clear there and be able to be tested
+                // and reused elsewhere
+                paths_to_open = order
                     .iter()
-                    .filter_map(|i| paths_to_open.get(*i).cloned())
-                    .collect::<Vec<_>>();
-                if paths_order.iter().enumerate().any(|(i, &j)| i != j) {
+                    .zip(paths.iter())
+                    .sorted_by_key(|(i, _)| *i)
+                    .map(|(_, path)| path.clone())
+                    .collect();
+
+                if order.iter().enumerate().any(|(i, &j)| i != j) {
                     project_handle
                         .update(&mut cx, |project, cx| {
                             project.set_worktrees_reordered(true, cx);

From e6b9a8ef9bdb4eb46e894d738df7d43c347f4b55 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Thu, 17 Oct 2024 17:49:17 +0200
Subject: [PATCH 727/762] ssh remoting: Handle OpenNewBuffer request (#19373)

Release Notes:

- N/A
---
 crates/remote_server/src/headless_project.rs | 27 ++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index e6eddac1d0eb5b..4536cc94638d85 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -154,6 +154,7 @@ impl HeadlessProject {
         client.add_request_handler(cx.weak_model(), Self::handle_remove_worktree);
 
         client.add_model_request_handler(Self::handle_open_buffer_by_path);
+        client.add_model_request_handler(Self::handle_open_new_buffer);
         client.add_model_request_handler(Self::handle_find_search_candidates);
         client.add_model_request_handler(Self::handle_open_server_settings);
 
@@ -363,6 +364,32 @@ impl HeadlessProject {
         })
     }
 
+    pub async fn handle_open_new_buffer(
+        this: Model<Self>,
+        _message: TypedEnvelope<proto::OpenNewBuffer>,
+        mut cx: AsyncAppContext,
+    ) -> Result<proto::OpenBufferResponse> {
+        let (buffer_store, buffer) = this.update(&mut cx, |this, cx| {
+            let buffer_store = this.buffer_store.clone();
+            let buffer = this
+                .buffer_store
+                .update(cx, |buffer_store, cx| buffer_store.create_buffer(cx));
+            anyhow::Ok((buffer_store, buffer))
+        })??;
+
+        let buffer = buffer.await?;
+        let buffer_id = buffer.read_with(&cx, |b, _| b.remote_id())?;
+        buffer_store.update(&mut cx, |buffer_store, cx| {
+            buffer_store
+                .create_buffer_for_peer(&buffer, SSH_PEER_ID, cx)
+                .detach_and_log_err(cx);
+        })?;
+
+        Ok(proto::OpenBufferResponse {
+            buffer_id: buffer_id.to_proto(),
+        })
+    }
+
     pub async fn handle_open_server_settings(
         this: Model<Self>,
         _: TypedEnvelope<proto::OpenServerSettings>,

From 65fb2782eb73c85ba7f6b59ecaf77af22e535cfc Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Thu, 17 Oct 2024 10:36:53 -0600
Subject: [PATCH 728/762] Always have cmd-o open a local project (#19376)

Release Notes:

- Fixed `cmd-o` in an SSH project to always open a local project
---
 crates/workspace/src/workspace.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 626d4d9c1defa2..5bb864423405fe 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -1897,11 +1897,7 @@ impl Workspace {
                 directories: true,
                 multiple: true,
             },
-            if self.project.read(cx).is_via_ssh() {
-                DirectoryLister::Project(self.project.clone())
-            } else {
-                DirectoryLister::Local(self.app_state.fs.clone())
-            },
+            DirectoryLister::Local(self.app_state.fs.clone()),
             cx,
         );
 

From 4ae2f930863385c97df931e51623c4e5474748e3 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Thu, 17 Oct 2024 12:50:19 -0400
Subject: [PATCH 729/762] ci: Improve GitHub Action modularity (#18861)

- Closes: https://github.com/zed-industries/zed/issues/19351
- Switch to using the official [typos GitHub Action](https://github.com/crate-ci/typos/blob/master/docs/github-action.md)
- Move the typos check into `actions/check_style`
- Move Squawk Postgres migration check out of `actions/check_style` file into ci.yml
- `actions/check_style` can now be run on stateless/linux runners (previous required self-hosted MacOS runner)
- ci.yml: Split old `style` into checks into those that can run statelessly (linux) and everything else into a new `migration` group which benefit from the full git checkout available on the MacOS runners.
- ci.yml: Move `Check unused dependencies` from style to `linux_tests`
- Add `if: github.repository_owner == 'zed-industries'` to all jobs so they won't try and run on GitHub forks.
---
 .github/actions/check_style/action.yml  | 11 +++---
 .github/workflows/ci.yml                | 47 ++++++++++++++++---------
 .github/workflows/deploy_cloudflare.yml |  1 +
 .github/workflows/docs.yml              |  8 +++--
 script/check-spelling                   | 14 --------
 5 files changed, 42 insertions(+), 39 deletions(-)
 delete mode 100755 script/check-spelling

diff --git a/.github/actions/check_style/action.yml b/.github/actions/check_style/action.yml
index 7f41e710c91358..9bddee44ef5218 100644
--- a/.github/actions/check_style/action.yml
+++ b/.github/actions/check_style/action.yml
@@ -4,12 +4,11 @@ description: "Checks code formatting use cargo fmt"
 runs:
   using: "composite"
   steps:
+    - name: Check for Typos with Typos-CLI
+      uses: crate-ci/typos@v1.24.6
+      with:
+        config: ./typos.toml
+
     - name: cargo fmt
       shell: bash -euxo pipefail {0}
       run: cargo fmt --all -- --check
-
-    - name: Find modified migrations
-      shell: bash -euxo pipefail {0}
-      run: |
-        export SQUAWK_GITHUB_TOKEN=${{ github.token }}
-        . ./script/squawk
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index eadd738fa5ab32..adf0cfa30f5fd7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -26,9 +26,10 @@ env:
   RUST_BACKTRACE: 1
 
 jobs:
-  style:
+  migration_checks:
+    name: Check Postgres and Protobuf migrations, mergability
+    if: github.repository_owner == 'zed-industries'
     timeout-minutes: 60
-    name: Check formatting and spelling
     runs-on:
       - self-hosted
       - test
@@ -37,25 +38,16 @@ jobs:
         uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
         with:
           clean: false
-          fetch-depth: 0
+          fetch-depth: 0 # fetch full history
 
       - name: Remove untracked files
         run: git clean -df
 
-      - name: Check spelling
-        run: script/check-spelling
-
-      - name: Run style checks
-        uses: ./.github/actions/check_style
-
-      - name: Check unused dependencies
-        uses: bnjbvr/cargo-machete@main
-
-      - name: Check licenses are present
-        run: script/check-licenses
-
-      - name: Check license generation
-        run: script/generate-licenses /tmp/zed_licenses_output
+      - name: Find modified migrations
+        shell: bash -euxo pipefail {0}
+        run: |
+          export SQUAWK_GITHUB_TOKEN=${{ github.token }}
+          . ./script/squawk
 
       - name: Ensure fresh merge
         shell: bash -euxo pipefail {0}
@@ -77,6 +69,19 @@ jobs:
           input: "crates/proto/proto/"
           against: "https://github.com/${GITHUB_REPOSITORY}.git#branch=${BUF_BASE_BRANCH},subdir=crates/proto/proto/"
 
+  style:
+    timeout-minutes: 60
+    name: Check formatting and spelling
+    if: github.repository_owner == 'zed-industries'
+    runs-on:
+      - buildjet-8vcpu-ubuntu-2204
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+
+      - name: Run style checks
+        uses: ./.github/actions/check_style
+
   macos_tests:
     timeout-minutes: 60
     name: (macOS) Run Clippy and tests
@@ -92,6 +97,14 @@ jobs:
       - name: cargo clippy
         run: ./script/clippy
 
+      - name: Check unused dependencies
+        uses: bnjbvr/cargo-machete@main
+
+      - name: Check licenses
+        run: |
+          script/check-licenses
+          script/generate-licenses /tmp/zed_licenses_output
+
       - name: Run tests
         uses: ./.github/actions/run_tests
 
diff --git a/.github/workflows/deploy_cloudflare.yml b/.github/workflows/deploy_cloudflare.yml
index 029a2092d98349..1c9e7bc5b08bba 100644
--- a/.github/workflows/deploy_cloudflare.yml
+++ b/.github/workflows/deploy_cloudflare.yml
@@ -8,6 +8,7 @@ on:
 jobs:
   deploy-docs:
     name: Deploy Docs
+    if: github.repository_owner == 'zed-industries'
     runs-on: ubuntu-latest
 
     steps:
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 0b291ca3742fce..437e7f96a678f4 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -11,6 +11,7 @@ on:
 jobs:
   check_formatting:
     name: "Check formatting"
+    if: github.repository_owner == 'zed-industries'
     runs-on: ubuntu-latest
 
     steps:
@@ -29,5 +30,8 @@ jobs:
             false
           }
 
-      - name: Check spelling
-        run: script/check-spelling docs/
+      - name: Check for Typos with Typos-CLI
+        uses: crate-ci/typos@v1.24.6
+        with:
+          config: ./typos.toml
+          files: ./docs/
diff --git a/script/check-spelling b/script/check-spelling
deleted file mode 100755
index 76ebf747286447..00000000000000
--- a/script/check-spelling
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/sh
-
-set -eu
-
-TYPOS_CLI_VERSION=1.24.6
-TARGET_DIR=${1:-""}
-
-if ! cargo install --list | grep "typos-cli v$TYPOS_CLI_VERSION" > /dev/null; then
-    echo "Installing typos-cli@$TYPOS_CLI_VERSION..."
-    cargo install "typos-cli@$TYPOS_CLI_VERSION"
-else
-    echo "typos-cli@$TYPOS_CLI_VERSION is already installed."
-fi
-typos $TARGET_DIR

From 411f64b374c69cb0446f66c2657a9bd68690c39c Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Thu, 17 Oct 2024 10:18:13 -0700
Subject: [PATCH 730/762] Restructure assistant edits to show all changes in a
 proposed-change editor (#18240)

This changes the `/workflow` command so that instead of emitting edits
in separate steps, the user is presented with a single tab, with an
editable diff that they can apply to the buffer.

Todo

* Assistant panel
* [x] Show a patch title and a list of changed files in a block
decoration
* [x] Don't store resolved patches as state on Context. Resolve on
demand.
    * [ ] Better presentation of patches in the panel
    * [ ] Show a spinner while patch is streaming in
* Patches
* [x] Preserve leading whitespace in new text, auto-indent insertions
    * [x] Ensure patch title is very short, to fit better in tab
* [x] Improve patch location resolution, prefer skipping whitespace over
skipping `}`
    * [x] Ensure patch edits are auto-indented properly
* [ ] Apply `Update` edits via a diff between the old and new text, to
get fine-grained edits.
* Proposed changes editor
    * [x] Show patch title in the tab
    * [x] Add a toolbar with an "Apply all" button
* [x] Make `open excerpts` open the corresponding location in the base
buffer (https://github.com/zed-industries/zed/pull/18591)
* [x] Add an apply button above every hunk
(https://github.com/zed-industries/zed/pull/18592)
* [x] Expand all diff hunks by default
(https://github.com/zed-industries/zed/pull/18598)
    * [x] Fix https://github.com/zed-industries/zed/issues/18589
* [x] Syntax highlighting doesn't work until the buffer is edited
(https://github.com/zed-industries/zed/pull/18648)
* [x] Disable LSP interaction in Proposed Changes editor
(https://github.com/zed-industries/zed/pull/18945)
* [x] No auto-indent? (https://github.com/zed-industries/zed/pull/18984)
* Prompt
    * [ ] make sure old_text is unique

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
Co-authored-by: Antonio <antonio@zed.dev>
Co-authored-by: Richard <richard@zed.dev>
Co-authored-by: Marshall <marshall@zed.dev>
Co-authored-by: Nate Butler <iamnbutler@gmail.com>
Co-authored-by: Antonio Scandurra <me@as-cii.com>
Co-authored-by: Richard Feldman <oss@rtfeldman.com>
---
 Cargo.lock                                    |    1 +
 assets/icons/diff.svg                         |    1 +
 assets/prompts/edit_workflow.hbs              |  324 ++--
 assets/prompts/step_resolution.hbs            |  496 ------
 crates/assistant/Cargo.toml                   |    1 +
 crates/assistant/src/assistant.rs             |   26 +-
 crates/assistant/src/assistant_panel.rs       | 1349 ++++-------------
 crates/assistant/src/assistant_settings.rs    |   21 +-
 crates/assistant/src/context.rs               |  431 +++---
 crates/assistant/src/context/context_tests.rs |  285 ++--
 crates/assistant/src/inline_assistant.rs      |   93 --
 crates/assistant/src/patch.rs                 |  746 +++++++++
 crates/assistant/src/prompts.rs               |    9 -
 .../src/slash_command/workflow_command.rs     |    4 +-
 crates/assistant/src/workflow.rs              |  507 -------
 crates/editor/src/editor.rs                   |   11 +-
 crates/editor/src/proposed_changes_editor.rs  |  138 +-
 crates/gpui/src/app/entity_map.rs             |   15 +-
 crates/language/src/buffer.rs                 |   19 +-
 crates/languages/Cargo.toml                   |    5 +-
 crates/text/src/text.rs                       |    2 +-
 crates/ui/src/components/icon.rs              |    1 +
 22 files changed, 1684 insertions(+), 2801 deletions(-)
 create mode 100644 assets/icons/diff.svg
 delete mode 100644 assets/prompts/step_resolution.hbs
 create mode 100644 crates/assistant/src/patch.rs
 delete mode 100644 crates/assistant/src/workflow.rs

diff --git a/Cargo.lock b/Cargo.lock
index b58716cd574394..c638ebafa4bd9f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -412,6 +412,7 @@ dependencies = [
  "parking_lot",
  "paths",
  "picker",
+ "pretty_assertions",
  "project",
  "proto",
  "rand 0.8.5",
diff --git a/assets/icons/diff.svg b/assets/icons/diff.svg
new file mode 100644
index 00000000000000..ca43c379daa63c
--- /dev/null
+++ b/assets/icons/diff.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-diff"><path d="M12 3v14"/><path d="M5 10h14"/><path d="M5 21h14"/></svg>
diff --git a/assets/prompts/edit_workflow.hbs b/assets/prompts/edit_workflow.hbs
index c558bc20d0e143..99a594cdd88e4c 100644
--- a/assets/prompts/edit_workflow.hbs
+++ b/assets/prompts/edit_workflow.hbs
@@ -1,85 +1,33 @@
 <task_description>
 
-# Code Change Workflow
-
-Your task is to guide the user through code changes using a series of steps. Each step should describe a high-level change, which can consist of multiple edits to distinct locations in the codebase.
-
-## Output Example
-
-Provide output as XML, with the following format:
-
-<step>
-Update the Person struct to store an age
-
-```rust
-struct Person {
-    // existing fields...
-    age: u8,
-    height: f32,
-    // existing fields...
-}
-
-impl Person {
-    fn age(&self) -> u8 {
-        self.age
-    }
-}
-```
-
-<edit>
-<path>src/person.rs</path>
-<operation>insert_before</operation>
-<search>height: f32,</search>
-<description>Add the age field</description>
-</edit>
-
-<edit>
-<path>src/person.rs</path>
-<operation>insert_after</operation>
-<search>impl Person {</search>
-<description>Add the age getter</description>
-</edit>
-</step>
-
-## Output Format
-
-First, each `<step>` must contain a written description of the change that should be made. The description should begin with a high-level overview, and can contain markdown code blocks as well. The description should be self-contained and actionable.
-
-After the description, each `<step>` must contain one or more `<edit>` tags, each of which refer to a specific range in a source file. Each `<edit>` tag must contain the following child tags:
-
-### `<path>` (required)
-
-This tag contains the path to the file that will be changed. It can be an existing path, or a path that should be created.
-
-### `<search>` (optional)
-
-This tag contains a search string to locate in the source file, e.g. `pub fn baz() {`. If not provided, the new content will be inserted at the top of the file. Make sure to produce a string that exists in the source file and that isn't ambiguous. When there's ambiguity, add more lines to the search to eliminate it.
-
-### `<description>` (required)
-
-This tag contains a single-line description of the edit that should be made at the given location.
-
-### `<operation>` (required)
-
-This tag indicates what type of change should be made, relative to the given location. It can be one of the following:
-- `update`: Rewrites the specified string entirely based on the given description.
-- `create`: Creates a new file with the given path based on the provided description.
-- `insert_before`: Inserts new text based on the given description before the specified search string.
-- `insert_after`: Inserts new text based on the given description after the specified search string.
-- `delete`: Deletes the specified string from the containing file.
+The user of a code editor wants to make a change to their codebase.
+You must describe the change using the following XML structure:
+
+- <patch> - A group of related code changes.
+  Child tags:
+    - <title> (required) - A high-level description of the changes. This should be as short
+      as possible, possibly using common abbreviations.
+    - <edit> (1 or more) - An edit to make at a particular range within a file.
+      Includes the following child tags:
+        - <path> (required) - The path to the file that will be changed.
+        - <description> (optional) - An arbitrarily-long comment that describes the purpose
+          of this edit.
+        - <old_text> (optional) - An excerpt from the file's current contents that uniquely
+          identifies a range within the file where the edit should occur. If this tag is not
+          specified, then the entire file will be used as the range.
+        - <new_text> (required) - The new text to insert into the file.
+        - <operation> (required) - The type of change that should occur at the given range
+          of the file. Must be one of the following values:
+            - `update`: Replaces the entire range with the new text.
+            - `insert_before`: Inserts the new text before the range.
+            - `insert_after`: Inserts new text after the range.
+            - `create`: Creates a new file with the given path and the new text.
+            - `delete`: Deletes the specified range from the file.
 
 <guidelines>
-- There's no need to describe *what* to do, just *where* to do it.
-- Only reference locations that actually exist (unless you're creating a file).
-- If creating a file, assume any subsequent updates are included at the time of creation.
-- Don't create and then update a file. Always create new files in one hot.
-- Prefer multiple edits to smaller regions, as opposed to one big edit to a larger region.
-- Don't produce edits that intersect each other. In that case, merge them into a bigger edit.
-- Never nest an edit with another edit. Never include CDATA. All edits are leaf nodes.
-- Descriptions are required for all edits except delete.
-- When generating multiple edits, ensure the descriptions are specific to each individual operation.
-- Avoid referring to the search string in the description. Focus on the change to be made, not the location where it's made. That's implicit with the `search` string you provide.
-- Don't generate multiple edits at the same location. Instead, combine them together in a single edit with a succinct combined description.
+- Never provide multiple edits whose ranges intersect each other. Instead, merge them into one edit.
+- Prefer multiple edits to smaller, disjoint ranges, rather than one edit to a larger range.
+- There's no need to escape angle brackets within XML tags.
 - Always ensure imports are added if you're referencing symbols that are not in scope.
 </guidelines>
 
@@ -124,189 +72,137 @@ Update all shapes to store their origin as an (x, y) tuple and implement Display
 <message role="assistant">
 We'll need to update both the rectangle and circle modules.
 
-<step>
-Add origin fields to both shape types.
-
-```rust
-struct Rectangle {
-    // existing fields ...
-    origin: (f64, f64),
-}
-```
-
-```rust
-struct Circle {
-    // existing fields ...
-    origin: (f64, f64),
-}
-```
-
+<patch>
+<title>Add origins and display impls to shapes</title>
 <edit>
 <path>src/shapes/rectangle.rs</path>
-<operation>insert_before</operation>
-<search>
-    width: f64,
-    height: f64,
-</search>
-<description>Add the origin field to Rectangle</description>
+<description>Add the origin field to Rectangle struct</description>
+<operation>insert_after</operation>
+<old_text>
+pub struct Rectangle {
+</old_text>
+<new_text>
+origin: (f64, f64),
+</new_text>
 </edit>
 
 <edit>
-<path>src/shapes/circle.rs</path>
-<operation>insert_before</operation>
-<search>
-    radius: f64,
-</search>
-<description>Add the origin field to Circle</description>
+<path>src/shapes/rectangle.rs</path>
+<description>Update the Rectangle's new function to take an origin parameter</description>
+<operation>update</operation>
+<old_text>
+fn new(width: f64, height: f64) -> Self {
+    Rectangle { width, height }
+}
+</old_text>
+<new_text>
+fn new(origin: (f64, f64), width: f64, height: f64) -> Self {
+    Rectangle { origin, width, height }
+}
+</new_text>
 </edit>
 
-<step>
-Update both shape's constructors to take an origin.
-
 <edit>
-<path>src/shapes/rectangle.rs</path>
-<operation>update</operation>
-<search>
-    fn new(width: f64, height: f64) -> Self {
-        Rectangle { width, height }
-    }
-</search>
-<description>Update the Rectangle new function to take an origin</description>
+<path>src/shapes/circle.rs</path>
+<description>Add the origin field to Circle struct</description>
+<operation>insert_after</operation>
+<old_text>
+pub struct Circle {
+    radius: f64,
+</old_text>
+<new_text>
+    origin: (f64, f64),
+</new_text>
 </edit>
 
 <edit>
 <path>src/shapes/circle.rs</path>
+<description>Update the Circle's new function to take an origin parameter</description>
 <operation>update</operation>
-<search>
-    fn new(radius: f64) -> Self {
-        Circle { radius }
-    }
-</search>
-<description>Update the Circle new function to take an origin</description>
+<old_text>
+fn new(radius: f64) -> Self {
+    Circle { radius }
+}
+</old_text>
+<new_text>
+fn new(origin: (f64, f64), radius: f64) -> Self {
+    Circle { origin, radius }
+}
+</new_text>
 </edit>
 </step>
 
-<step>
-Implement Display for both shapes
-
 <edit>
 <path>src/shapes/rectangle.rs</path>
+<description>Add an import for the std::fmt module</description>
 <operation>insert_before</operation>
-<search>
+<old_text>
 struct Rectangle {
-</search>
-<description>Add an import for the `std::fmt` module</description>
+</old_text>
+<new_text>
+use std::fmt;
+
+</new_text>
 </edit>
 
 <edit>
 <path>src/shapes/rectangle.rs</path>
+<description>Add a Display implementation for Rectangle</description>
 <operation>insert_after</operation>
-<search>
+<old_text>
         Rectangle { width, height }
     }
 }
-</search>
-<description>Add a Display implementation for Rectangle</description>
+</old_text>
+<new_text>
+impl fmt::Display for Rectangle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.format_struct(f, "Rectangle")
+            .field("origin", &self.origin)
+            .field("width", &self.width)
+            .field("height", &self.height)
+            .finish()
+    }
+}
+</new_text>
 </edit>
 
 <edit>
 <path>src/shapes/circle.rs</path>
+<description>Add an import for the `std::fmt` module</description>
 <operation>insert_before</operation>
-<search>
+<old_text>
 struct Circle {
-</search>
-<description>Add an import for the `std::fmt` module</description>
+</old_text>
+<new_text>
+use std::fmt;
+</new_text>
 </edit>
 
 <edit>
 <path>src/shapes/circle.rs</path>
+<description>Add a Display implementation for Circle</description>
 <operation>insert_after</operation>
-<search>
+<old_text>
         Circle { radius }
     }
 }
-</search>
-<description>Add a Display implementation for Circle</description>
-</edit>
-</step>
-</message>
-</example>
-
-<example number=2>
-<message role="user">
-
-```rs src/user.rs
-struct User {
-    pub name: String,
-    age: u32,
-    email: String,
-}
-
-impl User {
-    fn new(name: String, age: u32, email: String) -> Self {
-        User { name, age, email }
-    }
-
-    pub fn print_info(&self) {
-        todo!()
-    }
-}
-```
-
-Let's print all the user information and delete the email field.
-</message>
-
-<message role="assistant">
-<step>
-Update the 'print_info' method to print user information
-
-```rust
-impl User {
-    // ... other methods ...
-
-    pub fn print_info(&self) {
-        println!("Name: {name}, Age: {age}", name = self.name, age = self.age);
+</old_text>
+<new_text>
+impl fmt::Display for Rectangle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.format_struct(f, "Rectangle")
+            .field("origin", &self.origin)
+            .field("width", &self.width)
+            .field("height", &self.height)
+            .finish()
     }
 }
-```
-
-<edit>
-<path>src/user.rs</path>
-<operation>update</operation>
-<search>
-    pub fn print_info(&self) {
-        todo!()
-    }
-</search>
-<description>Print all the user information</description>
-</edit>
-</step>
-
-<step>
-Remove the 'email' field from the User struct
-
-<edit>
-<path>src/user.rs</path>
-<operation>delete</operation>
-<search>
-email: String,
-</search>
+</new_text>
 </edit>
+</patch>
 
-<edit>
-<path>src/user.rs</path>
-<operation>update</operation>
-<symbol>
-fn new(name: String, age: u32, email: String) -> Self {
-    User { name, age, email }
-}
-</symbol>
-<description>Remove email parameter from new method</description>
-</edit>
-</step>
 </message>
 </example>
 
-You should think step by step. When possible, produce smaller, coherent logical steps as opposed to one big step that combines lots of heterogeneous edits.
-
 </task_description>
diff --git a/assets/prompts/step_resolution.hbs b/assets/prompts/step_resolution.hbs
deleted file mode 100644
index 10bbdec81e9d51..00000000000000
--- a/assets/prompts/step_resolution.hbs
+++ /dev/null
@@ -1,496 +0,0 @@
-<overview>
-Your task is to map a step from a workflow to locations in source code where code needs to be changed to fulfill that step.
-Given a workflow containing background context plus a series of <step> tags, you will resolve *one* of these step tags to resolve to one or more locations in the code.
-With each location, you will produce a brief, one-line description of the changes to be made.
-
-<guidelines>
-- There's no need to describe *what* to do, just *where* to do it.
-- Only reference locations that actually exist (unless you're creating a file).
-- If creating a file, assume any subsequent updates are included at the time of creation.
-- Don't create and then update a file. Always create new files in shot.
-- Prefer updating symbols lower in the syntax tree if possible.
-- Never include suggestions on a parent symbol and one of its children in the same suggestions block.
-- Never nest an operation with another operation or include CDATA or other content. All suggestions are leaf nodes.
-- Descriptions are required for all suggestions except delete.
-- When generating multiple suggestions, ensure the descriptions are specific to each individual operation.
-- Avoid referring to the location in the description. Focus on the change to be made, not the location where it's made. That's implicit with the symbol you provide.
-- Don't generate multiple suggestions at the same location. Instead, combine them together in a single operation with a succinct combined description.
-- To add imports respond with a suggestion where the `"symbol"` key is set to `"#imports"`
-</guidelines>
-</overview>
-
-<examples>
-<example>
-<workflow_context>
-<message role="user">
-```rs src/rectangle.rs
-struct Rectangle {
-    width: f64,
-    height: f64,
-}
-
-impl Rectangle {
-    fn new(width: f64, height: f64) -> Self {
-        Rectangle { width, height }
-    }
-}
-```
-
-We need to add methods to calculate the area and perimeter of the rectangle. Can you help with that?
-</message>
-<message role="assistant">
-Sure, I can help with that!
-
-<step>Add new methods 'calculate_area' and 'calculate_perimeter' to the Rectangle struct</step>
-<step>Implement the 'Display' trait for the Rectangle struct</step>
-</message>
-</workflow_context>
-
-<step_to_resolve>
-Add new methods 'calculate_area' and 'calculate_perimeter' to the Rectangle struct
-</step_to_resolve>
-
-<incorrect_output reason="NEVER append multiple children at the same location.">
-{
-  "title": "Add Rectangle methods",
-  "suggestions": [
-    {
-      "kind": "AppendChild",
-      "path": "src/shapes.rs",
-      "symbol": "impl Rectangle",
-      "description": "Add calculate_area method"
-    },
-    {
-      "kind": "AppendChild",
-      "path": "src/shapes.rs",
-      "symbol": "impl Rectangle",
-      "description": "Add calculate_perimeter method"
-    }
-  ]
-}
-</incorrect_output>
-
-<correct_output>
-{
-  "title": "Add Rectangle methods",
-  "suggestions": [
-    {
-      "kind": "AppendChild",
-      "path": "src/shapes.rs",
-      "symbol": "impl Rectangle",
-      "description": "Add calculate area and perimeter methods"
-    }
-  ]
-}
-</correct_output>
-
-<step_to_resolve>
-Implement the 'Display' trait for the Rectangle struct
-</step_to_resolve>
-
-<output>
-{
-  "title": "Implement Display for Rectangle",
-  "suggestions": [
-    {
-      "kind": "InsertSiblingAfter",
-      "path": "src/shapes.rs",
-      "symbol": "impl Rectangle",
-      "description": "Implement Display trait for Rectangle"
-    }
-  ]
-}
-</output>
-
-<example>
-<workflow_context>
-<message role="user">
-```rs src/user.rs
-struct User {
-    pub name: String,
-    age: u32,
-    email: String,
-}
-
-impl User {
-    fn new(name: String, age: u32, email: String) -> Self {
-        User { name, age, email }
-    }
-
-    pub fn print_info(&self) {
-        println!("Name: {}, Age: {}, Email: {}", self.name, self.age, self.email);
-    }
-}
-```
-</message>
-<message role="assistant">
-Certainly!
-<step>Update the 'print_info' method to use formatted output</step>
-<step>Remove the 'email' field from the User struct</step>
-</message>
-</workflow_context>
-
-<step_to_resolve>
-Update the 'print_info' method to use formatted output
-</step_to_resolve>
-
-<output>
-{
-  "title": "Use formatted output",
-  "suggestions": [
-    {
-      "kind": "Update",
-      "path": "src/user.rs",
-      "symbol": "impl User pub fn print_info",
-      "description": "Use formatted output"
-    }
-  ]
-}
-</output>
-
-<step_to_resolve>
-Remove the 'email' field from the User struct
-</step_to_resolve>
-
-<output>
-{
-  "title": "Remove email field",
-  "suggestions": [
-      {
-        "kind": "Delete",
-        "path": "src/user.rs",
-        "symbol": "struct User email"
-      }
-    ]
-}
-</output>
-</example>
-
-<example>
-<workflow_context>
-<message role="user">
-```rs src/vehicle.rs
-struct Vehicle {
-    make: String,
-    model: String,
-    year: u32,
-}
-
-impl Vehicle {
-    fn new(make: String, model: String, year: u32) -> Self {
-        Vehicle { make, model, year }
-    }
-
-    fn print_year(&self) {
-        println!("Year: {}", self.year);
-    }
-}
-```
-</message>
-<message role="assistant">
-<step>Add a 'use std::fmt;' statement at the beginning of the file</step>
-<step>Add a new method 'start_engine' in the Vehicle impl block</step>
-</message>
-</workflow_context>
-
-<step_to_resolve>
-Add a 'use std::fmt;' statement at the beginning of the file
-</step_to_resolve>
-
-<output>
-{
-  "title": "Add use std::fmt statement",
-  "suggestions": [
-    {
-      "kind": "PrependChild",
-      "path": "src/vehicle.rs",
-      "symbol": "#imports",
-      "description": "Add 'use std::fmt' statement"
-    }
-  ]
-}
-</output>
-
-<step_to_resolve>
-Add a new method 'start_engine' in the Vehicle impl block
-</step_to_resolve>
-
-<output>
-{
-  "title": "Add start_engine method",
-  "suggestions": [
-    {
-      "kind": "InsertSiblingAfter",
-      "path": "src/vehicle.rs",
-      "symbol": "impl Vehicle fn new",
-      "description": "Add start_engine method"
-    }
-  ]
-}
-</output>
-</example>
-
-<example>
-<workflow_context>
-<message role="user">
-```rs src/employee.rs
-struct Employee {
-    name: String,
-    position: String,
-    salary: u32,
-    department: String,
-}
-
-impl Employee {
-    fn new(name: String, position: String, salary: u32, department: String) -> Self {
-        Employee { name, position, salary, department }
-    }
-
-    fn print_details(&self) {
-        println!("Name: {}, Position: {}, Salary: {}, Department: {}",
-                  self.name, self.position, self.salary, self.department);
-    }
-
-    fn give_raise(&mut self, amount: u32) {
-        self.salary += amount;
-    }
-}
-```
-</message>
-<message role="assistant">
-<step>Make salary an f32</step>
-<step>Remove the 'department' field and update the 'print_details' method</step>
-</message>
-</workflow_context>
-
-<step_to_resolve>
-Make salary an f32
-</step_to_resolve>
-
-<incorrect_output reason="NEVER include suggestions on a parent symbol and one of its children in the same suggestions block.">
-{
-  "title": "Change salary to f32",
-  "suggestions": [
-    {
-      "kind": "Update",
-      "path": "src/employee.rs",
-      "symbol": "struct Employee",
-      "description": "Change the type of salary to an f32"
-    },
-    {
-      "kind": "Update",
-      "path": "src/employee.rs",
-      "symbol": "struct Employee salary",
-      "description": "Change the type to an f32"
-    }
-  ]
-}
-</incorrect_output>
-
-<correct_output>
-{
-  "title": "Change salary to f32",
-  "suggestions": [
-    {
-      "kind": "Update",
-      "path": "src/employee.rs",
-      "symbol": "struct Employee salary",
-      "description": "Change the type to an f32"
-    }
-  ]
-}
-</correct_output>
-
-<step_to_resolve>
-Remove the 'department' field and update the 'print_details' method
-</step_to_resolve>
-
-<output>
-{
-  "title": "Remove department",
-  "suggestions": [
-    {
-      "kind": "Delete",
-      "path": "src/employee.rs",
-      "symbol": "struct Employee department"
-    },
-    {
-      "kind": "Update",
-      "path": "src/employee.rs",
-      "symbol": "impl Employee fn print_details",
-      "description": "Don't print the 'department' field"
-    }
-  ]
-}
-</output>
-</example>
-
-<example>
-<workflow_context>
-<message role="user">
-```rs src/game.rs
-struct Player {
-    name: String,
-    health: i32,
-    pub score: u32,
-}
-
-impl Player {
-    pub fn new(name: String) -> Self {
-        Player { name, health: 100, score: 0 }
-    }
-}
-
-struct Game {
-    players: Vec<Player>,
-}
-
-impl Game {
-    fn new() -> Self {
-        Game { players: Vec::new() }
-    }
-}
-```
-</message>
-<message role="assistant">
-<step>Add a 'level' field to Player and update the 'new' method</step>
-</message>
-</workflow_context>
-
-<step_to_resolve>
-Add a 'level' field to Player and update the 'new' method
-</step_to_resolve>
-
-<output>
-{
-  "title": "Add level field to Player",
-  "suggestions": [
-    {
-      "kind": "InsertSiblingAfter",
-      "path": "src/game.rs",
-      "symbol": "struct Player pub score",
-      "description": "Add level field to Player"
-    },
-    {
-      "kind": "Update",
-      "path": "src/game.rs",
-      "symbol": "impl Player pub fn new",
-      "description": "Initialize level in new method"
-    }
-  ]
-}
-</output>
-</example>
-
-<example>
-<workflow_context>
-<message role="user">
-```rs src/config.rs
-use std::collections::HashMap;
-
-struct Config {
-    settings: HashMap<String, String>,
-}
-
-impl Config {
-    fn new() -> Self {
-        Config { settings: HashMap::new() }
-    }
-}
-```
-</message>
-<message role="assistant">
-<step>Add a 'load_from_file' method to Config and import necessary modules</step>
-</message>
-</workflow_context>
-
-<step_to_resolve>
-Add a 'load_from_file' method to Config and import necessary modules
-</step_to_resolve>
-
-<output>
-{
-  "title": "Add load_from_file method",
-  "suggestions": [
-    {
-      "kind": "PrependChild",
-      "path": "src/config.rs",
-      "symbol": "#imports",
-      "description": "Import std::fs and std::io modules"
-    },
-    {
-      "kind": "AppendChild",
-      "path": "src/config.rs",
-      "symbol": "impl Config",
-      "description": "Add load_from_file method"
-    }
-  ]
-}
-</output>
-</example>
-
-<example>
-<workflow_context>
-<message role="user">
-```rs src/database.rs
-pub(crate) struct Database {
-    connection: Connection,
-}
-
-impl Database {
-    fn new(url: &str) -> Result<Self, Error> {
-        let connection = Connection::connect(url)?;
-        Ok(Database { connection })
-    }
-
-    async fn query(&self, sql: &str) -> Result<Vec<Row>, Error> {
-        self.connection.query(sql, &[])
-    }
-}
-```
-</message>
-<message role="assistant">
-<step>Add error handling to the 'query' method and create a custom error type</step>
-</message>
-</workflow_context>
-
-<step_to_resolve>
-Add error handling to the 'query' method and create a custom error type
-</step_to_resolve>
-
-<output>
-{
-  "title": "Add error handling to query",
-  "suggestions": [
-    {
-      "kind": "PrependChild",
-      "path": "src/database.rs",
-      "description": "Import necessary error handling modules"
-    },
-    {
-      "kind": "InsertSiblingBefore",
-      "path": "src/database.rs",
-      "symbol": "pub(crate) struct Database",
-      "description": "Define custom DatabaseError enum"
-    },
-    {
-      "kind": "Update",
-      "path": "src/database.rs",
-      "symbol": "impl Database async fn query",
-      "description": "Implement error handling in query method"
-    }
-  ]
-}
-</output>
-</example>
-</examples>
-
-Now generate the suggestions for the following step:
-
-<workflow_context>
-{{{workflow_context}}}
-</workflow_context>
-
-<step_to_resolve>
-{{{step_to_resolve}}}
-</step_to_resolve>
diff --git a/crates/assistant/Cargo.toml b/crates/assistant/Cargo.toml
index 9e61eee18aaf8a..21153b6fcc39d6 100644
--- a/crates/assistant/Cargo.toml
+++ b/crates/assistant/Cargo.toml
@@ -97,6 +97,7 @@ language = { workspace = true, features = ["test-support"] }
 language_model = { workspace = true, features = ["test-support"] }
 languages = { workspace = true, features = ["test-support"] }
 log.workspace = true
+pretty_assertions.workspace = true
 project = { workspace = true, features = ["test-support"] }
 rand.workspace = true
 serde_json_lenient.workspace = true
diff --git a/crates/assistant/src/assistant.rs b/crates/assistant/src/assistant.rs
index 9cc63af5a1adee..e1e574744fff61 100644
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -6,6 +6,7 @@ mod context;
 pub mod context_store;
 mod inline_assistant;
 mod model_selector;
+mod patch;
 mod prompt_library;
 mod prompts;
 mod slash_command;
@@ -14,7 +15,6 @@ pub mod slash_command_settings;
 mod streaming_diff;
 mod terminal_inline_assistant;
 mod tools;
-mod workflow;
 
 pub use assistant_panel::{AssistantPanel, AssistantPanelEvent};
 use assistant_settings::AssistantSettings;
@@ -35,11 +35,13 @@ use language_model::{
     LanguageModelId, LanguageModelProviderId, LanguageModelRegistry, LanguageModelResponseMessage,
 };
 pub(crate) use model_selector::*;
+pub use patch::*;
 pub use prompts::PromptBuilder;
 use prompts::PromptLoadingParams;
 use semantic_index::{CloudEmbeddingProvider, SemanticDb};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings, SettingsStore};
+use slash_command::workflow_command::WorkflowSlashCommand;
 use slash_command::{
     auto_command, cargo_workspace_command, context_server_command, default_command, delta_command,
     diagnostics_command, docs_command, fetch_command, file_command, now_command, project_command,
@@ -50,7 +52,6 @@ use std::path::PathBuf;
 use std::sync::Arc;
 pub(crate) use streaming_diff::*;
 use util::ResultExt;
-pub use workflow::*;
 
 use crate::slash_command_settings::SlashCommandSettings;
 
@@ -393,12 +394,25 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
     slash_command_registry.register_command(now_command::NowSlashCommand, false);
     slash_command_registry.register_command(diagnostics_command::DiagnosticsSlashCommand, true);
     slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
+    slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
 
     if let Some(prompt_builder) = prompt_builder {
-        slash_command_registry.register_command(
-            workflow_command::WorkflowSlashCommand::new(prompt_builder.clone()),
-            true,
-        );
+        cx.observe_global::<SettingsStore>({
+            let slash_command_registry = slash_command_registry.clone();
+            let prompt_builder = prompt_builder.clone();
+            move |cx| {
+                if AssistantSettings::get_global(cx).are_live_diffs_enabled(cx) {
+                    slash_command_registry.register_command(
+                        workflow_command::WorkflowSlashCommand::new(prompt_builder.clone()),
+                        true,
+                    );
+                } else {
+                    slash_command_registry.unregister_command_by_name(WorkflowSlashCommand::NAME);
+                }
+            }
+        })
+        .detach();
+
         cx.observe_flag::<project_command::ProjectSlashCommandFeatureFlag, _>({
             let slash_command_registry = slash_command_registry.clone();
             move |is_enabled, _cx| {
diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index a3e189287f4564..5c20caa8638eec 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -11,12 +11,12 @@ use crate::{
     },
     slash_command_picker,
     terminal_inline_assistant::TerminalInlineAssistant,
-    Assist, CacheStatus, ConfirmCommand, Content, Context, ContextEvent, ContextId, ContextStore,
-    ContextStoreEvent, CopyCode, CycleMessageRole, DeployHistory, DeployPromptLibrary,
-    InlineAssistId, InlineAssistant, InsertDraggedFiles, InsertIntoEditor, Message, MessageId,
-    MessageMetadata, MessageStatus, ModelPickerDelegate, ModelSelector, NewContext,
-    PendingSlashCommand, PendingSlashCommandStatus, QuoteSelection, RemoteContextMetadata,
-    SavedContextMetadata, Split, ToggleFocus, ToggleModelSelector, WorkflowStepResolution,
+    Assist, AssistantPatch, AssistantPatchStatus, CacheStatus, ConfirmCommand, Content, Context,
+    ContextEvent, ContextId, ContextStore, ContextStoreEvent, CopyCode, CycleMessageRole,
+    DeployHistory, DeployPromptLibrary, InlineAssistant, InsertDraggedFiles, InsertIntoEditor,
+    Message, MessageId, MessageMetadata, MessageStatus, ModelPickerDelegate, ModelSelector,
+    NewContext, PendingSlashCommand, PendingSlashCommandStatus, QuoteSelection,
+    RemoteContextMetadata, SavedContextMetadata, Split, ToggleFocus, ToggleModelSelector,
 };
 use anyhow::Result;
 use assistant_slash_command::{SlashCommand, SlashCommandOutputSection};
@@ -26,11 +26,12 @@ use collections::{BTreeSet, HashMap, HashSet};
 use editor::{
     actions::{FoldAt, MoveToEndOfLine, Newline, ShowCompletions, UnfoldAt},
     display_map::{
-        BlockDisposition, BlockId, BlockProperties, BlockStyle, Crease, CreaseMetadata,
-        CustomBlockId, FoldId, RenderBlock, ToDisplayPoint,
+        BlockContext, BlockDisposition, BlockId, BlockProperties, BlockStyle, Crease,
+        CreaseMetadata, CustomBlockId, FoldId, RenderBlock, ToDisplayPoint,
     },
-    scroll::{Autoscroll, AutoscrollStrategy, ScrollAnchor},
-    Anchor, Editor, EditorEvent, ExcerptRange, MultiBuffer, RowExt, ToOffset as _, ToPoint,
+    scroll::{Autoscroll, AutoscrollStrategy},
+    Anchor, Editor, EditorEvent, ProposedChangeLocation, ProposedChangesEditor, RowExt,
+    ToOffset as _, ToPoint,
 };
 use editor::{display_map::CreaseId, FoldPlaceholder};
 use fs::Fs;
@@ -38,15 +39,14 @@ use futures::FutureExt;
 use gpui::{
     canvas, div, img, percentage, point, pulsating_between, size, Action, Animation, AnimationExt,
     AnyElement, AnyView, AppContext, AsyncWindowContext, ClipboardEntry, ClipboardItem,
-    Context as _, Empty, Entity, EntityId, EventEmitter, ExternalPaths, FocusHandle, FocusableView,
-    FontWeight, InteractiveElement, IntoElement, Model, ParentElement, Pixels, ReadGlobal, Render,
-    RenderImage, SharedString, Size, StatefulInteractiveElement, Styled, Subscription, Task,
-    Transformation, UpdateGlobal, View, VisualContext, WeakView, WindowContext,
+    CursorStyle, Empty, Entity, EventEmitter, ExternalPaths, FocusHandle, FocusableView,
+    FontWeight, InteractiveElement, IntoElement, Model, ParentElement, Pixels, Render, RenderImage,
+    SharedString, Size, StatefulInteractiveElement, Styled, Subscription, Task, Transformation,
+    UpdateGlobal, View, VisualContext, WeakView, WindowContext,
 };
 use indexed_docs::IndexedDocsStore;
 use language::{
-    language_settings::SoftWrap, BufferSnapshot, Capability, LanguageRegistry, LspAdapterDelegate,
-    ToOffset,
+    language_settings::SoftWrap, BufferSnapshot, LanguageRegistry, LspAdapterDelegate, ToOffset,
 };
 use language_model::{
     provider::cloud::PROVIDER_ID, LanguageModelProvider, LanguageModelProviderId,
@@ -65,7 +65,6 @@ use smol::stream::StreamExt;
 use std::{
     borrow::Cow,
     cmp,
-    collections::hash_map,
     ops::{ControlFlow, Range},
     path::PathBuf,
     sync::Arc,
@@ -1444,61 +1443,16 @@ struct ScrollPosition {
     cursor: Anchor,
 }
 
-struct WorkflowStepViewState {
-    header_block_id: CustomBlockId,
-    header_crease_id: CreaseId,
-    footer_block_id: Option<CustomBlockId>,
-    footer_crease_id: Option<CreaseId>,
-    assist: Option<WorkflowAssist>,
-    resolution: Option<Arc<Result<WorkflowStepResolution>>>,
+struct PatchViewState {
+    footer_block_id: CustomBlockId,
+    crease_id: CreaseId,
+    editor: Option<PatchEditorState>,
+    update_task: Option<Task<()>>,
 }
 
-impl WorkflowStepViewState {
-    fn status(&self, cx: &AppContext) -> WorkflowStepStatus {
-        if let Some(assist) = &self.assist {
-            match assist.status(cx) {
-                WorkflowAssistStatus::Idle => WorkflowStepStatus::Idle,
-                WorkflowAssistStatus::Pending => WorkflowStepStatus::Pending,
-                WorkflowAssistStatus::Done => WorkflowStepStatus::Done,
-                WorkflowAssistStatus::Confirmed => WorkflowStepStatus::Confirmed,
-            }
-        } else if let Some(resolution) = self.resolution.as_deref() {
-            match resolution {
-                Err(err) => WorkflowStepStatus::Error(err),
-                Ok(_) => WorkflowStepStatus::Idle,
-            }
-        } else {
-            WorkflowStepStatus::Resolving
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-enum WorkflowStepStatus<'a> {
-    Resolving,
-    Error(&'a anyhow::Error),
-    Idle,
-    Pending,
-    Done,
-    Confirmed,
-}
-
-impl<'a> WorkflowStepStatus<'a> {
-    pub(crate) fn is_confirmed(&self) -> bool {
-        matches!(self, Self::Confirmed)
-    }
-}
-
-#[derive(Debug, Eq, PartialEq)]
-struct ActiveWorkflowStep {
-    range: Range<language::Anchor>,
-    resolved: bool,
-}
-
-struct WorkflowAssist {
-    editor: WeakView<Editor>,
-    editor_was_open: bool,
-    assist_ids: Vec<InlineAssistId>,
+struct PatchEditorState {
+    editor: WeakView<ProposedChangesEditor>,
+    opened_patch: AssistantPatch,
 }
 
 type MessageHeader = MessageMetadata;
@@ -1525,8 +1479,8 @@ pub struct ContextEditor {
     pending_slash_command_blocks: HashMap<Range<language::Anchor>, CustomBlockId>,
     pending_tool_use_creases: HashMap<Range<language::Anchor>, CreaseId>,
     _subscriptions: Vec<Subscription>,
-    workflow_steps: HashMap<Range<language::Anchor>, WorkflowStepViewState>,
-    active_workflow_step: Option<ActiveWorkflowStep>,
+    patches: HashMap<Range<language::Anchor>, PatchViewState>,
+    active_patch: Option<Range<language::Anchor>>,
     assistant_panel: WeakView<AssistantPanel>,
     last_error: Option<AssistError>,
     show_accept_terms: bool,
@@ -1580,7 +1534,7 @@ impl ContextEditor {
         ];
 
         let sections = context.read(cx).slash_command_output_sections().to_vec();
-        let edit_step_ranges = context.read(cx).workflow_step_ranges().collect::<Vec<_>>();
+        let patch_ranges = context.read(cx).patch_ranges().collect::<Vec<_>>();
         let mut this = Self {
             context,
             editor,
@@ -1596,8 +1550,8 @@ impl ContextEditor {
             pending_slash_command_blocks: HashMap::default(),
             pending_tool_use_creases: HashMap::default(),
             _subscriptions,
-            workflow_steps: HashMap::default(),
-            active_workflow_step: None,
+            patches: HashMap::default(),
+            active_patch: None,
             assistant_panel,
             last_error: None,
             show_accept_terms: false,
@@ -1607,7 +1561,7 @@ impl ContextEditor {
         this.update_message_headers(cx);
         this.update_image_blocks(cx);
         this.insert_slash_command_output_sections(sections, false, cx);
-        this.workflow_steps_updated(&Vec::new(), &edit_step_ranges, cx);
+        this.patches_updated(&Vec::new(), &patch_ranges, cx);
         this
     }
 
@@ -1642,134 +1596,28 @@ impl ContextEditor {
             return;
         }
 
-        if !self.apply_active_workflow_step(cx) {
-            self.last_error = None;
-            self.send_to_model(cx);
-            cx.notify();
-        }
-    }
-
-    fn apply_workflow_step(&mut self, range: Range<language::Anchor>, cx: &mut ViewContext<Self>) {
-        self.show_workflow_step(range.clone(), cx);
-
-        if let Some(workflow_step) = self.workflow_steps.get(&range) {
-            if let Some(assist) = workflow_step.assist.as_ref() {
-                let assist_ids = assist.assist_ids.clone();
-                cx.spawn(|this, mut cx| async move {
-                    for assist_id in assist_ids {
-                        let mut receiver = this.update(&mut cx, |_, cx| {
-                            cx.window_context().defer(move |cx| {
-                                InlineAssistant::update_global(cx, |assistant, cx| {
-                                    assistant.start_assist(assist_id, cx);
-                                })
-                            });
-                            InlineAssistant::update_global(cx, |assistant, _| {
-                                assistant.observe_assist(assist_id)
-                            })
-                        })?;
-                        while !receiver.borrow().is_done() {
-                            let _ = receiver.changed().await;
-                        }
-                    }
-                    anyhow::Ok(())
-                })
-                .detach_and_log_err(cx);
-            }
-        }
-    }
-
-    fn apply_active_workflow_step(&mut self, cx: &mut ViewContext<Self>) -> bool {
-        let Some((range, step)) = self.active_workflow_step() else {
-            return false;
-        };
-
-        if let Some(assist) = step.assist.as_ref() {
-            match assist.status(cx) {
-                WorkflowAssistStatus::Pending => {}
-                WorkflowAssistStatus::Confirmed => return false,
-                WorkflowAssistStatus::Done => self.confirm_workflow_step(range, cx),
-                WorkflowAssistStatus::Idle => self.apply_workflow_step(range, cx),
-            }
-        } else {
-            match step.resolution.as_deref() {
-                Some(Ok(_)) => self.apply_workflow_step(range, cx),
-                Some(Err(_)) => self.resolve_workflow_step(range, cx),
-                None => {}
-            }
-        }
-
-        true
-    }
-
-    fn resolve_workflow_step(
-        &mut self,
-        range: Range<language::Anchor>,
-        cx: &mut ViewContext<Self>,
-    ) {
-        self.context
-            .update(cx, |context, cx| context.resolve_workflow_step(range, cx));
-    }
-
-    fn stop_workflow_step(&mut self, range: Range<language::Anchor>, cx: &mut ViewContext<Self>) {
-        if let Some(workflow_step) = self.workflow_steps.get(&range) {
-            if let Some(assist) = workflow_step.assist.as_ref() {
-                let assist_ids = assist.assist_ids.clone();
-                cx.window_context().defer(|cx| {
-                    InlineAssistant::update_global(cx, |assistant, cx| {
-                        for assist_id in assist_ids {
-                            assistant.stop_assist(assist_id, cx);
-                        }
-                    })
-                });
-            }
+        if self.focus_active_patch(cx) {
+            return;
         }
-    }
 
-    fn undo_workflow_step(&mut self, range: Range<language::Anchor>, cx: &mut ViewContext<Self>) {
-        if let Some(workflow_step) = self.workflow_steps.get_mut(&range) {
-            if let Some(assist) = workflow_step.assist.take() {
-                cx.window_context().defer(|cx| {
-                    InlineAssistant::update_global(cx, |assistant, cx| {
-                        for assist_id in assist.assist_ids {
-                            assistant.undo_assist(assist_id, cx);
-                        }
-                    })
-                });
-            }
-        }
+        self.last_error = None;
+        self.send_to_model(cx);
+        cx.notify();
     }
 
-    fn confirm_workflow_step(
-        &mut self,
-        range: Range<language::Anchor>,
-        cx: &mut ViewContext<Self>,
-    ) {
-        if let Some(workflow_step) = self.workflow_steps.get(&range) {
-            if let Some(assist) = workflow_step.assist.as_ref() {
-                let assist_ids = assist.assist_ids.clone();
-                cx.window_context().defer(move |cx| {
-                    InlineAssistant::update_global(cx, |assistant, cx| {
-                        for assist_id in assist_ids {
-                            assistant.finish_assist(assist_id, false, cx);
-                        }
-                    })
-                });
+    fn focus_active_patch(&mut self, cx: &mut ViewContext<Self>) -> bool {
+        if let Some((_range, patch)) = self.active_patch() {
+            if let Some(editor) = patch
+                .editor
+                .as_ref()
+                .and_then(|state| state.editor.upgrade())
+            {
+                cx.focus_view(&editor);
+                return true;
             }
         }
-    }
 
-    fn reject_workflow_step(&mut self, range: Range<language::Anchor>, cx: &mut ViewContext<Self>) {
-        if let Some(workflow_step) = self.workflow_steps.get_mut(&range) {
-            if let Some(assist) = workflow_step.assist.take() {
-                cx.window_context().defer(move |cx| {
-                    InlineAssistant::update_global(cx, |assistant, cx| {
-                        for assist_id in assist.assist_ids {
-                            assistant.finish_assist(assist_id, true, cx);
-                        }
-                    })
-                });
-            }
-        }
+        false
     }
 
     fn send_to_model(&mut self, cx: &mut ViewContext<Self>) {
@@ -1802,19 +1650,6 @@ impl ContextEditor {
             return;
         }
 
-        if let Some((range, active_step)) = self.active_workflow_step() {
-            match active_step.status(cx) {
-                WorkflowStepStatus::Pending => {
-                    self.stop_workflow_step(range, cx);
-                    return;
-                }
-                WorkflowStepStatus::Done => {
-                    self.reject_workflow_step(range, cx);
-                    return;
-                }
-                _ => {}
-            }
-        }
         cx.propagate();
     }
 
@@ -2068,8 +1903,8 @@ impl ContextEditor {
                     );
                 });
             }
-            ContextEvent::WorkflowStepsUpdated { removed, updated } => {
-                self.workflow_steps_updated(removed, updated, cx);
+            ContextEvent::PatchesUpdated { removed, updated } => {
+                self.patches_updated(removed, updated, cx);
             }
             ContextEvent::PendingSlashCommandsUpdated { removed, updated } => {
                 self.editor.update(cx, |editor, cx| {
@@ -2309,7 +2144,7 @@ impl ContextEditor {
         }
     }
 
-    fn workflow_steps_updated(
+    fn patches_updated(
         &mut self,
         removed: &Vec<Range<text::Anchor>>,
         updated: &Vec<Range<text::Anchor>>,
@@ -2320,218 +2155,133 @@ impl ContextEditor {
         let mut removed_block_ids = HashSet::default();
         let mut editors_to_close = Vec::new();
         for range in removed {
-            if let Some(state) = self.workflow_steps.remove(range) {
-                editors_to_close.extend(self.hide_workflow_step(range.clone(), cx));
-                removed_block_ids.insert(state.header_block_id);
-                removed_crease_ids.push(state.header_crease_id);
-                removed_block_ids.extend(state.footer_block_id);
-                removed_crease_ids.extend(state.footer_crease_id);
+            if let Some(state) = self.patches.remove(range) {
+                editors_to_close.extend(state.editor.and_then(|state| state.editor.upgrade()));
+                removed_block_ids.insert(state.footer_block_id);
+                removed_crease_ids.push(state.crease_id);
             }
         }
 
-        for range in updated {
-            editors_to_close.extend(self.hide_workflow_step(range.clone(), cx));
-        }
-
         self.editor.update(cx, |editor, cx| {
             let snapshot = editor.snapshot(cx);
             let multibuffer = &snapshot.buffer_snapshot;
-            let (&excerpt_id, _, buffer) = multibuffer.as_singleton().unwrap();
+            let (&excerpt_id, _, _) = multibuffer.as_singleton().unwrap();
 
+            let mut replaced_blocks = HashMap::default();
             for range in updated {
-                let Some(step) = self.context.read(cx).workflow_step_for_range(&range, cx) else {
+                let Some(patch) = self.context.read(cx).patch_for_range(&range, cx).cloned() else {
                     continue;
                 };
 
-                let resolution = step.resolution.clone();
-                let header_start = step.range.start;
-                let header_end = if buffer.contains_str_at(step.leading_tags_end, "\n") {
-                    buffer.anchor_before(step.leading_tags_end.to_offset(&buffer) + 1)
-                } else {
-                    step.leading_tags_end
-                };
-                let header_range = multibuffer
-                    .anchor_in_excerpt(excerpt_id, header_start)
-                    .unwrap()
-                    ..multibuffer
-                        .anchor_in_excerpt(excerpt_id, header_end)
-                        .unwrap();
-                let footer_range = step.trailing_tag_start.map(|start| {
-                    let mut step_range_end = step.range.end.to_offset(&buffer);
-                    if buffer.contains_str_at(step_range_end, "\n") {
-                        // Only include the newline if it belongs to the same message.
-                        let messages = self
-                            .context
-                            .read(cx)
-                            .messages_for_offsets([step_range_end, step_range_end + 1], cx);
-                        if messages.len() == 1 {
-                            step_range_end += 1;
-                        }
+                let path_count = patch.path_count();
+                let patch_start = multibuffer
+                    .anchor_in_excerpt(excerpt_id, patch.range.start)
+                    .unwrap();
+                let patch_end = multibuffer
+                    .anchor_in_excerpt(excerpt_id, patch.range.end)
+                    .unwrap();
+                let render_block: RenderBlock = Box::new({
+                    let this = this.clone();
+                    let patch_range = range.clone();
+                    move |cx: &mut BlockContext<'_, '_>| {
+                        let max_width = cx.max_width;
+                        let gutter_width = cx.gutter_dimensions.full_width();
+                        let block_id = cx.block_id;
+                        this.update(&mut **cx, |this, cx| {
+                            this.render_patch_footer(
+                                patch_range.clone(),
+                                max_width,
+                                gutter_width,
+                                block_id,
+                                cx,
+                            )
+                        })
+                        .ok()
+                        .flatten()
+                        .unwrap_or_else(|| Empty.into_any())
                     }
-
-                    let end = buffer.anchor_before(step_range_end);
-                    multibuffer.anchor_in_excerpt(excerpt_id, start).unwrap()
-                        ..multibuffer.anchor_in_excerpt(excerpt_id, end).unwrap()
                 });
 
-                let block_ids = editor.insert_blocks(
-                    [BlockProperties {
-                        position: header_range.start,
-                        height: 1,
-                        style: BlockStyle::Flex,
-                        render: Box::new({
-                            let this = this.clone();
-                            let range = step.range.clone();
-                            move |cx| {
-                                let block_id = cx.block_id;
-                                let max_width = cx.max_width;
-                                let gutter_width = cx.gutter_dimensions.full_width();
-                                this.update(&mut **cx, |this, cx| {
-                                    this.render_workflow_step_header(
-                                        range.clone(),
-                                        max_width,
-                                        gutter_width,
-                                        block_id,
-                                        cx,
-                                    )
-                                })
-                                .ok()
-                                .flatten()
-                                .unwrap_or_else(|| Empty.into_any())
-                            }
-                        }),
-                        disposition: BlockDisposition::Above,
-                        priority: 0,
-                    }]
-                    .into_iter()
-                    .chain(footer_range.as_ref().map(|footer_range| {
-                        return BlockProperties {
-                            position: footer_range.end,
-                            height: 1,
-                            style: BlockStyle::Flex,
-                            render: Box::new({
-                                let this = this.clone();
-                                let range = step.range.clone();
-                                move |cx| {
-                                    let max_width = cx.max_width;
-                                    let gutter_width = cx.gutter_dimensions.full_width();
-                                    this.update(&mut **cx, |this, cx| {
-                                        this.render_workflow_step_footer(
-                                            range.clone(),
-                                            max_width,
-                                            gutter_width,
-                                            cx,
-                                        )
-                                    })
-                                    .ok()
-                                    .flatten()
-                                    .unwrap_or_else(|| Empty.into_any())
-                                }
-                            }),
-                            disposition: BlockDisposition::Below,
-                            priority: 0,
-                        };
-                    })),
-                    None,
-                    cx,
-                );
-
                 let header_placeholder = FoldPlaceholder {
-                    render: Arc::new(move |_, _crease_range, _cx| Empty.into_any()),
-                    constrain_width: false,
-                    merge_adjacent: false,
-                };
-                let footer_placeholder = FoldPlaceholder {
-                    render: render_fold_icon_button(
-                        cx.view().downgrade(),
-                        IconName::Code,
-                        "Edits".into(),
-                    ),
+                    render: {
+                        let this = this.clone();
+                        let patch_range = range.clone();
+                        Arc::new(move |fold_id, _range, cx| {
+                            this.update(cx, |this, cx| {
+                                this.render_patch_header(patch_range.clone(), fold_id, cx)
+                            })
+                            .ok()
+                            .flatten()
+                            .unwrap_or_else(|| Empty.into_any())
+                        })
+                    },
                     constrain_width: false,
                     merge_adjacent: false,
                 };
 
-                let new_crease_ids = editor.insert_creases(
-                    [Crease::new(
-                        header_range.clone(),
-                        header_placeholder.clone(),
-                        fold_toggle("step-header"),
-                        |_, _, _| Empty.into_any_element(),
-                    )]
-                    .into_iter()
-                    .chain(footer_range.clone().map(|footer_range| {
-                        Crease::new(
-                            footer_range,
-                            footer_placeholder.clone(),
-                            |row, is_folded, fold, cx| {
-                                if is_folded {
-                                    Empty.into_any_element()
-                                } else {
-                                    fold_toggle("step-footer")(row, is_folded, fold, cx)
-                                }
-                            },
-                            |_, _, _| Empty.into_any_element(),
-                        )
-                    })),
-                    cx,
-                );
-
-                let state = WorkflowStepViewState {
-                    header_block_id: block_ids[0],
-                    header_crease_id: new_crease_ids[0],
-                    footer_block_id: block_ids.get(1).copied(),
-                    footer_crease_id: new_crease_ids.get(1).copied(),
-                    resolution,
-                    assist: None,
-                };
-
-                let mut folds_to_insert = [(header_range.clone(), header_placeholder)]
-                    .into_iter()
-                    .chain(
-                        footer_range
-                            .clone()
-                            .map(|range| (range, footer_placeholder)),
-                    )
-                    .collect::<Vec<_>>();
-
-                match self.workflow_steps.entry(range.clone()) {
-                    hash_map::Entry::Vacant(entry) => {
-                        entry.insert(state);
-                    }
-                    hash_map::Entry::Occupied(mut entry) => {
-                        let entry = entry.get_mut();
-                        removed_block_ids.insert(entry.header_block_id);
-                        removed_crease_ids.push(entry.header_crease_id);
-                        removed_block_ids.extend(entry.footer_block_id);
-                        removed_crease_ids.extend(entry.footer_crease_id);
-                        folds_to_insert.retain(|(range, _)| snapshot.intersects_fold(range.start));
-                        *entry = state;
+                if let Some(state) = self.patches.get_mut(&range) {
+                    replaced_blocks.insert(state.footer_block_id, render_block);
+                    if let Some(editor_state) = &state.editor {
+                        if editor_state.opened_patch != patch {
+                            state.update_task = Some({
+                                let this = this.clone();
+                                cx.spawn(|_, cx| async move {
+                                    Self::update_patch_editor(this.clone(), patch, cx)
+                                        .await
+                                        .log_err();
+                                })
+                            });
+                        }
                     }
-                }
+                } else {
+                    let block_ids = editor.insert_blocks(
+                        [BlockProperties {
+                            position: patch_start,
+                            height: path_count as u32 + 1,
+                            style: BlockStyle::Flex,
+                            render: render_block,
+                            disposition: BlockDisposition::Below,
+                            priority: 0,
+                        }],
+                        None,
+                        cx,
+                    );
 
-                editor.unfold_ranges(
-                    [header_range.clone()]
-                        .into_iter()
-                        .chain(footer_range.clone()),
-                    true,
-                    false,
-                    cx,
-                );
+                    let new_crease_ids = editor.insert_creases(
+                        [Crease::new(
+                            patch_start..patch_end,
+                            header_placeholder.clone(),
+                            fold_toggle("patch-header"),
+                            |_, _, _| Empty.into_any_element(),
+                        )],
+                        cx,
+                    );
 
-                if !folds_to_insert.is_empty() {
-                    editor.fold_ranges(folds_to_insert, false, cx);
+                    self.patches.insert(
+                        range.clone(),
+                        PatchViewState {
+                            footer_block_id: block_ids[0],
+                            crease_id: new_crease_ids[0],
+                            editor: None,
+                            update_task: None,
+                        },
+                    );
                 }
+
+                editor.unfold_ranges([patch_start..patch_end], true, false, cx);
+                editor.fold_ranges([(patch_start..patch_end, header_placeholder)], false, cx);
             }
 
             editor.remove_creases(removed_crease_ids, cx);
             editor.remove_blocks(removed_block_ids, None, cx);
+            editor.replace_blocks(replaced_blocks, None, cx);
         });
 
-        for (editor, editor_was_open) in editors_to_close {
-            self.close_workflow_editor(cx, editor, editor_was_open);
+        for editor in editors_to_close {
+            self.close_patch_editor(editor, cx);
         }
 
-        self.update_active_workflow_step(cx);
+        self.update_active_patch(cx);
     }
 
     fn insert_slash_command_output_sections(
@@ -2604,87 +2354,75 @@ impl ContextEditor {
             }
             EditorEvent::SelectionsChanged { .. } => {
                 self.scroll_position = self.cursor_scroll_position(cx);
-                self.update_active_workflow_step(cx);
+                self.update_active_patch(cx);
             }
             _ => {}
         }
         cx.emit(event.clone());
     }
 
-    fn active_workflow_step(&self) -> Option<(Range<text::Anchor>, &WorkflowStepViewState)> {
-        let step = self.active_workflow_step.as_ref()?;
-        Some((step.range.clone(), self.workflow_steps.get(&step.range)?))
+    fn active_patch(&self) -> Option<(Range<text::Anchor>, &PatchViewState)> {
+        let patch = self.active_patch.as_ref()?;
+        Some((patch.clone(), self.patches.get(&patch)?))
     }
 
-    fn update_active_workflow_step(&mut self, cx: &mut ViewContext<Self>) {
-        let newest_cursor = self.editor.read(cx).selections.newest::<usize>(cx).head();
+    fn update_active_patch(&mut self, cx: &mut ViewContext<Self>) {
+        let newest_cursor = self.editor.read(cx).selections.newest::<Point>(cx).head();
         let context = self.context.read(cx);
 
-        let new_step = context
-            .workflow_step_containing(newest_cursor, cx)
-            .map(|step| ActiveWorkflowStep {
-                resolved: step.resolution.is_some(),
-                range: step.range.clone(),
-            });
-
-        if new_step.as_ref() != self.active_workflow_step.as_ref() {
-            let mut old_editor = None;
-            let mut old_editor_was_open = None;
-            if let Some(old_step) = self.active_workflow_step.take() {
-                (old_editor, old_editor_was_open) =
-                    self.hide_workflow_step(old_step.range, cx).unzip();
-            }
+        let new_patch = context.patch_containing(newest_cursor, cx).cloned();
 
-            let mut new_editor = None;
-            if let Some(new_step) = new_step {
-                new_editor = self.show_workflow_step(new_step.range.clone(), cx);
-                self.active_workflow_step = Some(new_step);
-            }
+        if new_patch.as_ref().map(|p| &p.range) == self.active_patch.as_ref() {
+            return;
+        }
 
-            if new_editor != old_editor {
-                if let Some((old_editor, old_editor_was_open)) = old_editor.zip(old_editor_was_open)
-                {
-                    self.close_workflow_editor(cx, old_editor, old_editor_was_open)
+        if let Some(old_patch_range) = self.active_patch.take() {
+            if let Some(patch_state) = self.patches.get_mut(&old_patch_range) {
+                if let Some(state) = patch_state.editor.take() {
+                    if let Some(editor) = state.editor.upgrade() {
+                        self.close_patch_editor(editor, cx);
+                    }
                 }
             }
         }
-    }
 
-    fn hide_workflow_step(
-        &mut self,
-        step_range: Range<language::Anchor>,
-        cx: &mut ViewContext<Self>,
-    ) -> Option<(View<Editor>, bool)> {
-        if let Some(step) = self.workflow_steps.get_mut(&step_range) {
-            let assist = step.assist.as_ref()?;
-            let editor = assist.editor.upgrade()?;
-
-            if matches!(step.status(cx), WorkflowStepStatus::Idle) {
-                let assist = step.assist.take().unwrap();
-                InlineAssistant::update_global(cx, |assistant, cx| {
-                    for assist_id in assist.assist_ids {
-                        assistant.finish_assist(assist_id, true, cx)
+        if let Some(new_patch) = new_patch {
+            self.active_patch = Some(new_patch.range.clone());
+
+            if let Some(patch_state) = self.patches.get_mut(&new_patch.range) {
+                let mut editor = None;
+                if let Some(state) = &patch_state.editor {
+                    if let Some(opened_editor) = state.editor.upgrade() {
+                        editor = Some(opened_editor);
                     }
-                });
-                return Some((editor, assist.editor_was_open));
+                }
+
+                if let Some(editor) = editor {
+                    self.workspace
+                        .update(cx, |workspace, cx| {
+                            workspace.activate_item(&editor, true, false, cx);
+                        })
+                        .ok();
+                } else {
+                    patch_state.update_task = Some(cx.spawn(move |this, cx| async move {
+                        Self::open_patch_editor(this, new_patch, cx).await.log_err();
+                    }));
+                }
             }
         }
-
-        None
     }
 
-    fn close_workflow_editor(
+    fn close_patch_editor(
         &mut self,
+        editor: View<ProposedChangesEditor>,
         cx: &mut ViewContext<ContextEditor>,
-        editor: View<Editor>,
-        editor_was_open: bool,
     ) {
         self.workspace
             .update(cx, |workspace, cx| {
                 if let Some(pane) = workspace.pane_for(&editor) {
                     pane.update(cx, |pane, cx| {
                         let item_id = editor.entity_id();
-                        if !editor_was_open && !editor.read(cx).is_focused(cx) {
+                        if !editor.read(cx).focus_handle(cx).is_focused(cx) {
                             pane.close_item_by_id(item_id, SaveIntent::Skip, cx)
                                 .detach_and_log_err(cx);
                         }
@@ -2694,190 +2432,94 @@ impl ContextEditor {
             .ok();
     }
 
-    fn show_workflow_step(
-        &mut self,
-        step_range: Range<language::Anchor>,
-        cx: &mut ViewContext<Self>,
-    ) -> Option<View<Editor>> {
-        let step = self.workflow_steps.get_mut(&step_range)?;
-
-        let mut editor_to_return = None;
-        let mut scroll_to_assist_id = None;
-        match step.status(cx) {
-            WorkflowStepStatus::Idle => {
-                if let Some(assist) = step.assist.as_ref() {
-                    scroll_to_assist_id = assist.assist_ids.first().copied();
-                } else if let Some(Ok(resolved)) = step.resolution.clone().as_deref() {
-                    step.assist = Self::open_assists_for_step(
-                        &resolved,
-                        &self.project,
-                        &self.assistant_panel,
-                        &self.workspace,
-                        cx,
-                    );
-                    editor_to_return = step
-                        .assist
-                        .as_ref()
-                        .and_then(|assist| assist.editor.upgrade());
-                }
-            }
-            WorkflowStepStatus::Pending => {
-                if let Some(assist) = step.assist.as_ref() {
-                    let assistant = InlineAssistant::global(cx);
-                    scroll_to_assist_id = assist
-                        .assist_ids
-                        .iter()
-                        .copied()
-                        .find(|assist_id| assistant.assist_status(*assist_id, cx).is_pending());
-                }
-            }
-            WorkflowStepStatus::Done => {
-                if let Some(assist) = step.assist.as_ref() {
-                    scroll_to_assist_id = assist.assist_ids.first().copied();
-                }
-            }
-            _ => {}
-        }
+    async fn open_patch_editor(
+        this: WeakView<Self>,
+        patch: AssistantPatch,
+        mut cx: AsyncWindowContext,
+    ) -> Result<()> {
+        let project = this.update(&mut cx, |this, _| this.project.clone())?;
+        let resolved_patch = patch.resolve(project.clone(), &mut cx).await;
 
-        if let Some(assist_id) = scroll_to_assist_id {
-            if let Some(assist_editor) = step
-                .assist
-                .as_ref()
-                .and_then(|assists| assists.editor.upgrade())
-            {
-                editor_to_return = Some(assist_editor.clone());
-                self.workspace
-                    .update(cx, |workspace, cx| {
-                        workspace.activate_item(&assist_editor, false, false, cx);
+        let editor = cx.new_view(|cx| {
+            let editor = ProposedChangesEditor::new(
+                patch.title.clone(),
+                resolved_patch
+                    .edit_groups
+                    .iter()
+                    .map(|(buffer, groups)| ProposedChangeLocation {
+                        buffer: buffer.clone(),
+                        ranges: groups
+                            .iter()
+                            .map(|group| group.context_range.clone())
+                            .collect(),
                     })
-                    .ok();
-                InlineAssistant::update_global(cx, |assistant, cx| {
-                    assistant.scroll_to_assist(assist_id, cx)
+                    .collect(),
+                Some(project.clone()),
+                cx,
+            );
+            resolved_patch.apply(&editor, cx);
+            editor
+        })?;
+
+        this.update(&mut cx, |this, cx| {
+            if let Some(patch_state) = this.patches.get_mut(&patch.range) {
+                patch_state.editor = Some(PatchEditorState {
+                    editor: editor.downgrade(),
+                    opened_patch: patch,
                 });
+                patch_state.update_task.take();
             }
-        }
-
-        editor_to_return
-    }
-
-    fn open_assists_for_step(
-        resolved_step: &WorkflowStepResolution,
-        project: &Model<Project>,
-        assistant_panel: &WeakView<AssistantPanel>,
-        workspace: &WeakView<Workspace>,
-        cx: &mut ViewContext<Self>,
-    ) -> Option<WorkflowAssist> {
-        let assistant_panel = assistant_panel.upgrade()?;
-        if resolved_step.suggestion_groups.is_empty() {
-            return None;
-        }
 
-        let editor;
-        let mut editor_was_open = false;
-        let mut suggestion_groups = Vec::new();
-        if resolved_step.suggestion_groups.len() == 1
-            && resolved_step
-                .suggestion_groups
-                .values()
-                .next()
-                .unwrap()
-                .len()
-                == 1
-        {
-            // If there's only one buffer and one suggestion group, open it directly
-            let (buffer, groups) = resolved_step.suggestion_groups.iter().next().unwrap();
-            let group = groups.into_iter().next().unwrap();
-            editor = workspace
+            this.workspace
                 .update(cx, |workspace, cx| {
-                    let active_pane = workspace.active_pane().clone();
-                    editor_was_open =
-                        workspace.is_project_item_open::<Editor>(&active_pane, buffer, cx);
-                    workspace.open_project_item::<Editor>(
-                        active_pane,
-                        buffer.clone(),
-                        false,
-                        false,
-                        cx,
-                    )
+                    workspace.add_item_to_active_pane(Box::new(editor.clone()), None, false, cx)
                 })
-                .log_err()?;
-            let (&excerpt_id, _, _) = editor
-                .read(cx)
-                .buffer()
-                .read(cx)
-                .read(cx)
-                .as_singleton()
-                .unwrap();
-
-            // Scroll the editor to the suggested assist
-            editor.update(cx, |editor, cx| {
-                let multibuffer = editor.buffer().read(cx).snapshot(cx);
-                let (&excerpt_id, _, buffer) = multibuffer.as_singleton().unwrap();
-                let anchor = if group.context_range.start.to_offset(buffer) == 0 {
-                    Anchor::min()
-                } else {
-                    multibuffer
-                        .anchor_in_excerpt(excerpt_id, group.context_range.start)
-                        .unwrap()
-                };
+                .log_err();
+        })?;
 
-                editor.set_scroll_anchor(
-                    ScrollAnchor {
-                        offset: gpui::Point::default(),
-                        anchor,
-                    },
-                    cx,
-                );
-            });
+        Ok(())
+    }
 
-            suggestion_groups.push((excerpt_id, group));
-        } else {
-            // If there are multiple buffers or suggestion groups, create a multibuffer
-            let multibuffer = cx.new_model(|cx| {
-                let mut multibuffer =
-                    MultiBuffer::new(Capability::ReadWrite).with_title(resolved_step.title.clone());
-                for (buffer, groups) in &resolved_step.suggestion_groups {
-                    let excerpt_ids = multibuffer.push_excerpts(
-                        buffer.clone(),
-                        groups.iter().map(|suggestion_group| ExcerptRange {
-                            context: suggestion_group.context_range.clone(),
-                            primary: None,
-                        }),
-                        cx,
-                    );
-                    suggestion_groups.extend(excerpt_ids.into_iter().zip(groups));
-                }
-                multibuffer
-            });
+    async fn update_patch_editor(
+        this: WeakView<Self>,
+        patch: AssistantPatch,
+        mut cx: AsyncWindowContext,
+    ) -> Result<()> {
+        let project = this.update(&mut cx, |this, _| this.project.clone())?;
+        let resolved_patch = patch.resolve(project.clone(), &mut cx).await;
+        this.update(&mut cx, |this, cx| {
+            let patch_state = this.patches.get_mut(&patch.range)?;
 
-            editor = cx.new_view(|cx| {
-                Editor::for_multibuffer(multibuffer, Some(project.clone()), true, cx)
-            });
-            workspace
-                .update(cx, |workspace, cx| {
-                    workspace.add_item_to_active_pane(Box::new(editor.clone()), None, false, cx)
+            let locations = resolved_patch
+                .edit_groups
+                .iter()
+                .map(|(buffer, groups)| ProposedChangeLocation {
+                    buffer: buffer.clone(),
+                    ranges: groups
+                        .iter()
+                        .map(|group| group.context_range.clone())
+                        .collect(),
                 })
-                .log_err()?;
-        }
+                .collect();
 
-        let mut assist_ids = Vec::new();
-        for (excerpt_id, suggestion_group) in suggestion_groups {
-            for suggestion in &suggestion_group.suggestions {
-                assist_ids.extend(suggestion.show(
-                    &editor,
-                    excerpt_id,
-                    workspace,
-                    &assistant_panel,
-                    cx,
-                ));
+            if let Some(state) = &mut patch_state.editor {
+                if let Some(editor) = state.editor.upgrade() {
+                    editor.update(cx, |editor, cx| {
+                        editor.set_title(patch.title.clone(), cx);
+                        editor.reset_locations(locations, cx);
+                        resolved_patch.apply(editor, cx);
+                    });
+
+                    state.opened_patch = patch;
+                } else {
+                    patch_state.editor.take();
+                }
             }
-        }
+            patch_state.update_task.take();
 
-        Some(WorkflowAssist {
-            assist_ids,
-            editor: editor.downgrade(),
-            editor_was_open,
-        })
+            Some(())
+        })?;
+        Ok(())
     }
 
     fn handle_editor_search_event(
@@ -3782,394 +3424,91 @@ impl ContextEditor {
             .unwrap_or_else(|| Cow::Borrowed(DEFAULT_TAB_TITLE))
     }
 
-    fn render_workflow_step_header(
+    fn render_patch_header(
         &self,
         range: Range<text::Anchor>,
-        max_width: Pixels,
-        gutter_width: Pixels,
-        id: BlockId,
+        _id: FoldId,
         cx: &mut ViewContext<Self>,
     ) -> Option<AnyElement> {
-        let step_state = self.workflow_steps.get(&range)?;
-        let status = step_state.status(cx);
-        let this = cx.view().downgrade();
-
-        let theme = cx.theme().status();
-        let is_confirmed = status.is_confirmed();
-        let border_color = if is_confirmed {
-            theme.ignored_border
-        } else {
-            theme.info_border
-        };
-
-        let editor = self.editor.read(cx);
-        let focus_handle = editor.focus_handle(cx);
-        let snapshot = editor
-            .buffer()
-            .read(cx)
-            .as_singleton()?
-            .read(cx)
-            .text_snapshot();
-        let start_offset = range.start.to_offset(&snapshot);
-        let parent_message = self
-            .context
-            .read(cx)
-            .messages_for_offsets([start_offset], cx);
-        debug_assert_eq!(parent_message.len(), 1);
-        let parent_message = parent_message.first()?;
-
-        let step_index = self
-            .workflow_steps
-            .keys()
-            .filter(|workflow_step_range| {
-                workflow_step_range
-                    .start
-                    .cmp(&parent_message.anchor_range.start, &snapshot)
-                    .is_ge()
-                    && workflow_step_range.end.cmp(&range.end, &snapshot).is_le()
-            })
-            .count();
-
-        let step_label = Label::new(format!("Step {step_index}")).size(LabelSize::Small);
-
-        let step_label = if is_confirmed {
-            h_flex()
-                .items_center()
-                .gap_2()
-                .child(step_label.strikethrough(true).color(Color::Muted))
-                .child(
-                    Icon::new(IconName::Check)
-                        .size(IconSize::Small)
-                        .color(Color::Created),
-                )
-        } else {
-            div().child(step_label)
-        };
-
+        let patch = self.context.read(cx).patch_for_range(&range, cx)?;
+        let theme = cx.theme().clone();
         Some(
-            v_flex()
-                .w(max_width)
-                .pl(gutter_width)
-                .child(
-                    h_flex()
-                        .w_full()
-                        .h_8()
-                        .border_b_1()
-                        .border_color(border_color)
-                        .items_center()
-                        .justify_between()
-                        .gap_2()
-                        .child(h_flex().justify_start().gap_2().child(step_label))
-                        .child(h_flex().w_full().justify_end().child(
-                            Self::render_workflow_step_status(
-                                status,
-                                range.clone(),
-                                focus_handle.clone(),
-                                this.clone(),
-                                id,
-                            ),
-                        )),
-                )
-                // todo!("do we wanna keep this?")
-                // .children(edit_paths.iter().map(|path| {
-                //     h_flex()
-                //         .gap_1()
-                //         .child(Icon::new(IconName::File))
-                //         .child(Label::new(path.clone()))
-                // }))
+            h_flex()
+                .px_1()
+                .py_0p5()
+                .border_b_1()
+                .border_color(theme.status().info_border)
+                .gap_1()
+                .child(Icon::new(IconName::Diff).size(IconSize::Small))
+                .child(Label::new(patch.title.clone()).size(LabelSize::Small))
                 .into_any(),
         )
     }
 
-    fn render_workflow_step_footer(
-        &self,
-        step_range: Range<text::Anchor>,
+    fn render_patch_footer(
+        &mut self,
+        range: Range<text::Anchor>,
         max_width: Pixels,
         gutter_width: Pixels,
+        id: BlockId,
         cx: &mut ViewContext<Self>,
     ) -> Option<AnyElement> {
-        let step = self.workflow_steps.get(&step_range)?;
-        let current_status = step.status(cx);
-        let theme = cx.theme().status();
-        let border_color = if current_status.is_confirmed() {
-            theme.ignored_border
-        } else {
-            theme.info_border
-        };
+        let snapshot = self.editor.update(cx, |editor, cx| editor.snapshot(cx));
+        let (excerpt_id, _buffer_id, _) = snapshot.buffer_snapshot.as_singleton().unwrap();
+        let excerpt_id = *excerpt_id;
+        let anchor = snapshot
+            .buffer_snapshot
+            .anchor_in_excerpt(excerpt_id, range.start)
+            .unwrap();
+
+        if !snapshot.intersects_fold(anchor) {
+            return None;
+        }
+
+        let patch = self.context.read(cx).patch_for_range(&range, cx)?;
+        let paths = patch
+            .paths()
+            .map(|p| SharedString::from(p.to_string()))
+            .collect::<BTreeSet<_>>();
+
         Some(
             v_flex()
-                .w(max_width)
-                .pt_1()
+                .id(id)
                 .pl(gutter_width)
-                .child(h_flex().h(px(1.)).bg(border_color))
-                .into_any(),
-        )
-    }
-
-    fn render_workflow_step_status(
-        status: WorkflowStepStatus,
-        step_range: Range<language::Anchor>,
-        focus_handle: FocusHandle,
-        editor: WeakView<ContextEditor>,
-        id: BlockId,
-    ) -> AnyElement {
-        let id = EntityId::from(id).as_u64();
-        fn display_keybind_in_tooltip(
-            step_range: &Range<language::Anchor>,
-            editor: &WeakView<ContextEditor>,
-            cx: &mut WindowContext<'_>,
-        ) -> bool {
-            editor
-                .update(cx, |this, _| {
-                    this.active_workflow_step
-                        .as_ref()
-                        .map(|step| &step.range == step_range)
-                })
-                .ok()
-                .flatten()
-                .unwrap_or_default()
-        }
-
-        match status {
-            WorkflowStepStatus::Error(error) => {
-                let error = error.to_string();
-                h_flex()
-                    .gap_2()
-                    .child(
-                        div()
-                            .id("step-resolution-failure")
-                            .child(
-                                Label::new("Step Resolution Failed")
-                                    .size(LabelSize::Small)
-                                    .color(Color::Error),
-                            )
-                            .tooltip(move |cx| Tooltip::text(error.clone(), cx)),
-                    )
-                    .child(
-                        Button::new(("transform", id), "Retry")
-                            .icon(IconName::Update)
-                            .icon_position(IconPosition::Start)
-                            .icon_size(IconSize::Small)
-                            .label_size(LabelSize::Small)
-                            .on_click({
-                                let editor = editor.clone();
-                                let step_range = step_range.clone();
-                                move |_, cx| {
-                                    editor
-                                        .update(cx, |this, cx| {
-                                            this.resolve_workflow_step(step_range.clone(), cx)
-                                        })
-                                        .ok();
-                                }
-                            }),
-                    )
-                    .into_any()
-            }
-            WorkflowStepStatus::Idle | WorkflowStepStatus::Resolving { .. } => {
-                Button::new(("transform", id), "Transform")
-                    .icon(IconName::SparkleAlt)
-                    .icon_position(IconPosition::Start)
-                    .icon_size(IconSize::Small)
-                    .label_size(LabelSize::Small)
-                    .style(ButtonStyle::Tinted(TintColor::Accent))
-                    .tooltip({
-                        let step_range = step_range.clone();
-                        let editor = editor.clone();
-                        move |cx| {
-                            cx.new_view(|cx| {
-                                let tooltip = Tooltip::new("Transform");
-                                if display_keybind_in_tooltip(&step_range, &editor, cx) {
-                                    tooltip.key_binding(KeyBinding::for_action_in(
-                                        &Assist,
-                                        &focus_handle,
-                                        cx,
-                                    ))
-                                } else {
-                                    tooltip
-                                }
-                            })
-                            .into()
-                        }
-                    })
-                    .on_click({
-                        let editor = editor.clone();
-                        let step_range = step_range.clone();
-                        let is_idle = matches!(status, WorkflowStepStatus::Idle);
-                        move |_, cx| {
-                            if is_idle {
-                                editor
-                                    .update(cx, |this, cx| {
-                                        this.apply_workflow_step(step_range.clone(), cx)
-                                    })
-                                    .ok();
-                            }
-                        }
-                    })
-                    .map(|this| {
-                        if let WorkflowStepStatus::Resolving = &status {
-                            this.with_animation(
-                                ("resolving-suggestion-animation", id),
+                .w(max_width)
+                .py_2()
+                .cursor(CursorStyle::PointingHand)
+                .on_click(cx.listener(move |this, _, cx| {
+                    this.editor.update(cx, |editor, cx| {
+                        editor.change_selections(None, cx, |selections| {
+                            selections.select_ranges(vec![anchor..anchor]);
+                        });
+                    });
+                    this.focus_active_patch(cx);
+                }))
+                .children(paths.into_iter().map(|path| {
+                    h_flex()
+                        .pl_1()
+                        .gap_1()
+                        .child(Icon::new(IconName::File).size(IconSize::Small))
+                        .child(Label::new(path).size(LabelSize::Small))
+                }))
+                .when(patch.status == AssistantPatchStatus::Pending, |div| {
+                    div.child(
+                        Label::new("Generating")
+                            .color(Color::Muted)
+                            .size(LabelSize::Small)
+                            .with_animation(
+                                "pulsating-label",
                                 Animation::new(Duration::from_secs(2))
                                     .repeat()
-                                    .with_easing(pulsating_between(0.4, 0.8)),
+                                    .with_easing(pulsating_between(0.4, 1.)),
                                 |label, delta| label.alpha(delta),
-                            )
-                            .into_any_element()
-                        } else {
-                            this.into_any_element()
-                        }
-                    })
-            }
-            WorkflowStepStatus::Pending => h_flex()
-                .items_center()
-                .gap_2()
-                .child(
-                    Label::new("Applying...")
-                        .size(LabelSize::Small)
-                        .with_animation(
-                            ("applying-step-transformation-label", id),
-                            Animation::new(Duration::from_secs(2))
-                                .repeat()
-                                .with_easing(pulsating_between(0.4, 0.8)),
-                            |label, delta| label.alpha(delta),
-                        ),
-                )
-                .child(
-                    IconButton::new(("stop-transformation", id), IconName::Stop)
-                        .icon_size(IconSize::Small)
-                        .icon_color(Color::Error)
-                        .style(ButtonStyle::Subtle)
-                        .tooltip({
-                            let step_range = step_range.clone();
-                            let editor = editor.clone();
-                            move |cx| {
-                                cx.new_view(|cx| {
-                                    let tooltip = Tooltip::new("Stop Transformation");
-                                    if display_keybind_in_tooltip(&step_range, &editor, cx) {
-                                        tooltip.key_binding(KeyBinding::for_action_in(
-                                            &editor::actions::Cancel,
-                                            &focus_handle,
-                                            cx,
-                                        ))
-                                    } else {
-                                        tooltip
-                                    }
-                                })
-                                .into()
-                            }
-                        })
-                        .on_click({
-                            let editor = editor.clone();
-                            let step_range = step_range.clone();
-                            move |_, cx| {
-                                editor
-                                    .update(cx, |this, cx| {
-                                        this.stop_workflow_step(step_range.clone(), cx)
-                                    })
-                                    .ok();
-                            }
-                        }),
-                )
-                .into_any_element(),
-            WorkflowStepStatus::Done => h_flex()
-                .gap_1()
-                .child(
-                    IconButton::new(("stop-transformation", id), IconName::Close)
-                        .icon_size(IconSize::Small)
-                        .style(ButtonStyle::Tinted(TintColor::Negative))
-                        .tooltip({
-                            let focus_handle = focus_handle.clone();
-                            let editor = editor.clone();
-                            let step_range = step_range.clone();
-                            move |cx| {
-                                cx.new_view(|cx| {
-                                    let tooltip = Tooltip::new("Reject Transformation");
-                                    if display_keybind_in_tooltip(&step_range, &editor, cx) {
-                                        tooltip.key_binding(KeyBinding::for_action_in(
-                                            &editor::actions::Cancel,
-                                            &focus_handle,
-                                            cx,
-                                        ))
-                                    } else {
-                                        tooltip
-                                    }
-                                })
-                                .into()
-                            }
-                        })
-                        .on_click({
-                            let editor = editor.clone();
-                            let step_range = step_range.clone();
-                            move |_, cx| {
-                                editor
-                                    .update(cx, |this, cx| {
-                                        this.reject_workflow_step(step_range.clone(), cx);
-                                    })
-                                    .ok();
-                            }
-                        }),
-                )
-                .child(
-                    Button::new(("confirm-workflow-step", id), "Accept")
-                        .icon(IconName::Check)
-                        .icon_position(IconPosition::Start)
-                        .icon_size(IconSize::Small)
-                        .label_size(LabelSize::Small)
-                        .style(ButtonStyle::Tinted(TintColor::Positive))
-                        .tooltip({
-                            let editor = editor.clone();
-                            let step_range = step_range.clone();
-                            move |cx| {
-                                cx.new_view(|cx| {
-                                    let tooltip = Tooltip::new("Accept Transformation");
-                                    if display_keybind_in_tooltip(&step_range, &editor, cx) {
-                                        tooltip.key_binding(KeyBinding::for_action_in(
-                                            &Assist,
-                                            &focus_handle,
-                                            cx,
-                                        ))
-                                    } else {
-                                        tooltip
-                                    }
-                                })
-                                .into()
-                            }
-                        })
-                        .on_click({
-                            let editor = editor.clone();
-                            let step_range = step_range.clone();
-                            move |_, cx| {
-                                editor
-                                    .update(cx, |this, cx| {
-                                        this.confirm_workflow_step(step_range.clone(), cx);
-                                    })
-                                    .ok();
-                            }
-                        }),
-                )
-                .into_any_element(),
-            WorkflowStepStatus::Confirmed => h_flex()
-                .child(
-                    Button::new(("revert-workflow-step", id), "Undo")
-                        .style(ButtonStyle::Filled)
-                        .icon(Some(IconName::Undo))
-                        .icon_position(IconPosition::Start)
-                        .icon_size(IconSize::Small)
-                        .label_size(LabelSize::Small)
-                        .on_click({
-                            let editor = editor.clone();
-                            let step_range = step_range.clone();
-                            move |_, cx| {
-                                editor
-                                    .update(cx, |this, cx| {
-                                        this.undo_workflow_step(step_range.clone(), cx);
-                                    })
-                                    .ok();
-                            }
-                        }),
-                )
-                .into_any_element(),
-        }
+                            ),
+                    )
+                })
+                .into_any(),
+        )
     }
 
     fn render_notice(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
@@ -4259,17 +3598,6 @@ impl ContextEditor {
 
     fn render_send_button(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         let focus_handle = self.focus_handle(cx).clone();
-        let button_text = match self.active_workflow_step() {
-            Some((_, step)) => match step.status(cx) {
-                WorkflowStepStatus::Error(_) => "Retry Step Resolution",
-                WorkflowStepStatus::Resolving => "Transform",
-                WorkflowStepStatus::Idle => "Transform",
-                WorkflowStepStatus::Pending => "Applying...",
-                WorkflowStepStatus::Done => "Accept",
-                WorkflowStepStatus::Confirmed => "Send",
-            },
-            None => "Send",
-        };
 
         let (style, tooltip) = match token_state(&self.context, cx) {
             Some(TokenState::NoTokensLeft { .. }) => (
@@ -4309,7 +3637,7 @@ impl ContextEditor {
                 button.tooltip(move |_| tooltip.clone())
             })
             .layer(ElevationIndex::ModalSurface)
-            .child(Label::new(button_text))
+            .child(Label::new("Send"))
             .children(
                 KeyBinding::for_action_in(&Assist, &focus_handle, cx)
                     .map(|binding| binding.into_any_element()),
@@ -5226,33 +4554,6 @@ pub enum WorkflowAssistStatus {
     Idle,
 }
 
-impl WorkflowAssist {
-    pub fn status(&self, cx: &AppContext) -> WorkflowAssistStatus {
-        let assistant = InlineAssistant::global(cx);
-        if self
-            .assist_ids
-            .iter()
-            .any(|assist_id| assistant.assist_status(*assist_id, cx).is_pending())
-        {
-            WorkflowAssistStatus::Pending
-        } else if self
-            .assist_ids
-            .iter()
-            .all(|assist_id| assistant.assist_status(*assist_id, cx).is_confirmed())
-        {
-            WorkflowAssistStatus::Confirmed
-        } else if self
-            .assist_ids
-            .iter()
-            .all(|assist_id| assistant.assist_status(*assist_id, cx).is_done())
-        {
-            WorkflowAssistStatus::Done
-        } else {
-            WorkflowAssistStatus::Idle
-        }
-    }
-}
-
 impl Render for ContextHistory {
     fn render(&mut self, _: &mut ViewContext<Self>) -> impl IntoElement {
         div().size_full().child(self.picker.clone())
diff --git a/crates/assistant/src/assistant_settings.rs b/crates/assistant/src/assistant_settings.rs
index 5aa379bae3fce9..2bab6a9624f314 100644
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use ::open_ai::Model as OpenAiModel;
 use anthropic::Model as AnthropicModel;
+use feature_flags::FeatureFlagAppExt;
 use fs::Fs;
 use gpui::{AppContext, Pixels};
 use language_model::provider::open_ai;
@@ -61,6 +62,13 @@ pub struct AssistantSettings {
     pub default_model: LanguageModelSelection,
     pub inline_alternatives: Vec<LanguageModelSelection>,
     pub using_outdated_settings_version: bool,
+    pub enable_experimental_live_diffs: bool,
+}
+
+impl AssistantSettings {
+    pub fn are_live_diffs_enabled(&self, cx: &AppContext) -> bool {
+        cx.is_staff() || self.enable_experimental_live_diffs
+    }
 }
 
 /// Assistant panel settings
@@ -238,6 +246,7 @@ impl AssistantSettingsContent {
                             }
                         }),
                     inline_alternatives: None,
+                    enable_experimental_live_diffs: None,
                 },
                 VersionedAssistantSettingsContent::V2(settings) => settings.clone(),
             },
@@ -257,6 +266,7 @@ impl AssistantSettingsContent {
                         .to_string(),
                 }),
                 inline_alternatives: None,
+                enable_experimental_live_diffs: None,
             },
         }
     }
@@ -373,6 +383,7 @@ impl Default for VersionedAssistantSettingsContent {
             default_height: None,
             default_model: None,
             inline_alternatives: None,
+            enable_experimental_live_diffs: None,
         })
     }
 }
@@ -403,6 +414,10 @@ pub struct AssistantSettingsContentV2 {
     default_model: Option<LanguageModelSelection>,
     /// Additional models with which to generate alternatives when performing inline assists.
     inline_alternatives: Option<Vec<LanguageModelSelection>>,
+    /// Enable experimental live diffs in the assistant panel.
+    ///
+    /// Default: false
+    enable_experimental_live_diffs: Option<bool>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
@@ -525,7 +540,10 @@ impl Settings for AssistantSettings {
             );
             merge(&mut settings.default_model, value.default_model);
             merge(&mut settings.inline_alternatives, value.inline_alternatives);
-            // merge(&mut settings.infer_context, value.infer_context); TODO re-enable this once we ship context inference
+            merge(
+                &mut settings.enable_experimental_live_diffs,
+                value.enable_experimental_live_diffs,
+            );
         }
 
         Ok(settings)
@@ -584,6 +602,7 @@ mod tests {
                             dock: None,
                             default_width: None,
                             default_height: None,
+                            enable_experimental_live_diffs: None,
                         }),
                     )
                 },
diff --git a/crates/assistant/src/context.rs b/crates/assistant/src/context.rs
index 610652a371442b..2818411d0d34c5 100644
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -2,8 +2,8 @@
 mod context_tests;
 
 use crate::{
-    prompts::PromptBuilder, slash_command::SlashCommandLine, MessageId, MessageStatus,
-    WorkflowStep, WorkflowStepEdit, WorkflowStepResolution, WorkflowSuggestionGroup,
+    prompts::PromptBuilder, slash_command::SlashCommandLine, AssistantEdit, AssistantPatch,
+    AssistantPatchStatus, MessageId, MessageStatus,
 };
 use anyhow::{anyhow, Context as _, Result};
 use assistant_slash_command::{
@@ -15,13 +15,10 @@ use clock::ReplicaId;
 use collections::{HashMap, HashSet};
 use feature_flags::{FeatureFlag, FeatureFlagAppExt};
 use fs::{Fs, RemoveOptions};
-use futures::{
-    future::{self, Shared},
-    FutureExt, StreamExt,
-};
+use futures::{future::Shared, FutureExt, StreamExt};
 use gpui::{
-    AppContext, AsyncAppContext, Context as _, EventEmitter, Model, ModelContext, RenderImage,
-    SharedString, Subscription, Task,
+    AppContext, Context as _, EventEmitter, Model, ModelContext, RenderImage, SharedString,
+    Subscription, Task,
 };
 
 use language::{AnchorRangeExt, Bias, Buffer, LanguageRegistry, OffsetRangeExt, Point, ToOffset};
@@ -38,7 +35,7 @@ use project::Project;
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use std::{
-    cmp::{self, max, Ordering},
+    cmp::{max, Ordering},
     fmt::Debug,
     iter, mem,
     ops::Range,
@@ -300,7 +297,7 @@ pub enum ContextEvent {
     MessagesEdited,
     SummaryChanged,
     StreamedCompletion,
-    WorkflowStepsUpdated {
+    PatchesUpdated {
         removed: Vec<Range<language::Anchor>>,
         updated: Vec<Range<language::Anchor>>,
     },
@@ -454,13 +451,14 @@ pub struct XmlTag {
 #[derive(Copy, Clone, Debug, strum::EnumString, PartialEq, Eq, strum::AsRefStr)]
 #[strum(serialize_all = "snake_case")]
 pub enum XmlTagKind {
-    Step,
+    Patch,
+    Title,
     Edit,
     Path,
-    Search,
-    Within,
-    Operation,
     Description,
+    OldText,
+    NewText,
+    Operation,
 }
 
 pub struct Context {
@@ -490,7 +488,7 @@ pub struct Context {
     _subscriptions: Vec<Subscription>,
     telemetry: Option<Arc<Telemetry>>,
     language_registry: Arc<LanguageRegistry>,
-    workflow_steps: Vec<WorkflowStep>,
+    patches: Vec<AssistantPatch>,
     xml_tags: Vec<XmlTag>,
     project: Option<Model<Project>>,
     prompt_builder: Arc<PromptBuilder>,
@@ -506,7 +504,7 @@ impl ContextAnnotation for PendingSlashCommand {
     }
 }
 
-impl ContextAnnotation for WorkflowStep {
+impl ContextAnnotation for AssistantPatch {
     fn range(&self) -> &Range<language::Anchor> {
         &self.range
     }
@@ -591,7 +589,7 @@ impl Context {
             telemetry,
             project,
             language_registry,
-            workflow_steps: Vec::new(),
+            patches: Vec::new(),
             xml_tags: Vec::new(),
             prompt_builder,
         };
@@ -929,48 +927,49 @@ impl Context {
         self.summary.as_ref()
     }
 
-    pub(crate) fn workflow_step_containing(
+    pub(crate) fn patch_containing(
         &self,
-        offset: usize,
+        position: Point,
         cx: &AppContext,
-    ) -> Option<&WorkflowStep> {
+    ) -> Option<&AssistantPatch> {
         let buffer = self.buffer.read(cx);
-        let index = self
-            .workflow_steps
-            .binary_search_by(|step| {
-                let step_range = step.range.to_offset(&buffer);
-                if offset < step_range.start {
-                    Ordering::Greater
-                } else if offset > step_range.end {
-                    Ordering::Less
-                } else {
-                    Ordering::Equal
-                }
-            })
-            .ok()?;
-        Some(&self.workflow_steps[index])
+        let index = self.patches.binary_search_by(|patch| {
+            let patch_range = patch.range.to_point(&buffer);
+            if position < patch_range.start {
+                Ordering::Greater
+            } else if position > patch_range.end {
+                Ordering::Less
+            } else {
+                Ordering::Equal
+            }
+        });
+        if let Ok(ix) = index {
+            Some(&self.patches[ix])
+        } else {
+            None
+        }
     }
 
-    pub fn workflow_step_ranges(&self) -> impl Iterator<Item = Range<language::Anchor>> + '_ {
-        self.workflow_steps.iter().map(|step| step.range.clone())
+    pub fn patch_ranges(&self) -> impl Iterator<Item = Range<language::Anchor>> + '_ {
+        self.patches.iter().map(|patch| patch.range.clone())
     }
 
-    pub(crate) fn workflow_step_for_range(
+    pub(crate) fn patch_for_range(
         &self,
         range: &Range<language::Anchor>,
         cx: &AppContext,
-    ) -> Option<&WorkflowStep> {
+    ) -> Option<&AssistantPatch> {
         let buffer = self.buffer.read(cx);
-        let index = self.workflow_step_index_for_range(range, buffer).ok()?;
-        Some(&self.workflow_steps[index])
+        let index = self.patch_index_for_range(range, buffer).ok()?;
+        Some(&self.patches[index])
     }
 
-    fn workflow_step_index_for_range(
+    fn patch_index_for_range(
         &self,
         tagged_range: &Range<text::Anchor>,
         buffer: &text::BufferSnapshot,
     ) -> Result<usize, usize> {
-        self.workflow_steps
+        self.patches
             .binary_search_by(|probe| probe.range.cmp(&tagged_range, buffer))
     }
 
@@ -1018,8 +1017,6 @@ impl Context {
             language::BufferEvent::Edited => {
                 self.count_remaining_tokens(cx);
                 self.reparse(cx);
-                // Use `inclusive = true` to invalidate a step when an edit occurs
-                // at the start/end of a parsed step.
                 cx.emit(ContextEvent::MessagesEdited);
             }
             _ => {}
@@ -1248,8 +1245,8 @@ impl Context {
 
         let mut removed_slash_command_ranges = Vec::new();
         let mut updated_slash_commands = Vec::new();
-        let mut removed_steps = Vec::new();
-        let mut updated_steps = Vec::new();
+        let mut removed_patches = Vec::new();
+        let mut updated_patches = Vec::new();
         while let Some(mut row_range) = row_ranges.next() {
             while let Some(next_row_range) = row_ranges.peek() {
                 if row_range.end >= next_row_range.start {
@@ -1273,11 +1270,11 @@ impl Context {
                 &mut removed_slash_command_ranges,
                 cx,
             );
-            self.reparse_workflow_steps_in_range(
+            self.reparse_patches_in_range(
                 start..end,
                 &buffer,
-                &mut updated_steps,
-                &mut removed_steps,
+                &mut updated_patches,
+                &mut removed_patches,
                 cx,
             );
         }
@@ -1289,10 +1286,10 @@ impl Context {
             });
         }
 
-        if !updated_steps.is_empty() || !removed_steps.is_empty() {
-            cx.emit(ContextEvent::WorkflowStepsUpdated {
-                removed: removed_steps,
-                updated: updated_steps,
+        if !updated_patches.is_empty() || !removed_patches.is_empty() {
+            cx.emit(ContextEvent::PatchesUpdated {
+                removed: removed_patches,
+                updated: updated_patches,
             });
         }
     }
@@ -1354,7 +1351,7 @@ impl Context {
         removed.extend(removed_commands.map(|command| command.source_range));
     }
 
-    fn reparse_workflow_steps_in_range(
+    fn reparse_patches_in_range(
         &mut self,
         range: Range<text::Anchor>,
         buffer: &BufferSnapshot,
@@ -1369,41 +1366,32 @@ impl Context {
         self.xml_tags
             .splice(intersecting_tags_range.clone(), new_tags);
 
-        // Find which steps intersect the changed range.
-        let intersecting_steps_range =
-            self.indices_intersecting_buffer_range(&self.workflow_steps, range.clone(), cx);
+        // Find which patches intersect the changed range.
+        let intersecting_patches_range =
+            self.indices_intersecting_buffer_range(&self.patches, range.clone(), cx);
 
-        // Reparse all tags after the last unchanged step before the change.
+        // Reparse all tags after the last unchanged patch before the change.
         let mut tags_start_ix = 0;
-        if let Some(preceding_unchanged_step) =
-            self.workflow_steps[..intersecting_steps_range.start].last()
+        if let Some(preceding_unchanged_patch) =
+            self.patches[..intersecting_patches_range.start].last()
         {
             tags_start_ix = match self.xml_tags.binary_search_by(|tag| {
                 tag.range
                     .start
-                    .cmp(&preceding_unchanged_step.range.end, buffer)
+                    .cmp(&preceding_unchanged_patch.range.end, buffer)
                     .then(Ordering::Less)
             }) {
                 Ok(ix) | Err(ix) => ix,
             };
         }
 
-        // Rebuild the edit suggestions in the range.
-        let mut new_steps = self.parse_steps(tags_start_ix, range.end, buffer);
-
-        if let Some(project) = self.project() {
-            for step in &mut new_steps {
-                Self::resolve_workflow_step_internal(step, &project, cx);
-            }
-        }
-
-        updated.extend(new_steps.iter().map(|step| step.range.clone()));
-        let removed_steps = self
-            .workflow_steps
-            .splice(intersecting_steps_range, new_steps);
+        // Rebuild the patches in the range.
+        let new_patches = self.parse_patches(tags_start_ix, range.end, buffer, cx);
+        updated.extend(new_patches.iter().map(|patch| patch.range.clone()));
+        let removed_patches = self.patches.splice(intersecting_patches_range, new_patches);
         removed.extend(
-            removed_steps
-                .map(|step| step.range)
+            removed_patches
+                .map(|patch| patch.range)
                 .filter(|range| !updated.contains(&range)),
         );
     }
@@ -1464,60 +1452,95 @@ impl Context {
         tags
     }
 
-    fn parse_steps(
+    fn parse_patches(
         &mut self,
         tags_start_ix: usize,
         buffer_end: text::Anchor,
         buffer: &BufferSnapshot,
-    ) -> Vec<WorkflowStep> {
-        let mut new_steps = Vec::new();
-        let mut pending_step = None;
-        let mut edit_step_depth = 0;
+        cx: &AppContext,
+    ) -> Vec<AssistantPatch> {
+        let mut new_patches = Vec::new();
+        let mut pending_patch = None;
+        let mut patch_tag_depth = 0;
         let mut tags = self.xml_tags[tags_start_ix..].iter().peekable();
         'tags: while let Some(tag) = tags.next() {
-            if tag.range.start.cmp(&buffer_end, buffer).is_gt() && edit_step_depth == 0 {
+            if tag.range.start.cmp(&buffer_end, buffer).is_gt() && patch_tag_depth == 0 {
                 break;
             }
 
-            if tag.kind == XmlTagKind::Step && tag.is_open_tag {
-                edit_step_depth += 1;
-                let edit_start = tag.range.start;
-                let mut edits = Vec::new();
-                let mut step = WorkflowStep {
-                    range: edit_start..edit_start,
-                    leading_tags_end: tag.range.end,
-                    trailing_tag_start: None,
+            if tag.kind == XmlTagKind::Patch && tag.is_open_tag {
+                patch_tag_depth += 1;
+                let patch_start = tag.range.start;
+                let mut edits = Vec::<Result<AssistantEdit>>::new();
+                let mut patch = AssistantPatch {
+                    range: patch_start..patch_start,
+                    title: String::new().into(),
                     edits: Default::default(),
-                    resolution: None,
-                    resolution_task: None,
+                    status: crate::AssistantPatchStatus::Pending,
                 };
 
                 while let Some(tag) = tags.next() {
-                    step.trailing_tag_start.get_or_insert(tag.range.start);
-
-                    if tag.kind == XmlTagKind::Step && !tag.is_open_tag {
-                        // step.trailing_tag_start = Some(tag.range.start);
-                        edit_step_depth -= 1;
-                        if edit_step_depth == 0 {
-                            step.range.end = tag.range.end;
-                            step.edits = edits.into();
-                            new_steps.push(step);
+                    if tag.kind == XmlTagKind::Patch && !tag.is_open_tag {
+                        patch_tag_depth -= 1;
+                        if patch_tag_depth == 0 {
+                            patch.range.end = tag.range.end;
+
+                            // Include the line immediately after this <patch> tag if it's empty.
+                            let patch_end_offset = patch.range.end.to_offset(buffer);
+                            let mut patch_end_chars = buffer.chars_at(patch_end_offset);
+                            if patch_end_chars.next() == Some('\n')
+                                && patch_end_chars.next().map_or(true, |ch| ch == '\n')
+                            {
+                                let messages = self.messages_for_offsets(
+                                    [patch_end_offset, patch_end_offset + 1],
+                                    cx,
+                                );
+                                if messages.len() == 1 {
+                                    patch.range.end = buffer.anchor_before(patch_end_offset + 1);
+                                }
+                            }
+
+                            edits.sort_unstable_by(|a, b| {
+                                if let (Ok(a), Ok(b)) = (a, b) {
+                                    a.path.cmp(&b.path)
+                                } else {
+                                    Ordering::Equal
+                                }
+                            });
+                            patch.edits = edits.into();
+                            patch.status = AssistantPatchStatus::Ready;
+                            new_patches.push(patch);
                             continue 'tags;
                         }
                     }
 
+                    if tag.kind == XmlTagKind::Title && tag.is_open_tag {
+                        let content_start = tag.range.end;
+                        while let Some(tag) = tags.next() {
+                            if tag.kind == XmlTagKind::Title && !tag.is_open_tag {
+                                let content_end = tag.range.start;
+                                patch.title =
+                                    trimmed_text_in_range(buffer, content_start..content_end)
+                                        .into();
+                                break;
+                            }
+                        }
+                    }
+
                     if tag.kind == XmlTagKind::Edit && tag.is_open_tag {
                         let mut path = None;
-                        let mut search = None;
+                        let mut old_text = None;
+                        let mut new_text = None;
                         let mut operation = None;
                         let mut description = None;
 
                         while let Some(tag) = tags.next() {
                             if tag.kind == XmlTagKind::Edit && !tag.is_open_tag {
-                                edits.push(WorkflowStepEdit::new(
+                                edits.push(AssistantEdit::new(
                                     path,
                                     operation,
-                                    search,
+                                    old_text,
+                                    new_text,
                                     description,
                                 ));
                                 break;
@@ -1526,7 +1549,8 @@ impl Context {
                             if tag.is_open_tag
                                 && [
                                     XmlTagKind::Path,
-                                    XmlTagKind::Search,
+                                    XmlTagKind::OldText,
+                                    XmlTagKind::NewText,
                                     XmlTagKind::Operation,
                                     XmlTagKind::Description,
                                 ]
@@ -1538,15 +1562,18 @@ impl Context {
                                     if tag.kind == kind && !tag.is_open_tag {
                                         let tag = tags.next().unwrap();
                                         let content_end = tag.range.start;
-                                        let mut content = buffer
-                                            .text_for_range(content_start..content_end)
-                                            .collect::<String>();
-                                        content.truncate(content.trim_end().len());
+                                        let content = trimmed_text_in_range(
+                                            buffer,
+                                            content_start..content_end,
+                                        );
                                         match kind {
                                             XmlTagKind::Path => path = Some(content),
                                             XmlTagKind::Operation => operation = Some(content),
-                                            XmlTagKind::Search => {
-                                                search = Some(content).filter(|s| !s.is_empty())
+                                            XmlTagKind::OldText => {
+                                                old_text = Some(content).filter(|s| !s.is_empty())
+                                            }
+                                            XmlTagKind::NewText => {
+                                                new_text = Some(content).filter(|s| !s.is_empty())
                                             }
                                             XmlTagKind::Description => {
                                                 description =
@@ -1561,162 +1588,28 @@ impl Context {
                     }
                 }
 
-                pending_step = Some(step);
+                patch.edits = edits.into();
+                pending_patch = Some(patch);
             }
         }
 
-        if let Some(mut pending_step) = pending_step {
-            pending_step.range.end = text::Anchor::MAX;
-            new_steps.push(pending_step);
-        }
-
-        new_steps
-    }
-
-    pub fn resolve_workflow_step(
-        &mut self,
-        tagged_range: Range<text::Anchor>,
-        cx: &mut ModelContext<Self>,
-    ) -> Option<()> {
-        let index = self
-            .workflow_step_index_for_range(&tagged_range, self.buffer.read(cx))
-            .ok()?;
-        let step = &mut self.workflow_steps[index];
-        let project = self.project.as_ref()?;
-        step.resolution.take();
-        Self::resolve_workflow_step_internal(step, project, cx);
-        None
-    }
-
-    fn resolve_workflow_step_internal(
-        step: &mut WorkflowStep,
-        project: &Model<Project>,
-        cx: &mut ModelContext<'_, Context>,
-    ) {
-        step.resolution_task = Some(cx.spawn({
-            let range = step.range.clone();
-            let edits = step.edits.clone();
-            let project = project.clone();
-            |this, mut cx| async move {
-                let suggestion_groups =
-                    Self::compute_step_resolution(project, edits, &mut cx).await;
-
-                this.update(&mut cx, |this, cx| {
-                    let buffer = this.buffer.read(cx).text_snapshot();
-                    let ix = this.workflow_step_index_for_range(&range, &buffer).ok();
-                    if let Some(ix) = ix {
-                        let step = &mut this.workflow_steps[ix];
-
-                        let resolution = suggestion_groups.map(|suggestion_groups| {
-                            let mut title = String::new();
-                            for mut chunk in buffer.text_for_range(
-                                step.leading_tags_end
-                                    ..step.trailing_tag_start.unwrap_or(step.range.end),
-                            ) {
-                                if title.is_empty() {
-                                    chunk = chunk.trim_start();
-                                }
-                                if let Some((prefix, _)) = chunk.split_once('\n') {
-                                    title.push_str(prefix);
-                                    break;
-                                } else {
-                                    title.push_str(chunk);
-                                }
-                            }
-
-                            WorkflowStepResolution {
-                                title,
-                                suggestion_groups,
-                            }
-                        });
-
-                        step.resolution = Some(Arc::new(resolution));
-                        cx.emit(ContextEvent::WorkflowStepsUpdated {
-                            removed: vec![],
-                            updated: vec![range],
-                        })
-                    }
-                })
-                .ok();
-            }
-        }));
-    }
-
-    async fn compute_step_resolution(
-        project: Model<Project>,
-        edits: Arc<[Result<WorkflowStepEdit>]>,
-        cx: &mut AsyncAppContext,
-    ) -> Result<HashMap<Model<Buffer>, Vec<WorkflowSuggestionGroup>>> {
-        let mut suggestion_tasks = Vec::new();
-        for edit in edits.iter() {
-            let edit = edit.as_ref().map_err(|e| anyhow!("{e}"))?;
-            suggestion_tasks.push(edit.resolve(project.clone(), cx.clone()));
-        }
-
-        // Expand the context ranges of each suggestion and group suggestions with overlapping context ranges.
-        let suggestions = future::try_join_all(suggestion_tasks).await?;
-
-        let mut suggestions_by_buffer = HashMap::default();
-        for (buffer, suggestion) in suggestions {
-            suggestions_by_buffer
-                .entry(buffer)
-                .or_insert_with(Vec::new)
-                .push(suggestion);
-        }
-
-        let mut suggestion_groups_by_buffer = HashMap::default();
-        for (buffer, mut suggestions) in suggestions_by_buffer {
-            let mut suggestion_groups = Vec::<WorkflowSuggestionGroup>::new();
-            let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot())?;
-            // Sort suggestions by their range so that earlier, larger ranges come first
-            suggestions.sort_by(|a, b| a.range().cmp(&b.range(), &snapshot));
-
-            // Merge overlapping suggestions
-            suggestions.dedup_by(|a, b| b.try_merge(a, &snapshot));
-
-            // Create context ranges for each suggestion
-            for suggestion in suggestions {
-                let context_range = {
-                    let suggestion_point_range = suggestion.range().to_point(&snapshot);
-                    let start_row = suggestion_point_range.start.row.saturating_sub(5);
-                    let end_row =
-                        cmp::min(suggestion_point_range.end.row + 5, snapshot.max_point().row);
-                    let start = snapshot.anchor_before(Point::new(start_row, 0));
-                    let end =
-                        snapshot.anchor_after(Point::new(end_row, snapshot.line_len(end_row)));
-                    start..end
-                };
-
-                if let Some(last_group) = suggestion_groups.last_mut() {
-                    if last_group
-                        .context_range
-                        .end
-                        .cmp(&context_range.start, &snapshot)
-                        .is_ge()
-                    {
-                        // Merge with the previous group if context ranges overlap
-                        last_group.context_range.end = context_range.end;
-                        last_group.suggestions.push(suggestion);
-                    } else {
-                        // Create a new group
-                        suggestion_groups.push(WorkflowSuggestionGroup {
-                            context_range,
-                            suggestions: vec![suggestion],
-                        });
-                    }
+        if let Some(mut pending_patch) = pending_patch {
+            let patch_start = pending_patch.range.start.to_offset(buffer);
+            if let Some(message) = self.message_for_offset(patch_start, cx) {
+                if message.anchor_range.end == text::Anchor::MAX {
+                    pending_patch.range.end = text::Anchor::MAX;
                 } else {
-                    // Create the first group
-                    suggestion_groups.push(WorkflowSuggestionGroup {
-                        context_range,
-                        suggestions: vec![suggestion],
-                    });
+                    let message_end = buffer.anchor_after(message.offset_range.end - 1);
+                    pending_patch.range.end = message_end;
                 }
+            } else {
+                pending_patch.range.end = text::Anchor::MAX;
             }
 
-            suggestion_groups_by_buffer.insert(buffer, suggestion_groups);
+            new_patches.push(pending_patch);
         }
 
-        Ok(suggestion_groups_by_buffer)
+        new_patches
     }
 
     pub fn pending_command_for_position(
@@ -2315,11 +2208,11 @@ impl Context {
         let mut updated = Vec::new();
         let mut removed = Vec::new();
         for range in ranges {
-            self.reparse_workflow_steps_in_range(range, &buffer, &mut updated, &mut removed, cx);
+            self.reparse_patches_in_range(range, &buffer, &mut updated, &mut removed, cx);
         }
 
         if !updated.is_empty() || !removed.is_empty() {
-            cx.emit(ContextEvent::WorkflowStepsUpdated { removed, updated })
+            cx.emit(ContextEvent::PatchesUpdated { removed, updated })
         }
     }
 
@@ -2825,6 +2718,24 @@ impl Context {
     }
 }
 
+fn trimmed_text_in_range(buffer: &BufferSnapshot, range: Range<text::Anchor>) -> String {
+    let mut is_start = true;
+    let mut content = buffer
+        .text_for_range(range)
+        .map(|mut chunk| {
+            if is_start {
+                chunk = chunk.trim_start_matches('\n');
+                if !chunk.is_empty() {
+                    is_start = false;
+                }
+            }
+            chunk
+        })
+        .collect::<String>();
+    content.truncate(content.trim_end().len());
+    content
+}
+
 #[derive(Debug, Default)]
 pub struct ContextVersion {
     context: clock::Global,
diff --git a/crates/assistant/src/context/context_tests.rs b/crates/assistant/src/context/context_tests.rs
index 2d6a2894c9521a..a11cfc375d21a4 100644
--- a/crates/assistant/src/context/context_tests.rs
+++ b/crates/assistant/src/context/context_tests.rs
@@ -1,8 +1,7 @@
-use super::{MessageCacheMetadata, WorkflowStepEdit};
+use super::{AssistantEdit, MessageCacheMetadata};
 use crate::{
-    assistant_panel, prompt_library, slash_command::file_command, CacheStatus, Context,
-    ContextEvent, ContextId, ContextOperation, MessageId, MessageStatus, PromptBuilder,
-    WorkflowStepEditKind,
+    assistant_panel, prompt_library, slash_command::file_command, AssistantEditKind, CacheStatus,
+    Context, ContextEvent, ContextId, ContextOperation, MessageId, MessageStatus, PromptBuilder,
 };
 use anyhow::Result;
 use assistant_slash_command::{
@@ -15,6 +14,7 @@ use gpui::{AppContext, Model, SharedString, Task, TestAppContext, WeakView};
 use language::{Buffer, BufferSnapshot, LanguageRegistry, LspAdapterDelegate};
 use language_model::{LanguageModelCacheConfiguration, LanguageModelRegistry, Role};
 use parking_lot::Mutex;
+use pretty_assertions::assert_eq;
 use project::Project;
 use rand::prelude::*;
 use serde_json::json;
@@ -478,7 +478,15 @@ async fn test_slash_commands(cx: &mut TestAppContext) {
 #[gpui::test]
 async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
     cx.update(prompt_library::init);
-    let settings_store = cx.update(SettingsStore::test);
+    let mut settings_store = cx.update(SettingsStore::test);
+    cx.update(|cx| {
+        settings_store
+            .set_user_settings(
+                r#"{ "assistant": { "enable_experimental_live_diffs": true } }"#,
+                cx,
+            )
+            .unwrap()
+    });
     cx.set_global(settings_store);
     cx.update(language::init);
     cx.update(Project::init_settings);
@@ -520,7 +528,7 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         »",
         cx,
     );
-    expect_steps(
+    expect_patches(
         &context,
         "
 
@@ -539,17 +547,17 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         one
         two
         «
-        <step»",
+        <patch»",
         cx,
     );
-    expect_steps(
+    expect_patches(
         &context,
         "
 
         one
         two
 
-        <step",
+        <patch",
         &[],
         cx,
     );
@@ -563,36 +571,24 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         one
         two
 
-        <step«>
-        Add a second function
-
-        ```rust
-        fn two() {}
-        ```
-
+        <patch«>
         <edit>»",
         cx,
     );
-    expect_steps(
+    expect_patches(
         &context,
         "
 
         one
         two
 
-        «<step>
-        Add a second function
-
-        ```rust
-        fn two() {}
-        ```
-
+        «<patch>
         <edit>»",
         &[&[]],
         cx,
     );
 
-    // The full suggestion is added
+    // The full patch is added
     edit(
         &context,
         "
@@ -600,51 +596,46 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         one
         two
 
-        <step>
-        Add a second function
-
-        ```rust
-        fn two() {}
-        ```
-
+        <patch>
         <edit>«
+        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <search>fn one</search>
-        <description>add a `two` function</description>
+        <old_text>fn one</old_text>
+        <new_text>
+        fn two() {}
+        </new_text>
         </edit>
-        </step>
+        </patch>
 
         also,»",
         cx,
     );
-    expect_steps(
+    expect_patches(
         &context,
         "
 
         one
         two
 
-        «<step>
-        Add a second function
-
-        ```rust
-        fn two() {}
-        ```
-
+        «<patch>
         <edit>
+        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <search>fn one</search>
-        <description>add a `two` function</description>
+        <old_text>fn one</old_text>
+        <new_text>
+        fn two() {}
+        </new_text>
         </edit>
-        </step>»
-
+        </patch>
+        »
         also,",
-        &[&[WorkflowStepEdit {
+        &[&[AssistantEdit {
             path: "src/lib.rs".into(),
-            kind: WorkflowStepEditKind::InsertAfter {
-                search: "fn one".into(),
+            kind: AssistantEditKind::InsertAfter {
+                old_text: "fn one".into(),
+                new_text: "fn two() {}".into(),
                 description: "add a `two` function".into(),
             },
         }]],
@@ -659,51 +650,46 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         one
         two
 
-        <step>
-        Add a second function
-
-        ```rust
-        fn two() {}
-        ```
-
+        <patch>
         <edit>
+        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <search>«fn zero»</search>
-        <description>add a `two` function</description>
+        <old_text>«fn zero»</old_text>
+        <new_text>
+        fn two() {}
+        </new_text>
         </edit>
-        </step>
+        </patch>
 
         also,",
         cx,
     );
-    expect_steps(
+    expect_patches(
         &context,
         "
 
         one
         two
 
-        «<step>
-        Add a second function
-
-        ```rust
-        fn two() {}
-        ```
-
+        «<patch>
         <edit>
+        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <search>fn zero</search>
-        <description>add a `two` function</description>
+        <old_text>fn zero</old_text>
+        <new_text>
+        fn two() {}
+        </new_text>
         </edit>
-        </step>»
-
+        </patch>
+        »
         also,",
-        &[&[WorkflowStepEdit {
+        &[&[AssistantEdit {
             path: "src/lib.rs".into(),
-            kind: WorkflowStepEditKind::InsertAfter {
-                search: "fn zero".into(),
+            kind: AssistantEditKind::InsertAfter {
+                old_text: "fn zero".into(),
+                new_text: "fn two() {}".into(),
                 description: "add a `two` function".into(),
             },
         }]],
@@ -715,27 +701,24 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         context.cycle_message_roles(HashSet::from_iter([assistant_message_id]), cx);
         context.cycle_message_roles(HashSet::from_iter([assistant_message_id]), cx);
     });
-    expect_steps(
+    expect_patches(
         &context,
         "
 
         one
         two
 
-        <step>
-        Add a second function
-
-        ```rust
-        fn two() {}
-        ```
-
+        <patch>
         <edit>
+        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <search>fn zero</search>
-        <description>add a `two` function</description>
+        <old_text>fn zero</old_text>
+        <new_text>
+        fn two() {}
+        </new_text>
         </edit>
-        </step>
+        </patch>
 
         also,",
         &[],
@@ -746,33 +729,31 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
     context.update(cx, |context, cx| {
         context.cycle_message_roles(HashSet::from_iter([assistant_message_id]), cx);
     });
-    expect_steps(
+    expect_patches(
         &context,
         "
 
         one
         two
 
-        «<step>
-        Add a second function
-
-        ```rust
-        fn two() {}
-        ```
-
+        «<patch>
         <edit>
+        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <search>fn zero</search>
-        <description>add a `two` function</description>
+        <old_text>fn zero</old_text>
+        <new_text>
+        fn two() {}
+        </new_text>
         </edit>
-        </step>»
-
+        </patch>
+        »
         also,",
-        &[&[WorkflowStepEdit {
+        &[&[AssistantEdit {
             path: "src/lib.rs".into(),
-            kind: WorkflowStepEditKind::InsertAfter {
-                search: "fn zero".into(),
+            kind: AssistantEditKind::InsertAfter {
+                old_text: "fn zero".into(),
+                new_text: "fn two() {}".into(),
                 description: "add a `two` function".into(),
             },
         }]],
@@ -792,33 +773,31 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
             cx,
         )
     });
-    expect_steps(
+    expect_patches(
         &deserialized_context,
         "
 
         one
         two
 
-        «<step>
-        Add a second function
-
-        ```rust
-        fn two() {}
-        ```
-
+        «<patch>
         <edit>
+        <description>add a `two` function</description>
         <path>src/lib.rs</path>
         <operation>insert_after</operation>
-        <search>fn zero</search>
-        <description>add a `two` function</description>
+        <old_text>fn zero</old_text>
+        <new_text>
+        fn two() {}
+        </new_text>
         </edit>
-        </step>»
-
+        </patch>
+        »
         also,",
-        &[&[WorkflowStepEdit {
+        &[&[AssistantEdit {
             path: "src/lib.rs".into(),
-            kind: WorkflowStepEditKind::InsertAfter {
-                search: "fn zero".into(),
+            kind: AssistantEditKind::InsertAfter {
+                old_text: "fn zero".into(),
+                new_text: "fn two() {}".into(),
                 description: "add a `two` function".into(),
             },
         }]],
@@ -834,48 +813,58 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
         cx.executor().run_until_parked();
     }
 
-    fn expect_steps(
+    #[track_caller]
+    fn expect_patches(
         context: &Model<Context>,
         expected_marked_text: &str,
-        expected_suggestions: &[&[WorkflowStepEdit]],
+        expected_suggestions: &[&[AssistantEdit]],
         cx: &mut TestAppContext,
     ) {
-        context.update(cx, |context, cx| {
-            let expected_marked_text = expected_marked_text.unindent();
-            let (expected_text, expected_ranges) = marked_text_ranges(&expected_marked_text, false);
+        let expected_marked_text = expected_marked_text.unindent();
+        let (expected_text, _) = marked_text_ranges(&expected_marked_text, false);
+
+        let (buffer_text, ranges, patches) = context.update(cx, |context, cx| {
             context.buffer.read_with(cx, |buffer, _| {
-                assert_eq!(buffer.text(), expected_text);
                 let ranges = context
-                    .workflow_steps
+                    .patches
                     .iter()
                     .map(|entry| entry.range.to_offset(buffer))
                     .collect::<Vec<_>>();
-                let marked = generate_marked_text(&expected_text, &ranges, false);
-                assert_eq!(
-                    marked,
-                    expected_marked_text,
-                    "unexpected suggestion ranges. actual: {ranges:?}, expected: {expected_ranges:?}"
-                );
-                let suggestions = context
-                    .workflow_steps
-                    .iter()
-                    .map(|step| {
-                        step.edits
-                            .iter()
-                            .map(|edit| {
-                                let edit = edit.as_ref().unwrap();
-                                WorkflowStepEdit {
-                                    path: edit.path.clone(),
-                                    kind: edit.kind.clone(),
-                                }
-                            })
-                            .collect::<Vec<_>>()
-                    })
-                    .collect::<Vec<_>>();
-
-                assert_eq!(suggestions, expected_suggestions);
-            });
+                (
+                    buffer.text(),
+                    ranges,
+                    context
+                        .patches
+                        .iter()
+                        .map(|step| step.edits.clone())
+                        .collect::<Vec<_>>(),
+                )
+            })
         });
+
+        assert_eq!(buffer_text, expected_text);
+
+        let actual_marked_text = generate_marked_text(&expected_text, &ranges, false);
+        assert_eq!(actual_marked_text, expected_marked_text);
+
+        assert_eq!(
+            patches
+                .iter()
+                .map(|patch| {
+                    patch
+                        .iter()
+                        .map(|edit| {
+                            let edit = edit.as_ref().unwrap();
+                            AssistantEdit {
+                                path: edit.path.clone(),
+                                kind: edit.kind.clone(),
+                            }
+                        })
+                        .collect::<Vec<_>>()
+                })
+                .collect::<Vec<_>>(),
+            expected_suggestions
+        );
     }
 }
 
diff --git a/crates/assistant/src/inline_assistant.rs b/crates/assistant/src/inline_assistant.rs
index ce01e63b513db0..a11d4113d87a91 100644
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -82,13 +82,6 @@ pub struct InlineAssistant {
     assists: HashMap<InlineAssistId, InlineAssist>,
     assists_by_editor: HashMap<WeakView<Editor>, EditorInlineAssists>,
     assist_groups: HashMap<InlineAssistGroupId, InlineAssistGroup>,
-    assist_observations: HashMap<
-        InlineAssistId,
-        (
-            async_watch::Sender<AssistStatus>,
-            async_watch::Receiver<AssistStatus>,
-        ),
-    >,
     confirmed_assists: HashMap<InlineAssistId, Model<CodegenAlternative>>,
     prompt_history: VecDeque<String>,
     prompt_builder: Arc<PromptBuilder>,
@@ -96,19 +89,6 @@ pub struct InlineAssistant {
     fs: Arc<dyn Fs>,
 }
 
-pub enum AssistStatus {
-    Idle,
-    Started,
-    Stopped,
-    Finished,
-}
-
-impl AssistStatus {
-    pub fn is_done(&self) -> bool {
-        matches!(self, Self::Stopped | Self::Finished)
-    }
-}
-
 impl Global for InlineAssistant {}
 
 impl InlineAssistant {
@@ -123,7 +103,6 @@ impl InlineAssistant {
             assists: HashMap::default(),
             assists_by_editor: HashMap::default(),
             assist_groups: HashMap::default(),
-            assist_observations: HashMap::default(),
             confirmed_assists: HashMap::default(),
             prompt_history: VecDeque::default(),
             prompt_builder,
@@ -835,17 +814,6 @@ impl InlineAssistant {
                     .insert(assist_id, confirmed_alternative);
             }
         }
-
-        // Remove the assist from the status updates map
-        self.assist_observations.remove(&assist_id);
-    }
-
-    pub fn undo_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) -> bool {
-        let Some(codegen) = self.confirmed_assists.remove(&assist_id) else {
-            return false;
-        };
-        codegen.update(cx, |this, cx| this.undo(cx));
-        true
     }
 
     fn dismiss_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) -> bool {
@@ -1039,10 +1007,6 @@ impl InlineAssistant {
                 codegen.start(user_prompt, assistant_panel_context, cx)
             })
             .log_err();
-
-        if let Some((tx, _)) = self.assist_observations.get(&assist_id) {
-            tx.send(AssistStatus::Started).ok();
-        }
     }
 
     pub fn stop_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) {
@@ -1053,25 +1017,6 @@ impl InlineAssistant {
         };
 
         assist.codegen.update(cx, |codegen, cx| codegen.stop(cx));
-
-        if let Some((tx, _)) = self.assist_observations.get(&assist_id) {
-            tx.send(AssistStatus::Stopped).ok();
-        }
-    }
-
-    pub fn assist_status(&self, assist_id: InlineAssistId, cx: &AppContext) -> InlineAssistStatus {
-        if let Some(assist) = self.assists.get(&assist_id) {
-            match assist.codegen.read(cx).status(cx) {
-                CodegenStatus::Idle => InlineAssistStatus::Idle,
-                CodegenStatus::Pending => InlineAssistStatus::Pending,
-                CodegenStatus::Done => InlineAssistStatus::Done,
-                CodegenStatus::Error(_) => InlineAssistStatus::Error,
-            }
-        } else if self.confirmed_assists.contains_key(&assist_id) {
-            InlineAssistStatus::Confirmed
-        } else {
-            InlineAssistStatus::Canceled
-        }
     }
 
     fn update_editor_highlights(&self, editor: &View<Editor>, cx: &mut WindowContext) {
@@ -1257,42 +1202,6 @@ impl InlineAssistant {
                 .collect();
         })
     }
-
-    pub fn observe_assist(
-        &mut self,
-        assist_id: InlineAssistId,
-    ) -> async_watch::Receiver<AssistStatus> {
-        if let Some((_, rx)) = self.assist_observations.get(&assist_id) {
-            rx.clone()
-        } else {
-            let (tx, rx) = async_watch::channel(AssistStatus::Idle);
-            self.assist_observations.insert(assist_id, (tx, rx.clone()));
-            rx
-        }
-    }
-}
-
-pub enum InlineAssistStatus {
-    Idle,
-    Pending,
-    Done,
-    Error,
-    Confirmed,
-    Canceled,
-}
-
-impl InlineAssistStatus {
-    pub(crate) fn is_pending(&self) -> bool {
-        matches!(self, Self::Pending)
-    }
-
-    pub(crate) fn is_confirmed(&self) -> bool {
-        matches!(self, Self::Confirmed)
-    }
-
-    pub(crate) fn is_done(&self) -> bool {
-        matches!(self, Self::Done)
-    }
 }
 
 struct EditorInlineAssists {
@@ -2290,8 +2199,6 @@ impl InlineAssist {
 
                             if assist.decorations.is_none() {
                                 this.finish_assist(assist_id, false, cx);
-                            } else if let Some(tx) = this.assist_observations.get(&assist_id) {
-                                tx.0.send(AssistStatus::Finished).ok();
                             }
                         }
                     })
diff --git a/crates/assistant/src/patch.rs b/crates/assistant/src/patch.rs
new file mode 100644
index 00000000000000..82c81d3b865505
--- /dev/null
+++ b/crates/assistant/src/patch.rs
@@ -0,0 +1,746 @@
+use anyhow::{anyhow, Context as _, Result};
+use collections::HashMap;
+use editor::ProposedChangesEditor;
+use futures::{future, TryFutureExt as _};
+use gpui::{AppContext, AsyncAppContext, Model, SharedString};
+use language::{AutoindentMode, Buffer, BufferSnapshot};
+use project::{Project, ProjectPath};
+use std::{cmp, ops::Range, path::Path, sync::Arc};
+use text::{AnchorRangeExt as _, Bias, OffsetRangeExt as _, Point};
+
+#[derive(Clone, Debug)]
+pub(crate) struct AssistantPatch {
+    pub range: Range<language::Anchor>,
+    pub title: SharedString,
+    pub edits: Arc<[Result<AssistantEdit>]>,
+    pub status: AssistantPatchStatus,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum AssistantPatchStatus {
+    Pending,
+    Ready,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct AssistantEdit {
+    pub path: String,
+    pub kind: AssistantEditKind,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum AssistantEditKind {
+    Update {
+        old_text: String,
+        new_text: String,
+        description: String,
+    },
+    Create {
+        new_text: String,
+        description: String,
+    },
+    InsertBefore {
+        old_text: String,
+        new_text: String,
+        description: String,
+    },
+    InsertAfter {
+        old_text: String,
+        new_text: String,
+        description: String,
+    },
+    Delete {
+        old_text: String,
+    },
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct ResolvedPatch {
+    pub edit_groups: HashMap<Model<Buffer>, Vec<ResolvedEditGroup>>,
+    pub errors: Vec<AssistantPatchResolutionError>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ResolvedEditGroup {
+    pub context_range: Range<language::Anchor>,
+    pub edits: Vec<ResolvedEdit>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ResolvedEdit {
+    range: Range<language::Anchor>,
+    new_text: String,
+    description: Option<String>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct AssistantPatchResolutionError {
+    pub edit_ix: usize,
+    pub message: String,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+enum SearchDirection {
+    Up,
+    Left,
+    Diagonal,
+}
+
+// A measure of the currently quality of an in-progress fuzzy search.
+//
+// Uses 60 bits to store a numeric cost, and 4 bits to store the preceding
+// operation in the search.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+struct SearchState {
+    score: u32,
+    direction: SearchDirection,
+}
+
+impl SearchState {
+    fn new(score: u32, direction: SearchDirection) -> Self {
+        Self { score, direction }
+    }
+}
+
+impl ResolvedPatch {
+    pub fn apply(&self, editor: &ProposedChangesEditor, cx: &mut AppContext) {
+        for (buffer, groups) in &self.edit_groups {
+            let branch = editor.branch_buffer_for_base(buffer).unwrap();
+            Self::apply_edit_groups(groups, &branch, cx);
+        }
+        editor.recalculate_all_buffer_diffs();
+    }
+
+    fn apply_edit_groups(
+        groups: &Vec<ResolvedEditGroup>,
+        buffer: &Model<Buffer>,
+        cx: &mut AppContext,
+    ) {
+        let mut edits = Vec::new();
+        for group in groups {
+            for suggestion in &group.edits {
+                edits.push((suggestion.range.clone(), suggestion.new_text.clone()));
+            }
+        }
+        buffer.update(cx, |buffer, cx| {
+            buffer.edit(
+                edits,
+                Some(AutoindentMode::Block {
+                    original_indent_columns: Vec::new(),
+                }),
+                cx,
+            );
+        });
+    }
+}
+
+impl ResolvedEdit {
+    pub fn try_merge(&mut self, other: &Self, buffer: &text::BufferSnapshot) -> bool {
+        let range = &self.range;
+        let other_range = &other.range;
+
+        // Don't merge if we don't contain the other suggestion.
+        if range.start.cmp(&other_range.start, buffer).is_gt()
+            || range.end.cmp(&other_range.end, buffer).is_lt()
+        {
+            return false;
+        }
+
+        if let Some(description) = &mut self.description {
+            if let Some(other_description) = &other.description {
+                description.push('\n');
+                description.push_str(other_description);
+            }
+        }
+        true
+    }
+}
+
+impl AssistantEdit {
+    pub fn new(
+        path: Option<String>,
+        operation: Option<String>,
+        old_text: Option<String>,
+        new_text: Option<String>,
+        description: Option<String>,
+    ) -> Result<Self> {
+        let path = path.ok_or_else(|| anyhow!("missing path"))?;
+        let operation = operation.ok_or_else(|| anyhow!("missing operation"))?;
+
+        let kind = match operation.as_str() {
+            "update" => AssistantEditKind::Update {
+                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
+                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
+            },
+            "insert_before" => AssistantEditKind::InsertBefore {
+                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
+                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
+            },
+            "insert_after" => AssistantEditKind::InsertAfter {
+                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
+                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
+            },
+            "delete" => AssistantEditKind::Delete {
+                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
+            },
+            "create" => AssistantEditKind::Create {
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
+                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
+            },
+            _ => Err(anyhow!("unknown operation {operation:?}"))?,
+        };
+
+        Ok(Self { path, kind })
+    }
+
+    pub async fn resolve(
+        &self,
+        project: Model<Project>,
+        mut cx: AsyncAppContext,
+    ) -> Result<(Model<Buffer>, ResolvedEdit)> {
+        let path = self.path.clone();
+        let kind = self.kind.clone();
+        let buffer = project
+            .update(&mut cx, |project, cx| {
+                let project_path = project
+                    .find_project_path(Path::new(&path), cx)
+                    .or_else(|| {
+                        // If we couldn't find a project path for it, put it in the active worktree
+                        // so that when we create the buffer, it can be saved.
+                        let worktree = project
+                            .active_entry()
+                            .and_then(|entry_id| project.worktree_for_entry(entry_id, cx))
+                            .or_else(|| project.worktrees(cx).next())?;
+                        let worktree = worktree.read(cx);
+
+                        Some(ProjectPath {
+                            worktree_id: worktree.id(),
+                            path: Arc::from(Path::new(&path)),
+                        })
+                    })
+                    .with_context(|| format!("worktree not found for {:?}", path))?;
+                anyhow::Ok(project.open_buffer(project_path, cx))
+            })??
+            .await?;
+
+        let snapshot = buffer.update(&mut cx, |buffer, _| buffer.snapshot())?;
+        let suggestion = cx
+            .background_executor()
+            .spawn(async move { kind.resolve(&snapshot) })
+            .await;
+
+        Ok((buffer, suggestion))
+    }
+}
+
+impl AssistantEditKind {
+    fn resolve(self, snapshot: &BufferSnapshot) -> ResolvedEdit {
+        match self {
+            Self::Update {
+                old_text,
+                new_text,
+                description,
+            } => {
+                let range = Self::resolve_location(&snapshot, &old_text);
+                ResolvedEdit {
+                    range,
+                    new_text,
+                    description: Some(description),
+                }
+            }
+            Self::Create {
+                new_text,
+                description,
+            } => ResolvedEdit {
+                range: text::Anchor::MIN..text::Anchor::MAX,
+                description: Some(description),
+                new_text,
+            },
+            Self::InsertBefore {
+                old_text,
+                mut new_text,
+                description,
+            } => {
+                let range = Self::resolve_location(&snapshot, &old_text);
+                new_text.push('\n');
+                ResolvedEdit {
+                    range: range.start..range.start,
+                    new_text,
+                    description: Some(description),
+                }
+            }
+            Self::InsertAfter {
+                old_text,
+                mut new_text,
+                description,
+            } => {
+                let range = Self::resolve_location(&snapshot, &old_text);
+                new_text.insert(0, '\n');
+                ResolvedEdit {
+                    range: range.end..range.end,
+                    new_text,
+                    description: Some(description),
+                }
+            }
+            Self::Delete { old_text } => {
+                let range = Self::resolve_location(&snapshot, &old_text);
+                ResolvedEdit {
+                    range,
+                    new_text: String::new(),
+                    description: None,
+                }
+            }
+        }
+    }
+
+    fn resolve_location(buffer: &text::BufferSnapshot, search_query: &str) -> Range<text::Anchor> {
+        const INSERTION_COST: u32 = 3;
+        const WHITESPACE_INSERTION_COST: u32 = 1;
+        const DELETION_COST: u32 = 3;
+        const WHITESPACE_DELETION_COST: u32 = 1;
+        const EQUALITY_BONUS: u32 = 5;
+
+        struct Matrix {
+            cols: usize,
+            data: Vec<SearchState>,
+        }
+
+        impl Matrix {
+            fn new(rows: usize, cols: usize) -> Self {
+                Matrix {
+                    cols,
+                    data: vec![SearchState::new(0, SearchDirection::Diagonal); rows * cols],
+                }
+            }
+
+            fn get(&self, row: usize, col: usize) -> SearchState {
+                self.data[row * self.cols + col]
+            }
+
+            fn set(&mut self, row: usize, col: usize, cost: SearchState) {
+                self.data[row * self.cols + col] = cost;
+            }
+        }
+
+        let buffer_len = buffer.len();
+        let query_len = search_query.len();
+        let mut matrix = Matrix::new(query_len + 1, buffer_len + 1);
+
+        for (row, query_byte) in search_query.bytes().enumerate() {
+            for (col, buffer_byte) in buffer.bytes_in_range(0..buffer.len()).flatten().enumerate() {
+                let deletion_cost = if query_byte.is_ascii_whitespace() {
+                    WHITESPACE_DELETION_COST
+                } else {
+                    DELETION_COST
+                };
+                let insertion_cost = if buffer_byte.is_ascii_whitespace() {
+                    WHITESPACE_INSERTION_COST
+                } else {
+                    INSERTION_COST
+                };
+
+                let up = SearchState::new(
+                    matrix.get(row, col + 1).score.saturating_sub(deletion_cost),
+                    SearchDirection::Up,
+                );
+                let left = SearchState::new(
+                    matrix
+                        .get(row + 1, col)
+                        .score
+                        .saturating_sub(insertion_cost),
+                    SearchDirection::Left,
+                );
+                let diagonal = SearchState::new(
+                    if query_byte == *buffer_byte {
+                        matrix.get(row, col).score.saturating_add(EQUALITY_BONUS)
+                    } else {
+                        matrix
+                            .get(row, col)
+                            .score
+                            .saturating_sub(deletion_cost + insertion_cost)
+                    },
+                    SearchDirection::Diagonal,
+                );
+                matrix.set(row + 1, col + 1, up.max(left).max(diagonal));
+            }
+        }
+
+        // Traceback to find the best match
+        let mut best_buffer_end = buffer_len;
+        let mut best_score = 0;
+        for col in 1..=buffer_len {
+            let score = matrix.get(query_len, col).score;
+            if score > best_score {
+                best_score = score;
+                best_buffer_end = col;
+            }
+        }
+
+        let mut query_ix = query_len;
+        let mut buffer_ix = best_buffer_end;
+        while query_ix > 0 && buffer_ix > 0 {
+            let current = matrix.get(query_ix, buffer_ix);
+            match current.direction {
+                SearchDirection::Diagonal => {
+                    query_ix -= 1;
+                    buffer_ix -= 1;
+                }
+                SearchDirection::Up => {
+                    query_ix -= 1;
+                }
+                SearchDirection::Left => {
+                    buffer_ix -= 1;
+                }
+            }
+        }
+
+        let mut start = buffer.offset_to_point(buffer.clip_offset(buffer_ix, Bias::Left));
+        start.column = 0;
+        let mut end = buffer.offset_to_point(buffer.clip_offset(best_buffer_end, Bias::Right));
+        if end.column > 0 {
+            end.column = buffer.line_len(end.row);
+        }
+
+        buffer.anchor_after(start)..buffer.anchor_before(end)
+    }
+}
+
+impl AssistantPatch {
+    pub(crate) async fn resolve(
+        &self,
+        project: Model<Project>,
+        cx: &mut AsyncAppContext,
+    ) -> ResolvedPatch {
+        let mut resolve_tasks = Vec::new();
+        for (ix, edit) in self.edits.iter().enumerate() {
+            if let Ok(edit) = edit.as_ref() {
+                resolve_tasks.push(
+                    edit.resolve(project.clone(), cx.clone())
+                        .map_err(move |error| (ix, error)),
+                );
+            }
+        }
+
+        let edits = future::join_all(resolve_tasks).await;
+        let mut errors = Vec::new();
+        let mut edits_by_buffer = HashMap::default();
+        for entry in edits {
+            match entry {
+                Ok((buffer, edit)) => {
+                    edits_by_buffer
+                        .entry(buffer)
+                        .or_insert_with(Vec::new)
+                        .push(edit);
+                }
+                Err((edit_ix, error)) => errors.push(AssistantPatchResolutionError {
+                    edit_ix,
+                    message: error.to_string(),
+                }),
+            }
+        }
+
+        // Expand the context ranges of each edit and group edits with overlapping context ranges.
+        let mut edit_groups_by_buffer = HashMap::default();
+        for (buffer, edits) in edits_by_buffer {
+            if let Ok(snapshot) = buffer.update(cx, |buffer, _| buffer.text_snapshot()) {
+                edit_groups_by_buffer.insert(buffer, Self::group_edits(edits, &snapshot));
+            }
+        }
+
+        ResolvedPatch {
+            edit_groups: edit_groups_by_buffer,
+            errors,
+        }
+    }
+
+    fn group_edits(
+        mut edits: Vec<ResolvedEdit>,
+        snapshot: &text::BufferSnapshot,
+    ) -> Vec<ResolvedEditGroup> {
+        let mut edit_groups = Vec::<ResolvedEditGroup>::new();
+        // Sort edits by their range so that earlier, larger ranges come first
+        edits.sort_by(|a, b| a.range.cmp(&b.range, &snapshot));
+
+        // Merge overlapping edits
+        edits.dedup_by(|a, b| b.try_merge(a, &snapshot));
+
+        // Create context ranges for each edit
+        for edit in edits {
+            let context_range = {
+                let edit_point_range = edit.range.to_point(&snapshot);
+                let start_row = edit_point_range.start.row.saturating_sub(5);
+                let end_row = cmp::min(edit_point_range.end.row + 5, snapshot.max_point().row);
+                let start = snapshot.anchor_before(Point::new(start_row, 0));
+                let end = snapshot.anchor_after(Point::new(end_row, snapshot.line_len(end_row)));
+                start..end
+            };
+
+            if let Some(last_group) = edit_groups.last_mut() {
+                if last_group
+                    .context_range
+                    .end
+                    .cmp(&context_range.start, &snapshot)
+                    .is_ge()
+                {
+                    // Merge with the previous group if context ranges overlap
+                    last_group.context_range.end = context_range.end;
+                    last_group.edits.push(edit);
+                } else {
+                    // Create a new group
+                    edit_groups.push(ResolvedEditGroup {
+                        context_range,
+                        edits: vec![edit],
+                    });
+                }
+            } else {
+                // Create the first group
+                edit_groups.push(ResolvedEditGroup {
+                    context_range,
+                    edits: vec![edit],
+                });
+            }
+        }
+
+        edit_groups
+    }
+
+    pub fn path_count(&self) -> usize {
+        self.paths().count()
+    }
+
+    pub fn paths(&self) -> impl '_ + Iterator<Item = &str> {
+        let mut prev_path = None;
+        self.edits.iter().filter_map(move |edit| {
+            if let Ok(edit) = edit {
+                let path = Some(edit.path.as_str());
+                if path != prev_path {
+                    prev_path = path;
+                    return path;
+                }
+            }
+            None
+        })
+    }
+}
+
+impl PartialEq for AssistantPatch {
+    fn eq(&self, other: &Self) -> bool {
+        self.range == other.range
+            && self.title == other.title
+            && Arc::ptr_eq(&self.edits, &other.edits)
+    }
+}
+
+impl Eq for AssistantPatch {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gpui::{AppContext, Context};
+    use language::{
+        language_settings::AllLanguageSettings, Language, LanguageConfig, LanguageMatcher,
+    };
+    use settings::SettingsStore;
+    use text::{OffsetRangeExt, Point};
+    use ui::BorrowAppContext;
+    use unindent::Unindent as _;
+
+    #[gpui::test]
+    fn test_resolve_location(cx: &mut AppContext) {
+        {
+            let buffer = cx.new_model(|cx| {
+                Buffer::local(
+                    concat!(
+                        "    Lorem\n",
+                        "    ipsum\n",
+                        "    dolor sit amet\n",
+                        "    consecteur",
+                    ),
+                    cx,
+                )
+            });
+            let snapshot = buffer.read(cx).snapshot();
+            assert_eq!(
+                AssistantEditKind::resolve_location(&snapshot, "ipsum\ndolor").to_point(&snapshot),
+                Point::new(1, 0)..Point::new(2, 18)
+            );
+        }
+
+        {
+            let buffer = cx.new_model(|cx| {
+                Buffer::local(
+                    concat!(
+                        "fn foo1(a: usize) -> usize {\n",
+                        "    40\n",
+                        "}\n",
+                        "\n",
+                        "fn foo2(b: usize) -> usize {\n",
+                        "    42\n",
+                        "}\n",
+                    ),
+                    cx,
+                )
+            });
+            let snapshot = buffer.read(cx).snapshot();
+            assert_eq!(
+                AssistantEditKind::resolve_location(&snapshot, "fn foo1(b: usize) {\n40\n}")
+                    .to_point(&snapshot),
+                Point::new(0, 0)..Point::new(2, 1)
+            );
+        }
+
+        {
+            let buffer = cx.new_model(|cx| {
+                Buffer::local(
+                    concat!(
+                        "fn main() {\n",
+                        "    Foo\n",
+                        "        .bar()\n",
+                        "        .baz()\n",
+                        "        .qux()\n",
+                        "}\n",
+                        "\n",
+                        "fn foo2(b: usize) -> usize {\n",
+                        "    42\n",
+                        "}\n",
+                    ),
+                    cx,
+                )
+            });
+            let snapshot = buffer.read(cx).snapshot();
+            assert_eq!(
+                AssistantEditKind::resolve_location(&snapshot, "Foo.bar.baz.qux()")
+                    .to_point(&snapshot),
+                Point::new(1, 0)..Point::new(4, 14)
+            );
+        }
+    }
+
+    #[gpui::test]
+    fn test_resolve_edits(cx: &mut AppContext) {
+        let settings_store = SettingsStore::test(cx);
+        cx.set_global(settings_store);
+        language::init(cx);
+        cx.update_global::<SettingsStore, _>(|settings, cx| {
+            settings.update_user_settings::<AllLanguageSettings>(cx, |_| {});
+        });
+
+        assert_edits(
+            "
+                /// A person
+                struct Person {
+                    name: String,
+                    age: usize,
+                }
+
+                /// A dog
+                struct Dog {
+                    weight: f32,
+                }
+
+                impl Person {
+                    fn name(&self) -> &str {
+                        &self.name
+                    }
+                }
+            "
+            .unindent(),
+            vec![
+                AssistantEditKind::Update {
+                    old_text: "
+                        name: String,
+                    "
+                    .unindent(),
+                    new_text: "
+                        first_name: String,
+                        last_name: String,
+                    "
+                    .unindent(),
+                    description: "".into(),
+                },
+                AssistantEditKind::Update {
+                    old_text: "
+                        fn name(&self) -> &str {
+                            &self.name
+                        }
+                    "
+                    .unindent(),
+                    new_text: "
+                        fn name(&self) -> String {
+                            format!(\"{} {}\", self.first_name, self.last_name)
+                        }
+                    "
+                    .unindent(),
+                    description: "".into(),
+                },
+            ],
+            "
+                /// A person
+                struct Person {
+                    first_name: String,
+                    last_name: String,
+                    age: usize,
+                }
+
+                /// A dog
+                struct Dog {
+                    weight: f32,
+                }
+
+                impl Person {
+                    fn name(&self) -> String {
+                        format!(\"{} {}\", self.first_name, self.last_name)
+                    }
+                }
+            "
+            .unindent(),
+            cx,
+        );
+    }
+
+    #[track_caller]
+    fn assert_edits(
+        old_text: String,
+        edits: Vec<AssistantEditKind>,
+        new_text: String,
+        cx: &mut AppContext,
+    ) {
+        let buffer =
+            cx.new_model(|cx| Buffer::local(old_text, cx).with_language(Arc::new(rust_lang()), cx));
+        let snapshot = buffer.read(cx).snapshot();
+        let resolved_edits = edits
+            .into_iter()
+            .map(|kind| kind.resolve(&snapshot))
+            .collect();
+        let edit_groups = AssistantPatch::group_edits(resolved_edits, &snapshot);
+        ResolvedPatch::apply_edit_groups(&edit_groups, &buffer, cx);
+        let actual_new_text = buffer.read(cx).text();
+        pretty_assertions::assert_eq!(actual_new_text, new_text);
+    }
+
+    fn rust_lang() -> Language {
+        Language::new(
+            LanguageConfig {
+                name: "Rust".into(),
+                matcher: LanguageMatcher {
+                    path_suffixes: vec!["rs".to_string()],
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            Some(language::tree_sitter_rust::LANGUAGE.into()),
+        )
+        .with_indents_query(
+            r#"
+            (call_expression) @indent
+            (field_expression) @indent
+            (_ "(" ")" @end) @indent
+            (_ "{" "}" @end) @indent
+            "#,
+        )
+        .unwrap()
+    }
+}
diff --git a/crates/assistant/src/prompts.rs b/crates/assistant/src/prompts.rs
index 106935cb882695..132b3df68f4bc6 100644
--- a/crates/assistant/src/prompts.rs
+++ b/crates/assistant/src/prompts.rs
@@ -45,15 +45,6 @@ pub struct ProjectSlashCommandPromptContext {
     pub context_buffer: String,
 }
 
-/// Context required to generate a workflow step resolution prompt.
-#[derive(Debug, Serialize)]
-pub struct StepResolutionContext {
-    /// The full context, including <step>...</step> tags
-    pub workflow_context: String,
-    /// The text of the specific step from the context to resolve
-    pub step_to_resolve: String,
-}
-
 pub struct PromptLoadingParams<'a> {
     pub fs: Arc<dyn Fs>,
     pub repo_path: Option<PathBuf>,
diff --git a/crates/assistant/src/slash_command/workflow_command.rs b/crates/assistant/src/slash_command/workflow_command.rs
index 071b4feaf436e3..50c0e6cbc60e60 100644
--- a/crates/assistant/src/slash_command/workflow_command.rs
+++ b/crates/assistant/src/slash_command/workflow_command.rs
@@ -18,6 +18,8 @@ pub(crate) struct WorkflowSlashCommand {
 }
 
 impl WorkflowSlashCommand {
+    pub const NAME: &'static str = "workflow";
+
     pub fn new(prompt_builder: Arc<PromptBuilder>) -> Self {
         Self { prompt_builder }
     }
@@ -25,7 +27,7 @@ impl WorkflowSlashCommand {
 
 impl SlashCommand for WorkflowSlashCommand {
     fn name(&self) -> String {
-        "workflow".into()
+        Self::NAME.into()
     }
 
     fn description(&self) -> String {
diff --git a/crates/assistant/src/workflow.rs b/crates/assistant/src/workflow.rs
deleted file mode 100644
index 8a770e21aa7caa..00000000000000
--- a/crates/assistant/src/workflow.rs
+++ /dev/null
@@ -1,507 +0,0 @@
-use crate::{AssistantPanel, InlineAssistId, InlineAssistant};
-use anyhow::{anyhow, Context as _, Result};
-use collections::HashMap;
-use editor::Editor;
-use gpui::AsyncAppContext;
-use gpui::{Model, Task, UpdateGlobal as _, View, WeakView, WindowContext};
-use language::{Buffer, BufferSnapshot};
-use project::{Project, ProjectPath};
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use std::{ops::Range, path::Path, sync::Arc};
-use text::Bias;
-use workspace::Workspace;
-
-#[derive(Debug)]
-pub(crate) struct WorkflowStep {
-    pub range: Range<language::Anchor>,
-    pub leading_tags_end: text::Anchor,
-    pub trailing_tag_start: Option<text::Anchor>,
-    pub edits: Arc<[Result<WorkflowStepEdit>]>,
-    pub resolution_task: Option<Task<()>>,
-    pub resolution: Option<Arc<Result<WorkflowStepResolution>>>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct WorkflowStepEdit {
-    pub path: String,
-    pub kind: WorkflowStepEditKind,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub(crate) struct WorkflowStepResolution {
-    pub title: String,
-    pub suggestion_groups: HashMap<Model<Buffer>, Vec<WorkflowSuggestionGroup>>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct WorkflowSuggestionGroup {
-    pub context_range: Range<language::Anchor>,
-    pub suggestions: Vec<WorkflowSuggestion>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum WorkflowSuggestion {
-    Update {
-        range: Range<language::Anchor>,
-        description: String,
-    },
-    CreateFile {
-        description: String,
-    },
-    InsertBefore {
-        position: language::Anchor,
-        description: String,
-    },
-    InsertAfter {
-        position: language::Anchor,
-        description: String,
-    },
-    Delete {
-        range: Range<language::Anchor>,
-    },
-}
-
-impl WorkflowSuggestion {
-    pub fn range(&self) -> Range<language::Anchor> {
-        match self {
-            Self::Update { range, .. } => range.clone(),
-            Self::CreateFile { .. } => language::Anchor::MIN..language::Anchor::MAX,
-            Self::InsertBefore { position, .. } | Self::InsertAfter { position, .. } => {
-                *position..*position
-            }
-            Self::Delete { range, .. } => range.clone(),
-        }
-    }
-
-    pub fn description(&self) -> Option<&str> {
-        match self {
-            Self::Update { description, .. }
-            | Self::CreateFile { description }
-            | Self::InsertBefore { description, .. }
-            | Self::InsertAfter { description, .. } => Some(description),
-            Self::Delete { .. } => None,
-        }
-    }
-
-    fn description_mut(&mut self) -> Option<&mut String> {
-        match self {
-            Self::Update { description, .. }
-            | Self::CreateFile { description }
-            | Self::InsertBefore { description, .. }
-            | Self::InsertAfter { description, .. } => Some(description),
-            Self::Delete { .. } => None,
-        }
-    }
-
-    pub fn try_merge(&mut self, other: &Self, buffer: &BufferSnapshot) -> bool {
-        let range = self.range();
-        let other_range = other.range();
-
-        // Don't merge if we don't contain the other suggestion.
-        if range.start.cmp(&other_range.start, buffer).is_gt()
-            || range.end.cmp(&other_range.end, buffer).is_lt()
-        {
-            return false;
-        }
-
-        if let Some(description) = self.description_mut() {
-            if let Some(other_description) = other.description() {
-                description.push('\n');
-                description.push_str(other_description);
-            }
-        }
-        true
-    }
-
-    pub fn show(
-        &self,
-        editor: &View<Editor>,
-        excerpt_id: editor::ExcerptId,
-        workspace: &WeakView<Workspace>,
-        assistant_panel: &View<AssistantPanel>,
-        cx: &mut WindowContext,
-    ) -> Option<InlineAssistId> {
-        let mut initial_transaction_id = None;
-        let initial_prompt;
-        let suggestion_range;
-        let buffer = editor.read(cx).buffer().clone();
-        let snapshot = buffer.read(cx).snapshot(cx);
-
-        match self {
-            Self::Update {
-                range, description, ..
-            } => {
-                initial_prompt = description.clone();
-                suggestion_range = snapshot.anchor_in_excerpt(excerpt_id, range.start)?
-                    ..snapshot.anchor_in_excerpt(excerpt_id, range.end)?;
-            }
-            Self::CreateFile { description } => {
-                initial_prompt = description.clone();
-                suggestion_range = editor::Anchor::min()..editor::Anchor::min();
-            }
-            Self::InsertBefore {
-                position,
-                description,
-                ..
-            } => {
-                let position = snapshot.anchor_in_excerpt(excerpt_id, *position)?;
-                initial_prompt = description.clone();
-                suggestion_range = buffer.update(cx, |buffer, cx| {
-                    buffer.start_transaction(cx);
-                    let line_start = buffer.insert_empty_line(position, true, true, cx);
-                    initial_transaction_id = buffer.end_transaction(cx);
-                    buffer.refresh_preview(cx);
-
-                    let line_start = buffer.read(cx).anchor_before(line_start);
-                    line_start..line_start
-                });
-            }
-            Self::InsertAfter {
-                position,
-                description,
-                ..
-            } => {
-                let position = snapshot.anchor_in_excerpt(excerpt_id, *position)?;
-                initial_prompt = description.clone();
-                suggestion_range = buffer.update(cx, |buffer, cx| {
-                    buffer.start_transaction(cx);
-                    let line_start = buffer.insert_empty_line(position, true, true, cx);
-                    initial_transaction_id = buffer.end_transaction(cx);
-                    buffer.refresh_preview(cx);
-
-                    let line_start = buffer.read(cx).anchor_before(line_start);
-                    line_start..line_start
-                });
-            }
-            Self::Delete { range, .. } => {
-                initial_prompt = "Delete".to_string();
-                suggestion_range = snapshot.anchor_in_excerpt(excerpt_id, range.start)?
-                    ..snapshot.anchor_in_excerpt(excerpt_id, range.end)?;
-            }
-        }
-
-        InlineAssistant::update_global(cx, |inline_assistant, cx| {
-            Some(inline_assistant.suggest_assist(
-                editor,
-                suggestion_range,
-                initial_prompt,
-                initial_transaction_id,
-                false,
-                Some(workspace.clone()),
-                Some(assistant_panel),
-                cx,
-            ))
-        })
-    }
-}
-
-impl WorkflowStepEdit {
-    pub fn new(
-        path: Option<String>,
-        operation: Option<String>,
-        search: Option<String>,
-        description: Option<String>,
-    ) -> Result<Self> {
-        let path = path.ok_or_else(|| anyhow!("missing path"))?;
-        let operation = operation.ok_or_else(|| anyhow!("missing operation"))?;
-
-        let kind = match operation.as_str() {
-            "update" => WorkflowStepEditKind::Update {
-                search: search.ok_or_else(|| anyhow!("missing search"))?,
-                description: description.ok_or_else(|| anyhow!("missing description"))?,
-            },
-            "insert_before" => WorkflowStepEditKind::InsertBefore {
-                search: search.ok_or_else(|| anyhow!("missing search"))?,
-                description: description.ok_or_else(|| anyhow!("missing description"))?,
-            },
-            "insert_after" => WorkflowStepEditKind::InsertAfter {
-                search: search.ok_or_else(|| anyhow!("missing search"))?,
-                description: description.ok_or_else(|| anyhow!("missing description"))?,
-            },
-            "delete" => WorkflowStepEditKind::Delete {
-                search: search.ok_or_else(|| anyhow!("missing search"))?,
-            },
-            "create" => WorkflowStepEditKind::Create {
-                description: description.ok_or_else(|| anyhow!("missing description"))?,
-            },
-            _ => Err(anyhow!("unknown operation {operation:?}"))?,
-        };
-
-        Ok(Self { path, kind })
-    }
-
-    pub async fn resolve(
-        &self,
-        project: Model<Project>,
-        mut cx: AsyncAppContext,
-    ) -> Result<(Model<Buffer>, super::WorkflowSuggestion)> {
-        let path = self.path.clone();
-        let kind = self.kind.clone();
-        let buffer = project
-            .update(&mut cx, |project, cx| {
-                let project_path = project
-                    .find_project_path(Path::new(&path), cx)
-                    .or_else(|| {
-                        // If we couldn't find a project path for it, put it in the active worktree
-                        // so that when we create the buffer, it can be saved.
-                        let worktree = project
-                            .active_entry()
-                            .and_then(|entry_id| project.worktree_for_entry(entry_id, cx))
-                            .or_else(|| project.worktrees(cx).next())?;
-                        let worktree = worktree.read(cx);
-
-                        Some(ProjectPath {
-                            worktree_id: worktree.id(),
-                            path: Arc::from(Path::new(&path)),
-                        })
-                    })
-                    .with_context(|| format!("worktree not found for {:?}", path))?;
-                anyhow::Ok(project.open_buffer(project_path, cx))
-            })??
-            .await?;
-
-        let snapshot = buffer.update(&mut cx, |buffer, _| buffer.snapshot())?;
-        let suggestion = cx
-            .background_executor()
-            .spawn(async move {
-                match kind {
-                    WorkflowStepEditKind::Update {
-                        search,
-                        description,
-                    } => {
-                        let range = Self::resolve_location(&snapshot, &search);
-                        WorkflowSuggestion::Update { range, description }
-                    }
-                    WorkflowStepEditKind::Create { description } => {
-                        WorkflowSuggestion::CreateFile { description }
-                    }
-                    WorkflowStepEditKind::InsertBefore {
-                        search,
-                        description,
-                    } => {
-                        let range = Self::resolve_location(&snapshot, &search);
-                        WorkflowSuggestion::InsertBefore {
-                            position: range.start,
-                            description,
-                        }
-                    }
-                    WorkflowStepEditKind::InsertAfter {
-                        search,
-                        description,
-                    } => {
-                        let range = Self::resolve_location(&snapshot, &search);
-                        WorkflowSuggestion::InsertAfter {
-                            position: range.end,
-                            description,
-                        }
-                    }
-                    WorkflowStepEditKind::Delete { search } => {
-                        let range = Self::resolve_location(&snapshot, &search);
-                        WorkflowSuggestion::Delete { range }
-                    }
-                }
-            })
-            .await;
-
-        Ok((buffer, suggestion))
-    }
-
-    fn resolve_location(buffer: &text::BufferSnapshot, search_query: &str) -> Range<text::Anchor> {
-        const INSERTION_SCORE: f64 = -1.0;
-        const DELETION_SCORE: f64 = -1.0;
-        const REPLACEMENT_SCORE: f64 = -1.0;
-        const EQUALITY_SCORE: f64 = 5.0;
-
-        struct Matrix {
-            cols: usize,
-            data: Vec<f64>,
-        }
-
-        impl Matrix {
-            fn new(rows: usize, cols: usize) -> Self {
-                Matrix {
-                    cols,
-                    data: vec![0.0; rows * cols],
-                }
-            }
-
-            fn get(&self, row: usize, col: usize) -> f64 {
-                self.data[row * self.cols + col]
-            }
-
-            fn set(&mut self, row: usize, col: usize, value: f64) {
-                self.data[row * self.cols + col] = value;
-            }
-        }
-
-        let buffer_len = buffer.len();
-        let query_len = search_query.len();
-        let mut matrix = Matrix::new(query_len + 1, buffer_len + 1);
-
-        for (i, query_byte) in search_query.bytes().enumerate() {
-            for (j, buffer_byte) in buffer.bytes_in_range(0..buffer.len()).flatten().enumerate() {
-                let match_score = if query_byte == *buffer_byte {
-                    EQUALITY_SCORE
-                } else {
-                    REPLACEMENT_SCORE
-                };
-                let up = matrix.get(i + 1, j) + DELETION_SCORE;
-                let left = matrix.get(i, j + 1) + INSERTION_SCORE;
-                let diagonal = matrix.get(i, j) + match_score;
-                let score = up.max(left.max(diagonal)).max(0.);
-                matrix.set(i + 1, j + 1, score);
-            }
-        }
-
-        // Traceback to find the best match
-        let mut best_buffer_end = buffer_len;
-        let mut best_score = 0.0;
-        for col in 1..=buffer_len {
-            let score = matrix.get(query_len, col);
-            if score > best_score {
-                best_score = score;
-                best_buffer_end = col;
-            }
-        }
-
-        let mut query_ix = query_len;
-        let mut buffer_ix = best_buffer_end;
-        while query_ix > 0 && buffer_ix > 0 {
-            let current = matrix.get(query_ix, buffer_ix);
-            let up = matrix.get(query_ix - 1, buffer_ix);
-            let left = matrix.get(query_ix, buffer_ix - 1);
-            if current == left + INSERTION_SCORE {
-                buffer_ix -= 1;
-            } else if current == up + DELETION_SCORE {
-                query_ix -= 1;
-            } else {
-                query_ix -= 1;
-                buffer_ix -= 1;
-            }
-        }
-
-        let mut start = buffer.offset_to_point(buffer.clip_offset(buffer_ix, Bias::Left));
-        start.column = 0;
-        let mut end = buffer.offset_to_point(buffer.clip_offset(best_buffer_end, Bias::Right));
-        end.column = buffer.line_len(end.row);
-
-        buffer.anchor_after(start)..buffer.anchor_before(end)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
-#[serde(tag = "operation")]
-pub enum WorkflowStepEditKind {
-    /// Rewrites the specified text entirely based on the given description.
-    /// This operation completely replaces the given text.
-    Update {
-        /// A string in the source text to apply the update to.
-        search: String,
-        /// A brief description of the transformation to apply to the symbol.
-        description: String,
-    },
-    /// Creates a new file with the given path based on the provided description.
-    /// This operation adds a new file to the codebase.
-    Create {
-        /// A brief description of the file to be created.
-        description: String,
-    },
-    /// Inserts text before the specified text in the source file.
-    InsertBefore {
-        /// A string in the source text to insert text before.
-        search: String,
-        /// A brief description of how the new text should be generated.
-        description: String,
-    },
-    /// Inserts text after the specified text in the source file.
-    InsertAfter {
-        /// A string in the source text to insert text after.
-        search: String,
-        /// A brief description of how the new text should be generated.
-        description: String,
-    },
-    /// Deletes the specified symbol from the containing file.
-    Delete {
-        /// A string in the source text to delete.
-        search: String,
-    },
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use gpui::{AppContext, Context};
-    use text::{OffsetRangeExt, Point};
-
-    #[gpui::test]
-    fn test_resolve_location(cx: &mut AppContext) {
-        {
-            let buffer = cx.new_model(|cx| {
-                Buffer::local(
-                    concat!(
-                        "    Lorem\n",
-                        "    ipsum\n",
-                        "    dolor sit amet\n",
-                        "    consecteur",
-                    ),
-                    cx,
-                )
-            });
-            let snapshot = buffer.read(cx).snapshot();
-            assert_eq!(
-                WorkflowStepEdit::resolve_location(&snapshot, "ipsum\ndolor").to_point(&snapshot),
-                Point::new(1, 0)..Point::new(2, 18)
-            );
-        }
-
-        {
-            let buffer = cx.new_model(|cx| {
-                Buffer::local(
-                    concat!(
-                        "fn foo1(a: usize) -> usize {\n",
-                        "    42\n",
-                        "}\n",
-                        "\n",
-                        "fn foo2(b: usize) -> usize {\n",
-                        "    42\n",
-                        "}\n",
-                    ),
-                    cx,
-                )
-            });
-            let snapshot = buffer.read(cx).snapshot();
-            assert_eq!(
-                WorkflowStepEdit::resolve_location(&snapshot, "fn foo1(b: usize) {\n42\n}")
-                    .to_point(&snapshot),
-                Point::new(0, 0)..Point::new(2, 1)
-            );
-        }
-
-        {
-            let buffer = cx.new_model(|cx| {
-                Buffer::local(
-                    concat!(
-                        "fn main() {\n",
-                        "    Foo\n",
-                        "        .bar()\n",
-                        "        .baz()\n",
-                        "        .qux()\n",
-                        "}\n",
-                        "\n",
-                        "fn foo2(b: usize) -> usize {\n",
-                        "    42\n",
-                        "}\n",
-                    ),
-                    cx,
-                )
-            });
-            let snapshot = buffer.read(cx).snapshot();
-            assert_eq!(
-                WorkflowStepEdit::resolve_location(&snapshot, "Foo.bar.baz.qux()")
-                    .to_point(&snapshot),
-                Point::new(1, 0)..Point::new(4, 14)
-            );
-        }
-    }
-}
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 72205273f80702..9d9cfde7b9c119 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -100,7 +100,7 @@ use language::{
 };
 use linked_editing_ranges::refresh_linked_ranges;
 pub use proposed_changes_editor::{
-    ProposedChangesBuffer, ProposedChangesEditor, ProposedChangesEditorToolbar,
+    ProposedChangeLocation, ProposedChangesEditor, ProposedChangesEditorToolbar,
 };
 use similar::{ChangeTag, TextDiff};
 use task::{ResolvedTask, TaskTemplate, TaskVariables};
@@ -12363,10 +12363,15 @@ impl Editor {
 
         let proposed_changes_buffers = new_selections_by_buffer
             .into_iter()
-            .map(|(buffer, ranges)| ProposedChangesBuffer { buffer, ranges })
+            .map(|(buffer, ranges)| ProposedChangeLocation { buffer, ranges })
             .collect::<Vec<_>>();
         let proposed_changes_editor = cx.new_view(|cx| {
-            ProposedChangesEditor::new(proposed_changes_buffers, self.project.clone(), cx)
+            ProposedChangesEditor::new(
+                "Proposed changes",
+                proposed_changes_buffers,
+                self.project.clone(),
+                cx,
+            )
         });
 
         cx.window_context().defer(move |cx| {
diff --git a/crates/editor/src/proposed_changes_editor.rs b/crates/editor/src/proposed_changes_editor.rs
index 056daf28a839e9..2c99b9d2775b53 100644
--- a/crates/editor/src/proposed_changes_editor.rs
+++ b/crates/editor/src/proposed_changes_editor.rs
@@ -16,16 +16,24 @@ use workspace::{
 
 pub struct ProposedChangesEditor {
     editor: View<Editor>,
-    _subscriptions: Vec<Subscription>,
+    multibuffer: Model<MultiBuffer>,
+    title: SharedString,
+    buffer_entries: Vec<BufferEntry>,
     _recalculate_diffs_task: Task<Option<()>>,
     recalculate_diffs_tx: mpsc::UnboundedSender<RecalculateDiff>,
 }
 
-pub struct ProposedChangesBuffer<T> {
+pub struct ProposedChangeLocation<T> {
     pub buffer: Model<Buffer>,
     pub ranges: Vec<Range<T>>,
 }
 
+struct BufferEntry {
+    base: Model<Buffer>,
+    branch: Model<Buffer>,
+    _subscription: Subscription,
+}
+
 pub struct ProposedChangesEditorToolbar {
     current_editor: Option<View<ProposedChangesEditor>>,
 }
@@ -43,32 +51,14 @@ struct BranchBufferSemanticsProvider(Rc<dyn SemanticsProvider>);
 
 impl ProposedChangesEditor {
     pub fn new<T: ToOffset>(
-        buffers: Vec<ProposedChangesBuffer<T>>,
+        title: impl Into<SharedString>,
+        locations: Vec<ProposedChangeLocation<T>>,
         project: Option<Model<Project>>,
         cx: &mut ViewContext<Self>,
     ) -> Self {
-        let mut subscriptions = Vec::new();
         let multibuffer = cx.new_model(|_| MultiBuffer::new(Capability::ReadWrite));
-
-        for buffer in buffers {
-            let branch_buffer = buffer.buffer.update(cx, |buffer, cx| buffer.branch(cx));
-            subscriptions.push(cx.subscribe(&branch_buffer, Self::on_buffer_event));
-
-            multibuffer.update(cx, |multibuffer, cx| {
-                multibuffer.push_excerpts(
-                    branch_buffer,
-                    buffer.ranges.into_iter().map(|range| ExcerptRange {
-                        context: range,
-                        primary: None,
-                    }),
-                    cx,
-                );
-            });
-        }
-
         let (recalculate_diffs_tx, mut recalculate_diffs_rx) = mpsc::unbounded();
-
-        Self {
+        let mut this = Self {
             editor: cx.new_view(|cx| {
                 let mut editor = Editor::for_multibuffer(multibuffer.clone(), project, true, cx);
                 editor.set_expand_all_diff_hunks();
@@ -81,6 +71,9 @@ impl ProposedChangesEditor {
                 );
                 editor
             }),
+            multibuffer,
+            title: title.into(),
+            buffer_entries: Vec::new(),
             recalculate_diffs_tx,
             _recalculate_diffs_task: cx.spawn(|_, mut cx| async move {
                 let mut buffers_to_diff = HashSet::default();
@@ -112,7 +105,100 @@ impl ProposedChangesEditor {
                 }
                 None
             }),
-            _subscriptions: subscriptions,
+        };
+        this.reset_locations(locations, cx);
+        this
+    }
+
+    pub fn branch_buffer_for_base(&self, base_buffer: &Model<Buffer>) -> Option<Model<Buffer>> {
+        self.buffer_entries.iter().find_map(|entry| {
+            if &entry.base == base_buffer {
+                Some(entry.branch.clone())
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn set_title(&mut self, title: SharedString, cx: &mut ViewContext<Self>) {
+        self.title = title;
+        cx.notify();
+    }
+
+    pub fn reset_locations<T: ToOffset>(
+        &mut self,
+        locations: Vec<ProposedChangeLocation<T>>,
+        cx: &mut ViewContext<Self>,
+    ) {
+        // Undo all branch changes
+        for entry in &self.buffer_entries {
+            let base_version = entry.base.read(cx).version();
+            entry.branch.update(cx, |buffer, cx| {
+                let undo_counts = buffer
+                    .operations()
+                    .iter()
+                    .filter_map(|(timestamp, _)| {
+                        if !base_version.observed(*timestamp) {
+                            Some((*timestamp, u32::MAX))
+                        } else {
+                            None
+                        }
+                    })
+                    .collect();
+                buffer.undo_operations(undo_counts, cx);
+            });
+        }
+
+        self.multibuffer.update(cx, |multibuffer, cx| {
+            multibuffer.clear(cx);
+        });
+
+        let mut buffer_entries = Vec::new();
+        for location in locations {
+            let branch_buffer;
+            if let Some(ix) = self
+                .buffer_entries
+                .iter()
+                .position(|entry| entry.base == location.buffer)
+            {
+                let entry = self.buffer_entries.remove(ix);
+                branch_buffer = entry.branch.clone();
+                buffer_entries.push(entry);
+            } else {
+                branch_buffer = location.buffer.update(cx, |buffer, cx| buffer.branch(cx));
+                buffer_entries.push(BufferEntry {
+                    branch: branch_buffer.clone(),
+                    base: location.buffer.clone(),
+                    _subscription: cx.subscribe(&branch_buffer, Self::on_buffer_event),
+                });
+            }
+
+            self.multibuffer.update(cx, |multibuffer, cx| {
+                multibuffer.push_excerpts(
+                    branch_buffer,
+                    location.ranges.into_iter().map(|range| ExcerptRange {
+                        context: range,
+                        primary: None,
+                    }),
+                    cx,
+                );
+            });
+        }
+
+        self.buffer_entries = buffer_entries;
+        self.editor.update(cx, |editor, cx| {
+            editor.change_selections(None, cx, |selections| selections.refresh())
+        });
+    }
+
+    pub fn recalculate_all_buffer_diffs(&self) {
+        for (ix, entry) in self.buffer_entries.iter().enumerate().rev() {
+            self.recalculate_diffs_tx
+                .unbounded_send(RecalculateDiff {
+                    buffer: entry.branch.clone(),
+                    debounce: ix > 0,
+                })
+                .ok();
         }
     }
 
@@ -162,11 +248,11 @@ impl Item for ProposedChangesEditor {
     type Event = EditorEvent;
 
     fn tab_icon(&self, _cx: &ui::WindowContext) -> Option<Icon> {
-        Some(Icon::new(IconName::Pencil))
+        Some(Icon::new(IconName::Diff))
     }
 
     fn tab_content_text(&self, _cx: &WindowContext) -> Option<SharedString> {
-        Some("Proposed changes".into())
+        Some(self.title.clone())
     }
 
     fn as_searchable(&self, _: &View<Self>) -> Option<Box<dyn SearchableItemHandle>> {
diff --git a/crates/gpui/src/app/entity_map.rs b/crates/gpui/src/app/entity_map.rs
index 5f65cebdb2828e..4d5452acc0e5fe 100644
--- a/crates/gpui/src/app/entity_map.rs
+++ b/crates/gpui/src/app/entity_map.rs
@@ -434,12 +434,10 @@ impl<T> Clone for Model<T> {
 
 impl<T> std::fmt::Debug for Model<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "Model {{ entity_id: {:?}, entity_type: {:?} }}",
-            self.any_model.entity_id,
-            type_name::<T>()
-        )
+        f.debug_struct("Model")
+            .field("entity_id", &self.any_model.entity_id)
+            .field("entity_type", &type_name::<T>())
+            .finish()
     }
 }
 
@@ -569,7 +567,10 @@ pub struct WeakModel<T> {
 
 impl<T> std::fmt::Debug for WeakModel<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct(type_name::<WeakModel<T>>()).finish()
+        f.debug_struct(&type_name::<Self>())
+            .field("entity_id", &self.any_model.entity_id)
+            .field("entity_type", &type_name::<T>())
+            .finish()
     }
 }
 
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 28bbb25d1bb87f..92cd84202a250d 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -20,6 +20,7 @@ use anyhow::{anyhow, Context, Result};
 use async_watch as watch;
 use clock::Lamport;
 pub use clock::ReplicaId;
+use collections::HashMap;
 use futures::channel::oneshot;
 use gpui::{
     AnyElement, AppContext, Context as _, EventEmitter, HighlightStyle, Model, ModelContext,
@@ -910,10 +911,8 @@ impl Buffer {
         self.apply_ops([operation.clone()], cx);
 
         if let Some(timestamp) = operation_to_undo {
-            let operation = self
-                .text
-                .undo_operations([(timestamp, u32::MAX)].into_iter().collect());
-            self.send_operation(Operation::Buffer(operation), true, cx);
+            let counts = [(timestamp, u32::MAX)].into_iter().collect();
+            self.undo_operations(counts, cx);
         }
 
         self.diff_base_version += 1;
@@ -2331,6 +2330,18 @@ impl Buffer {
         undone
     }
 
+    pub fn undo_operations(
+        &mut self,
+        counts: HashMap<Lamport, u32>,
+        cx: &mut ModelContext<Buffer>,
+    ) {
+        let was_dirty = self.is_dirty();
+        let operation = self.text.undo_operations(counts);
+        let old_version = self.version.clone();
+        self.send_operation(Operation::Buffer(operation), true, cx);
+        self.did_edit(&old_version, was_dirty, cx);
+    }
+
     /// Manually redoes a specific transaction in the buffer's redo history.
     pub fn redo(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
         let was_dirty = self.is_dirty();
diff --git a/crates/languages/Cargo.toml b/crates/languages/Cargo.toml
index 33fa874ec8690a..c4f14d13549eb6 100644
--- a/crates/languages/Cargo.toml
+++ b/crates/languages/Cargo.toml
@@ -9,7 +9,9 @@ license = "GPL-3.0-or-later"
 workspace = true
 
 [features]
-test-support = []
+test-support = [
+    "tree-sitter"
+]
 load-grammars = [
     "tree-sitter-bash",
     "tree-sitter-c",
@@ -75,6 +77,7 @@ tree-sitter-yaml = { workspace = true, optional = true }
 util.workspace = true
 
 [dev-dependencies]
+tree-sitter.workspace = true
 text.workspace = true
 theme = { workspace = true, features = ["test-support"] }
 unindent.workspace = true
diff --git a/crates/text/src/text.rs b/crates/text/src/text.rs
index b1e6be8a1cb74f..380ced5253aad9 100644
--- a/crates/text/src/text.rs
+++ b/crates/text/src/text.rs
@@ -1427,7 +1427,7 @@ impl Buffer {
     fn undo_or_redo(&mut self, transaction: Transaction) -> Operation {
         let mut counts = HashMap::default();
         for edit_id in transaction.edit_ids {
-            counts.insert(edit_id, self.undo_map.undo_count(edit_id) + 1);
+            counts.insert(edit_id, self.undo_map.undo_count(edit_id).saturating_add(1));
         }
 
         let operation = self.undo_operations(counts);
diff --git a/crates/ui/src/components/icon.rs b/crates/ui/src/components/icon.rs
index 683bcec5a8c3f4..0727f7ed9d27e6 100644
--- a/crates/ui/src/components/icon.rs
+++ b/crates/ui/src/components/icon.rs
@@ -170,6 +170,7 @@ pub enum IconName {
     Dash,
     DatabaseZap,
     Delete,
+    Diff,
     Disconnected,
     Download,
     Ellipsis,

From 9d61cd512093f11b4c987d2bbe700b829d4fc6cb Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 17 Oct 2024 13:47:23 -0400
Subject: [PATCH 731/762] ci: Check spelling separately from formatting
 (#19385)

This PR moves the spelling check out of the `check_style` action, which
we can leave for just checking formatting.

We can't use the `crates-ci-typos` action as-is on the macOS runners due
to the absence of `wget`.

Release Notes:

- N/A
---
 .github/actions/check_style/action.yml | 5 -----
 .github/workflows/ci.yml               | 5 +++++
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/actions/check_style/action.yml b/.github/actions/check_style/action.yml
index 9bddee44ef5218..f8362bc636f938 100644
--- a/.github/actions/check_style/action.yml
+++ b/.github/actions/check_style/action.yml
@@ -4,11 +4,6 @@ description: "Checks code formatting use cargo fmt"
 runs:
   using: "composite"
   steps:
-    - name: Check for Typos with Typos-CLI
-      uses: crate-ci/typos@v1.24.6
-      with:
-        config: ./typos.toml
-
     - name: cargo fmt
       shell: bash -euxo pipefail {0}
       run: cargo fmt --all -- --check
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index adf0cfa30f5fd7..64739b6513304c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -82,6 +82,11 @@ jobs:
       - name: Run style checks
         uses: ./.github/actions/check_style
 
+      - name: Check for typos
+        uses: crate-ci/typos@v1.24.6
+        with:
+          config: ./typos.toml
+
   macos_tests:
     timeout-minutes: 60
     name: (macOS) Run Clippy and tests

From 3c32f01a8f3b7d038ce3ac2a9c79c3a1b2906714 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 17 Oct 2024 15:36:29 -0400
Subject: [PATCH 732/762] paths: Update doc comment (#19388)

This PR updates a doc comment to use proper capitalization.

Also removes an unneeded `return`.

Release Notes:

- N/A
---
 crates/paths/src/paths.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/paths/src/paths.rs b/crates/paths/src/paths.rs
index 1649ccb475de92..679bab32d2bb0a 100644
--- a/crates/paths/src/paths.rs
+++ b/crates/paths/src/paths.rs
@@ -101,10 +101,10 @@ pub fn logs_dir() -> &'static PathBuf {
     })
 }
 
-/// Returns the path to the zed server directory on this ssh host.
+/// Returns the path to the Zed server directory on this SSH host.
 pub fn remote_server_state_dir() -> &'static PathBuf {
     static REMOTE_SERVER_STATE: OnceLock<PathBuf> = OnceLock::new();
-    REMOTE_SERVER_STATE.get_or_init(|| return support_dir().join("server_state"))
+    REMOTE_SERVER_STATE.get_or_init(|| support_dir().join("server_state"))
 }
 
 /// Returns the path to the `Zed.log` file.

From 2bcf9fc4904fca6ea9aa24eba5a4df5259048e3d Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 17 Oct 2024 16:18:35 -0400
Subject: [PATCH 733/762] Add `client::zed_urls` module for constructing
 zed.dev URLs (#19391)

This PR adds a new `zed_urls` module to the `client` crate.

This module contains functions for constructing URLs to Zed properties,
such as zed.dev.

The URLs produced by this module will respect the server URL set via
settings or the `ZED_SERVER_URL` environment variable. This allows them
to correctly reflect the current environment (such as when testing Zed
against a local collab/zed.dev).

Release Notes:

- N/A
---
 crates/assistant/src/assistant_panel.rs     |  8 +++-----
 crates/client/src/client.rs                 |  1 +
 crates/client/src/zed_urls.rs               | 19 +++++++++++++++++++
 crates/language_model/src/provider/cloud.rs |  9 +++++----
 crates/zed/src/zed.rs                       |  5 ++---
 5 files changed, 30 insertions(+), 12 deletions(-)
 create mode 100644 crates/client/src/zed_urls.rs

diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs
index 5c20caa8638eec..91a8eb77285aa8 100644
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -21,7 +21,7 @@ use crate::{
 use anyhow::Result;
 use assistant_slash_command::{SlashCommand, SlashCommandOutputSection};
 use assistant_tool::ToolRegistry;
-use client::{proto, Client, Status};
+use client::{proto, zed_urls, Client, Status};
 use collections::{BTreeSet, HashMap, HashSet};
 use editor::{
     actions::{FoldAt, MoveToEndOfLine, Newline, ShowCompletions, UnfoldAt},
@@ -3675,7 +3675,6 @@ impl ContextEditor {
 
     fn render_payment_required_error(&self, cx: &mut ViewContext<Self>) -> AnyElement {
         const ERROR_MESSAGE: &str = "Free tier exceeded. Subscribe and add payment to continue using Zed LLMs. You'll be billed at cost for tokens used.";
-        const ACCOUNT_URL: &str = "https://zed.dev/account";
 
         v_flex()
             .gap_0p5()
@@ -3700,7 +3699,7 @@ impl ContextEditor {
                     .child(Button::new("subscribe", "Subscribe").on_click(cx.listener(
                         |this, _, cx| {
                             this.last_error = None;
-                            cx.open_url(ACCOUNT_URL);
+                            cx.open_url(&zed_urls::account_url(cx));
                             cx.notify();
                         },
                     )))
@@ -3716,7 +3715,6 @@ impl ContextEditor {
 
     fn render_max_monthly_spend_reached_error(&self, cx: &mut ViewContext<Self>) -> AnyElement {
         const ERROR_MESSAGE: &str = "You have reached your maximum monthly spend. Increase your spend limit to continue using Zed LLMs.";
-        const ACCOUNT_URL: &str = "https://zed.dev/account";
 
         v_flex()
             .gap_0p5()
@@ -3742,7 +3740,7 @@ impl ContextEditor {
                         Button::new("subscribe", "Update Monthly Spend Limit").on_click(
                             cx.listener(|this, _, cx| {
                                 this.last_error = None;
-                                cx.open_url(ACCOUNT_URL);
+                                cx.open_url(&zed_urls::account_url(cx));
                                 cx.notify();
                             }),
                         ),
diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs
index 33e2bff6fbc508..4a42554ebfda8c 100644
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -4,6 +4,7 @@ pub mod test;
 mod socks;
 pub mod telemetry;
 pub mod user;
+pub mod zed_urls;
 
 use anyhow::{anyhow, bail, Context as _, Result};
 use async_recursion::async_recursion;
diff --git a/crates/client/src/zed_urls.rs b/crates/client/src/zed_urls.rs
new file mode 100644
index 00000000000000..a5b27cf288e2ee
--- /dev/null
+++ b/crates/client/src/zed_urls.rs
@@ -0,0 +1,19 @@
+//! Contains helper functions for constructing URLs to various Zed-related pages.
+//!
+//! These URLs will adapt to the configured server URL in order to construct
+//! links appropriate for the environment (e.g., by linking to a local copy of
+//! zed.dev in development).
+
+use gpui::AppContext;
+use settings::Settings;
+
+use crate::ClientSettings;
+
+fn server_url(cx: &AppContext) -> &str {
+    &ClientSettings::get_global(cx).server_url
+}
+
+/// Returns the URL to the account page on zed.dev.
+pub fn account_url(cx: &AppContext) -> String {
+    format!("{server_url}/account", server_url = server_url(cx))
+}
diff --git a/crates/language_model/src/provider/cloud.rs b/crates/language_model/src/provider/cloud.rs
index eb66a22e59f7fe..b81f8e68819206 100644
--- a/crates/language_model/src/provider/cloud.rs
+++ b/crates/language_model/src/provider/cloud.rs
@@ -8,7 +8,7 @@ use crate::{
 use anthropic::AnthropicError;
 use anyhow::{anyhow, Result};
 use client::{
-    Client, PerformCompletionParams, UserStore, EXPIRED_LLM_TOKEN_HEADER_NAME,
+    zed_urls, Client, PerformCompletionParams, UserStore, EXPIRED_LLM_TOKEN_HEADER_NAME,
     MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME,
 };
 use collections::BTreeMap;
@@ -905,7 +905,6 @@ impl ConfigurationView {
 impl Render for ConfigurationView {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         const ZED_AI_URL: &str = "https://zed.dev/ai";
-        const ACCOUNT_SETTINGS_URL: &str = "https://zed.dev/account";
 
         let is_connected = !self.state.read(cx).is_signed_out();
         let plan = self.state.read(cx).user_store.read(cx).current_plan();
@@ -922,7 +921,7 @@ impl Render for ConfigurationView {
                 h_flex().child(
                     Button::new("manage_settings", "Manage Subscription")
                         .style(ButtonStyle::Tinted(TintColor::Accent))
-                        .on_click(cx.listener(|_, _, cx| cx.open_url(ACCOUNT_SETTINGS_URL))),
+                        .on_click(cx.listener(|_, _, cx| cx.open_url(&zed_urls::account_url(cx)))),
                 ),
             )
         } else if cx.has_flag::<ZedPro>() {
@@ -938,7 +937,9 @@ impl Render for ConfigurationView {
                         Button::new("upgrade", "Upgrade")
                             .style(ButtonStyle::Subtle)
                             .color(Color::Accent)
-                            .on_click(cx.listener(|_, _, cx| cx.open_url(ACCOUNT_SETTINGS_URL))),
+                            .on_click(
+                                cx.listener(|_, _, cx| cx.open_url(&zed_urls::account_url(cx))),
+                            ),
                     ),
             )
         } else {
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index c33cef4a4b2555..6ffa79e565f006 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -11,7 +11,7 @@ pub(crate) mod windows_only_instance;
 pub use app_menus::*;
 use assistant::PromptBuilder;
 use breadcrumbs::Breadcrumbs;
-use client::ZED_URL_SCHEME;
+use client::{zed_urls, ZED_URL_SCHEME};
 use collections::VecDeque;
 use command_palette_hooks::CommandPaletteFilter;
 use editor::ProposedChangesEditorToolbar;
@@ -419,8 +419,7 @@ pub fn initialize_workspace(
             )
             .register_action(
                 |_: &mut Workspace, _: &OpenAccountSettings, cx: &mut ViewContext<Workspace>| {
-                    let server_url = &client::ClientSettings::get_global(cx).server_url;
-                    cx.open_url(&format!("{server_url}/account"));
+                    cx.open_url(&zed_urls::account_url(cx));
                 },
             )
             .register_action(

From 5168fc27a17dca0f1dac52f4431376eabfd18782 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Thu, 17 Oct 2024 20:21:45 -0400
Subject: [PATCH 734/762] docs: More Java extension documentation (#19390)

Follow up of: https://github.com/zed-industries/zed/pull/19113
---
 docs/src/languages/java.md | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/docs/src/languages/java.md b/docs/src/languages/java.md
index 5d3cf771cf50a7..de666879424d3a 100644
--- a/docs/src/languages/java.md
+++ b/docs/src/languages/java.md
@@ -12,10 +12,10 @@ Both use:
 
 ## Pre-requisites
 
-You will need to install both a Java runtime (OpenJDK) and Eclipse JDT Language Server (`eclipse.jdt.ls`).
-
 ### Install OpenJDK
 
+You will need to install a Java runtime (OpenJDK).
+
 - MacOS: `brew install openjdk`
 - Ubuntu: `sudo add-apt-repository ppa:openjdk-23 && sudo apt-get install openjdk-23`
 - Windows: `choco install openjdk`
@@ -23,7 +23,11 @@ You will need to install both a Java runtime (OpenJDK) and Eclipse JDT Language
 
 Or manually download and install [OpenJDK 23](https://jdk.java.net/23/).
 
-### Install JDTLS
+### (Optional) Install JDTLS
+
+If you are using Java with Eclipse JDTLS, you can skip this section as it will automatically download a binary for you.
+
+If you are using Zed Java you need to install your own copy of Eclipse JDT Language Server (`eclipse.jdt.ls`).
 
 - MacOS: `brew install jdtls`
 - Arch: [`jdtls` from AUR](https://aur.archlinux.org/packages/jdtls)
@@ -40,7 +44,7 @@ We recommend you install one or the other and not both.
 
 ## Settings / Initialization Options
 
-See [JDTLS Language Server Settings & Capabilities](https://github.com/eclipse-jdtls/eclipse.jdt.ls/wiki/Language-Server-Settings-&-Capabilities) for a complete list of options.
+See [JDTLS Language Server Settings & Capabilities](https://github.com/eclipse-jdtls/eclipse.jdt.ls/wiki/Language-Server-Settings-&-Capabilities) for a complete list of settings.
 
 Add the following to your Zed Settings by launching {#action zed::OpenSettings}({#kb zed::OpenSettings}).
 
@@ -52,7 +56,6 @@ Add the following to your Zed Settings by launching {#action zed::OpenSettings}(
     "jdtls": {
       "settings": {},
       "initialization_options": {}
-      }
     }
   }
 }
@@ -76,7 +79,7 @@ Add the following to your Zed Settings by launching {#action zed::OpenSettings}(
 - [Zed Java Readme](https://github.com/zed-extensions/java)
 - [Java with Eclipse JDTLS Readme](https://github.com/ABckh/zed-java-eclipse-jdtls)
 
-### Support
+## Support
 
 If you have issues with either of these plugins, please open issues on their respective repositories:
 
@@ -101,7 +104,7 @@ You can optionally configure the class path that JDTLS uses with:
 }
 ```
 
-#### Zed Java Initialization Options
+### Zed Java Initialization Options
 
 There are also many more options you can pass directly to the language server, for example:
 
@@ -184,7 +187,7 @@ There are also many more options you can pass directly to the language server, f
 }
 ```
 
-## Java with Eclipse JTDLS Configuration {#zed-java-eclipse-configuration}
+### Java with Eclipse JTDLS Configuration {#zed-java-eclipse-configuration}
 
 Configuration options match those provided in the [redhat-developer/vscode-java extension](https://github.com/redhat-developer/vscode-java#supported-vs-code-settings).
 

From ea460014ab502bb56515745a733f56246efcc237 Mon Sep 17 00:00:00 2001
From: Thorsten Ball <mrnugget@gmail.com>
Date: Fri, 18 Oct 2024 10:48:11 +0200
Subject: [PATCH 735/762] ssh remoting: Undo the spawning of message handlers
 (#19409)

I suspect that this might have something to do with saving files not
being possible after a while.

I want to merge this and bump nightly.

Release Notes:

- N/A
---
 crates/remote/src/ssh_session.rs | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 6f9df8a4a34241..38bb6d05b71408 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -1526,19 +1526,16 @@ impl ChannelClient {
                             cx.clone(),
                         ) {
                             log::debug!("ssh message received. name:{type_name}");
-                            cx.foreground_executor().spawn(async move {
-                                match future.await {
-                                    Ok(_) => {
-                                        log::debug!("ssh message handled. name:{type_name}");
-                                    }
-                                    Err(error) => {
-                                        log::error!(
-                                            "error handling message. type:{type_name}, error:{error}",
-                                        );
-                                    }
+                            match future.await {
+                                Ok(_) => {
+                                    log::debug!("ssh message handled. name:{type_name}");
                                 }
-                            }).detach();
-
+                                Err(error) => {
+                                    log::error!(
+                                        "error handling message. type:{type_name}, error:{error}",
+                                    );
+                                }
+                            }
                         } else {
                             log::error!("unhandled ssh message name:{type_name}");
                         }

From f5124c21d1f6a5e52e1d853229b50021d8b74eb9 Mon Sep 17 00:00:00 2001
From: CharlesChen0823 <yongchen0823@gmail.com>
Date: Fri, 18 Oct 2024 20:07:50 +0800
Subject: [PATCH 736/762] scrollbar: Fix horizontal scrollbar display overflow
 last item (#19403)

currently, the laste item display is overflow by scrollbar, cause it
cannot clickable.
So remain one item height for display horizontal scrollbar,.
![Screenshot 2024-10-18
192352](https://github.com/user-attachments/assets/d686f0e8-93f8-426e-8816-6f00ed17a599)



Release Notes:

- N/A
---
 crates/project_panel/src/project_panel.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 121238b7d3dd02..a7ec02c06c087c 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -2701,7 +2701,6 @@ impl ProjectPanel {
                 .cursor_default()
                 .when(self.width.is_some(), |this| {
                     this.children(Scrollbar::horizontal(
-                        //percentage as f32..end_offset as f32,
                         self.horizontal_scrollbar_state.clone(),
                     ))
                 }),
@@ -2918,7 +2917,9 @@ impl Render for ProjectPanel {
                     .track_scroll(self.scroll_handle.clone()),
                 )
                 .children(self.render_vertical_scrollbar(cx))
-                .children(self.render_horizontal_scrollbar(cx))
+                .when_some(self.render_horizontal_scrollbar(cx), |this, scrollbar| {
+                    this.pb_4().child(scrollbar)
+                })
                 .children(self.context_menu.as_ref().map(|(menu, position, _)| {
                     deferred(
                         anchored()

From 9e27b6694a6b8641b8c85e315a7d5c966af8faf6 Mon Sep 17 00:00:00 2001
From: Peter Tripp <peter@zed.dev>
Date: Fri, 18 Oct 2024 10:12:39 -0400
Subject: [PATCH 737/762] keymap: Add cmd-o 'Go to symbol' for JetBrains MacOS
 key bindings (#19415)

---
 assets/keymaps/macos/jetbrains.json | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/assets/keymaps/macos/jetbrains.json b/assets/keymaps/macos/jetbrains.json
index 1d5f1181f48a6b..f3c69a76fb6a2f 100644
--- a/assets/keymaps/macos/jetbrains.json
+++ b/assets/keymaps/macos/jetbrains.json
@@ -34,7 +34,7 @@
       "cmd-]": "pane::GoForward",
       "alt-f7": "editor::FindAllReferences",
       "cmd-alt-f7": "editor::FindAllReferences",
-      "cmd-b": "editor::GoToDefinition",
+      "cmd-b": "editor::GoToDefinition", // Conflicts with workspace::ToggleLeftDock
       "cmd-alt-b": "editor::GoToDefinitionSplit",
       "cmd-shift-b": "editor::GoToTypeDefinition",
       "cmd-alt-shift-b": "editor::GoToTypeDefinitionSplit",
@@ -64,7 +64,8 @@
       "cmd-shift-o": "file_finder::Toggle",
       "cmd-shift-a": "command_palette::Toggle",
       "shift shift": "command_palette::Toggle",
-      "cmd-alt-o": "project_symbols::Toggle",
+      "cmd-alt-o": "project_symbols::Toggle", // JetBrains: Go to Symbol
+      "cmd-o": "project_symbols::Toggle", // JetBrains: Go to Class
       "cmd-1": "workspace::ToggleLeftDock",
       "cmd-6": "diagnostics::Deploy"
     }

From 35f2f2aac4837ded29279587092237baea13973d Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 18 Oct 2024 11:11:29 -0400
Subject: [PATCH 738/762] Treat `.postcss` files as CSS (#19416)

This PR makes it so `.postcss` files are recognized as CSS.

The `tree-sitter-css` grammar has basic support for PostCSS:
https://github.com/tree-sitter/tree-sitter-css/issues/17#issuecomment-1830349808.

Closes #18051.

Release Notes:

- `.postcss` files are now recognized as CSS.
---
 assets/icons/file_icons/file_types.json | 1 +
 crates/languages/src/css/config.toml    | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/assets/icons/file_icons/file_types.json b/assets/icons/file_icons/file_types.json
index fee76aa0440721..bf95879b88a0e6 100644
--- a/assets/icons/file_icons/file_types.json
+++ b/assets/icons/file_icons/file_types.json
@@ -128,6 +128,7 @@
     "php": "php",
     "plist": "template",
     "png": "image",
+    "postcss": "css",
     "ppt": "document",
     "pptx": "document",
     "prettierignore": "prettier",
diff --git a/crates/languages/src/css/config.toml b/crates/languages/src/css/config.toml
index e22abe6d7056dc..9b0c9c703c07f1 100644
--- a/crates/languages/src/css/config.toml
+++ b/crates/languages/src/css/config.toml
@@ -1,6 +1,6 @@
 name = "CSS"
 grammar = "css"
-path_suffixes = ["css"]
+path_suffixes = ["css", "postcss"]
 autoclose_before = ";:.,=}])>"
 brackets = [
     { start = "{", end = "}", close = true, newline = true },

From 5508832ba6420adc39b31ffee0f9de292eca6d13 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 18 Oct 2024 11:25:03 -0400
Subject: [PATCH 739/762] svelte: Adjust block keyword highlighting (#19418)

This PR adjusts the highlights for `{#each ...}` and `{#if ...}`
expression blocks to use keyword highlighting.

Extracted from https://github.com/zed-industries/zed/pull/18052.

Release Notes:

- N/A

Co-authored-by: Albert Marashi <albert@lumina.earth>
---
 extensions/svelte/languages/svelte/highlights.scm | 9 +++++----
 extensions/svelte/languages/svelte/injections.scm | 8 +++-----
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/extensions/svelte/languages/svelte/highlights.scm b/extensions/svelte/languages/svelte/highlights.scm
index 01d8bb8db6531b..cd3a08921ee64c 100755
--- a/extensions/svelte/languages/svelte/highlights.scm
+++ b/extensions/svelte/languages/svelte/highlights.scm
@@ -20,6 +20,7 @@
     )
 )
 
+; Style self-closing component attributes as @tag.property
 (self_closing_tag
     (
         (tag_name) @_tag_name
@@ -77,19 +78,19 @@
 ; Treating (if, each, ...) as a keyword inside of blocks
 ; like {#if ...} or {#each ...}
 (block_start_tag
-    tag: _ @tag.keyword
+    tag: _ @keyword
 )
 
 (block_tag
-    tag: _ @tag.keyword
+    tag: _ @keyword
 )
 
 (block_end_tag
-    tag: _ @tag.keyword
+    tag: _ @keyword
 )
 
 (expression_tag
-    tag: _ @tag.keyword
+    tag: _ @keyword
 )
 
 ; Style quoted string attribute values
diff --git a/extensions/svelte/languages/svelte/injections.scm b/extensions/svelte/languages/svelte/injections.scm
index 73d2b9abb1bb6d..c3b7f088d6e4af 100755
--- a/extensions/svelte/languages/svelte/injections.scm
+++ b/extensions/svelte/languages/svelte/injections.scm
@@ -55,7 +55,7 @@
     (#set! "language" "ts")
 )
 
-; Match style tags with a lang attribute
+; Match <style lang="language"> as the specified language
 (style_element
     (start_tag
         (attribute
@@ -69,7 +69,7 @@
     (raw_text) @content
 )
 
-; Match style tags without a lang attribute
+; Match <style> tags without a lang attribute as CSS
 (style_element
     (start_tag
         (attribute
@@ -81,6 +81,4 @@
     (#set! language "css")
 )
 
-
-; Downstream TODO: Style highlighting for `style:background="red"` and `style="background: red"` strings
-; Downstream TODO: Style component comments as markdown
+; Downstream TODO: Style @component comments as markdown

From 6f24c1da79ffb194204cabaea47211ad787f1656 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 18 Oct 2024 11:36:30 -0400
Subject: [PATCH 740/762] vue: Support `lang` attribute for `style` tag
 injections (#19419)

This PR adds support for injecting languages into `<style>` tags using
`<style lang="...">` in Vue.

Extracted from https://github.com/zed-industries/zed/pull/18052.

Release Notes:

- N/A

Co-authored-by: Albert Marashi <albert@lumina.earth>
---
 extensions/vue/languages/vue/injections.scm | 27 ++++++++++++++++++---
 1 file changed, 24 insertions(+), 3 deletions(-)

diff --git a/extensions/vue/languages/vue/injections.scm b/extensions/vue/languages/vue/injections.scm
index 0cb0ec1804037b..975fbe12fadc0a 100644
--- a/extensions/vue/languages/vue/injections.scm
+++ b/extensions/vue/languages/vue/injections.scm
@@ -54,7 +54,28 @@
     (attribute_value) @content
     (#set! "language" "typescript")))
 
-; TODO: support less/sass/scss
+; Vue <style lang="css"> injections
 (style_element
-  (raw_text) @content
-  (#set! "language" "css"))
+    (start_tag
+        (attribute
+            (attribute_name) @_attr_name
+            (#eq? @_attr_name "lang")
+            (quoted_attribute_value
+                (attribute_value) @language
+            )
+        )
+    )
+    (raw_text) @content
+)
+
+; Vue <style> css injections (no lang attribute)
+(style_element
+    (start_tag
+        (attribute
+            (attribute_name) @_attr_name
+        )*
+    )
+    (raw_text) @content
+    (#not-any-of? @_attr_name "lang")
+    (#set! language "css")
+)

From 2cd6c198732ecbd3b10c83c0cbf3d51ca0ea518a Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 18 Oct 2024 11:37:51 -0400
Subject: [PATCH 741/762] svelte: Bump to v0.2.1 (#19420)

This PR bumps the Svelte extension to v0.2.1.

Changes:

- https://github.com/zed-industries/zed/pull/19418

Release Notes:

- N/A
---
 Cargo.lock                       | 2 +-
 extensions/svelte/Cargo.toml     | 2 +-
 extensions/svelte/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c638ebafa4bd9f..aed49f43d6fc1a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14866,7 +14866,7 @@ dependencies = [
 
 [[package]]
 name = "zed_svelte"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/svelte/Cargo.toml b/extensions/svelte/Cargo.toml
index 09ad78aec2db8b..d410c4b70e9f91 100644
--- a/extensions/svelte/Cargo.toml
+++ b/extensions/svelte/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_svelte"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/svelte/extension.toml b/extensions/svelte/extension.toml
index a4ecf460a85ad4..fce1432ea9aa75 100644
--- a/extensions/svelte/extension.toml
+++ b/extensions/svelte/extension.toml
@@ -1,7 +1,7 @@
 id = "svelte"
 name = "Svelte"
 description = "Svelte support"
-version = "0.2.0"
+version = "0.2.1"
 schema_version = 1
 authors = []
 repository = "https://github.com/zed-extensions/svelte"

From 73a6c542f34d50b77d624598cba86c97f9c22973 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 18 Oct 2024 11:56:16 -0400
Subject: [PATCH 742/762] vue: Bump to v0.1.1 (#19421)

This PR bumps the Vue extension to v0.1.1.

Changes:

- https://github.com/zed-industries/zed/pull/19419

Release Notes:

- N/A
---
 Cargo.lock                    | 2 +-
 extensions/vue/Cargo.toml     | 2 +-
 extensions/vue/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index aed49f43d6fc1a..88cf3d2c429578 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14901,7 +14901,7 @@ dependencies = [
 
 [[package]]
 name = "zed_vue"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "serde",
  "zed_extension_api 0.1.0",
diff --git a/extensions/vue/Cargo.toml b/extensions/vue/Cargo.toml
index 31d6603ec3193e..db36785a403865 100644
--- a/extensions/vue/Cargo.toml
+++ b/extensions/vue/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_vue"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/vue/extension.toml b/extensions/vue/extension.toml
index 2050d034689d35..da7085f0c9b632 100644
--- a/extensions/vue/extension.toml
+++ b/extensions/vue/extension.toml
@@ -1,7 +1,7 @@
 id = "vue"
 name = "Vue"
 description = "Vue support."
-version = "0.1.0"
+version = "0.1.1"
 schema_version = 1
 authors = ["Piotr Osiewicz <piotr@zed.dev>"]
 repository = "https://github.com/zed-industries/zed"

From b3c93130ec3b41f5080ed4852290cc8cdfd914cd Mon Sep 17 00:00:00 2001
From: David Baldwin <baldwindavid@gmail.com>
Date: Fri, 18 Oct 2024 12:39:24 -0400
Subject: [PATCH 743/762] elixir: Support describe, test, setup, setup_all in
 outlines (#19135)

Closes #9894

Release Notes:

- N/A

### Before


![2024-10-12T204848@2x](https://github.com/user-attachments/assets/84b7f123-8845-4e6d-b1b1-444e54ea6599)

### After


![2024-10-12T204749@2x](https://github.com/user-attachments/assets/67fdcead-bad3-4967-9ac4-0b85f1da7bca)
---
 extensions/elixir/languages/elixir/outline.scm | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/extensions/elixir/languages/elixir/outline.scm b/extensions/elixir/languages/elixir/outline.scm
index 12a1a25e5f12d9..2e864136fc56a7 100644
--- a/extensions/elixir/languages/elixir/outline.scm
+++ b/extensions/elixir/languages/elixir/outline.scm
@@ -3,6 +3,16 @@
   (arguments (alias) @name)
   (#match? @context "^(defmodule|defprotocol)$")) @item
 
+(call
+  target: (identifier) @context
+  (arguments (_) @name)?
+  (#match? @context "^(setup|setup_all)$")) @item
+
+(call
+  target: (identifier) @context
+  (arguments (string) @name)
+  (#match? @context "^(describe|test)$")) @item
+
 (unary_operator
   operator: "@" @name
   operand: (call

From c59a75db1d38436ddcc8ad86ebca9c0c7b151ace Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Fri, 18 Oct 2024 12:41:36 -0400
Subject: [PATCH 744/762] Update actions/upload-artifact digest to b4b15b8
 (#19310)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
|
[actions/upload-artifact](https://redirect.github.com/actions/upload-artifact)
| action | digest | `604373d` -> `b4b15b8` |

---

### Configuration

📅 **Schedule**: Branch creation - "after 3pm on Wednesday" in timezone
America/New_York, Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you
are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

Release Notes:

- N/A

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4xMjAuMSIsInVwZGF0ZWRJblZlciI6IjM4LjEyMC4xIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6W119-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 64739b6513304c..78bbee3160bb78 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -266,20 +266,20 @@ jobs:
           mv target/x86_64-apple-darwin/release/Zed.dmg target/x86_64-apple-darwin/release/Zed-x86_64.dmg
 
       - name: Upload app bundle (universal) to workflow run if main branch or specific label
-        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
+        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: Zed_${{ github.event.pull_request.head.sha || github.sha }}.dmg
           path: target/release/Zed.dmg
       - name: Upload app bundle (aarch64) to workflow run if main branch or specific label
-        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
+        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: Zed_${{ github.event.pull_request.head.sha || github.sha }}-aarch64.dmg
           path: target/aarch64-apple-darwin/release/Zed-aarch64.dmg
 
       - name: Upload app bundle (x86_64) to workflow run if main branch or specific label
-        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
+        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: Zed_${{ github.event.pull_request.head.sha || github.sha }}-x86_64.dmg
@@ -330,7 +330,7 @@ jobs:
         run: script/bundle-linux
 
       - name: Upload Linux bundle to workflow run if main branch or specific label
-        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
+        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: zed-${{ github.event.pull_request.head.sha || github.sha }}-x86_64-unknown-linux-gnu.tar.gz
@@ -377,7 +377,7 @@ jobs:
         run: script/bundle-linux
 
       - name: Upload Linux bundle to workflow run if main branch or specific label
-        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4
+        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
         if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-bundling') }}
         with:
           name: zed-${{ github.event.pull_request.head.sha || github.sha }}-aarch64-unknown-linux-gnu.tar.gz

From 5b745a82e1639cab7f348aa60d5f2ac3442b4fa7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E5=B0=8F=E7=99=BD?= <364772080@qq.com>
Date: Sat, 19 Oct 2024 00:57:00 +0800
Subject: [PATCH 745/762] reqwest_client: Fix `socks` proxy settings (#19123)

Closes #19362

This pull request includes several updates to the `reqwest_client` crate
and its dependencies. The most important changes involve adding support
for SOCKS proxies, improving error handling for proxy URIs, and adding
tests for proxy functionality.

### Dependency Updates:
*
[`Cargo.toml`](diffhunk://#diff-2e9d962a08321605940b5a657135052fbcef87b5e360662bb527c96d9a615542L394-R401):
Added support for SOCKS proxies in the `reqwest` dependency by including
the `socks` feature.

### Code Improvements:
*
[`crates/reqwest_client/src/reqwest_client.rs`](diffhunk://#diff-8e036b034e987390be2f57373864b75d6983f0cf84e85c43793eb431d13538f3L47-R52):
Improved error handling when parsing proxy URIs by logging errors
instead of directly panicking.

### Testing Enhancements:
*
[`crates/reqwest_client/src/reqwest_client.rs`](diffhunk://#diff-8e036b034e987390be2f57373864b75d6983f0cf84e85c43793eb431d13538f3R274-R317):
Added tests to verify the handling of various proxy URIs, including
valid and invalid cases.

Release Notes:

- N/A
---
 Cargo.lock                                  |  2 +
 Cargo.toml                                  |  9 +++-
 crates/reqwest_client/src/reqwest_client.rs | 52 ++++++++++++++++++++-
 3 files changed, 60 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 88cf3d2c429578..77e2a2760c700f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9303,6 +9303,7 @@ dependencies = [
  "system-configuration 0.6.1",
  "tokio",
  "tokio-rustls 0.26.0",
+ "tokio-socks",
  "tokio-util",
  "tower-service",
  "url",
@@ -12001,6 +12002,7 @@ dependencies = [
  "futures-io",
  "futures-util",
  "thiserror",
+ "tokio",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 4a4ddb44244441..b38a046d3d400a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -391,7 +391,14 @@ pulldown-cmark = { version = "0.12.0", default-features = false }
 rand = "0.8.5"
 regex = "1.5"
 repair_json = "0.1.0"
-reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29", default-features = false, features = ["charset", "http2", "macos-system-configuration", "rustls-tls-native-roots", "stream"]}
+reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29", default-features = false, features = [
+    "charset",
+    "http2",
+    "macos-system-configuration",
+    "rustls-tls-native-roots",
+    "socks",
+    "stream",
+] }
 rsa = "0.9.6"
 runtimelib = { version = "0.15", default-features = false, features = [
     "async-dispatcher-runtime",
diff --git a/crates/reqwest_client/src/reqwest_client.rs b/crates/reqwest_client/src/reqwest_client.rs
index ade115bcd0a596..08054a01287f48 100644
--- a/crates/reqwest_client/src/reqwest_client.rs
+++ b/crates/reqwest_client/src/reqwest_client.rs
@@ -44,8 +44,12 @@ impl ReqwestClient {
         let mut client = reqwest::Client::builder()
             .use_rustls_tls()
             .default_headers(map);
-        if let Some(proxy) = proxy.clone() {
-            client = client.proxy(reqwest::Proxy::all(proxy.to_string())?);
+        if let Some(proxy) = proxy.clone().and_then(|proxy_uri| {
+            reqwest::Proxy::all(proxy_uri.to_string())
+                .inspect_err(|e| log::error!("Failed to parse proxy URI {}: {}", proxy_uri, e))
+                .ok()
+        }) {
+            client = client.proxy(proxy);
         }
         let client = client.build()?;
         let mut client: ReqwestClient = client.into();
@@ -232,3 +236,47 @@ impl http_client::HttpClient for ReqwestClient {
         .boxed()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use http_client::{http, HttpClient};
+
+    use crate::ReqwestClient;
+
+    #[test]
+    fn test_proxy_uri() {
+        let client = ReqwestClient::new();
+        assert_eq!(client.proxy(), None);
+
+        let proxy = http::Uri::from_static("http://localhost:10809");
+        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
+        assert_eq!(client.proxy(), Some(&proxy));
+
+        let proxy = http::Uri::from_static("https://localhost:10809");
+        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
+        assert_eq!(client.proxy(), Some(&proxy));
+
+        let proxy = http::Uri::from_static("socks4://localhost:10808");
+        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
+        assert_eq!(client.proxy(), Some(&proxy));
+
+        let proxy = http::Uri::from_static("socks4a://localhost:10808");
+        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
+        assert_eq!(client.proxy(), Some(&proxy));
+
+        let proxy = http::Uri::from_static("socks5://localhost:10808");
+        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
+        assert_eq!(client.proxy(), Some(&proxy));
+
+        let proxy = http::Uri::from_static("socks5h://localhost:10808");
+        let client = ReqwestClient::proxy_and_user_agent(Some(proxy.clone()), "test").unwrap();
+        assert_eq!(client.proxy(), Some(&proxy));
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_invalid_proxy_uri() {
+        let proxy = http::Uri::from_static("file:///etc/hosts");
+        ReqwestClient::proxy_and_user_agent(Some(proxy), "test").unwrap();
+    }
+}

From 34b8655bf61756b1ff535175ff326c2133dc10b8 Mon Sep 17 00:00:00 2001
From: Thomas <thomas.aubry94@gmail.com>
Date: Fri, 18 Oct 2024 19:03:34 +0200
Subject: [PATCH 746/762] Improve increment/decrement with leading zeros in vim
 mode (#18362)

- Closes: 18360

Release Notes:

- Added support for incrementing and decrementing numbers with leading
zeros
---
 crates/vim/src/normal/increment.rs            | 128 +++++++++++++++---
 ...rement_sign_change_with_leading_zeros.json |   8 ++
 ...increment_with_changing_leading_zeros.json |   6 +
 .../test_increment_with_leading_zeros.json    |   6 +
 ...increment_with_leading_zeros_and_zero.json |   7 +
 .../test_increment_zero_leading_zeros.json    |   4 +
 6 files changed, 138 insertions(+), 21 deletions(-)
 create mode 100644 crates/vim/test_data/test_increment_sign_change_with_leading_zeros.json
 create mode 100644 crates/vim/test_data/test_increment_with_changing_leading_zeros.json
 create mode 100644 crates/vim/test_data/test_increment_with_leading_zeros.json
 create mode 100644 crates/vim/test_data/test_increment_with_leading_zeros_and_zero.json
 create mode 100644 crates/vim/test_data/test_increment_zero_leading_zeros.json

diff --git a/crates/vim/src/normal/increment.rs b/crates/vim/src/normal/increment.rs
index b0501eeef7da3c..ec24064b31adb7 100644
--- a/crates/vim/src/normal/increment.rs
+++ b/crates/vim/src/normal/increment.rs
@@ -98,32 +98,40 @@ impl Vim {
     }
 }
 
-fn increment_decimal_string(mut num: &str, mut delta: i64) -> String {
-    let mut negative = false;
-    if num.chars().next() == Some('-') {
-        negative = true;
-        delta = 0 - delta;
-        num = &num[1..];
-    }
-    let result = if let Ok(value) = u64::from_str_radix(num, 10) {
-        let wrapped = value.wrapping_add_signed(delta);
-        if delta < 0 && wrapped > value {
-            negative = !negative;
-            (u64::MAX - wrapped).wrapping_add(1)
-        } else if delta > 0 && wrapped < value {
-            negative = !negative;
-            u64::MAX - wrapped
-        } else {
-            wrapped
+fn increment_decimal_string(num: &str, delta: i64) -> String {
+    let (negative, delta, num_str) = match num.strip_prefix('-') {
+        Some(n) => (true, -delta, n),
+        None => (false, delta, num),
+    };
+    let num_length = num_str.len();
+    let leading_zero = num_str.starts_with('0');
+
+    let (result, new_negative) = match u64::from_str_radix(num_str, 10) {
+        Ok(value) => {
+            let wrapped = value.wrapping_add_signed(delta);
+            if delta < 0 && wrapped > value {
+                ((u64::MAX - wrapped).wrapping_add(1), !negative)
+            } else if delta > 0 && wrapped < value {
+                (u64::MAX - wrapped, !negative)
+            } else {
+                (wrapped, negative)
+            }
         }
+        Err(_) => (u64::MAX, negative),
+    };
+
+    let formatted = format!("{}", result);
+    let new_significant_digits = formatted.len();
+    let padding = if leading_zero {
+        num_length.saturating_sub(new_significant_digits)
     } else {
-        u64::MAX
+        0
     };
 
-    if result == 0 || !negative {
-        format!("{}", result)
+    if new_negative && result != 0 {
+        format!("-{}{}", "0".repeat(padding), formatted)
     } else {
-        format!("-{}", result)
+        format!("{}{}", "0".repeat(padding), formatted)
     }
 }
 
@@ -286,6 +294,63 @@ mod test {
             "});
     }
 
+    #[gpui::test]
+    async fn test_increment_with_leading_zeros(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+
+        cx.set_shared_state(indoc! {"
+            000ˇ9
+            "})
+            .await;
+
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+            001ˇ0
+            "});
+        cx.simulate_shared_keystrokes("2 ctrl-x").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+            000ˇ8
+            "});
+    }
+
+    #[gpui::test]
+    async fn test_increment_with_leading_zeros_and_zero(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+
+        cx.set_shared_state(indoc! {"
+            01ˇ1
+            "})
+            .await;
+
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+            01ˇ2
+            "});
+        cx.simulate_shared_keystrokes("1 2 ctrl-x").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+            00ˇ0
+            "});
+    }
+
+    #[gpui::test]
+    async fn test_increment_with_changing_leading_zeros(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+
+        cx.set_shared_state(indoc! {"
+            099ˇ9
+            "})
+            .await;
+
+        cx.simulate_shared_keystrokes("ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+            100ˇ0
+            "});
+        cx.simulate_shared_keystrokes("2 ctrl-x").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+            99ˇ8
+            "});
+    }
+
     #[gpui::test]
     async fn test_increment_with_two_dots(cx: &mut gpui::TestAppContext) {
         let mut cx = NeovimBackedTestContext::new(cx).await;
@@ -322,6 +387,27 @@ mod test {
                 "});
     }
 
+    #[gpui::test]
+    async fn test_increment_sign_change_with_leading_zeros(cx: &mut gpui::TestAppContext) {
+        let mut cx = NeovimBackedTestContext::new(cx).await;
+        cx.set_shared_state(indoc! {"
+                00ˇ1
+                "})
+            .await;
+        cx.simulate_shared_keystrokes("ctrl-x").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                00ˇ0
+                "});
+        cx.simulate_shared_keystrokes("ctrl-x").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                -00ˇ1
+                "});
+        cx.simulate_shared_keystrokes("2 ctrl-a").await;
+        cx.shared_state().await.assert_eq(indoc! {"
+                00ˇ1
+                "});
+    }
+
     #[gpui::test]
     async fn test_increment_bin_wrapping_and_padding(cx: &mut gpui::TestAppContext) {
         let mut cx = NeovimBackedTestContext::new(cx).await;
diff --git a/crates/vim/test_data/test_increment_sign_change_with_leading_zeros.json b/crates/vim/test_data/test_increment_sign_change_with_leading_zeros.json
new file mode 100644
index 00000000000000..c1257012b5656d
--- /dev/null
+++ b/crates/vim/test_data/test_increment_sign_change_with_leading_zeros.json
@@ -0,0 +1,8 @@
+{"Put":{"state":"00ˇ1\n"}}
+{"Key":"ctrl-x"}
+{"Get":{"state":"00ˇ0\n","mode":"Normal"}}
+{"Key":"ctrl-x"}
+{"Get":{"state":"-00ˇ1\n","mode":"Normal"}}
+{"Key":"2"}
+{"Key":"ctrl-a"}
+{"Get":{"state":"00ˇ1\n","mode":"Normal"}}
diff --git a/crates/vim/test_data/test_increment_with_changing_leading_zeros.json b/crates/vim/test_data/test_increment_with_changing_leading_zeros.json
new file mode 100644
index 00000000000000..dce392e25f286a
--- /dev/null
+++ b/crates/vim/test_data/test_increment_with_changing_leading_zeros.json
@@ -0,0 +1,6 @@
+{"Put":{"state":"099ˇ9\n"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"100ˇ0\n","mode":"Normal"}}
+{"Key":"2"}
+{"Key":"ctrl-x"}
+{"Get":{"state":"99ˇ8\n","mode":"Normal"}}
diff --git a/crates/vim/test_data/test_increment_with_leading_zeros.json b/crates/vim/test_data/test_increment_with_leading_zeros.json
new file mode 100644
index 00000000000000..bab262463f6be0
--- /dev/null
+++ b/crates/vim/test_data/test_increment_with_leading_zeros.json
@@ -0,0 +1,6 @@
+{"Put":{"state":"000ˇ9\n"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"001ˇ0\n","mode":"Normal"}}
+{"Key":"2"}
+{"Key":"ctrl-x"}
+{"Get":{"state":"000ˇ8\n","mode":"Normal"}}
diff --git a/crates/vim/test_data/test_increment_with_leading_zeros_and_zero.json b/crates/vim/test_data/test_increment_with_leading_zeros_and_zero.json
new file mode 100644
index 00000000000000..94a1a1a71573af
--- /dev/null
+++ b/crates/vim/test_data/test_increment_with_leading_zeros_and_zero.json
@@ -0,0 +1,7 @@
+{"Put":{"state":"01ˇ1\n"}}
+{"Key":"ctrl-a"}
+{"Get":{"state":"01ˇ2\n","mode":"Normal"}}
+{"Key":"1"}
+{"Key":"2"}
+{"Key":"ctrl-x"}
+{"Get":{"state":"00ˇ0\n","mode":"Normal"}}
diff --git a/crates/vim/test_data/test_increment_zero_leading_zeros.json b/crates/vim/test_data/test_increment_zero_leading_zeros.json
new file mode 100644
index 00000000000000..5361fcbc7fb481
--- /dev/null
+++ b/crates/vim/test_data/test_increment_zero_leading_zeros.json
@@ -0,0 +1,4 @@
+{"Put":{"state":"001ˇ0\n"}}
+{"Key":"10"}
+{"Key":"ctrl-x"}
+{"Get":{"state":"000ˇ9\n","mode":"Normal"}}

From 2db9090a2f967926463b0d066cbb537faf0a1b7b Mon Sep 17 00:00:00 2001
From: Shish <shish@shishnet.org>
Date: Fri, 18 Oct 2024 18:09:52 +0100
Subject: [PATCH 747/762] remote: Polish for connection progress & error
 dialogs (#19379)

Before/after:

![err1-before](https://github.com/user-attachments/assets/43d959b3-c9d9-45dd-938e-42d34ec1cfc5)

![err1-after](https://github.com/user-attachments/assets/311d53e0-752c-4eb8-9816-64b1970c228d)

Before/after (I feel like text-wrapping would be more useful than
text-ellipsis here, but I don't see any wrap function):

![err2-before](https://github.com/user-attachments/assets/1626cda9-bf06-43fe-9b7d-3ec64f4db08a)

![err2-after](https://github.com/user-attachments/assets/749a6950-1409-4e75-808e-a1a96dbfc87e)

Before/after:

![prog-before](https://github.com/user-attachments/assets/f5f5a171-db42-4797-bab0-ad71c750bb20)

![prog-after](https://github.com/user-attachments/assets/b52a7694-36f6-4f7a-8a90-ceb223f12ec1)

Release Notes:

- N/A
---
 crates/recent_projects/src/ssh_connections.rs |  5 +++--
 crates/remote/src/ssh_session.rs              | 11 +++++++----
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/crates/recent_projects/src/ssh_connections.rs b/crates/recent_projects/src/ssh_connections.rs
index c8043acc48fd5e..814126e9f972bb 100644
--- a/crates/recent_projects/src/ssh_connections.rs
+++ b/crates/recent_projects/src/ssh_connections.rs
@@ -175,7 +175,7 @@ impl Render for SshPrompt {
             .child(
                 h_flex()
                     .p_2()
-                    .flex_wrap()
+                    .flex()
                     .child(if self.error_message.is_some() {
                         Icon::new(IconName::XCircle)
                             .size(IconSize::Medium)
@@ -195,6 +195,7 @@ impl Render for SshPrompt {
                     })
                     .child(
                         div()
+                            .ml_1()
                             .text_ellipsis()
                             .overflow_x_hidden()
                             .when_some(self.error_message.as_ref(), |el, error| {
@@ -205,7 +206,7 @@ impl Render for SshPrompt {
                                 |el| {
                                     el.child(
                                         Label::new(format!(
-                                            "－{}…",
+                                            "{}…",
                                             self.status_message.clone().unwrap()
                                         ))
                                         .size(LabelSize::Small),
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 38bb6d05b71408..f7ef74ce392398 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -1321,7 +1321,10 @@ impl SshRemoteConnection {
             let mut stderr = master_process.stderr.take().unwrap();
             stderr.read_to_end(&mut output).await?;
 
-            let error_message = format!("failed to connect: {}", String::from_utf8_lossy(&output));
+            let error_message = format!(
+                "failed to connect: {}",
+                String::from_utf8_lossy(&output).trim()
+            );
             delegate.set_error(error_message.clone(), cx);
             Err(anyhow!(error_message))?;
         }
@@ -1382,14 +1385,14 @@ impl SshRemoteConnection {
         let server_mode = 0o755;
 
         let t0 = Instant::now();
-        delegate.set_status(Some("uploading remote development server"), cx);
+        delegate.set_status(Some("Uploading remote development server"), cx);
         log::info!("uploading remote development server ({}kb)", size / 1024);
         self.upload_file(&src_path, &dst_path_gz)
             .await
             .context("failed to upload server binary")?;
         log::info!("uploaded remote development server in {:?}", t0.elapsed());
 
-        delegate.set_status(Some("extracting remote development server"), cx);
+        delegate.set_status(Some("Extracting remote development server"), cx);
         run_cmd(
             self.socket
                 .ssh_command("gunzip")
@@ -1398,7 +1401,7 @@ impl SshRemoteConnection {
         )
         .await?;
 
-        delegate.set_status(Some("unzipping remote development server"), cx);
+        delegate.set_status(Some("Marking remote development server executable"), cx);
         run_cmd(
             self.socket
                 .ssh_command("chmod")

From 15449cdf30447b5c0cf34365380b0069b6186215 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 18 Oct 2024 13:36:07 -0400
Subject: [PATCH 748/762] svelte: Extract to zed-extensions/svelte repository
 (#19425)

This PR extracts the Svelte extension to the
[zed-extensions/svelte](https://github.com/zed-extensions/svelte)
repository.

Release Notes:

- N/A
---
 Cargo.lock                                    |   7 -
 Cargo.toml                                    |   1 -
 extensions/svelte/.gitignore                  |   3 -
 extensions/svelte/Cargo.toml                  |  16 ---
 extensions/svelte/LICENSE-APACHE              |   1 -
 extensions/svelte/extension.toml              |  15 ---
 .../svelte/languages/svelte/brackets.scm      |   7 -
 .../svelte/languages/svelte/config.toml       |  22 ----
 .../svelte/languages/svelte/highlights.scm    | 108 ---------------
 .../svelte/languages/svelte/indents.scm       |   9 --
 .../svelte/languages/svelte/injections.scm    |  84 ------------
 .../svelte/languages/svelte/outline.scm       |  69 ----------
 .../svelte/languages/svelte/overrides.scm     |   7 -
 extensions/svelte/src/svelte.rs               | 124 ------------------
 14 files changed, 473 deletions(-)
 delete mode 100644 extensions/svelte/.gitignore
 delete mode 100644 extensions/svelte/Cargo.toml
 delete mode 120000 extensions/svelte/LICENSE-APACHE
 delete mode 100644 extensions/svelte/extension.toml
 delete mode 100644 extensions/svelte/languages/svelte/brackets.scm
 delete mode 100644 extensions/svelte/languages/svelte/config.toml
 delete mode 100755 extensions/svelte/languages/svelte/highlights.scm
 delete mode 100755 extensions/svelte/languages/svelte/indents.scm
 delete mode 100755 extensions/svelte/languages/svelte/injections.scm
 delete mode 100644 extensions/svelte/languages/svelte/outline.scm
 delete mode 100644 extensions/svelte/languages/svelte/overrides.scm
 delete mode 100644 extensions/svelte/src/svelte.rs

diff --git a/Cargo.lock b/Cargo.lock
index 77e2a2760c700f..646b7fdde88236 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14866,13 +14866,6 @@ dependencies = [
  "zed_extension_api 0.1.0",
 ]
 
-[[package]]
-name = "zed_svelte"
-version = "0.2.1"
-dependencies = [
- "zed_extension_api 0.1.0",
-]
-
 [[package]]
 name = "zed_terraform"
 version = "0.1.1"
diff --git a/Cargo.toml b/Cargo.toml
index b38a046d3d400a..f1bbe1efee4582 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -158,7 +158,6 @@ members = [
     "extensions/ruff",
     "extensions/slash-commands-example",
     "extensions/snippets",
-    "extensions/svelte",
     "extensions/terraform",
     "extensions/test-extension",
     "extensions/toml",
diff --git a/extensions/svelte/.gitignore b/extensions/svelte/.gitignore
deleted file mode 100644
index 6aba30215ee94f..00000000000000
--- a/extensions/svelte/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-target
-*.wasm
-grammars
diff --git a/extensions/svelte/Cargo.toml b/extensions/svelte/Cargo.toml
deleted file mode 100644
index d410c4b70e9f91..00000000000000
--- a/extensions/svelte/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "zed_svelte"
-version = "0.2.1"
-edition = "2021"
-publish = false
-license = "Apache-2.0"
-
-[lints]
-workspace = true
-
-[lib]
-path = "src/svelte.rs"
-crate-type = ["cdylib"]
-
-[dependencies]
-zed_extension_api = "0.1.0"
diff --git a/extensions/svelte/LICENSE-APACHE b/extensions/svelte/LICENSE-APACHE
deleted file mode 120000
index 1cd601d0a3affa..00000000000000
--- a/extensions/svelte/LICENSE-APACHE
+++ /dev/null
@@ -1 +0,0 @@
-../../LICENSE-APACHE
\ No newline at end of file
diff --git a/extensions/svelte/extension.toml b/extensions/svelte/extension.toml
deleted file mode 100644
index fce1432ea9aa75..00000000000000
--- a/extensions/svelte/extension.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-id = "svelte"
-name = "Svelte"
-description = "Svelte support"
-version = "0.2.1"
-schema_version = 1
-authors = []
-repository = "https://github.com/zed-extensions/svelte"
-
-[language_servers.svelte-language-server]
-name = "Svelte Language Server"
-language = "Svelte"
-
-[grammars.svelte]
-repository = "https://github.com/tree-sitter-grammars/tree-sitter-svelte"
-commit = "3f06f705410683adb17d146b5eca28c62fe81ba6"
diff --git a/extensions/svelte/languages/svelte/brackets.scm b/extensions/svelte/languages/svelte/brackets.scm
deleted file mode 100644
index deb34f80a806ff..00000000000000
--- a/extensions/svelte/languages/svelte/brackets.scm
+++ /dev/null
@@ -1,7 +0,0 @@
-("<" @open ">" @close)
-("{" @open "}" @close)
-("'" @open "'" @close)
-("\"" @open "\"" @close)
-("(" @open ")" @close)
-; ("[" @open "]" @close)
-; ("`" @open "`" @close)
diff --git a/extensions/svelte/languages/svelte/config.toml b/extensions/svelte/languages/svelte/config.toml
deleted file mode 100644
index 4db968be8c8f64..00000000000000
--- a/extensions/svelte/languages/svelte/config.toml
+++ /dev/null
@@ -1,22 +0,0 @@
-name = "Svelte"
-grammar = "svelte"
-path_suffixes = ["svelte"]
-block_comment = ["<!-- ", " -->"]
-autoclose_before = ":\"'}]>"
-brackets = [
-    { start = "{", end = "}", close = true, newline = true },
-    { start = "<", end = ">", close = true, newline = true, not_in = ["string"] },
-    { start = "[", end = "]", close = true, newline = true },
-    { start = "(", end = ")", close = true, newline = true },
-    { start = "!--", end = " --", close = true, newline = true },
-    { start = "\"", end = "\"", close = true, newline = true, not_in = ["string"] },
-    { start = "'", end = "'", close = true, newline = true, not_in = ["string"] },
-    { start = "`", end = "`", close = true, newline = true, not_in = ["string"] },
-]
-scope_opt_in_language_servers = ["tailwindcss-language-server"]
-prettier_parser_name = "svelte"
-prettier_plugins = ["prettier-plugin-svelte"]
-
-[overrides.string]
-word_characters = ["-"]
-opt_into_language_servers = ["tailwindcss-language-server"]
diff --git a/extensions/svelte/languages/svelte/highlights.scm b/extensions/svelte/languages/svelte/highlights.scm
deleted file mode 100755
index cd3a08921ee64c..00000000000000
--- a/extensions/svelte/languages/svelte/highlights.scm
+++ /dev/null
@@ -1,108 +0,0 @@
-
-; comments
-(comment) @comment
-
-; property attribute
-(attribute_directive) @attribute.function
-(attribute_identifier) @attribute
-(attribute_modifier) @attribute.special
-
-; Style component attributes as @property
-(start_tag
-    (
-        (tag_name) @_tag_name
-        (#match? @_tag_name "^[A-Z]")
-    )
-    (attribute
-        (attribute_name
-            (attribute_identifier) @tag.property
-        )
-    )
-)
-
-; Style self-closing component attributes as @tag.property
-(self_closing_tag
-    (
-        (tag_name) @_tag_name
-        (#match? @_tag_name "^[A-Z]")
-    )
-    (attribute
-        (attribute_name
-            (attribute_identifier) @tag.property
-        )
-    )
-)
-
-
-; style elements starting with lowercase letters as tags
-(
-    (tag_name) @tag
-    (#match? @tag "^[a-z]")
-)
-
-; style elements starting with uppercase letters as components (types)
-; Also valid might be to treat them as constructors
-(
-    (tag_name) @tag @tag.component.type.constructor
-    (#match? @tag "^[A-Z]")
-)
-
-[
-  "<"
-  ">"
-  "</"
-  "/>"
-] @tag.punctuation.bracket
-
-
-[
-  "{"
-  "}"
-] @punctuation.bracket
-
-[
-    "|"
-] @punctuation.delimiter
-
-
-[
-  "@"
-  "#"
-  ":"
-  "/"
-] @tag.punctuation.special
-
-"=" @operator
-
-
-; Treating (if, each, ...) as a keyword inside of blocks
-; like {#if ...} or {#each ...}
-(block_start_tag
-    tag: _ @keyword
-)
-
-(block_tag
-    tag: _ @keyword
-)
-
-(block_end_tag
-    tag: _ @keyword
-)
-
-(expression_tag
-    tag: _ @keyword
-)
-
-; Style quoted string attribute values
-(quoted_attribute_value) @string
-
-
-; Highlight the `as` keyword in each blocks
-(each_start
-    ("as") @tag.keyword
-)
-
-
-; Highlight the snippet name as a function
-; (e.g. {#snippet foo(bar)}
-(snippet_name) @function
diff --git a/extensions/svelte/languages/svelte/indents.scm b/extensions/svelte/languages/svelte/indents.scm
deleted file mode 100755
index 89082e1a505387..00000000000000
--- a/extensions/svelte/languages/svelte/indents.scm
+++ /dev/null
@@ -1,9 +0,0 @@
-[
-  (element)
-  (if_statement)
-  (each_statement)
-  (await_statement)
-  (snippet_statement)
-  (script_element)
-  (style_element)
-] @indent
diff --git a/extensions/svelte/languages/svelte/injections.scm b/extensions/svelte/languages/svelte/injections.scm
deleted file mode 100755
index c3b7f088d6e4af..00000000000000
--- a/extensions/svelte/languages/svelte/injections.scm
+++ /dev/null
@@ -1,84 +0,0 @@
-; ; injections.scm
-; ; --------------
-
-; Match script tags with a lang attribute
-(script_element
-    (start_tag
-        (attribute
-            (attribute_name) @_attr_name
-            (#eq? @_attr_name "lang")
-            (quoted_attribute_value
-                (attribute_value) @language
-            )
-        )
-    )
-    (raw_text) @content
-)
-
-; Match script tags without a lang attribute
-(script_element
-    (start_tag
-        (attribute
-            (attribute_name) @_attr_name
-        )*
-    )
-    (raw_text) @content
-    (#not-any-of? @_attr_name "lang")
-    (#set! language "javascript")
-)
-
-; Match the contents of the script's generics="T extends string" as typescript code
-;
-; Disabled for the time-being because tree-sitter is treating the generics
-; attribute as a top-level typescript statement, where `T extends string` is
-; not a valid top-level typescript statement.
-;
-; (script_element
-;     (start_tag
-;         (attribute
-;             (attribute_name) @_attr_name
-;             (#eq? @_attr_name "generics")
-;             (quoted_attribute_value
-;                 (attribute_value) @content
-;             )
-;         )
-;     )
-; 	(#set! language "typescript")
-; )
-
-
-; Mark everything as typescript because it's
-; a more generic superset of javascript
-; Not sure if it's possible to somehow refer to the
-; script's language attribute here.
-((svelte_raw_text) @content
-    (#set! "language" "ts")
-)
-
-; Match <style lang="language"> as the specified language
-(style_element
-    (start_tag
-        (attribute
-            (attribute_name) @_attr_name
-            (#eq? @_attr_name "lang")
-            (quoted_attribute_value
-                (attribute_value) @language
-            )
-        )
-    )
-    (raw_text) @content
-)
-
-; Match <style> tags without a lang attribute as CSS
-(style_element
-    (start_tag
-        (attribute
-            (attribute_name) @_attr_name
-        )*
-    )
-    (raw_text) @content
-    (#not-any-of? @_attr_name "lang")
-    (#set! language "css")
-)
-
-; Downstream TODO: Style @component comments as markdown
diff --git a/extensions/svelte/languages/svelte/outline.scm b/extensions/svelte/languages/svelte/outline.scm
deleted file mode 100644
index 8242ada2433de2..00000000000000
--- a/extensions/svelte/languages/svelte/outline.scm
+++ /dev/null
@@ -1,69 +0,0 @@
-
-(script_element
-    (start_tag) @name
-    (raw_text) @context @item
-)
-
-(script_element
-    (end_tag) @name @item
-)
-
-(style_element
-    (start_tag) @name
-    (raw_text) @context
-) @item
-
-
-(document) @item
-
-(comment) @annotation
-
-(if_statement
-    (if_start) @name
-) @item
-
-(else_block
-    (else_start) @name
-) @item
-
-(else_if_block
-    (else_if_start) @name
-) @item
-
-(element
-    (start_tag) @name
-) @item
-
-(element
-    (self_closing_tag) @name
-) @item
-
-
-; (if_end) @name @item
-
-(each_statement
-    (each_start) @name
-) @item
-
-
-(snippet_statement
-    (snippet_start) @name
-) @item
-
-(snippet_end) @name @item
-
-(html_tag) @name @item
-
-(const_tag) @name @item
-
-(await_statement
-    (await_start) @name
-) @item
-
-(then_block
-    (then_start) @name
-) @item
-
-(catch_block
-    (catch_start) @name
-) @item
diff --git a/extensions/svelte/languages/svelte/overrides.scm b/extensions/svelte/languages/svelte/overrides.scm
deleted file mode 100644
index 2a76410297833c..00000000000000
--- a/extensions/svelte/languages/svelte/overrides.scm
+++ /dev/null
@@ -1,7 +0,0 @@
-(comment) @comment
-
-[
-  (raw_text)
-  (attribute_value)
-  (quoted_attribute_value)
-] @string
diff --git a/extensions/svelte/src/svelte.rs b/extensions/svelte/src/svelte.rs
deleted file mode 100644
index 378e763e04ea56..00000000000000
--- a/extensions/svelte/src/svelte.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-use std::{env, fs};
-use zed_extension_api::{self as zed, serde_json, Result};
-
-struct SvelteExtension {
-    did_find_server: bool,
-}
-
-const SERVER_PATH: &str = "node_modules/svelte-language-server/bin/server.js";
-const PACKAGE_NAME: &str = "svelte-language-server";
-
-impl SvelteExtension {
-    fn server_exists(&self) -> bool {
-        fs::metadata(SERVER_PATH).map_or(false, |stat| stat.is_file())
-    }
-
-    fn server_script_path(&mut self, id: &zed::LanguageServerId) -> Result<String> {
-        let server_exists = self.server_exists();
-        if self.did_find_server && server_exists {
-            return Ok(SERVER_PATH.to_string());
-        }
-
-        zed::set_language_server_installation_status(
-            id,
-            &zed::LanguageServerInstallationStatus::CheckingForUpdate,
-        );
-        let version = zed::npm_package_latest_version(PACKAGE_NAME)?;
-
-        if !server_exists
-            || zed::npm_package_installed_version(PACKAGE_NAME)?.as_ref() != Some(&version)
-        {
-            zed::set_language_server_installation_status(
-                id,
-                &zed::LanguageServerInstallationStatus::Downloading,
-            );
-            let result = zed::npm_install_package(PACKAGE_NAME, &version);
-            match result {
-                Ok(()) => {
-                    if !self.server_exists() {
-                        Err(format!(
-                            "installed package '{PACKAGE_NAME}' did not contain expected path '{SERVER_PATH}'",
-                        ))?;
-                    }
-                }
-                Err(error) => {
-                    if !self.server_exists() {
-                        Err(error)?;
-                    }
-                }
-            }
-        }
-
-        self.did_find_server = true;
-        Ok(SERVER_PATH.to_string())
-    }
-}
-
-impl zed::Extension for SvelteExtension {
-    fn new() -> Self {
-        Self {
-            did_find_server: false,
-        }
-    }
-
-    fn language_server_command(
-        &mut self,
-        id: &zed::LanguageServerId,
-        _: &zed::Worktree,
-    ) -> Result<zed::Command> {
-        let server_path = self.server_script_path(id)?;
-        Ok(zed::Command {
-            command: zed::node_binary_path()?,
-            args: vec![
-                env::current_dir()
-                    .unwrap()
-                    .join(&server_path)
-                    .to_string_lossy()
-                    .to_string(),
-                "--stdio".to_string(),
-            ],
-            env: Default::default(),
-        })
-    }
-
-    fn language_server_initialization_options(
-        &mut self,
-        _: &zed::LanguageServerId,
-        _: &zed::Worktree,
-    ) -> Result<Option<serde_json::Value>> {
-        let config = serde_json::json!({
-          "inlayHints": {
-            "parameterNames": {
-              "enabled": "all",
-              "suppressWhenArgumentMatchesName": false
-            },
-            "parameterTypes": {
-              "enabled": true
-            },
-            "variableTypes": {
-              "enabled": true,
-              "suppressWhenTypeMatchesName": false
-            },
-            "propertyDeclarationTypes": {
-              "enabled": true
-            },
-            "functionLikeReturnTypes": {
-              "enabled": true
-            },
-            "enumMemberValues": {
-              "enabled": true
-            }
-          }
-        });
-
-        Ok(Some(serde_json::json!({
-            "provideFormatter": true,
-            "configuration": {
-                "typescript": config,
-                "javascript": config
-            }
-        })))
-    }
-}
-
-zed::register_extension!(SvelteExtension);

From fa738ee5e17abf3ad104bc054b2c4e23f0710b04 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 18 Oct 2024 14:08:32 -0400
Subject: [PATCH 749/762] vue: Extract to zed-extensions/vue repository
 (#19426)

This PR extracts the Vue extension to the
[zed-extensions/vue](https://github.com/zed-extensions/vue) repository.

Release Notes:

- N/A
---
 Cargo.lock                                  |   8 -
 Cargo.toml                                  |   1 -
 extensions/vue/Cargo.toml                   |  17 --
 extensions/vue/LICENSE-APACHE               |   1 -
 extensions/vue/extension.toml               |  19 --
 extensions/vue/languages/vue/brackets.scm   |   2 -
 extensions/vue/languages/vue/config.toml    |  22 ---
 extensions/vue/languages/vue/highlights.scm |  15 --
 extensions/vue/languages/vue/injections.scm |  81 --------
 extensions/vue/languages/vue/overrides.scm  |   7 -
 extensions/vue/src/vue.rs                   | 205 --------------------
 11 files changed, 378 deletions(-)
 delete mode 100644 extensions/vue/Cargo.toml
 delete mode 120000 extensions/vue/LICENSE-APACHE
 delete mode 100644 extensions/vue/extension.toml
 delete mode 100644 extensions/vue/languages/vue/brackets.scm
 delete mode 100644 extensions/vue/languages/vue/config.toml
 delete mode 100644 extensions/vue/languages/vue/highlights.scm
 delete mode 100644 extensions/vue/languages/vue/injections.scm
 delete mode 100644 extensions/vue/languages/vue/overrides.scm
 delete mode 100644 extensions/vue/src/vue.rs

diff --git a/Cargo.lock b/Cargo.lock
index 646b7fdde88236..a27005e5d12df9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14894,14 +14894,6 @@ dependencies = [
  "zed_extension_api 0.1.0",
 ]
 
-[[package]]
-name = "zed_vue"
-version = "0.1.1"
-dependencies = [
- "serde",
- "zed_extension_api 0.1.0",
-]
-
 [[package]]
 name = "zed_zig"
 version = "0.3.1"
diff --git a/Cargo.toml b/Cargo.toml
index f1bbe1efee4582..e6d71a291aee9f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -162,7 +162,6 @@ members = [
     "extensions/test-extension",
     "extensions/toml",
     "extensions/uiua",
-    "extensions/vue",
     "extensions/zig",
 
     #
diff --git a/extensions/vue/Cargo.toml b/extensions/vue/Cargo.toml
deleted file mode 100644
index db36785a403865..00000000000000
--- a/extensions/vue/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-name = "zed_vue"
-version = "0.1.1"
-edition = "2021"
-publish = false
-license = "Apache-2.0"
-
-[lints]
-workspace = true
-
-[lib]
-path = "src/vue.rs"
-crate-type = ["cdylib"]
-
-[dependencies]
-serde = { version = "1.0", features = ["derive"] }
-zed_extension_api = "0.1.0"
diff --git a/extensions/vue/LICENSE-APACHE b/extensions/vue/LICENSE-APACHE
deleted file mode 120000
index 1cd601d0a3affa..00000000000000
--- a/extensions/vue/LICENSE-APACHE
+++ /dev/null
@@ -1 +0,0 @@
-../../LICENSE-APACHE
\ No newline at end of file
diff --git a/extensions/vue/extension.toml b/extensions/vue/extension.toml
deleted file mode 100644
index da7085f0c9b632..00000000000000
--- a/extensions/vue/extension.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-id = "vue"
-name = "Vue"
-description = "Vue support."
-version = "0.1.1"
-schema_version = 1
-authors = ["Piotr Osiewicz <piotr@zed.dev>"]
-repository = "https://github.com/zed-industries/zed"
-
-[language_servers.vue-language-server]
-name = "Vue Language Server"
-language = "Vue.js"
-language_ids = { "Vue.js" = "vue" }
-# REFACTOR is explicitly disabled, as vue-lsp does not adhere to LSP protocol for code actions with these - it
-# sends back a CodeAction with neither `command` nor `edits` fields set, which is against the spec.
-code_action_kinds = ["", "quickfix", "refactor.rewrite"]
-
-[grammars.vue]
-repository = "https://github.com/tree-sitter-grammars/tree-sitter-vue"
-commit = "7e48557b903a9db9c38cea3b7839ef7e1f36c693"
diff --git a/extensions/vue/languages/vue/brackets.scm b/extensions/vue/languages/vue/brackets.scm
deleted file mode 100644
index 2d12b17daab82f..00000000000000
--- a/extensions/vue/languages/vue/brackets.scm
+++ /dev/null
@@ -1,2 +0,0 @@
-("<" @open ">" @close)
-("\"" @open "\"" @close)
diff --git a/extensions/vue/languages/vue/config.toml b/extensions/vue/languages/vue/config.toml
deleted file mode 100644
index 606c733ffc1f5d..00000000000000
--- a/extensions/vue/languages/vue/config.toml
+++ /dev/null
@@ -1,22 +0,0 @@
-name = "Vue.js"
-code_fence_block_name = "vue"
-grammar = "vue"
-path_suffixes = ["vue"]
-block_comment = ["<!-- ", " -->"]
-autoclose_before = ";:.,=}])>"
-brackets = [
-    { start = "{", end = "}", close = true, newline = true },
-    { start = "[", end = "]", close = true, newline = true },
-    { start = "(", end = ")", close = true, newline = true },
-    { start = "<", end = ">", close = true, newline = true, not_in = ["string", "comment"] },
-    { start = "\"", end = "\"", close = true, newline = false, not_in = ["string"] },
-    { start = "'", end = "'", close = true, newline = false, not_in = ["string", "comment"] },
-    { start = "`", end = "`", close = true, newline = false, not_in = ["string"] },
-]
-word_characters = ["-"]
-scope_opt_in_language_servers = ["tailwindcss-language-server"]
-prettier_parser_name = "vue"
-
-[overrides.string]
-word_characters = ["-"]
-opt_into_language_servers = ["tailwindcss-language-server"]
diff --git a/extensions/vue/languages/vue/highlights.scm b/extensions/vue/languages/vue/highlights.scm
deleted file mode 100644
index 548f57d26762a3..00000000000000
--- a/extensions/vue/languages/vue/highlights.scm
+++ /dev/null
@@ -1,15 +0,0 @@
-(attribute) @property
-(directive_attribute) @property
-(quoted_attribute_value) @string
-(interpolation) @punctuation.special
-(raw_text) @embedded
-
-((tag_name) @type
- (#match? @type "^[A-Z]"))
-
-(directive_name) @keyword
-(directive_argument) @constant
-
-(start_tag) @tag
-(end_tag) @tag
-(self_closing_tag) @tag
diff --git a/extensions/vue/languages/vue/injections.scm b/extensions/vue/languages/vue/injections.scm
deleted file mode 100644
index 975fbe12fadc0a..00000000000000
--- a/extensions/vue/languages/vue/injections.scm
+++ /dev/null
@@ -1,81 +0,0 @@
-; <script>
-((script_element
-    (start_tag) @_no_lang
-    (raw_text) @content)
-  (#not-match? @_no_lang "lang=")
-  (#set! "language" "javascript"))
-
-; <script lang="js">
-((script_element
-  (start_tag
-    (attribute
-      (attribute_name) @_lang
-      (quoted_attribute_value
-        (attribute_value) @_js)))
-  (raw_text) @content)
-  (#eq? @_lang "lang")
-  (#eq? @_js "js")
-  (#set! "language" "javascript"))
-
-; <script lang="ts">
-((script_element
-  (start_tag
-    (attribute
-      (attribute_name) @_lang
-      (quoted_attribute_value
-        (attribute_value) @_ts)))
-  (raw_text) @content)
-  (#eq? @_lang "lang")
-  (#eq? @_ts "ts")
-  (#set! "language" "typescript"))
-
-; <script lang="tsx">
-; <script lang="jsx">
-; Zed built-in tsx, we mark it as tsx ^:)
-(script_element
-  (start_tag
-    (attribute
-      (attribute_name) @_attr
-      (quoted_attribute_value
-        (attribute_value) @language)))
-  (#eq? @_attr "lang")
-  (#any-of? @language "tsx" "jsx")
-  (raw_text) @content)
-
-
-; {{ }}
-((interpolation
-  (raw_text) @content)
-  (#set! "language" "typescript"))
-
-; v-
-(directive_attribute
-  (quoted_attribute_value
-    (attribute_value) @content
-    (#set! "language" "typescript")))
-
-; Vue <style lang="css"> injections
-(style_element
-    (start_tag
-        (attribute
-            (attribute_name) @_attr_name
-            (#eq? @_attr_name "lang")
-            (quoted_attribute_value
-                (attribute_value) @language
-            )
-        )
-    )
-    (raw_text) @content
-)
-
-; Vue <style> css injections (no lang attribute)
-(style_element
-    (start_tag
-        (attribute
-            (attribute_name) @_attr_name
-        )*
-    )
-    (raw_text) @content
-    (#not-any-of? @_attr_name "lang")
-    (#set! language "css")
-)
diff --git a/extensions/vue/languages/vue/overrides.scm b/extensions/vue/languages/vue/overrides.scm
deleted file mode 100644
index 2a76410297833c..00000000000000
--- a/extensions/vue/languages/vue/overrides.scm
+++ /dev/null
@@ -1,7 +0,0 @@
-(comment) @comment
-
-[
-  (raw_text)
-  (attribute_value)
-  (quoted_attribute_value)
-] @string
diff --git a/extensions/vue/src/vue.rs b/extensions/vue/src/vue.rs
deleted file mode 100644
index f4b33cd04a2780..00000000000000
--- a/extensions/vue/src/vue.rs
+++ /dev/null
@@ -1,205 +0,0 @@
-use std::collections::HashMap;
-use std::{env, fs};
-
-use serde::Deserialize;
-use zed::lsp::{Completion, CompletionKind};
-use zed::CodeLabelSpan;
-use zed_extension_api::{self as zed, serde_json, Result};
-
-const SERVER_PATH: &str = "node_modules/@vue/language-server/bin/vue-language-server.js";
-const PACKAGE_NAME: &str = "@vue/language-server";
-
-const TYPESCRIPT_PACKAGE_NAME: &str = "typescript";
-
-/// The relative path to TypeScript's SDK.
-const TYPESCRIPT_TSDK_PATH: &str = "node_modules/typescript/lib";
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct PackageJson {
-    #[serde(default)]
-    dependencies: HashMap<String, String>,
-    #[serde(default)]
-    dev_dependencies: HashMap<String, String>,
-}
-
-struct VueExtension {
-    did_find_server: bool,
-    typescript_tsdk_path: String,
-}
-
-impl VueExtension {
-    fn server_exists(&self) -> bool {
-        fs::metadata(SERVER_PATH).map_or(false, |stat| stat.is_file())
-    }
-
-    fn server_script_path(
-        &mut self,
-        language_server_id: &zed::LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<String> {
-        let server_exists = self.server_exists();
-        if self.did_find_server && server_exists {
-            self.install_typescript_if_needed(worktree)?;
-            return Ok(SERVER_PATH.to_string());
-        }
-
-        zed::set_language_server_installation_status(
-            language_server_id,
-            &zed::LanguageServerInstallationStatus::CheckingForUpdate,
-        );
-        // We hardcode the version to 1.8 since we do not support @vue/language-server 2.0 yet.
-        let version = "1.8".to_string();
-
-        if !server_exists
-            || zed::npm_package_installed_version(PACKAGE_NAME)?.as_ref() != Some(&version)
-        {
-            zed::set_language_server_installation_status(
-                language_server_id,
-                &zed::LanguageServerInstallationStatus::Downloading,
-            );
-            let result = zed::npm_install_package(PACKAGE_NAME, &version);
-            match result {
-                Ok(()) => {
-                    if !self.server_exists() {
-                        Err(format!(
-                            "installed package '{PACKAGE_NAME}' did not contain expected path '{SERVER_PATH}'",
-                        ))?;
-                    }
-                }
-                Err(error) => {
-                    if !self.server_exists() {
-                        Err(error)?;
-                    }
-                }
-            }
-        }
-
-        self.install_typescript_if_needed(worktree)?;
-        self.did_find_server = true;
-        Ok(SERVER_PATH.to_string())
-    }
-
-    /// Returns whether a local copy of TypeScript exists in the worktree.
-    fn typescript_exists_for_worktree(&self, worktree: &zed::Worktree) -> Result<bool> {
-        let package_json = worktree.read_text_file("package.json")?;
-        let package_json: PackageJson = serde_json::from_str(&package_json)
-            .map_err(|err| format!("failed to parse package.json: {err}"))?;
-
-        let dev_dependencies = &package_json.dev_dependencies;
-        let dependencies = &package_json.dependencies;
-
-        // Since the extension is not allowed to read the filesystem within the project
-        // except through the worktree (which does not contains `node_modules`), we check
-        // the `package.json` to see if `typescript` is listed in the dependencies.
-        Ok(dev_dependencies.contains_key(TYPESCRIPT_PACKAGE_NAME)
-            || dependencies.contains_key(TYPESCRIPT_PACKAGE_NAME))
-    }
-
-    fn install_typescript_if_needed(&mut self, worktree: &zed::Worktree) -> Result<()> {
-        if self
-            .typescript_exists_for_worktree(worktree)
-            .unwrap_or_default()
-        {
-            println!("found local TypeScript installation at '{TYPESCRIPT_TSDK_PATH}'");
-            return Ok(());
-        }
-
-        let installed_typescript_version =
-            zed::npm_package_installed_version(TYPESCRIPT_PACKAGE_NAME)?;
-        let latest_typescript_version = zed::npm_package_latest_version(TYPESCRIPT_PACKAGE_NAME)?;
-
-        if installed_typescript_version.as_ref() != Some(&latest_typescript_version) {
-            println!("installing {TYPESCRIPT_PACKAGE_NAME}@{latest_typescript_version}");
-            zed::npm_install_package(TYPESCRIPT_PACKAGE_NAME, &latest_typescript_version)?;
-        } else {
-            println!("typescript already installed");
-        }
-
-        self.typescript_tsdk_path = env::current_dir()
-            .unwrap()
-            .join(TYPESCRIPT_TSDK_PATH)
-            .to_string_lossy()
-            .to_string();
-
-        Ok(())
-    }
-}
-
-impl zed::Extension for VueExtension {
-    fn new() -> Self {
-        Self {
-            did_find_server: false,
-            typescript_tsdk_path: TYPESCRIPT_TSDK_PATH.to_owned(),
-        }
-    }
-
-    fn language_server_command(
-        &mut self,
-        language_server_id: &zed::LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<zed::Command> {
-        let server_path = self.server_script_path(language_server_id, worktree)?;
-        Ok(zed::Command {
-            command: zed::node_binary_path()?,
-            args: vec![
-                env::current_dir()
-                    .unwrap()
-                    .join(&server_path)
-                    .to_string_lossy()
-                    .to_string(),
-                "--stdio".to_string(),
-            ],
-            env: Default::default(),
-        })
-    }
-
-    fn language_server_initialization_options(
-        &mut self,
-        _language_server_id: &zed::LanguageServerId,
-        _worktree: &zed::Worktree,
-    ) -> Result<Option<serde_json::Value>> {
-        Ok(Some(serde_json::json!({
-            "typescript": {
-                "tsdk": self.typescript_tsdk_path
-            }
-        })))
-    }
-
-    fn label_for_completion(
-        &self,
-        _language_server_id: &zed::LanguageServerId,
-        completion: Completion,
-    ) -> Option<zed::CodeLabel> {
-        let highlight_name = match completion.kind? {
-            CompletionKind::Class | CompletionKind::Interface => "type",
-            CompletionKind::Constructor => "type",
-            CompletionKind::Constant => "constant",
-            CompletionKind::Function | CompletionKind::Method => "function",
-            CompletionKind::Property | CompletionKind::Field => "tag",
-            CompletionKind::Variable => "type",
-            CompletionKind::Keyword => "keyword",
-            CompletionKind::Value => "tag",
-            _ => return None,
-        };
-
-        let len = completion.label.len();
-        let name_span = CodeLabelSpan::literal(completion.label, Some(highlight_name.to_string()));
-
-        Some(zed::CodeLabel {
-            code: Default::default(),
-            spans: if let Some(detail) = completion.detail {
-                vec![
-                    name_span,
-                    CodeLabelSpan::literal(" ", None),
-                    CodeLabelSpan::literal(detail, None),
-                ]
-            } else {
-                vec![name_span]
-            },
-            filter_range: (0..len).into(),
-        })
-    }
-}
-
-zed::register_extension!(VueExtension);

From 64a6e9cafb23c9a68721b1454d36a0ee311ff906 Mon Sep 17 00:00:00 2001
From: Vladimir Varankin <vladimir@varank.in>
Date: Fri, 18 Oct 2024 20:20:15 +0200
Subject: [PATCH 750/762] docs: Outline Jsonnet language (#19410)

This PR adds a basic documentation about the Jsonnet language support.

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
---
 docs/src/languages.md         |  2 +-
 docs/src/languages/jsonnet.md | 24 ++++++++++++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)
 create mode 100644 docs/src/languages/jsonnet.md

diff --git a/docs/src/languages.md b/docs/src/languages.md
index bfda1e6b0efe72..2e29898f2d5803 100644
--- a/docs/src/languages.md
+++ b/docs/src/languages.md
@@ -32,6 +32,7 @@ Zed supports hundreds of programming languages and text formats. Some work out-o
 - [JavaScript](./languages/javascript.md)
 - [Julia](./languages/julia.md)
 - [JSON](./languages/json.md)
+- [Jsonnet](./languages/jsonnet.md)
 - [Kotlin](./languages/kotlin.md)
 - [Lua](./languages/lua.md)
 - [Luau](./languages/luau.md)
@@ -104,7 +105,6 @@ Zed supports hundreds of programming languages and text formats. Some work out-o
 - [Groq](https://github.com/juice49/zed-groq)
 - [INI](https://github.com/bajrangCoder/zed-ini)
 - [Java](https://github.com/zed-extensions/java)
-- [Jsonnet](https://github.com/narqo/zed-jsonnet)
 - [Justfiles](https://github.com/jackTabsCode/zed-just)
 - [LaTeX](https://github.com/rzukic/zed-latex)
 - [Ledger](https://github.com/mrkstwrt/zed-ledger)
diff --git a/docs/src/languages/jsonnet.md b/docs/src/languages/jsonnet.md
new file mode 100644
index 00000000000000..e9df8002ae8d22
--- /dev/null
+++ b/docs/src/languages/jsonnet.md
@@ -0,0 +1,24 @@
+# Jsonnet
+
+Jsonnet language support in Zed is provided by the community-maintained [Jsonnet extension](https://github.com/narqo/zed-jsonnet).
+
+- Tree Sitter: [sourcegraph/tree-sitter-jsonnet](https://github.com/sourcegraph/tree-sitter-jsonnet)
+- Language Server: [grafana/jsonnet-language-server](https://github.com/grafana/jsonnet-language-server)
+
+## Configuration
+
+Workspace configuration options can be passed to the language server via the `lsp` settings of the `settings.json`.
+
+The following example enables support for resolving [tanka](https://tanka.dev) import paths in `jsonnet-language-server`:
+
+```json
+{
+  "lsp": {
+    "jsonnet-language-server": {
+      "settings": {
+        "resolve_paths_with_tanka": true
+      }
+    }
+  }
+}
+```

From 6a463be1aeb0f011810e57689a062ccce2509361 Mon Sep 17 00:00:00 2001
From: Valentine Briese <valentinegb@icloud.com>
Date: Fri, 18 Oct 2024 12:02:42 -0700
Subject: [PATCH 751/762] docs: Direct Java extension users to JDTLS
 initialization options (#19401)

Continuation of #19390
---
 docs/src/languages/java.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/src/languages/java.md b/docs/src/languages/java.md
index de666879424d3a..d819ecd92b8ed2 100644
--- a/docs/src/languages/java.md
+++ b/docs/src/languages/java.md
@@ -44,7 +44,7 @@ We recommend you install one or the other and not both.
 
 ## Settings / Initialization Options
 
-See [JDTLS Language Server Settings & Capabilities](https://github.com/eclipse-jdtls/eclipse.jdt.ls/wiki/Language-Server-Settings-&-Capabilities) for a complete list of settings.
+For available `initialization_options` please see the [Initialize Request section of the Eclipse.jdt.ls Wiki](https://github.com/eclipse-jdtls/eclipse.jdt.ls/wiki/Running-the-JAVA-LS-server-from-the-command-line#initialize-request).
 
 Add the following to your Zed Settings by launching {#action zed::OpenSettings}({#kb zed::OpenSettings}).
 

From be81e29b0f646129aed4c8d851f2d0cb1ce959ad Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Fri, 18 Oct 2024 15:04:26 -0400
Subject: [PATCH 752/762] Prefer users to open new issues if closed stale issue
 is valid (#19428)

I no longer want to have to keep my ears and eyes open for GitHub
notifications that relate to someone requesting a closed stale issue be
reopened. As a community maintainer, I can get hundreds or even
thousands of notifications a week, and a lot of those are about activity
on closed issues. If everyone following an issue did not react fast
enough (7 days) to keep an issue flagged as `stale` open, let's instruct
them to open new issues, so we are forced to see it during next triage.

Release Notes:

- N/A
---
 .github/workflows/close_stale_issues.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/close_stale_issues.yml
index c38db5bfd764f6..8689c0db0bedc4 100644
--- a/.github/workflows/close_stale_issues.yml
+++ b/.github/workflows/close_stale_issues.yml
@@ -17,7 +17,7 @@ jobs:
             We're working to clean up our issue tracker by closing older issues that might not be relevant anymore. Are you able to reproduce this issue in the latest version of Zed? If so, please let us know by commenting on this issue and we will keep it open; otherwise, we'll close it in 7 days. Feel free to open a new issue if you're seeing this message after the issue has been closed.
 
             Thanks for your help!
-          close-issue-message: "This issue was closed due to inactivity. If you're still experiencing this problem, feel free to ping a Zed team member to reopen this issue or open a new one."
+            close-issue-message: "This issue was closed due to inactivity. If you're still experiencing this problem, please open a new issue with a link to this issue."
           # We will increase `days-before-stale` to 365 on or after Jan 24th,
           # 2024. This date marks one year since migrating issues from
           # 'community' to 'zed' repository. The migration added activity to all

From 11a82e3347f1455f51aa59e25684f2c0f4d36068 Mon Sep 17 00:00:00 2001
From: "Joseph T. Lyons" <JosephTLyons@gmail.com>
Date: Fri, 18 Oct 2024 15:36:20 -0400
Subject: [PATCH 753/762] Do not run CI on changes to community action config
 files (#19430)

Release Notes:

- N/A
---
 .github/workflows/ci.yml                                         | 1 +
 .../{close_stale_issues.yml => community_close_stale_issues.yml} | 0
 .../{delete_comments.yml => community_delete_comments.yml}       | 0
 .../{release_actions.yml => community_release_actions.yml}       | 0
 ...ng_issues.yml => community_update_all_top_ranking_issues.yml} | 0
 ...issues.yml => community_update_weekly_top_ranking_issues.yml} | 0
 6 files changed, 1 insertion(+)
 rename .github/workflows/{close_stale_issues.yml => community_close_stale_issues.yml} (100%)
 rename .github/workflows/{delete_comments.yml => community_delete_comments.yml} (100%)
 rename .github/workflows/{release_actions.yml => community_release_actions.yml} (100%)
 rename .github/workflows/{update_all_top_ranking_issues.yml => community_update_all_top_ranking_issues.yml} (100%)
 rename .github/workflows/{update_weekly_top_ranking_issues.yml => community_update_weekly_top_ranking_issues.yml} (100%)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 78bbee3160bb78..a569a612c0d1c7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -14,6 +14,7 @@ on:
       - "**"
     paths-ignore:
       - "docs/**"
+      - ".github/workflows/community_*"
 
 concurrency:
   # Allow only one workflow per any non-`main` branch.
diff --git a/.github/workflows/close_stale_issues.yml b/.github/workflows/community_close_stale_issues.yml
similarity index 100%
rename from .github/workflows/close_stale_issues.yml
rename to .github/workflows/community_close_stale_issues.yml
diff --git a/.github/workflows/delete_comments.yml b/.github/workflows/community_delete_comments.yml
similarity index 100%
rename from .github/workflows/delete_comments.yml
rename to .github/workflows/community_delete_comments.yml
diff --git a/.github/workflows/release_actions.yml b/.github/workflows/community_release_actions.yml
similarity index 100%
rename from .github/workflows/release_actions.yml
rename to .github/workflows/community_release_actions.yml
diff --git a/.github/workflows/update_all_top_ranking_issues.yml b/.github/workflows/community_update_all_top_ranking_issues.yml
similarity index 100%
rename from .github/workflows/update_all_top_ranking_issues.yml
rename to .github/workflows/community_update_all_top_ranking_issues.yml
diff --git a/.github/workflows/update_weekly_top_ranking_issues.yml b/.github/workflows/community_update_weekly_top_ranking_issues.yml
similarity index 100%
rename from .github/workflows/update_weekly_top_ranking_issues.yml
rename to .github/workflows/community_update_weekly_top_ranking_issues.yml

From b44bed0115e9db6c86bd3a1e584a58846ca6abf6 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 18 Oct 2024 15:55:28 -0400
Subject: [PATCH 754/762] collab: Unconditionally execute billing checks
 (#19432)

This PR removes the conditional checks around the billing-related
enforcement for LLM completions.

These were just in place to prevent executing any billing code before we
had rolled it out. Now that it is rolled out, we don't need this
conditional execution anymore.

Release Notes:

- N/A
---
 crates/collab/src/lib.rs |  4 ----
 crates/collab/src/llm.rs | 52 ++++++++++++++++------------------------
 2 files changed, 21 insertions(+), 35 deletions(-)

diff --git a/crates/collab/src/lib.rs b/crates/collab/src/lib.rs
index c82968efecd9c1..78f514adb734d9 100644
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -198,10 +198,6 @@ impl Config {
         }
     }
 
-    pub fn is_llm_billing_enabled(&self) -> bool {
-        self.stripe_api_key.is_some()
-    }
-
     #[cfg(test)]
     pub fn test() -> Self {
         Self {
diff --git a/crates/collab/src/llm.rs b/crates/collab/src/llm.rs
index b782db58706dfa..9ee31ab3d15cff 100644
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -460,29 +460,27 @@ async fn check_usage_limit(
         )
         .await?;
 
-    if state.config.is_llm_billing_enabled() {
-        if usage.spending_this_month >= FREE_TIER_MONTHLY_SPENDING_LIMIT {
-            if !claims.has_llm_subscription {
-                return Err(Error::http(
-                    StatusCode::PAYMENT_REQUIRED,
-                    "Maximum spending limit reached for this month.".to_string(),
-                ));
-            }
+    if usage.spending_this_month >= FREE_TIER_MONTHLY_SPENDING_LIMIT {
+        if !claims.has_llm_subscription {
+            return Err(Error::http(
+                StatusCode::PAYMENT_REQUIRED,
+                "Maximum spending limit reached for this month.".to_string(),
+            ));
+        }
 
-            if (usage.spending_this_month - FREE_TIER_MONTHLY_SPENDING_LIMIT)
-                >= Cents(claims.max_monthly_spend_in_cents)
-            {
-                return Err(Error::Http(
-                    StatusCode::FORBIDDEN,
-                    "Maximum spending limit reached for this month.".to_string(),
-                    [(
-                        HeaderName::from_static(MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME),
-                        HeaderValue::from_static("true"),
-                    )]
-                    .into_iter()
-                    .collect(),
-                ));
-            }
+        if (usage.spending_this_month - FREE_TIER_MONTHLY_SPENDING_LIMIT)
+            >= Cents(claims.max_monthly_spend_in_cents)
+        {
+            return Err(Error::Http(
+                StatusCode::FORBIDDEN,
+                "Maximum spending limit reached for this month.".to_string(),
+                [(
+                    HeaderName::from_static(MAX_LLM_MONTHLY_SPEND_REACHED_HEADER_NAME),
+                    HeaderValue::from_static("true"),
+                )]
+                .into_iter()
+                .collect(),
+            ));
         }
     }
 
@@ -627,7 +625,6 @@ where
 impl<S> Drop for TokenCountingStream<S> {
     fn drop(&mut self) {
         let state = self.state.clone();
-        let is_llm_billing_enabled = state.config.is_llm_billing_enabled();
         let claims = self.claims.clone();
         let provider = self.provider;
         let model = std::mem::take(&mut self.model);
@@ -641,14 +638,7 @@ impl<S> Drop for TokenCountingStream<S> {
                     provider,
                     &model,
                     tokens,
-                    // We're passing `false` here if LLM billing is not enabled
-                    // so that we don't write any records to the
-                    // `billing_events` table until we're ready to bill users.
-                    if is_llm_billing_enabled {
-                        claims.has_llm_subscription
-                    } else {
-                        false
-                    },
+                    claims.has_llm_subscription,
                     Cents(claims.max_monthly_spend_in_cents),
                     Utc::now(),
                 )

From be474a6d6fd3470806d8c1e67331f20bac51edef Mon Sep 17 00:00:00 2001
From: Valentine Briese <valentinegb@icloud.com>
Date: Fri, 18 Oct 2024 14:12:34 -0700
Subject: [PATCH 755/762] docs: Update info on JDTLS install for Java (#19436)

---
 docs/src/languages/java.md | 80 ++++++++++++++++----------------------
 1 file changed, 33 insertions(+), 47 deletions(-)

diff --git a/docs/src/languages/java.md b/docs/src/languages/java.md
index d819ecd92b8ed2..b42685a9209c34 100644
--- a/docs/src/languages/java.md
+++ b/docs/src/languages/java.md
@@ -10,9 +10,7 @@ Both use:
 - Tree Sitter: [tree-sitter/tree-sitter-java](https://github.com/tree-sitter/tree-sitter-java)
 - Language Server: [eclipse-jdtls/eclipse.jdt.ls](https://github.com/eclipse-jdtls/eclipse.jdt.ls)
 
-## Pre-requisites
-
-### Install OpenJDK
+## Install OpenJDK
 
 You will need to install a Java runtime (OpenJDK).
 
@@ -23,30 +21,19 @@ You will need to install a Java runtime (OpenJDK).
 
 Or manually download and install [OpenJDK 23](https://jdk.java.net/23/).
 
-### (Optional) Install JDTLS
-
-If you are using Java with Eclipse JDTLS, you can skip this section as it will automatically download a binary for you.
-
-If you are using Zed Java you need to install your own copy of Eclipse JDT Language Server (`eclipse.jdt.ls`).
-
-- MacOS: `brew install jdtls`
-- Arch: [`jdtls` from AUR](https://aur.archlinux.org/packages/jdtls)
-
-Or manually download install:
-
-- [JDTLS Milestone Builds](http://download.eclipse.org/jdtls/milestones/) (updated every two weeks)
-- [JDTLS Snapshot Builds](https://download.eclipse.org/jdtls/snapshots/) (frequent updates)
-
 ## Extension Install
 
 You can install either by opening {#action zed::Extensions}({#kb zed::Extensions}) and searching for `java`.
+
 We recommend you install one or the other and not both.
 
 ## Settings / Initialization Options
 
+Both extensions will automatically download the language server, see: [Manual JDTLS Install](#manual-jdts-install) below if you'd prefer to manage that yourself.
+
 For available `initialization_options` please see the [Initialize Request section of the Eclipse.jdt.ls Wiki](https://github.com/eclipse-jdtls/eclipse.jdt.ls/wiki/Running-the-JAVA-LS-server-from-the-command-line#initialize-request).
 
-Add the following to your Zed Settings by launching {#action zed::OpenSettings}({#kb zed::OpenSettings}).
+You can add these customizations to your Zed Settings by launching {#action zed::OpenSettings}({#kb zed::OpenSettings}) or by using a `.zed/setting.json` inside your project.
 
 ### Zed Java Settings
 
@@ -54,7 +41,10 @@ Add the following to your Zed Settings by launching {#action zed::OpenSettings}(
 {
   "lsp": {
     "jdtls": {
-      "settings": {},
+      "settings": {
+        "version": "1.40.0", // jdtls version to download and use
+        "classpath": "/path/to/classes.jar:/path/to/more/classes/"
+      },
       "initialization_options": {}
     }
   }
@@ -74,36 +64,8 @@ Add the following to your Zed Settings by launching {#action zed::OpenSettings}(
 }
 ```
 
-## See also
-
-- [Zed Java Readme](https://github.com/zed-extensions/java)
-- [Java with Eclipse JDTLS Readme](https://github.com/ABckh/zed-java-eclipse-jdtls)
-
-## Support
-
-If you have issues with either of these plugins, please open issues on their respective repositories:
-
-- [Zed Java Issues](https://github.com/zed-extensions/java/issues)
-- [Java with Eclipse JDTLS Issues](https://github.com/ABckh/zed-java-eclipse-jdtls/issues)
-
 ## Example Configs
 
-### Zed Java Classpath
-
-You can optionally configure the class path that JDTLS uses with:
-
-```json
-{
-  "lsp": {
-    "jdtls": {
-      "settings": {
-        "classpath": "/path/to/classes.jar:/path/to/more/classes/"
-      }
-    }
-  }
-}
-```
-
 ### Zed Java Initialization Options
 
 There are also many more options you can pass directly to the language server, for example:
@@ -204,3 +166,27 @@ For example, to enable [Lombok Support](https://github.com/redhat-developer/vsco
   }
 }
 ```
+
+## Manual JDTLS Install
+
+If you prefer, you can install JDTLS yourself and both extensions can be configured to use that instead.
+
+- MacOS: `brew install jdtls`
+- Arch: [`jdtls` from AUR](https://aur.archlinux.org/packages/jdtls)
+
+Or manually download install:
+
+- [JDTLS Milestone Builds](http://download.eclipse.org/jdtls/milestones/) (updated every two weeks)
+- [JDTLS Snapshot Builds](https://download.eclipse.org/jdtls/snapshots/) (frequent updates)
+
+## See also
+
+- [Zed Java Readme](https://github.com/zed-extensions/java)
+- [Java with Eclipse JDTLS Readme](https://github.com/ABckh/zed-java-eclipse-jdtls)
+
+## Support
+
+If you have issues with either of these plugins, please open issues on their respective repositories:
+
+- [Zed Java Issues](https://github.com/zed-extensions/java/issues)
+- [Java with Eclipse JDTLS Issues](https://github.com/ABckh/zed-java-eclipse-jdtls/issues)

From 98ecb43b2dac3d70f43d745ab32be5a3d4bf323b Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Fri, 18 Oct 2024 15:28:08 -0600
Subject: [PATCH 756/762] SSH reconnect reliability (#19398)

Release Notes:

- SSH Remoting: Fix message reliability across restarts

---------

Co-authored-by: Nathan <nathan@zed.dev>
---
 Cargo.lock                                    |   1 +
 .../remote_editing_collaboration_tests.rs     |   3 +-
 crates/project/src/project.rs                 |   4 +
 crates/proto/proto/zed.proto                  |   8 +-
 crates/proto/src/macros.rs                    |   1 +
 crates/proto/src/proto.rs                     |   2 +
 crates/remote/Cargo.toml                      |   1 +
 crates/remote/src/ssh_session.rs              | 433 +++++++++++++++---
 .../remote_server/src/remote_editing_tests.rs |  46 +-
 9 files changed, 420 insertions(+), 79 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a27005e5d12df9..f32d24dbfb6c2f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9119,6 +9119,7 @@ name = "remote"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "async-trait",
  "collections",
  "fs",
  "futures 0.3.30",
diff --git a/crates/collab/src/tests/remote_editing_collaboration_tests.rs b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
index dae33457555ec4..a23aadf5e02a52 100644
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -26,7 +26,7 @@ async fn test_sharing_an_ssh_remote_project(
         .await;
 
     // Set up project on remote FS
-    let (client_ssh, server_ssh) = SshRemoteClient::fake(cx_a, server_cx);
+    let (forwarder, server_ssh) = SshRemoteClient::fake_server(server_cx);
     let remote_fs = FakeFs::new(server_cx.executor());
     remote_fs
         .insert_tree(
@@ -67,6 +67,7 @@ async fn test_sharing_an_ssh_remote_project(
         )
     });
 
+    let client_ssh = SshRemoteClient::fake_client(forwarder, cx_a).await;
     let (project_a, worktree_id) = client_a
         .build_ssh_project("/code/project1", client_ssh, cx_a)
         .await;
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 70d5962647c487..8ea9e78cb7a914 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -1243,6 +1243,10 @@ impl Project {
         self.client.clone()
     }
 
+    pub fn ssh_client(&self) -> Option<Model<SshRemoteClient>> {
+        self.ssh_client.clone()
+    }
+
     pub fn user_store(&self) -> Model<UserStore> {
         self.user_store.clone()
     }
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index 09891de6fecd3b..e089fcdebaa3f4 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -12,6 +12,7 @@ message Envelope {
     uint32 id = 1;
     optional uint32 responding_to = 2;
     optional PeerId original_sender_id = 3;
+    optional uint32 ack_id = 266;
 
     oneof payload {
         Hello hello = 4;
@@ -295,7 +296,9 @@ message Envelope {
         OpenServerSettings open_server_settings = 263;
 
         GetPermalinkToLine get_permalink_to_line = 264;
-        GetPermalinkToLineResponse get_permalink_to_line_response = 265;  // current max
+        GetPermalinkToLineResponse get_permalink_to_line_response = 265;
+
+        FlushBufferedMessages flush_buffered_messages = 267;
     }
 
     reserved 87 to 88;
@@ -2521,3 +2524,6 @@ message GetPermalinkToLine {
 message GetPermalinkToLineResponse {
     string permalink = 1;
 }
+
+message FlushBufferedMessages {}
+message FlushBufferedMessagesResponse {}
diff --git a/crates/proto/src/macros.rs b/crates/proto/src/macros.rs
index 4fdbfff81b6c4f..2ce0c0df259d8d 100644
--- a/crates/proto/src/macros.rs
+++ b/crates/proto/src/macros.rs
@@ -32,6 +32,7 @@ macro_rules! messages {
                         responding_to,
                         original_sender_id,
                         payload: Some(envelope::Payload::$name(self)),
+                        ack_id: None,
                     }
                 }
 
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index ffbbeb49c2b48a..8179473feaa5f4 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -372,6 +372,7 @@ messages!(
     (OpenServerSettings, Foreground),
     (GetPermalinkToLine, Foreground),
     (GetPermalinkToLineResponse, Foreground),
+    (FlushBufferedMessages, Foreground),
 );
 
 request_messages!(
@@ -498,6 +499,7 @@ request_messages!(
     (RemoveWorktree, Ack),
     (OpenServerSettings, OpenBufferResponse),
     (GetPermalinkToLine, GetPermalinkToLineResponse),
+    (FlushBufferedMessages, Ack),
 );
 
 entity_messages!(
diff --git a/crates/remote/Cargo.toml b/crates/remote/Cargo.toml
index b8c5f34cc5854a..937a69ee592787 100644
--- a/crates/remote/Cargo.toml
+++ b/crates/remote/Cargo.toml
@@ -19,6 +19,7 @@ test-support = ["fs/test-support"]
 
 [dependencies]
 anyhow.workspace = true
+async-trait.workspace = true
 collections.workspace = true
 fs.workspace = true
 futures.workspace = true
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index f7ef74ce392398..e4d292d2f8c8b2 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -6,6 +6,7 @@ use crate::{
     proxy::ProxyLaunchError,
 };
 use anyhow::{anyhow, Context as _, Result};
+use async_trait::async_trait;
 use collections::HashMap;
 use futures::{
     channel::{
@@ -31,6 +32,7 @@ use smol::{
 };
 use std::{
     any::TypeId,
+    collections::VecDeque,
     ffi::OsStr,
     fmt,
     ops::ControlFlow,
@@ -276,7 +278,7 @@ async fn run_cmd(command: &mut process::Command) -> Result<String> {
     }
 }
 
-struct ChannelForwarder {
+pub struct ChannelForwarder {
     quit_tx: UnboundedSender<()>,
     forwarding_task: Task<(UnboundedSender<Envelope>, UnboundedReceiver<Envelope>)>,
 }
@@ -347,7 +349,7 @@ const MAX_RECONNECT_ATTEMPTS: usize = 3;
 enum State {
     Connecting,
     Connected {
-        ssh_connection: SshRemoteConnection,
+        ssh_connection: Box<dyn SshRemoteProcess>,
         delegate: Arc<dyn SshClientDelegate>,
         forwarder: ChannelForwarder,
 
@@ -357,7 +359,7 @@ enum State {
     HeartbeatMissed {
         missed_heartbeats: usize,
 
-        ssh_connection: SshRemoteConnection,
+        ssh_connection: Box<dyn SshRemoteProcess>,
         delegate: Arc<dyn SshClientDelegate>,
         forwarder: ChannelForwarder,
 
@@ -366,7 +368,7 @@ enum State {
     },
     Reconnecting,
     ReconnectFailed {
-        ssh_connection: SshRemoteConnection,
+        ssh_connection: Box<dyn SshRemoteProcess>,
         delegate: Arc<dyn SshClientDelegate>,
         forwarder: ChannelForwarder,
 
@@ -392,11 +394,11 @@ impl fmt::Display for State {
 }
 
 impl State {
-    fn ssh_connection(&self) -> Option<&SshRemoteConnection> {
+    fn ssh_connection(&self) -> Option<&dyn SshRemoteProcess> {
         match self {
-            Self::Connected { ssh_connection, .. } => Some(ssh_connection),
-            Self::HeartbeatMissed { ssh_connection, .. } => Some(ssh_connection),
-            Self::ReconnectFailed { ssh_connection, .. } => Some(ssh_connection),
+            Self::Connected { ssh_connection, .. } => Some(ssh_connection.as_ref()),
+            Self::HeartbeatMissed { ssh_connection, .. } => Some(ssh_connection.as_ref()),
+            Self::ReconnectFailed { ssh_connection, .. } => Some(ssh_connection.as_ref()),
             _ => None,
         }
     }
@@ -541,23 +543,19 @@ impl SshRemoteClient {
             let (proxy, proxy_incoming_tx, proxy_outgoing_rx) =
                 ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
 
-            let (ssh_connection, ssh_proxy_process) = Self::establish_connection(
+            let (ssh_connection, io_task) = Self::establish_connection(
                 unique_identifier,
                 false,
                 connection_options,
+                proxy_incoming_tx,
+                proxy_outgoing_rx,
+                connection_activity_tx,
                 delegate.clone(),
                 &mut cx,
             )
             .await?;
 
-            let multiplex_task = Self::multiplex(
-                this.downgrade(),
-                ssh_proxy_process,
-                proxy_incoming_tx,
-                proxy_outgoing_rx,
-                connection_activity_tx,
-                &mut cx,
-            );
+            let multiplex_task = Self::monitor(this.downgrade(), io_task, &cx);
 
             if let Err(error) = client.ping(HEARTBEAT_TIMEOUT).await {
                 log::error!("failed to establish connection: {}", error);
@@ -703,30 +701,24 @@ impl SshRemoteClient {
                 };
             }
 
-            if let Err(error) = ssh_connection.master_process.kill() {
+            if let Err(error) = ssh_connection.kill().await.context("Failed to kill ssh process") {
                 failed!(error, attempts, ssh_connection, delegate, forwarder);
             };
 
-            if let Err(error) = ssh_connection
-                .master_process
-                .status()
-                .await
-                .context("Failed to kill ssh process")
-            {
-                failed!(error, attempts, ssh_connection, delegate, forwarder);
-            }
-
-            let connection_options = ssh_connection.socket.connection_options.clone();
+            let connection_options = ssh_connection.connection_options();
 
             let (incoming_tx, outgoing_rx) = forwarder.into_channels().await;
             let (forwarder, proxy_incoming_tx, proxy_outgoing_rx) =
                 ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
             let (connection_activity_tx, connection_activity_rx) = mpsc::channel::<()>(1);
 
-            let (ssh_connection, ssh_process) = match Self::establish_connection(
+            let (ssh_connection, io_task) = match Self::establish_connection(
                 identifier,
                 true,
                 connection_options,
+                proxy_incoming_tx,
+                proxy_outgoing_rx,
+                connection_activity_tx,
                 delegate.clone(),
                 &mut cx,
             )
@@ -738,16 +730,9 @@ impl SshRemoteClient {
                 }
             };
 
-            let multiplex_task = Self::multiplex(
-                this.clone(),
-                ssh_process,
-                proxy_incoming_tx,
-                proxy_outgoing_rx,
-                connection_activity_tx,
-                &mut cx,
-            );
+            let multiplex_task = Self::monitor(this.clone(), io_task, &cx);
 
-            if let Err(error) = client.ping(HEARTBEAT_TIMEOUT).await {
+            if let Err(error) = client.resync(HEARTBEAT_TIMEOUT).await {
                 failed!(error, attempts, ssh_connection, delegate, forwarder);
             };
 
@@ -911,18 +896,17 @@ impl SshRemoteClient {
     }
 
     fn multiplex(
-        this: WeakModel<Self>,
         mut ssh_proxy_process: Child,
         incoming_tx: UnboundedSender<Envelope>,
         mut outgoing_rx: UnboundedReceiver<Envelope>,
         mut connection_activity_tx: Sender<()>,
         cx: &AsyncAppContext,
-    ) -> Task<Result<()>> {
+    ) -> Task<Result<Option<i32>>> {
         let mut child_stderr = ssh_proxy_process.stderr.take().unwrap();
         let mut child_stdout = ssh_proxy_process.stdout.take().unwrap();
         let mut child_stdin = ssh_proxy_process.stdin.take().unwrap();
 
-        let io_task = cx.background_executor().spawn(async move {
+        cx.background_executor().spawn(async move {
             let mut stdin_buffer = Vec::new();
             let mut stdout_buffer = Vec::new();
             let mut stderr_buffer = Vec::new();
@@ -1001,8 +985,14 @@ impl SshRemoteClient {
                     }
                 }
             }
-        });
+        })
+    }
 
+    fn monitor(
+        this: WeakModel<Self>,
+        io_task: Task<Result<Option<i32>>>,
+        cx: &AsyncAppContext,
+    ) -> Task<Result<()>> {
         cx.spawn(|mut cx| async move {
             let result = io_task.await;
 
@@ -1061,21 +1051,40 @@ impl SshRemoteClient {
         cx.notify();
     }
 
+    #[allow(clippy::too_many_arguments)]
     async fn establish_connection(
         unique_identifier: String,
         reconnect: bool,
         connection_options: SshConnectionOptions,
+        proxy_incoming_tx: UnboundedSender<Envelope>,
+        proxy_outgoing_rx: UnboundedReceiver<Envelope>,
+        connection_activity_tx: Sender<()>,
         delegate: Arc<dyn SshClientDelegate>,
         cx: &mut AsyncAppContext,
-    ) -> Result<(SshRemoteConnection, Child)> {
+    ) -> Result<(Box<dyn SshRemoteProcess>, Task<Result<Option<i32>>>)> {
+        #[cfg(any(test, feature = "test-support"))]
+        if let Some(fake) = fake::SshRemoteConnection::new(&connection_options) {
+            let io_task = fake::SshRemoteConnection::multiplex(
+                fake.connection_options(),
+                proxy_incoming_tx,
+                proxy_outgoing_rx,
+                connection_activity_tx,
+                cx,
+            )
+            .await;
+            return Ok((fake, io_task));
+        }
+
         let ssh_connection =
             SshRemoteConnection::new(connection_options, delegate.clone(), cx).await?;
 
         let platform = ssh_connection.query_platform().await?;
         let remote_binary_path = delegate.remote_server_binary_path(platform, cx)?;
-        ssh_connection
-            .ensure_server_binary(&delegate, &remote_binary_path, platform, cx)
-            .await?;
+        if !reconnect {
+            ssh_connection
+                .ensure_server_binary(&delegate, &remote_binary_path, platform, cx)
+                .await?;
+        }
 
         let socket = ssh_connection.socket.clone();
         run_cmd(socket.ssh_command(&remote_binary_path).arg("version")).await?;
@@ -1100,7 +1109,15 @@ impl SshRemoteClient {
             .spawn()
             .context("failed to spawn remote server")?;
 
-        Ok((ssh_connection, ssh_proxy_process))
+        let io_task = Self::multiplex(
+            ssh_proxy_process,
+            proxy_incoming_tx,
+            proxy_outgoing_rx,
+            connection_activity_tx,
+            &cx,
+        );
+
+        Ok((Box::new(ssh_connection), io_task))
     }
 
     pub fn subscribe_to_entity<E: 'static>(&self, remote_id: u64, entity: &Model<E>) {
@@ -1112,7 +1129,7 @@ impl SshRemoteClient {
             .lock()
             .as_ref()
             .and_then(|state| state.ssh_connection())
-            .map(|ssh_connection| ssh_connection.socket.ssh_args())
+            .map(|ssh_connection| ssh_connection.ssh_args())
     }
 
     pub fn proto_client(&self) -> AnyProtoClient {
@@ -1127,7 +1144,6 @@ impl SshRemoteClient {
         self.connection_options.clone()
     }
 
-    #[cfg(not(any(test, feature = "test-support")))]
     pub fn connection_state(&self) -> ConnectionState {
         self.state
             .lock()
@@ -1136,37 +1152,69 @@ impl SshRemoteClient {
             .unwrap_or(ConnectionState::Disconnected)
     }
 
-    #[cfg(any(test, feature = "test-support"))]
-    pub fn connection_state(&self) -> ConnectionState {
-        ConnectionState::Connected
-    }
-
     pub fn is_disconnected(&self) -> bool {
         self.connection_state() == ConnectionState::Disconnected
     }
 
     #[cfg(any(test, feature = "test-support"))]
-    pub fn fake(
-        client_cx: &mut gpui::TestAppContext,
+    pub fn simulate_disconnect(&self, cx: &mut AppContext) -> Task<()> {
+        use gpui::BorrowAppContext;
+
+        let port = self.connection_options().port.unwrap();
+
+        let disconnect =
+            cx.update_global(|c: &mut fake::GlobalConnections, _cx| c.take(port).into_channels());
+        cx.spawn(|mut cx| async move {
+            let (input_rx, output_tx) = disconnect.await;
+            let (forwarder, _, _) = ChannelForwarder::new(input_rx, output_tx, &mut cx);
+            cx.update_global(|c: &mut fake::GlobalConnections, _cx| c.replace(port, forwarder))
+                .unwrap()
+        })
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn fake_server(
         server_cx: &mut gpui::TestAppContext,
-    ) -> (Model<Self>, Arc<ChannelClient>) {
-        use gpui::Context;
+    ) -> (ChannelForwarder, Arc<ChannelClient>) {
+        server_cx.update(|cx| {
+            let (outgoing_tx, outgoing_rx) = mpsc::unbounded::<Envelope>();
+            let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();
 
-        let (server_to_client_tx, server_to_client_rx) = mpsc::unbounded();
-        let (client_to_server_tx, client_to_server_rx) = mpsc::unbounded();
+            // We use the forwarder on the server side (in production we only use one on the client side)
+            // the idea is that we can simulate a disconnect/reconnect by just messing with the forwarder.
+            let (forwarder, _, _) =
+                ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx.to_async());
 
-        (
-            client_cx.update(|cx| {
-                let client = ChannelClient::new(server_to_client_rx, client_to_server_tx, cx);
-                cx.new_model(|_| Self {
-                    client,
-                    unique_identifier: "fake".to_string(),
-                    connection_options: SshConnectionOptions::default(),
-                    state: Arc::new(Mutex::new(None)),
-                })
-            }),
-            server_cx.update(|cx| ChannelClient::new(client_to_server_rx, server_to_client_tx, cx)),
-        )
+            let client = ChannelClient::new(incoming_rx, outgoing_tx, cx);
+            (forwarder, client)
+        })
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub async fn fake_client(
+        forwarder: ChannelForwarder,
+        client_cx: &mut gpui::TestAppContext,
+    ) -> Model<Self> {
+        use gpui::BorrowAppContext;
+        client_cx
+            .update(|cx| {
+                let port = cx.update_default_global(|c: &mut fake::GlobalConnections, _cx| {
+                    c.push(forwarder)
+                });
+
+                Self::new(
+                    "fake".to_string(),
+                    SshConnectionOptions {
+                        host: "<fake>".to_string(),
+                        port: Some(port),
+                        ..Default::default()
+                    },
+                    Arc::new(fake::Delegate),
+                    cx,
+                )
+            })
+            .await
+            .unwrap()
     }
 }
 
@@ -1176,6 +1224,13 @@ impl From<SshRemoteClient> for AnyProtoClient {
     }
 }
 
+#[async_trait]
+trait SshRemoteProcess: Send + Sync {
+    async fn kill(&mut self) -> Result<()>;
+    fn ssh_args(&self) -> Vec<String>;
+    fn connection_options(&self) -> SshConnectionOptions;
+}
+
 struct SshRemoteConnection {
     socket: SshSocket,
     master_process: process::Child,
@@ -1190,6 +1245,25 @@ impl Drop for SshRemoteConnection {
     }
 }
 
+#[async_trait]
+impl SshRemoteProcess for SshRemoteConnection {
+    async fn kill(&mut self) -> Result<()> {
+        self.master_process.kill()?;
+
+        self.master_process.status().await?;
+
+        Ok(())
+    }
+
+    fn ssh_args(&self) -> Vec<String> {
+        self.socket.ssh_args()
+    }
+
+    fn connection_options(&self) -> SshConnectionOptions {
+        self.socket.connection_options.clone()
+    }
+}
+
 impl SshRemoteConnection {
     #[cfg(not(unix))]
     async fn new(
@@ -1472,8 +1546,10 @@ type ResponseChannels = Mutex<HashMap<MessageId, oneshot::Sender<(Envelope, ones
 pub struct ChannelClient {
     next_message_id: AtomicU32,
     outgoing_tx: mpsc::UnboundedSender<Envelope>,
-    response_channels: ResponseChannels,             // Lock
-    message_handlers: Mutex<ProtoMessageHandlerSet>, // Lock
+    buffer: Mutex<VecDeque<Envelope>>,
+    response_channels: ResponseChannels,
+    message_handlers: Mutex<ProtoMessageHandlerSet>,
+    max_received: AtomicU32,
 }
 
 impl ChannelClient {
@@ -1485,8 +1561,10 @@ impl ChannelClient {
         let this = Arc::new(Self {
             outgoing_tx,
             next_message_id: AtomicU32::new(0),
+            max_received: AtomicU32::new(0),
             response_channels: ResponseChannels::default(),
             message_handlers: Default::default(),
+            buffer: Mutex::new(VecDeque::new()),
         });
 
         Self::start_handling_messages(this.clone(), incoming_rx, cx);
@@ -1507,6 +1585,25 @@ impl ChannelClient {
                     let Some(this) = this.upgrade() else {
                         return anyhow::Ok(());
                     };
+                    if let Some(ack_id) = incoming.ack_id {
+                        let mut buffer = this.buffer.lock();
+                        while buffer.front().is_some_and(|msg| msg.id <= ack_id) {
+                            buffer.pop_front();
+                        }
+                    }
+                    if let Some(proto::envelope::Payload::FlushBufferedMessages(_)) = &incoming.payload {
+                        {
+                            let buffer = this.buffer.lock();
+                            for envelope in buffer.iter() {
+                                this.outgoing_tx.unbounded_send(envelope.clone()).ok();
+                            }
+                        }
+                        let response = proto::Ack{}.into_envelope(0, Some(incoming.id), None);
+                        this.send_dynamic(response).ok();
+                        continue;
+                    }
+
+                    this.max_received.store(incoming.id, SeqCst);
 
                     if let Some(request_id) = incoming.responding_to {
                         let request_id = MessageId(request_id);
@@ -1583,6 +1680,23 @@ impl ChannelClient {
         }
     }
 
+    pub async fn resync(&self, timeout: Duration) -> Result<()> {
+        smol::future::or(
+            async {
+                self.request(proto::FlushBufferedMessages {}).await?;
+                for envelope in self.buffer.lock().iter() {
+                    self.outgoing_tx.unbounded_send(envelope.clone()).ok();
+                }
+                Ok(())
+            },
+            async {
+                smol::Timer::after(timeout).await;
+                Err(anyhow!("Timeout detected"))
+            },
+        )
+        .await
+    }
+
     pub async fn ping(&self, timeout: Duration) -> Result<()> {
         smol::future::or(
             async {
@@ -1612,7 +1726,8 @@ impl ChannelClient {
         let mut response_channels_lock = self.response_channels.lock();
         response_channels_lock.insert(MessageId(envelope.id), tx);
         drop(response_channels_lock);
-        let result = self.outgoing_tx.unbounded_send(envelope);
+
+        let result = self.send_buffered(envelope);
         async move {
             if let Err(error) = &result {
                 log::error!("failed to send message: {}", error);
@@ -1629,6 +1744,12 @@ impl ChannelClient {
 
     pub fn send_dynamic(&self, mut envelope: proto::Envelope) -> Result<()> {
         envelope.id = self.next_message_id.fetch_add(1, SeqCst);
+        self.send_buffered(envelope)
+    }
+
+    pub fn send_buffered(&self, mut envelope: proto::Envelope) -> Result<()> {
+        envelope.ack_id = Some(self.max_received.load(SeqCst));
+        self.buffer.lock().push_back(envelope.clone());
         self.outgoing_tx.unbounded_send(envelope)?;
         Ok(())
     }
@@ -1659,3 +1780,165 @@ impl ProtoClient for ChannelClient {
         false
     }
 }
+
+#[cfg(any(test, feature = "test-support"))]
+mod fake {
+    use std::path::PathBuf;
+
+    use anyhow::Result;
+    use async_trait::async_trait;
+    use futures::{
+        channel::{
+            mpsc::{self, Sender},
+            oneshot,
+        },
+        select_biased, FutureExt, SinkExt, StreamExt,
+    };
+    use gpui::{AsyncAppContext, BorrowAppContext, Global, SemanticVersion, Task};
+    use rpc::proto::Envelope;
+
+    use super::{
+        ChannelForwarder, SshClientDelegate, SshConnectionOptions, SshPlatform, SshRemoteProcess,
+    };
+
+    pub(super) struct SshRemoteConnection {
+        connection_options: SshConnectionOptions,
+    }
+
+    impl SshRemoteConnection {
+        pub(super) fn new(
+            connection_options: &SshConnectionOptions,
+        ) -> Option<Box<dyn SshRemoteProcess>> {
+            if connection_options.host == "<fake>" {
+                return Some(Box::new(Self {
+                    connection_options: connection_options.clone(),
+                }));
+            }
+            return None;
+        }
+        pub(super) async fn multiplex(
+            connection_options: SshConnectionOptions,
+            mut client_tx: mpsc::UnboundedSender<Envelope>,
+            mut client_rx: mpsc::UnboundedReceiver<Envelope>,
+            mut connection_activity_tx: Sender<()>,
+            cx: &mut AsyncAppContext,
+        ) -> Task<Result<Option<i32>>> {
+            let (server_tx, server_rx) = cx
+                .update(|cx| {
+                    cx.update_global(|conns: &mut GlobalConnections, _| {
+                        conns.take(connection_options.port.unwrap())
+                    })
+                })
+                .unwrap()
+                .into_channels()
+                .await;
+
+            let (forwarder, mut proxy_tx, mut proxy_rx) =
+                ChannelForwarder::new(server_tx, server_rx, cx);
+
+            cx.update(|cx| {
+                cx.update_global(|conns: &mut GlobalConnections, _| {
+                    conns.replace(connection_options.port.unwrap(), forwarder)
+                })
+            })
+            .unwrap();
+
+            cx.background_executor().spawn(async move {
+                loop {
+                    select_biased! {
+                        server_to_client = proxy_rx.next().fuse() => {
+                            let Some(server_to_client) = server_to_client else {
+                                return Ok(Some(1))
+                            };
+                            connection_activity_tx.try_send(()).ok();
+                            client_tx.send(server_to_client).await.ok();
+                        }
+                        client_to_server = client_rx.next().fuse() => {
+                            let Some(client_to_server) = client_to_server else {
+                                return Ok(None)
+                            };
+                            proxy_tx.send(client_to_server).await.ok();
+
+                        }
+                    }
+                }
+            })
+        }
+    }
+
+    #[async_trait]
+    impl SshRemoteProcess for SshRemoteConnection {
+        async fn kill(&mut self) -> Result<()> {
+            Ok(())
+        }
+
+        fn ssh_args(&self) -> Vec<String> {
+            Vec::new()
+        }
+
+        fn connection_options(&self) -> SshConnectionOptions {
+            self.connection_options.clone()
+        }
+    }
+
+    #[derive(Default)]
+    pub(super) struct GlobalConnections(Vec<Option<ChannelForwarder>>);
+    impl Global for GlobalConnections {}
+
+    impl GlobalConnections {
+        pub(super) fn push(&mut self, forwarder: ChannelForwarder) -> u16 {
+            self.0.push(Some(forwarder));
+            self.0.len() as u16 - 1
+        }
+
+        pub(super) fn take(&mut self, port: u16) -> ChannelForwarder {
+            self.0
+                .get_mut(port as usize)
+                .expect("no fake server for port")
+                .take()
+                .expect("fake server is already borrowed")
+        }
+        pub(super) fn replace(&mut self, port: u16, forwarder: ChannelForwarder) {
+            let ret = self
+                .0
+                .get_mut(port as usize)
+                .expect("no fake server for port")
+                .replace(forwarder);
+            if ret.is_some() {
+                panic!("fake server is already replaced");
+            }
+        }
+    }
+
+    pub(super) struct Delegate;
+
+    impl SshClientDelegate for Delegate {
+        fn ask_password(
+            &self,
+            _: String,
+            _: &mut AsyncAppContext,
+        ) -> oneshot::Receiver<Result<String>> {
+            unreachable!()
+        }
+        fn remote_server_binary_path(
+            &self,
+            _: SshPlatform,
+            _: &mut AsyncAppContext,
+        ) -> Result<PathBuf> {
+            unreachable!()
+        }
+        fn get_server_binary(
+            &self,
+            _: SshPlatform,
+            _: &mut AsyncAppContext,
+        ) -> oneshot::Receiver<Result<(PathBuf, SemanticVersion)>> {
+            unreachable!()
+        }
+        fn set_status(&self, _: Option<&str>, _: &mut AsyncAppContext) {
+            unreachable!()
+        }
+        fn set_error(&self, _: String, _: &mut AsyncAppContext) {
+            unreachable!()
+        }
+    }
+}
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 41065ad5508310..bfe58931c9e89b 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -641,6 +641,47 @@ async fn test_open_server_settings(cx: &mut TestAppContext, server_cx: &mut Test
     })
 }
 
+#[gpui::test(iterations = 10)]
+async fn test_reconnect(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {
+    let (project, _headless, fs) = init_test(cx, server_cx).await;
+
+    let (worktree, _) = project
+        .update(cx, |project, cx| {
+            project.find_or_create_worktree("/code/project1", true, cx)
+        })
+        .await
+        .unwrap();
+
+    let worktree_id = worktree.read_with(cx, |worktree, _| worktree.id());
+    let buffer = project
+        .update(cx, |project, cx| {
+            project.open_buffer((worktree_id, Path::new("src/lib.rs")), cx)
+        })
+        .await
+        .unwrap();
+
+    buffer.update(cx, |buffer, cx| {
+        assert_eq!(buffer.text(), "fn one() -> usize { 1 }");
+        let ix = buffer.text().find('1').unwrap();
+        buffer.edit([(ix..ix + 1, "100")], None, cx);
+    });
+
+    let client = cx.read(|cx| project.read(cx).ssh_client().unwrap());
+    client
+        .update(cx, |client, cx| client.simulate_disconnect(cx))
+        .detach();
+
+    project
+        .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx))
+        .await
+        .unwrap();
+
+    assert_eq!(
+        fs.load("/code/project1/src/lib.rs".as_ref()).await.unwrap(),
+        "fn one() -> usize { 100 }"
+    );
+}
+
 fn init_logger() {
     if std::env::var("RUST_LOG").is_ok() {
         env_logger::try_init().ok();
@@ -651,9 +692,9 @@ async fn init_test(
     cx: &mut TestAppContext,
     server_cx: &mut TestAppContext,
 ) -> (Model<Project>, Model<HeadlessProject>, Arc<FakeFs>) {
-    let (ssh_remote_client, ssh_server_client) = SshRemoteClient::fake(cx, server_cx);
     init_logger();
 
+    let (forwarder, ssh_server_client) = SshRemoteClient::fake_server(server_cx);
     let fs = FakeFs::new(server_cx.executor());
     fs.insert_tree(
         "/code",
@@ -694,8 +735,9 @@ async fn init_test(
             cx,
         )
     });
-    let project = build_project(ssh_remote_client, cx);
 
+    let ssh = SshRemoteClient::fake_client(forwarder, cx).await;
+    let project = build_project(ssh, cx);
     project
         .update(cx, {
             let headless = headless.clone();

From 47380001cce322381c8f0d47323d10169ce69009 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 18 Oct 2024 17:31:41 -0400
Subject: [PATCH 757/762] remote: Fix formatting (#19438)

This PR fixes some formatting issues from #19398 that slipped past CI,
somehow.

Release Notes:

- N/A
---
 crates/remote/src/ssh_session.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index e4d292d2f8c8b2..74ee837e46584f 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -1591,14 +1591,16 @@ impl ChannelClient {
                             buffer.pop_front();
                         }
                     }
-                    if let Some(proto::envelope::Payload::FlushBufferedMessages(_)) = &incoming.payload {
+                    if let Some(proto::envelope::Payload::FlushBufferedMessages(_)) =
+                        &incoming.payload
+                    {
                         {
                             let buffer = this.buffer.lock();
                             for envelope in buffer.iter() {
                                 this.outgoing_tx.unbounded_send(envelope.clone()).ok();
                             }
                         }
-                        let response = proto::Ack{}.into_envelope(0, Some(incoming.id), None);
+                        let response = proto::Ack {}.into_envelope(0, Some(incoming.id), None);
                         this.send_dynamic(response).ok();
                         continue;
                     }

From a5492b3ea6b00577a8461223844f1a3c47ac1d4f Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Fri, 18 Oct 2024 16:08:56 -0600
Subject: [PATCH 758/762] Revert "SSH reconnect reliability (#19398)" (#19440)

This reverts commit 98ecb43b2dac3d70f43d745ab32be5a3d4bf323b.

Tests fail on main?!

Closes #ISSUE

Release Notes:

- N/A
---
 Cargo.lock                                    |   1 -
 .../remote_editing_collaboration_tests.rs     |   3 +-
 crates/project/src/project.rs                 |   4 -
 crates/proto/proto/zed.proto                  |   8 +-
 crates/proto/src/macros.rs                    |   1 -
 crates/proto/src/proto.rs                     |   2 -
 crates/remote/Cargo.toml                      |   1 -
 crates/remote/src/ssh_session.rs              | 435 +++---------------
 .../remote_server/src/remote_editing_tests.rs |  46 +-
 9 files changed, 79 insertions(+), 422 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f32d24dbfb6c2f..a27005e5d12df9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9119,7 +9119,6 @@ name = "remote"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "async-trait",
  "collections",
  "fs",
  "futures 0.3.30",
diff --git a/crates/collab/src/tests/remote_editing_collaboration_tests.rs b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
index a23aadf5e02a52..dae33457555ec4 100644
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -26,7 +26,7 @@ async fn test_sharing_an_ssh_remote_project(
         .await;
 
     // Set up project on remote FS
-    let (forwarder, server_ssh) = SshRemoteClient::fake_server(server_cx);
+    let (client_ssh, server_ssh) = SshRemoteClient::fake(cx_a, server_cx);
     let remote_fs = FakeFs::new(server_cx.executor());
     remote_fs
         .insert_tree(
@@ -67,7 +67,6 @@ async fn test_sharing_an_ssh_remote_project(
         )
     });
 
-    let client_ssh = SshRemoteClient::fake_client(forwarder, cx_a).await;
     let (project_a, worktree_id) = client_a
         .build_ssh_project("/code/project1", client_ssh, cx_a)
         .await;
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 8ea9e78cb7a914..70d5962647c487 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -1243,10 +1243,6 @@ impl Project {
         self.client.clone()
     }
 
-    pub fn ssh_client(&self) -> Option<Model<SshRemoteClient>> {
-        self.ssh_client.clone()
-    }
-
     pub fn user_store(&self) -> Model<UserStore> {
         self.user_store.clone()
     }
diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto
index e089fcdebaa3f4..09891de6fecd3b 100644
--- a/crates/proto/proto/zed.proto
+++ b/crates/proto/proto/zed.proto
@@ -12,7 +12,6 @@ message Envelope {
     uint32 id = 1;
     optional uint32 responding_to = 2;
     optional PeerId original_sender_id = 3;
-    optional uint32 ack_id = 266;
 
     oneof payload {
         Hello hello = 4;
@@ -296,9 +295,7 @@ message Envelope {
         OpenServerSettings open_server_settings = 263;
 
         GetPermalinkToLine get_permalink_to_line = 264;
-        GetPermalinkToLineResponse get_permalink_to_line_response = 265;
-
-        FlushBufferedMessages flush_buffered_messages = 267;
+        GetPermalinkToLineResponse get_permalink_to_line_response = 265;  // current max
     }
 
     reserved 87 to 88;
@@ -2524,6 +2521,3 @@ message GetPermalinkToLine {
 message GetPermalinkToLineResponse {
     string permalink = 1;
 }
-
-message FlushBufferedMessages {}
-message FlushBufferedMessagesResponse {}
diff --git a/crates/proto/src/macros.rs b/crates/proto/src/macros.rs
index 2ce0c0df259d8d..4fdbfff81b6c4f 100644
--- a/crates/proto/src/macros.rs
+++ b/crates/proto/src/macros.rs
@@ -32,7 +32,6 @@ macro_rules! messages {
                         responding_to,
                         original_sender_id,
                         payload: Some(envelope::Payload::$name(self)),
-                        ack_id: None,
                     }
                 }
 
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index 8179473feaa5f4..ffbbeb49c2b48a 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -372,7 +372,6 @@ messages!(
     (OpenServerSettings, Foreground),
     (GetPermalinkToLine, Foreground),
     (GetPermalinkToLineResponse, Foreground),
-    (FlushBufferedMessages, Foreground),
 );
 
 request_messages!(
@@ -499,7 +498,6 @@ request_messages!(
     (RemoveWorktree, Ack),
     (OpenServerSettings, OpenBufferResponse),
     (GetPermalinkToLine, GetPermalinkToLineResponse),
-    (FlushBufferedMessages, Ack),
 );
 
 entity_messages!(
diff --git a/crates/remote/Cargo.toml b/crates/remote/Cargo.toml
index 937a69ee592787..b8c5f34cc5854a 100644
--- a/crates/remote/Cargo.toml
+++ b/crates/remote/Cargo.toml
@@ -19,7 +19,6 @@ test-support = ["fs/test-support"]
 
 [dependencies]
 anyhow.workspace = true
-async-trait.workspace = true
 collections.workspace = true
 fs.workspace = true
 futures.workspace = true
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index 74ee837e46584f..f7ef74ce392398 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -6,7 +6,6 @@ use crate::{
     proxy::ProxyLaunchError,
 };
 use anyhow::{anyhow, Context as _, Result};
-use async_trait::async_trait;
 use collections::HashMap;
 use futures::{
     channel::{
@@ -32,7 +31,6 @@ use smol::{
 };
 use std::{
     any::TypeId,
-    collections::VecDeque,
     ffi::OsStr,
     fmt,
     ops::ControlFlow,
@@ -278,7 +276,7 @@ async fn run_cmd(command: &mut process::Command) -> Result<String> {
     }
 }
 
-pub struct ChannelForwarder {
+struct ChannelForwarder {
     quit_tx: UnboundedSender<()>,
     forwarding_task: Task<(UnboundedSender<Envelope>, UnboundedReceiver<Envelope>)>,
 }
@@ -349,7 +347,7 @@ const MAX_RECONNECT_ATTEMPTS: usize = 3;
 enum State {
     Connecting,
     Connected {
-        ssh_connection: Box<dyn SshRemoteProcess>,
+        ssh_connection: SshRemoteConnection,
         delegate: Arc<dyn SshClientDelegate>,
         forwarder: ChannelForwarder,
 
@@ -359,7 +357,7 @@ enum State {
     HeartbeatMissed {
         missed_heartbeats: usize,
 
-        ssh_connection: Box<dyn SshRemoteProcess>,
+        ssh_connection: SshRemoteConnection,
         delegate: Arc<dyn SshClientDelegate>,
         forwarder: ChannelForwarder,
 
@@ -368,7 +366,7 @@ enum State {
     },
     Reconnecting,
     ReconnectFailed {
-        ssh_connection: Box<dyn SshRemoteProcess>,
+        ssh_connection: SshRemoteConnection,
         delegate: Arc<dyn SshClientDelegate>,
         forwarder: ChannelForwarder,
 
@@ -394,11 +392,11 @@ impl fmt::Display for State {
 }
 
 impl State {
-    fn ssh_connection(&self) -> Option<&dyn SshRemoteProcess> {
+    fn ssh_connection(&self) -> Option<&SshRemoteConnection> {
         match self {
-            Self::Connected { ssh_connection, .. } => Some(ssh_connection.as_ref()),
-            Self::HeartbeatMissed { ssh_connection, .. } => Some(ssh_connection.as_ref()),
-            Self::ReconnectFailed { ssh_connection, .. } => Some(ssh_connection.as_ref()),
+            Self::Connected { ssh_connection, .. } => Some(ssh_connection),
+            Self::HeartbeatMissed { ssh_connection, .. } => Some(ssh_connection),
+            Self::ReconnectFailed { ssh_connection, .. } => Some(ssh_connection),
             _ => None,
         }
     }
@@ -543,19 +541,23 @@ impl SshRemoteClient {
             let (proxy, proxy_incoming_tx, proxy_outgoing_rx) =
                 ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
 
-            let (ssh_connection, io_task) = Self::establish_connection(
+            let (ssh_connection, ssh_proxy_process) = Self::establish_connection(
                 unique_identifier,
                 false,
                 connection_options,
-                proxy_incoming_tx,
-                proxy_outgoing_rx,
-                connection_activity_tx,
                 delegate.clone(),
                 &mut cx,
             )
             .await?;
 
-            let multiplex_task = Self::monitor(this.downgrade(), io_task, &cx);
+            let multiplex_task = Self::multiplex(
+                this.downgrade(),
+                ssh_proxy_process,
+                proxy_incoming_tx,
+                proxy_outgoing_rx,
+                connection_activity_tx,
+                &mut cx,
+            );
 
             if let Err(error) = client.ping(HEARTBEAT_TIMEOUT).await {
                 log::error!("failed to establish connection: {}", error);
@@ -701,24 +703,30 @@ impl SshRemoteClient {
                 };
             }
 
-            if let Err(error) = ssh_connection.kill().await.context("Failed to kill ssh process") {
+            if let Err(error) = ssh_connection.master_process.kill() {
                 failed!(error, attempts, ssh_connection, delegate, forwarder);
             };
 
-            let connection_options = ssh_connection.connection_options();
+            if let Err(error) = ssh_connection
+                .master_process
+                .status()
+                .await
+                .context("Failed to kill ssh process")
+            {
+                failed!(error, attempts, ssh_connection, delegate, forwarder);
+            }
+
+            let connection_options = ssh_connection.socket.connection_options.clone();
 
             let (incoming_tx, outgoing_rx) = forwarder.into_channels().await;
             let (forwarder, proxy_incoming_tx, proxy_outgoing_rx) =
                 ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx);
             let (connection_activity_tx, connection_activity_rx) = mpsc::channel::<()>(1);
 
-            let (ssh_connection, io_task) = match Self::establish_connection(
+            let (ssh_connection, ssh_process) = match Self::establish_connection(
                 identifier,
                 true,
                 connection_options,
-                proxy_incoming_tx,
-                proxy_outgoing_rx,
-                connection_activity_tx,
                 delegate.clone(),
                 &mut cx,
             )
@@ -730,9 +738,16 @@ impl SshRemoteClient {
                 }
             };
 
-            let multiplex_task = Self::monitor(this.clone(), io_task, &cx);
+            let multiplex_task = Self::multiplex(
+                this.clone(),
+                ssh_process,
+                proxy_incoming_tx,
+                proxy_outgoing_rx,
+                connection_activity_tx,
+                &mut cx,
+            );
 
-            if let Err(error) = client.resync(HEARTBEAT_TIMEOUT).await {
+            if let Err(error) = client.ping(HEARTBEAT_TIMEOUT).await {
                 failed!(error, attempts, ssh_connection, delegate, forwarder);
             };
 
@@ -896,17 +911,18 @@ impl SshRemoteClient {
     }
 
     fn multiplex(
+        this: WeakModel<Self>,
         mut ssh_proxy_process: Child,
         incoming_tx: UnboundedSender<Envelope>,
         mut outgoing_rx: UnboundedReceiver<Envelope>,
         mut connection_activity_tx: Sender<()>,
         cx: &AsyncAppContext,
-    ) -> Task<Result<Option<i32>>> {
+    ) -> Task<Result<()>> {
         let mut child_stderr = ssh_proxy_process.stderr.take().unwrap();
         let mut child_stdout = ssh_proxy_process.stdout.take().unwrap();
         let mut child_stdin = ssh_proxy_process.stdin.take().unwrap();
 
-        cx.background_executor().spawn(async move {
+        let io_task = cx.background_executor().spawn(async move {
             let mut stdin_buffer = Vec::new();
             let mut stdout_buffer = Vec::new();
             let mut stderr_buffer = Vec::new();
@@ -985,14 +1001,8 @@ impl SshRemoteClient {
                     }
                 }
             }
-        })
-    }
+        });
 
-    fn monitor(
-        this: WeakModel<Self>,
-        io_task: Task<Result<Option<i32>>>,
-        cx: &AsyncAppContext,
-    ) -> Task<Result<()>> {
         cx.spawn(|mut cx| async move {
             let result = io_task.await;
 
@@ -1051,40 +1061,21 @@ impl SshRemoteClient {
         cx.notify();
     }
 
-    #[allow(clippy::too_many_arguments)]
     async fn establish_connection(
         unique_identifier: String,
         reconnect: bool,
         connection_options: SshConnectionOptions,
-        proxy_incoming_tx: UnboundedSender<Envelope>,
-        proxy_outgoing_rx: UnboundedReceiver<Envelope>,
-        connection_activity_tx: Sender<()>,
         delegate: Arc<dyn SshClientDelegate>,
         cx: &mut AsyncAppContext,
-    ) -> Result<(Box<dyn SshRemoteProcess>, Task<Result<Option<i32>>>)> {
-        #[cfg(any(test, feature = "test-support"))]
-        if let Some(fake) = fake::SshRemoteConnection::new(&connection_options) {
-            let io_task = fake::SshRemoteConnection::multiplex(
-                fake.connection_options(),
-                proxy_incoming_tx,
-                proxy_outgoing_rx,
-                connection_activity_tx,
-                cx,
-            )
-            .await;
-            return Ok((fake, io_task));
-        }
-
+    ) -> Result<(SshRemoteConnection, Child)> {
         let ssh_connection =
             SshRemoteConnection::new(connection_options, delegate.clone(), cx).await?;
 
         let platform = ssh_connection.query_platform().await?;
         let remote_binary_path = delegate.remote_server_binary_path(platform, cx)?;
-        if !reconnect {
-            ssh_connection
-                .ensure_server_binary(&delegate, &remote_binary_path, platform, cx)
-                .await?;
-        }
+        ssh_connection
+            .ensure_server_binary(&delegate, &remote_binary_path, platform, cx)
+            .await?;
 
         let socket = ssh_connection.socket.clone();
         run_cmd(socket.ssh_command(&remote_binary_path).arg("version")).await?;
@@ -1109,15 +1100,7 @@ impl SshRemoteClient {
             .spawn()
             .context("failed to spawn remote server")?;
 
-        let io_task = Self::multiplex(
-            ssh_proxy_process,
-            proxy_incoming_tx,
-            proxy_outgoing_rx,
-            connection_activity_tx,
-            &cx,
-        );
-
-        Ok((Box::new(ssh_connection), io_task))
+        Ok((ssh_connection, ssh_proxy_process))
     }
 
     pub fn subscribe_to_entity<E: 'static>(&self, remote_id: u64, entity: &Model<E>) {
@@ -1129,7 +1112,7 @@ impl SshRemoteClient {
             .lock()
             .as_ref()
             .and_then(|state| state.ssh_connection())
-            .map(|ssh_connection| ssh_connection.ssh_args())
+            .map(|ssh_connection| ssh_connection.socket.ssh_args())
     }
 
     pub fn proto_client(&self) -> AnyProtoClient {
@@ -1144,6 +1127,7 @@ impl SshRemoteClient {
         self.connection_options.clone()
     }
 
+    #[cfg(not(any(test, feature = "test-support")))]
     pub fn connection_state(&self) -> ConnectionState {
         self.state
             .lock()
@@ -1152,69 +1136,37 @@ impl SshRemoteClient {
             .unwrap_or(ConnectionState::Disconnected)
     }
 
-    pub fn is_disconnected(&self) -> bool {
-        self.connection_state() == ConnectionState::Disconnected
-    }
-
     #[cfg(any(test, feature = "test-support"))]
-    pub fn simulate_disconnect(&self, cx: &mut AppContext) -> Task<()> {
-        use gpui::BorrowAppContext;
-
-        let port = self.connection_options().port.unwrap();
-
-        let disconnect =
-            cx.update_global(|c: &mut fake::GlobalConnections, _cx| c.take(port).into_channels());
-        cx.spawn(|mut cx| async move {
-            let (input_rx, output_tx) = disconnect.await;
-            let (forwarder, _, _) = ChannelForwarder::new(input_rx, output_tx, &mut cx);
-            cx.update_global(|c: &mut fake::GlobalConnections, _cx| c.replace(port, forwarder))
-                .unwrap()
-        })
+    pub fn connection_state(&self) -> ConnectionState {
+        ConnectionState::Connected
     }
 
-    #[cfg(any(test, feature = "test-support"))]
-    pub fn fake_server(
-        server_cx: &mut gpui::TestAppContext,
-    ) -> (ChannelForwarder, Arc<ChannelClient>) {
-        server_cx.update(|cx| {
-            let (outgoing_tx, outgoing_rx) = mpsc::unbounded::<Envelope>();
-            let (incoming_tx, incoming_rx) = mpsc::unbounded::<Envelope>();
-
-            // We use the forwarder on the server side (in production we only use one on the client side)
-            // the idea is that we can simulate a disconnect/reconnect by just messing with the forwarder.
-            let (forwarder, _, _) =
-                ChannelForwarder::new(incoming_tx, outgoing_rx, &mut cx.to_async());
-
-            let client = ChannelClient::new(incoming_rx, outgoing_tx, cx);
-            (forwarder, client)
-        })
+    pub fn is_disconnected(&self) -> bool {
+        self.connection_state() == ConnectionState::Disconnected
     }
 
     #[cfg(any(test, feature = "test-support"))]
-    pub async fn fake_client(
-        forwarder: ChannelForwarder,
+    pub fn fake(
         client_cx: &mut gpui::TestAppContext,
-    ) -> Model<Self> {
-        use gpui::BorrowAppContext;
-        client_cx
-            .update(|cx| {
-                let port = cx.update_default_global(|c: &mut fake::GlobalConnections, _cx| {
-                    c.push(forwarder)
-                });
+        server_cx: &mut gpui::TestAppContext,
+    ) -> (Model<Self>, Arc<ChannelClient>) {
+        use gpui::Context;
 
-                Self::new(
-                    "fake".to_string(),
-                    SshConnectionOptions {
-                        host: "<fake>".to_string(),
-                        port: Some(port),
-                        ..Default::default()
-                    },
-                    Arc::new(fake::Delegate),
-                    cx,
-                )
-            })
-            .await
-            .unwrap()
+        let (server_to_client_tx, server_to_client_rx) = mpsc::unbounded();
+        let (client_to_server_tx, client_to_server_rx) = mpsc::unbounded();
+
+        (
+            client_cx.update(|cx| {
+                let client = ChannelClient::new(server_to_client_rx, client_to_server_tx, cx);
+                cx.new_model(|_| Self {
+                    client,
+                    unique_identifier: "fake".to_string(),
+                    connection_options: SshConnectionOptions::default(),
+                    state: Arc::new(Mutex::new(None)),
+                })
+            }),
+            server_cx.update(|cx| ChannelClient::new(client_to_server_rx, server_to_client_tx, cx)),
+        )
     }
 }
 
@@ -1224,13 +1176,6 @@ impl From<SshRemoteClient> for AnyProtoClient {
     }
 }
 
-#[async_trait]
-trait SshRemoteProcess: Send + Sync {
-    async fn kill(&mut self) -> Result<()>;
-    fn ssh_args(&self) -> Vec<String>;
-    fn connection_options(&self) -> SshConnectionOptions;
-}
-
 struct SshRemoteConnection {
     socket: SshSocket,
     master_process: process::Child,
@@ -1245,25 +1190,6 @@ impl Drop for SshRemoteConnection {
     }
 }
 
-#[async_trait]
-impl SshRemoteProcess for SshRemoteConnection {
-    async fn kill(&mut self) -> Result<()> {
-        self.master_process.kill()?;
-
-        self.master_process.status().await?;
-
-        Ok(())
-    }
-
-    fn ssh_args(&self) -> Vec<String> {
-        self.socket.ssh_args()
-    }
-
-    fn connection_options(&self) -> SshConnectionOptions {
-        self.socket.connection_options.clone()
-    }
-}
-
 impl SshRemoteConnection {
     #[cfg(not(unix))]
     async fn new(
@@ -1546,10 +1472,8 @@ type ResponseChannels = Mutex<HashMap<MessageId, oneshot::Sender<(Envelope, ones
 pub struct ChannelClient {
     next_message_id: AtomicU32,
     outgoing_tx: mpsc::UnboundedSender<Envelope>,
-    buffer: Mutex<VecDeque<Envelope>>,
-    response_channels: ResponseChannels,
-    message_handlers: Mutex<ProtoMessageHandlerSet>,
-    max_received: AtomicU32,
+    response_channels: ResponseChannels,             // Lock
+    message_handlers: Mutex<ProtoMessageHandlerSet>, // Lock
 }
 
 impl ChannelClient {
@@ -1561,10 +1485,8 @@ impl ChannelClient {
         let this = Arc::new(Self {
             outgoing_tx,
             next_message_id: AtomicU32::new(0),
-            max_received: AtomicU32::new(0),
             response_channels: ResponseChannels::default(),
             message_handlers: Default::default(),
-            buffer: Mutex::new(VecDeque::new()),
         });
 
         Self::start_handling_messages(this.clone(), incoming_rx, cx);
@@ -1585,27 +1507,6 @@ impl ChannelClient {
                     let Some(this) = this.upgrade() else {
                         return anyhow::Ok(());
                     };
-                    if let Some(ack_id) = incoming.ack_id {
-                        let mut buffer = this.buffer.lock();
-                        while buffer.front().is_some_and(|msg| msg.id <= ack_id) {
-                            buffer.pop_front();
-                        }
-                    }
-                    if let Some(proto::envelope::Payload::FlushBufferedMessages(_)) =
-                        &incoming.payload
-                    {
-                        {
-                            let buffer = this.buffer.lock();
-                            for envelope in buffer.iter() {
-                                this.outgoing_tx.unbounded_send(envelope.clone()).ok();
-                            }
-                        }
-                        let response = proto::Ack {}.into_envelope(0, Some(incoming.id), None);
-                        this.send_dynamic(response).ok();
-                        continue;
-                    }
-
-                    this.max_received.store(incoming.id, SeqCst);
 
                     if let Some(request_id) = incoming.responding_to {
                         let request_id = MessageId(request_id);
@@ -1682,23 +1583,6 @@ impl ChannelClient {
         }
     }
 
-    pub async fn resync(&self, timeout: Duration) -> Result<()> {
-        smol::future::or(
-            async {
-                self.request(proto::FlushBufferedMessages {}).await?;
-                for envelope in self.buffer.lock().iter() {
-                    self.outgoing_tx.unbounded_send(envelope.clone()).ok();
-                }
-                Ok(())
-            },
-            async {
-                smol::Timer::after(timeout).await;
-                Err(anyhow!("Timeout detected"))
-            },
-        )
-        .await
-    }
-
     pub async fn ping(&self, timeout: Duration) -> Result<()> {
         smol::future::or(
             async {
@@ -1728,8 +1612,7 @@ impl ChannelClient {
         let mut response_channels_lock = self.response_channels.lock();
         response_channels_lock.insert(MessageId(envelope.id), tx);
         drop(response_channels_lock);
-
-        let result = self.send_buffered(envelope);
+        let result = self.outgoing_tx.unbounded_send(envelope);
         async move {
             if let Err(error) = &result {
                 log::error!("failed to send message: {}", error);
@@ -1746,12 +1629,6 @@ impl ChannelClient {
 
     pub fn send_dynamic(&self, mut envelope: proto::Envelope) -> Result<()> {
         envelope.id = self.next_message_id.fetch_add(1, SeqCst);
-        self.send_buffered(envelope)
-    }
-
-    pub fn send_buffered(&self, mut envelope: proto::Envelope) -> Result<()> {
-        envelope.ack_id = Some(self.max_received.load(SeqCst));
-        self.buffer.lock().push_back(envelope.clone());
         self.outgoing_tx.unbounded_send(envelope)?;
         Ok(())
     }
@@ -1782,165 +1659,3 @@ impl ProtoClient for ChannelClient {
         false
     }
 }
-
-#[cfg(any(test, feature = "test-support"))]
-mod fake {
-    use std::path::PathBuf;
-
-    use anyhow::Result;
-    use async_trait::async_trait;
-    use futures::{
-        channel::{
-            mpsc::{self, Sender},
-            oneshot,
-        },
-        select_biased, FutureExt, SinkExt, StreamExt,
-    };
-    use gpui::{AsyncAppContext, BorrowAppContext, Global, SemanticVersion, Task};
-    use rpc::proto::Envelope;
-
-    use super::{
-        ChannelForwarder, SshClientDelegate, SshConnectionOptions, SshPlatform, SshRemoteProcess,
-    };
-
-    pub(super) struct SshRemoteConnection {
-        connection_options: SshConnectionOptions,
-    }
-
-    impl SshRemoteConnection {
-        pub(super) fn new(
-            connection_options: &SshConnectionOptions,
-        ) -> Option<Box<dyn SshRemoteProcess>> {
-            if connection_options.host == "<fake>" {
-                return Some(Box::new(Self {
-                    connection_options: connection_options.clone(),
-                }));
-            }
-            return None;
-        }
-        pub(super) async fn multiplex(
-            connection_options: SshConnectionOptions,
-            mut client_tx: mpsc::UnboundedSender<Envelope>,
-            mut client_rx: mpsc::UnboundedReceiver<Envelope>,
-            mut connection_activity_tx: Sender<()>,
-            cx: &mut AsyncAppContext,
-        ) -> Task<Result<Option<i32>>> {
-            let (server_tx, server_rx) = cx
-                .update(|cx| {
-                    cx.update_global(|conns: &mut GlobalConnections, _| {
-                        conns.take(connection_options.port.unwrap())
-                    })
-                })
-                .unwrap()
-                .into_channels()
-                .await;
-
-            let (forwarder, mut proxy_tx, mut proxy_rx) =
-                ChannelForwarder::new(server_tx, server_rx, cx);
-
-            cx.update(|cx| {
-                cx.update_global(|conns: &mut GlobalConnections, _| {
-                    conns.replace(connection_options.port.unwrap(), forwarder)
-                })
-            })
-            .unwrap();
-
-            cx.background_executor().spawn(async move {
-                loop {
-                    select_biased! {
-                        server_to_client = proxy_rx.next().fuse() => {
-                            let Some(server_to_client) = server_to_client else {
-                                return Ok(Some(1))
-                            };
-                            connection_activity_tx.try_send(()).ok();
-                            client_tx.send(server_to_client).await.ok();
-                        }
-                        client_to_server = client_rx.next().fuse() => {
-                            let Some(client_to_server) = client_to_server else {
-                                return Ok(None)
-                            };
-                            proxy_tx.send(client_to_server).await.ok();
-
-                        }
-                    }
-                }
-            })
-        }
-    }
-
-    #[async_trait]
-    impl SshRemoteProcess for SshRemoteConnection {
-        async fn kill(&mut self) -> Result<()> {
-            Ok(())
-        }
-
-        fn ssh_args(&self) -> Vec<String> {
-            Vec::new()
-        }
-
-        fn connection_options(&self) -> SshConnectionOptions {
-            self.connection_options.clone()
-        }
-    }
-
-    #[derive(Default)]
-    pub(super) struct GlobalConnections(Vec<Option<ChannelForwarder>>);
-    impl Global for GlobalConnections {}
-
-    impl GlobalConnections {
-        pub(super) fn push(&mut self, forwarder: ChannelForwarder) -> u16 {
-            self.0.push(Some(forwarder));
-            self.0.len() as u16 - 1
-        }
-
-        pub(super) fn take(&mut self, port: u16) -> ChannelForwarder {
-            self.0
-                .get_mut(port as usize)
-                .expect("no fake server for port")
-                .take()
-                .expect("fake server is already borrowed")
-        }
-        pub(super) fn replace(&mut self, port: u16, forwarder: ChannelForwarder) {
-            let ret = self
-                .0
-                .get_mut(port as usize)
-                .expect("no fake server for port")
-                .replace(forwarder);
-            if ret.is_some() {
-                panic!("fake server is already replaced");
-            }
-        }
-    }
-
-    pub(super) struct Delegate;
-
-    impl SshClientDelegate for Delegate {
-        fn ask_password(
-            &self,
-            _: String,
-            _: &mut AsyncAppContext,
-        ) -> oneshot::Receiver<Result<String>> {
-            unreachable!()
-        }
-        fn remote_server_binary_path(
-            &self,
-            _: SshPlatform,
-            _: &mut AsyncAppContext,
-        ) -> Result<PathBuf> {
-            unreachable!()
-        }
-        fn get_server_binary(
-            &self,
-            _: SshPlatform,
-            _: &mut AsyncAppContext,
-        ) -> oneshot::Receiver<Result<(PathBuf, SemanticVersion)>> {
-            unreachable!()
-        }
-        fn set_status(&self, _: Option<&str>, _: &mut AsyncAppContext) {
-            unreachable!()
-        }
-        fn set_error(&self, _: String, _: &mut AsyncAppContext) {
-            unreachable!()
-        }
-    }
-}
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index bfe58931c9e89b..41065ad5508310 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -641,47 +641,6 @@ async fn test_open_server_settings(cx: &mut TestAppContext, server_cx: &mut Test
     })
 }
 
-#[gpui::test(iterations = 10)]
-async fn test_reconnect(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {
-    let (project, _headless, fs) = init_test(cx, server_cx).await;
-
-    let (worktree, _) = project
-        .update(cx, |project, cx| {
-            project.find_or_create_worktree("/code/project1", true, cx)
-        })
-        .await
-        .unwrap();
-
-    let worktree_id = worktree.read_with(cx, |worktree, _| worktree.id());
-    let buffer = project
-        .update(cx, |project, cx| {
-            project.open_buffer((worktree_id, Path::new("src/lib.rs")), cx)
-        })
-        .await
-        .unwrap();
-
-    buffer.update(cx, |buffer, cx| {
-        assert_eq!(buffer.text(), "fn one() -> usize { 1 }");
-        let ix = buffer.text().find('1').unwrap();
-        buffer.edit([(ix..ix + 1, "100")], None, cx);
-    });
-
-    let client = cx.read(|cx| project.read(cx).ssh_client().unwrap());
-    client
-        .update(cx, |client, cx| client.simulate_disconnect(cx))
-        .detach();
-
-    project
-        .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx))
-        .await
-        .unwrap();
-
-    assert_eq!(
-        fs.load("/code/project1/src/lib.rs".as_ref()).await.unwrap(),
-        "fn one() -> usize { 100 }"
-    );
-}
-
 fn init_logger() {
     if std::env::var("RUST_LOG").is_ok() {
         env_logger::try_init().ok();
@@ -692,9 +651,9 @@ async fn init_test(
     cx: &mut TestAppContext,
     server_cx: &mut TestAppContext,
 ) -> (Model<Project>, Model<HeadlessProject>, Arc<FakeFs>) {
+    let (ssh_remote_client, ssh_server_client) = SshRemoteClient::fake(cx, server_cx);
     init_logger();
 
-    let (forwarder, ssh_server_client) = SshRemoteClient::fake_server(server_cx);
     let fs = FakeFs::new(server_cx.executor());
     fs.insert_tree(
         "/code",
@@ -735,9 +694,8 @@ async fn init_test(
             cx,
         )
     });
+    let project = build_project(ssh_remote_client, cx);
 
-    let ssh = SshRemoteClient::fake_client(forwarder, cx).await;
-    let project = build_project(ssh, cx);
     project
         .update(cx, {
             let headless = headless.clone();

From 30e081b3f738846cf26b68efabc6e72b2df8ed0d Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Fri, 18 Oct 2024 18:31:08 -0400
Subject: [PATCH 759/762] elixir: Bump to v0.1.1 (#19437)

This PR bumps the Elixir extension to v0.1.1.

Changes:

- https://github.com/zed-industries/zed/pull/19135

Release Notes:

- N/A
---
 Cargo.lock                       | 2 +-
 extensions/elixir/Cargo.toml     | 2 +-
 extensions/elixir/extension.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a27005e5d12df9..2b51a987642276 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14742,7 +14742,7 @@ dependencies = [
 
 [[package]]
 name = "zed_elixir"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
diff --git a/extensions/elixir/Cargo.toml b/extensions/elixir/Cargo.toml
index 174711b1ba1931..139d21f1c5e895 100644
--- a/extensions/elixir/Cargo.toml
+++ b/extensions/elixir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "zed_elixir"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
diff --git a/extensions/elixir/extension.toml b/extensions/elixir/extension.toml
index 6f00c29a79650d..ba8a1f66872659 100644
--- a/extensions/elixir/extension.toml
+++ b/extensions/elixir/extension.toml
@@ -1,7 +1,7 @@
 id = "elixir"
 name = "Elixir"
 description = "Elixir support."
-version = "0.1.0"
+version = "0.1.1"
 schema_version = 1
 authors = ["Marshall Bowers <elliott.codes@gmail.com>"]
 repository = "https://github.com/zed-industries/zed"

From 8a912726d7dd4136aae10fcc868e36e59db9c434 Mon Sep 17 00:00:00 2001
From: Mikayla Maki <mikayla@zed.dev>
Date: Fri, 18 Oct 2024 15:41:43 -0700
Subject: [PATCH 760/762] Fix flakey SSH connection (#19439)

Fixes a bug due to the `select!` macro tossing futures that had
partially read messages, causing us to desync our message reading with
the input stream.

Release Notes:

- N/A

---------

Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>
Co-authored-by: conrad <conrad@zed.dev>
---
 crates/remote/src/protocol.rs    |   5 +-
 crates/remote/src/ssh_session.rs | 144 +++++++++++++++----------------
 crates/remote_server/src/unix.rs |  23 +++--
 3 files changed, 90 insertions(+), 82 deletions(-)

diff --git a/crates/remote/src/protocol.rs b/crates/remote/src/protocol.rs
index 311385f73b15b0..787094781d831b 100644
--- a/crates/remote/src/protocol.rs
+++ b/crates/remote/src/protocol.rs
@@ -2,7 +2,6 @@ use anyhow::Result;
 use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use prost::Message as _;
 use rpc::proto::Envelope;
-use std::mem::size_of;
 
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct MessageId(pub u32);
@@ -30,8 +29,10 @@ pub async fn read_message<S: AsyncRead + Unpin>(
 ) -> Result<Envelope> {
     buffer.resize(MESSAGE_LEN_SIZE, 0);
     stream.read_exact(buffer).await?;
+
     let len = message_len_from_buffer(buffer);
-    read_message_with_len(stream, buffer, len).await
+    let result = read_message_with_len(stream, buffer, len).await;
+    result
 }
 
 pub async fn write_message<S: AsyncWrite + Unpin>(
diff --git a/crates/remote/src/ssh_session.rs b/crates/remote/src/ssh_session.rs
index f7ef74ce392398..1d8006a0608a70 100644
--- a/crates/remote/src/ssh_session.rs
+++ b/crates/remote/src/ssh_session.rs
@@ -13,8 +13,7 @@ use futures::{
         oneshot,
     },
     future::BoxFuture,
-    select_biased, AsyncReadExt as _, AsyncWriteExt as _, Future, FutureExt as _, SinkExt,
-    StreamExt as _,
+    select_biased, AsyncReadExt as _, Future, FutureExt as _, SinkExt, StreamExt as _,
 };
 use gpui::{
     AppContext, AsyncAppContext, Context, EventEmitter, Model, ModelContext, SemanticVersion, Task,
@@ -922,92 +921,90 @@ impl SshRemoteClient {
         let mut child_stdout = ssh_proxy_process.stdout.take().unwrap();
         let mut child_stdin = ssh_proxy_process.stdin.take().unwrap();
 
-        let io_task = cx.background_executor().spawn(async move {
-            let mut stdin_buffer = Vec::new();
-            let mut stdout_buffer = Vec::new();
-            let mut stderr_buffer = Vec::new();
-            let mut stderr_offset = 0;
+        let mut stdin_buffer = Vec::new();
+        let mut stdout_buffer = Vec::new();
+        let mut stderr_buffer = Vec::new();
+        let mut stderr_offset = 0;
 
-            loop {
-                stdout_buffer.resize(MESSAGE_LEN_SIZE, 0);
-                stderr_buffer.resize(stderr_offset + 1024, 0);
+        let stdin_task = cx.background_executor().spawn(async move {
+            while let Some(outgoing) = outgoing_rx.next().await {
+                write_message(&mut child_stdin, &mut stdin_buffer, outgoing).await?;
+            }
+            anyhow::Ok(())
+        });
 
-                select_biased! {
-                    outgoing = outgoing_rx.next().fuse() => {
-                        let Some(outgoing) = outgoing else {
-                            return anyhow::Ok(None);
-                        };
+        let stdout_task = cx.background_executor().spawn({
+            let mut connection_activity_tx = connection_activity_tx.clone();
+            async move {
+                loop {
+                    stdout_buffer.resize(MESSAGE_LEN_SIZE, 0);
+                    let len = child_stdout.read(&mut stdout_buffer).await?;
 
-                        write_message(&mut child_stdin, &mut stdin_buffer, outgoing).await?;
+                    if len == 0 {
+                        return anyhow::Ok(());
                     }
 
-                    result = child_stdout.read(&mut stdout_buffer).fuse() => {
-                        match result {
-                            Ok(0) => {
-                                child_stdin.close().await?;
-                                outgoing_rx.close();
-                                let status = ssh_proxy_process.status().await?;
-                                // If we don't have a code, we assume process
-                                // has been killed and treat it as non-zero exit
-                                // code
-                                return Ok(status.code().or_else(|| Some(1)));
-                            }
-                            Ok(len) => {
-                                if len < stdout_buffer.len() {
-                                    child_stdout.read_exact(&mut stdout_buffer[len..]).await?;
-                                }
-
-                                let message_len = message_len_from_buffer(&stdout_buffer);
-                                match read_message_with_len(&mut child_stdout, &mut stdout_buffer, message_len).await {
-                                    Ok(envelope) => {
-                                        connection_activity_tx.try_send(()).ok();
-                                        incoming_tx.unbounded_send(envelope).ok();
-                                    }
-                                    Err(error) => {
-                                        log::error!("error decoding message {error:?}");
-                                    }
-                                }
-                            }
-                            Err(error) => {
-                                Err(anyhow!("error reading stdout: {error:?}"))?;
-                            }
-                        }
+                    if len < MESSAGE_LEN_SIZE {
+                        child_stdout.read_exact(&mut stdout_buffer[len..]).await?;
                     }
 
-                    result = child_stderr.read(&mut stderr_buffer[stderr_offset..]).fuse() => {
-                        match result {
-                            Ok(len) => {
-                                stderr_offset += len;
-                                let mut start_ix = 0;
-                                while let Some(ix) = stderr_buffer[start_ix..stderr_offset].iter().position(|b| b == &b'\n') {
-                                    let line_ix = start_ix + ix;
-                                    let content = &stderr_buffer[start_ix..line_ix];
-                                    start_ix = line_ix + 1;
-                                    if let Ok(record) = serde_json::from_slice::<LogRecord>(content) {
-                                        record.log(log::logger())
-                                    } else {
-                                        eprintln!("(remote) {}", String::from_utf8_lossy(content));
-                                    }
-                                }
-                                stderr_buffer.drain(0..start_ix);
-                                stderr_offset -= start_ix;
+                    let message_len = message_len_from_buffer(&stdout_buffer);
+                    let envelope =
+                        read_message_with_len(&mut child_stdout, &mut stdout_buffer, message_len)
+                            .await?;
+                    connection_activity_tx.try_send(()).ok();
+                    incoming_tx.unbounded_send(envelope).ok();
+                }
+            }
+        });
 
-                                connection_activity_tx.try_send(()).ok();
-                            }
-                            Err(error) => {
-                                Err(anyhow!("error reading stderr: {error:?}"))?;
-                            }
-                        }
+        let stderr_task: Task<anyhow::Result<()>> = cx.background_executor().spawn(async move {
+            loop {
+                stderr_buffer.resize(stderr_offset + 1024, 0);
+
+                let len = child_stderr
+                    .read(&mut stderr_buffer[stderr_offset..])
+                    .await?;
+
+                stderr_offset += len;
+                let mut start_ix = 0;
+                while let Some(ix) = stderr_buffer[start_ix..stderr_offset]
+                    .iter()
+                    .position(|b| b == &b'\n')
+                {
+                    let line_ix = start_ix + ix;
+                    let content = &stderr_buffer[start_ix..line_ix];
+                    start_ix = line_ix + 1;
+                    if let Ok(record) = serde_json::from_slice::<LogRecord>(content) {
+                        record.log(log::logger())
+                    } else {
+                        eprintln!("(remote) {}", String::from_utf8_lossy(content));
                     }
                 }
+                stderr_buffer.drain(0..start_ix);
+                stderr_offset -= start_ix;
+
+                connection_activity_tx.try_send(()).ok();
             }
         });
 
         cx.spawn(|mut cx| async move {
-            let result = io_task.await;
+            let result = futures::select! {
+                result = stdin_task.fuse() => {
+                    result.context("stdin")
+                }
+                result = stdout_task.fuse() => {
+                    result.context("stdout")
+                }
+                result = stderr_task.fuse() => {
+                    result.context("stderr")
+                }
+            };
 
             match result {
-                Ok(Some(exit_code)) => {
+                Ok(_) => {
+                    let exit_code = ssh_proxy_process.status().await?.code().unwrap_or(1);
+
                     if let Some(error) = ProxyLaunchError::from_exit_code(exit_code) {
                         match error {
                             ProxyLaunchError::ServerNotRunning => {
@@ -1025,7 +1022,6 @@ impl SshRemoteClient {
                         })?;
                     }
                 }
-                Ok(None) => {}
                 Err(error) => {
                     log::warn!("ssh io task died with error: {:?}. reconnecting...", error);
                     this.update(&mut cx, |this, cx| {
@@ -1033,6 +1029,7 @@ impl SshRemoteClient {
                     })?;
                 }
             }
+
             Ok(())
         })
     }
@@ -1206,6 +1203,7 @@ impl SshRemoteConnection {
         delegate: Arc<dyn SshClientDelegate>,
         cx: &mut AsyncAppContext,
     ) -> Result<Self> {
+        use futures::AsyncWriteExt as _;
         use futures::{io::BufReader, AsyncBufReadExt as _};
         use smol::{fs::unix::PermissionsExt as _, net::unix::UnixListener};
         use util::ResultExt as _;
diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs
index 60b7fc458d0b43..30b2bacd0a6133 100644
--- a/crates/remote_server/src/unix.rs
+++ b/crates/remote_server/src/unix.rs
@@ -12,6 +12,7 @@ use language::LanguageRegistry;
 use node_runtime::{NodeBinaryOptions, NodeRuntime};
 use paths::logs_dir;
 use project::project_settings::ProjectSettings;
+
 use remote::proxy::ProxyLaunchError;
 use remote::ssh_session::ChannelClient;
 use remote::{
@@ -213,19 +214,27 @@ fn start_server(
 
             let mut input_buffer = Vec::new();
             let mut output_buffer = Vec::new();
+
+            let (mut stdin_msg_tx, mut stdin_msg_rx) = mpsc::unbounded::<Envelope>();
+            cx.background_executor().spawn(async move {
+                while let Ok(msg) = read_message(&mut stdin_stream, &mut input_buffer).await {
+                    if let Err(_) = stdin_msg_tx.send(msg).await {
+                        break;
+                    }
+                }
+            }).detach();
+
             loop {
+
                 select_biased! {
                     _ = app_quit_rx.next().fuse() => {
                         return anyhow::Ok(());
                     }
 
-                    stdin_message = read_message(&mut stdin_stream, &mut input_buffer).fuse() => {
-                        let message = match stdin_message {
-                            Ok(message) => message,
-                            Err(error) => {
-                                log::warn!("error reading message on stdin: {}. exiting.", error);
-                                break;
-                            }
+                    stdin_message = stdin_msg_rx.next().fuse() => {
+                        let Some(message) = stdin_message else {
+                            log::warn!("error reading message on stdin. exiting.");
+                            break;
                         };
                         if let Err(error) = incoming_tx.unbounded_send(message) {
                             log::error!("failed to send message to application: {:?}. exiting.", error);

From 3e0c5c10b73fe8db87780ab63c3be2ee995d6870 Mon Sep 17 00:00:00 2001
From: Vitaly Slobodin <vitaliy.slobodin@gmail.com>
Date: Sat, 19 Oct 2024 00:52:17 +0200
Subject: [PATCH 761/762] lsp: Handle unregistration "textDocument/rename" from
 a server (#19427)

Hi. While working on https://github.com/zed-industries/zed/pull/19230 I
noticed that some servers send a request to unregistered the
`textDocument/rename` capability. I thought it would be good to handle
that message in Zed:

```plaintext
[2024-10-18T21:25:07+02:00 WARN  project::lsp_store] unhandled capability unregistration: Unregistration { id: "biome_rename", method: "textDocument/rename" }
```

So this pull request implements that. Thanks.

Release Notes:

- N/A
---
 crates/project/src/lsp_store.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 61f959259d5ab8..fe0a6443bc8118 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -6057,6 +6057,16 @@ impl LspStore {
                                         );
                                     })?;
                                 }
+                                "textDocument/rename" => {
+                                    this.update(&mut cx, |this, _| {
+                                        if let Some(server) = this.language_server_for_id(server_id)
+                                        {
+                                            server.update_capabilities(|capabilities| {
+                                                capabilities.rename_provider = None
+                                            })
+                                        }
+                                    })?;
+                                }
                                 "textDocument/rangeFormatting" => {
                                     this.update(&mut cx, |this, _| {
                                         if let Some(server) = this.language_server_for_id(server_id)

From d209eab05879ddd49c4ebbb439966150f7c3b686 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Fri, 18 Oct 2024 17:58:07 -0700
Subject: [PATCH 762/762] Combine excerpt footer and header into a single block
 (#19441)

This simplifies rendering of excerpt headers and footers, and removes
the need to store a `BlockDisposition` on these boundary blocks. It's a
step toward implementing "replace blocks", which we want to use in the
assistant panel.

We've also cleaned up the way heights are specified for headers and
footers and fixed some visual asymmetries between the "expand upward"
and "expand downward" buttons.

Release Notes:

- N/A

---------

Co-authored-by: Richard <richard@zed.dev>
---
 crates/diagnostics/src/diagnostics_tests.rs |   4 +-
 crates/editor/src/display_map/block_map.rs  | 301 +++++-----
 crates/editor/src/editor.rs                 |  31 +-
 crates/editor/src/element.rs                | 577 ++++++++------------
 crates/editor/src/movement.rs               |   2 +-
 crates/multi_buffer/src/multi_buffer.rs     |   2 +
 crates/repl/src/session.rs                  |  29 +-
 7 files changed, 397 insertions(+), 549 deletions(-)

diff --git a/crates/diagnostics/src/diagnostics_tests.rs b/crates/diagnostics/src/diagnostics_tests.rs
index 75bfd6415cc7b3..1daffffb4eabcf 100644
--- a/crates/diagnostics/src/diagnostics_tests.rs
+++ b/crates/diagnostics/src/diagnostics_tests.rs
@@ -962,7 +962,6 @@ fn random_diagnostic(
 
 const FILE_HEADER: &str = "file header";
 const EXCERPT_HEADER: &str = "excerpt header";
-const EXCERPT_FOOTER: &str = "excerpt footer";
 
 fn editor_blocks(
     editor: &View<Editor>,
@@ -998,7 +997,7 @@ fn editor_blocks(
                                     .ok()?
                             }
 
-                            Block::ExcerptHeader {
+                            Block::ExcerptBoundary {
                                 starts_new_buffer, ..
                             } => {
                                 if *starts_new_buffer {
@@ -1007,7 +1006,6 @@ fn editor_blocks(
                                     EXCERPT_HEADER.into()
                                 }
                             }
-                            Block::ExcerptFooter { .. } => EXCERPT_FOOTER.into(),
                         };
 
                         Some((row, name))
diff --git a/crates/editor/src/display_map/block_map.rs b/crates/editor/src/display_map/block_map.rs
index 52e0ca2486d25d..f4ee57408b1ca8 100644
--- a/crates/editor/src/display_map/block_map.rs
+++ b/crates/editor/src/display_map/block_map.rs
@@ -5,8 +5,8 @@ use super::{
 use crate::{EditorStyle, GutterDimensions};
 use collections::{Bound, HashMap, HashSet};
 use gpui::{AnyElement, EntityId, Pixels, WindowContext};
-use language::{BufferSnapshot, Chunk, Patch, Point};
-use multi_buffer::{Anchor, ExcerptId, ExcerptRange, MultiBufferRow, ToPoint as _};
+use language::{Chunk, Patch, Point};
+use multi_buffer::{Anchor, ExcerptId, ExcerptInfo, MultiBufferRow, ToPoint as _};
 use parking_lot::Mutex;
 use std::{
     cell::RefCell,
@@ -128,26 +128,17 @@ pub struct BlockContext<'a, 'b> {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum BlockId {
     Custom(CustomBlockId),
-    ExcerptHeader(ExcerptId),
-    ExcerptFooter(ExcerptId),
-}
-
-impl From<BlockId> for EntityId {
-    fn from(value: BlockId) -> Self {
-        match value {
-            BlockId::Custom(CustomBlockId(id)) => EntityId::from(id as u64),
-            BlockId::ExcerptHeader(id) => id.into(),
-            BlockId::ExcerptFooter(id) => id.into(),
-        }
-    }
+    ExcerptBoundary(Option<ExcerptId>),
 }
 
 impl From<BlockId> for ElementId {
     fn from(value: BlockId) -> Self {
         match value {
             BlockId::Custom(CustomBlockId(id)) => ("Block", id).into(),
-            BlockId::ExcerptHeader(id) => ("ExcerptHeader", EntityId::from(id)).into(),
-            BlockId::ExcerptFooter(id) => ("ExcerptFooter", EntityId::from(id)).into(),
+            BlockId::ExcerptBoundary(next_excerpt) => match next_excerpt {
+                Some(id) => ("ExcerptBoundary", EntityId::from(id)).into(),
+                None => "LastExcerptBoundary".into(),
+            },
         }
     }
 }
@@ -156,8 +147,7 @@ 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::ExcerptHeader(id) => write!(f, "ExcerptHeader({id:?})"),
-            Self::ExcerptFooter(id) => write!(f, "ExcerptFooter({id:?})"),
+            Self::ExcerptBoundary(id) => write!(f, "ExcerptHeader({id:?})"),
         }
     }
 }
@@ -177,8 +167,7 @@ struct Transform {
 
 pub(crate) enum BlockType {
     Custom(CustomBlockId),
-    Header,
-    Footer,
+    ExcerptBoundary,
 }
 
 pub(crate) trait BlockLike {
@@ -191,27 +180,20 @@ pub(crate) trait BlockLike {
 #[derive(Clone)]
 pub enum Block {
     Custom(Arc<CustomBlock>),
-    ExcerptHeader {
-        id: ExcerptId,
-        buffer: BufferSnapshot,
-        range: ExcerptRange<text::Anchor>,
+    ExcerptBoundary {
+        prev_excerpt: Option<ExcerptInfo>,
+        next_excerpt: Option<ExcerptInfo>,
         height: u32,
         starts_new_buffer: bool,
         show_excerpt_controls: bool,
     },
-    ExcerptFooter {
-        id: ExcerptId,
-        disposition: BlockDisposition,
-        height: u32,
-    },
 }
 
 impl BlockLike for Block {
     fn block_type(&self) -> BlockType {
         match self {
             Block::Custom(block) => BlockType::Custom(block.id),
-            Block::ExcerptHeader { .. } => BlockType::Header,
-            Block::ExcerptFooter { .. } => BlockType::Footer,
+            Block::ExcerptBoundary { .. } => BlockType::ExcerptBoundary,
         }
     }
 
@@ -222,8 +204,7 @@ impl BlockLike for Block {
     fn priority(&self) -> usize {
         match self {
             Block::Custom(block) => block.priority,
-            Block::ExcerptHeader { .. } => usize::MAX,
-            Block::ExcerptFooter { .. } => 0,
+            Block::ExcerptBoundary { .. } => usize::MAX,
         }
     }
 }
@@ -232,32 +213,36 @@ impl Block {
     pub fn id(&self) -> BlockId {
         match self {
             Block::Custom(block) => BlockId::Custom(block.id),
-            Block::ExcerptHeader { id, .. } => BlockId::ExcerptHeader(*id),
-            Block::ExcerptFooter { id, .. } => BlockId::ExcerptFooter(*id),
+            Block::ExcerptBoundary { next_excerpt, .. } => {
+                BlockId::ExcerptBoundary(next_excerpt.as_ref().map(|info| info.id))
+            }
         }
     }
 
     fn disposition(&self) -> BlockDisposition {
         match self {
             Block::Custom(block) => block.disposition,
-            Block::ExcerptHeader { .. } => BlockDisposition::Above,
-            Block::ExcerptFooter { disposition, .. } => *disposition,
+            Block::ExcerptBoundary { next_excerpt, .. } => {
+                if next_excerpt.is_some() {
+                    BlockDisposition::Above
+                } else {
+                    BlockDisposition::Below
+                }
+            }
         }
     }
 
     pub fn height(&self) -> u32 {
         match self {
             Block::Custom(block) => block.height,
-            Block::ExcerptHeader { height, .. } => *height,
-            Block::ExcerptFooter { height, .. } => *height,
+            Block::ExcerptBoundary { height, .. } => *height,
         }
     }
 
     pub fn style(&self) -> BlockStyle {
         match self {
             Block::Custom(block) => block.style,
-            Block::ExcerptHeader { .. } => BlockStyle::Sticky,
-            Block::ExcerptFooter { .. } => BlockStyle::Sticky,
+            Block::ExcerptBoundary { .. } => BlockStyle::Sticky,
         }
     }
 }
@@ -266,24 +251,17 @@ 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::ExcerptHeader {
-                buffer,
+            Self::ExcerptBoundary {
                 starts_new_buffer,
-                id,
+                next_excerpt,
+                prev_excerpt,
                 ..
             } => f
-                .debug_struct("ExcerptHeader")
-                .field("id", &id)
-                .field("path", &buffer.file().map(|f| f.path()))
+                .debug_struct("ExcerptBoundary")
+                .field("prev_excerpt", &prev_excerpt)
+                .field("next_excerpt", &next_excerpt)
                 .field("starts_new_buffer", &starts_new_buffer)
                 .finish(),
-            Block::ExcerptFooter {
-                id, disposition, ..
-            } => f
-                .debug_struct("ExcerptFooter")
-                .field("id", &id)
-                .field("disposition", &disposition)
-                .finish(),
         }
     }
 }
@@ -595,66 +573,62 @@ impl BlockMap {
     {
         buffer
             .excerpt_boundaries_in_range(range)
-            .flat_map(move |excerpt_boundary| {
-                let mut wrap_row = wrap_snapshot
-                    .make_wrap_point(Point::new(excerpt_boundary.row.0, 0), Bias::Left)
-                    .row();
-
-                [
-                    show_excerpt_controls
-                        .then(|| {
-                            let disposition;
-                            if excerpt_boundary.next.is_some() {
-                                disposition = BlockDisposition::Above;
-                            } else {
-                                wrap_row = wrap_snapshot
-                                    .make_wrap_point(
-                                        Point::new(
-                                            excerpt_boundary.row.0,
-                                            buffer.line_len(excerpt_boundary.row),
-                                        ),
-                                        Bias::Left,
-                                    )
-                                    .row();
-                                disposition = BlockDisposition::Below;
-                            }
-
-                            excerpt_boundary.prev.as_ref().map(|prev| {
-                                (
-                                    wrap_row,
-                                    Block::ExcerptFooter {
-                                        id: prev.id,
-                                        height: excerpt_footer_height,
-                                        disposition,
-                                    },
-                                )
-                            })
-                        })
-                        .flatten(),
-                    excerpt_boundary.next.map(|next| {
-                        let starts_new_buffer = excerpt_boundary
-                            .prev
-                            .map_or(true, |prev| prev.buffer_id != next.buffer_id);
-
-                        (
-                            wrap_row,
-                            Block::ExcerptHeader {
-                                id: next.id,
-                                buffer: next.buffer,
-                                range: next.range,
-                                height: if starts_new_buffer {
-                                    buffer_header_height
-                                } else {
-                                    excerpt_header_height
-                                },
-                                starts_new_buffer,
-                                show_excerpt_controls,
-                            },
+            .filter_map(move |excerpt_boundary| {
+                let wrap_row;
+                if excerpt_boundary.next.is_some() {
+                    wrap_row = wrap_snapshot
+                        .make_wrap_point(Point::new(excerpt_boundary.row.0, 0), Bias::Left)
+                        .row();
+                } else {
+                    wrap_row = wrap_snapshot
+                        .make_wrap_point(
+                            Point::new(
+                                excerpt_boundary.row.0,
+                                buffer.line_len(excerpt_boundary.row),
+                            ),
+                            Bias::Left,
                         )
-                    }),
-                ]
+                        .row();
+                }
+
+                let starts_new_buffer = match (&excerpt_boundary.prev, &excerpt_boundary.next) {
+                    (_, None) => false,
+                    (None, Some(_)) => true,
+                    (Some(prev), Some(next)) => prev.buffer_id != next.buffer_id,
+                };
+
+                let mut height = 0;
+                if excerpt_boundary.prev.is_some() {
+                    if show_excerpt_controls {
+                        height += excerpt_footer_height;
+                    }
+                }
+                if excerpt_boundary.next.is_some() {
+                    if starts_new_buffer {
+                        height += buffer_header_height;
+                        if show_excerpt_controls {
+                            height += excerpt_header_height;
+                        }
+                    } else {
+                        height += excerpt_header_height;
+                    }
+                }
+
+                if height == 0 {
+                    return None;
+                }
+
+                Some((
+                    wrap_row,
+                    Block::ExcerptBoundary {
+                        prev_excerpt: excerpt_boundary.prev,
+                        next_excerpt: excerpt_boundary.next,
+                        height,
+                        starts_new_buffer,
+                        show_excerpt_controls,
+                    },
+                ))
             })
-            .flatten()
     }
 
     pub(crate) fn sort_blocks<B: BlockLike>(blocks: &mut [(u32, B)]) {
@@ -665,12 +639,9 @@ impl BlockMap {
                     .disposition()
                     .cmp(&block_b.disposition())
                     .then_with(|| match ((block_a.block_type()), (block_b.block_type())) {
-                        (BlockType::Footer, BlockType::Footer) => Ordering::Equal,
-                        (BlockType::Footer, _) => Ordering::Less,
-                        (_, BlockType::Footer) => Ordering::Greater,
-                        (BlockType::Header, BlockType::Header) => Ordering::Equal,
-                        (BlockType::Header, _) => Ordering::Less,
-                        (_, BlockType::Header) => Ordering::Greater,
+                        (BlockType::ExcerptBoundary, BlockType::ExcerptBoundary) => Ordering::Equal,
+                        (BlockType::ExcerptBoundary, _) => Ordering::Less,
+                        (_, BlockType::ExcerptBoundary) => Ordering::Greater,
                         (BlockType::Custom(a_id), BlockType::Custom(b_id)) => block_b
                             .priority()
                             .cmp(&block_a.priority())
@@ -1045,33 +1016,19 @@ impl BlockSnapshot {
                 let custom_block = self.custom_blocks_by_id.get(&custom_block_id)?;
                 Some(Block::Custom(custom_block.clone()))
             }
-            BlockId::ExcerptHeader(excerpt_id) => {
-                let excerpt_range = buffer.range_for_excerpt::<Point>(excerpt_id)?;
-                let wrap_point = self
-                    .wrap_snapshot
-                    .make_wrap_point(excerpt_range.start, Bias::Left);
-                let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&());
-                cursor.seek(&WrapRow(wrap_point.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().0 > WrapRow(wrap_point.row()) {
-                        break;
-                    }
-
-                    cursor.next(&());
+            BlockId::ExcerptBoundary(next_excerpt_id) => {
+                let wrap_point;
+                if let Some(next_excerpt_id) = next_excerpt_id {
+                    let excerpt_range = buffer.range_for_excerpt::<Point>(next_excerpt_id)?;
+                    wrap_point = self
+                        .wrap_snapshot
+                        .make_wrap_point(excerpt_range.start, Bias::Left);
+                } else {
+                    wrap_point = self
+                        .wrap_snapshot
+                        .make_wrap_point(buffer.max_point(), Bias::Left);
                 }
 
-                None
-            }
-            BlockId::ExcerptFooter(excerpt_id) => {
-                let excerpt_range = buffer.range_for_excerpt::<Point>(excerpt_id)?;
-                let wrap_point = self
-                    .wrap_snapshot
-                    .make_wrap_point(excerpt_range.end, Bias::Left);
-
                 let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>(&());
                 cursor.seek(&WrapRow(wrap_point.row()), Bias::Left, &());
                 while let Some(transform) = cursor.item() {
@@ -1468,7 +1425,7 @@ mod tests {
     };
     use gpui::{div, font, px, AppContext, Context as _, Element};
     use language::{Buffer, Capability};
-    use multi_buffer::MultiBuffer;
+    use multi_buffer::{ExcerptRange, MultiBuffer};
     use rand::prelude::*;
     use settings::SettingsStore;
     use std::env;
@@ -1724,22 +1681,20 @@ mod tests {
         // Each excerpt has a header above and footer below. Excerpts are also *separated* by a newline.
         assert_eq!(
             snapshot.text(),
-            "\nBuff\ner 1\n\n\nBuff\ner 2\n\n\nBuff\ner 3\n"
+            "\n\nBuff\ner 1\n\n\n\nBuff\ner 2\n\n\n\nBuff\ner 3\n"
         );
 
         let blocks: Vec<_> = snapshot
             .blocks_in_range(0..u32::MAX)
-            .map(|(row, block)| (row, block.id()))
+            .map(|(row, block)| (row..row + block.height(), block.id()))
             .collect();
         assert_eq!(
             blocks,
             vec![
-                (0, BlockId::ExcerptHeader(excerpt_ids[0])),
-                (3, BlockId::ExcerptFooter(excerpt_ids[0])),
-                (4, BlockId::ExcerptHeader(excerpt_ids[1])),
-                (7, BlockId::ExcerptFooter(excerpt_ids[1])),
-                (8, BlockId::ExcerptHeader(excerpt_ids[2])),
-                (11, BlockId::ExcerptFooter(excerpt_ids[2]))
+                (0..2, BlockId::ExcerptBoundary(Some(excerpt_ids[0]))), // path, header
+                (4..7, BlockId::ExcerptBoundary(Some(excerpt_ids[1]))), // footer, path, header
+                (9..12, BlockId::ExcerptBoundary(Some(excerpt_ids[2]))), // footer, path, header
+                (14..15, BlockId::ExcerptBoundary(None)),               // footer
             ]
         );
     }
@@ -2283,13 +2238,10 @@ mod tests {
 
         #[derive(Debug, Eq, PartialEq)]
         enum ExpectedBlock {
-            ExcerptHeader {
+            ExcerptBoundary {
                 height: u32,
                 starts_new_buffer: bool,
-            },
-            ExcerptFooter {
-                height: u32,
-                disposition: BlockDisposition,
+                is_last: bool,
             },
             Custom {
                 disposition: BlockDisposition,
@@ -2303,8 +2255,7 @@ mod tests {
             fn block_type(&self) -> BlockType {
                 match self {
                     ExpectedBlock::Custom { id, .. } => BlockType::Custom(*id),
-                    ExpectedBlock::ExcerptHeader { .. } => BlockType::Header,
-                    ExpectedBlock::ExcerptFooter { .. } => BlockType::Footer,
+                    ExpectedBlock::ExcerptBoundary { .. } => BlockType::ExcerptBoundary,
                 }
             }
 
@@ -2315,8 +2266,7 @@ mod tests {
             fn priority(&self) -> usize {
                 match self {
                     ExpectedBlock::Custom { priority, .. } => *priority,
-                    ExpectedBlock::ExcerptHeader { .. } => usize::MAX,
-                    ExpectedBlock::ExcerptFooter { .. } => 0,
+                    ExpectedBlock::ExcerptBoundary { .. } => usize::MAX,
                 }
             }
         }
@@ -2324,17 +2274,21 @@ mod tests {
         impl ExpectedBlock {
             fn height(&self) -> u32 {
                 match self {
-                    ExpectedBlock::ExcerptHeader { height, .. } => *height,
+                    ExpectedBlock::ExcerptBoundary { height, .. } => *height,
                     ExpectedBlock::Custom { height, .. } => *height,
-                    ExpectedBlock::ExcerptFooter { height, .. } => *height,
                 }
             }
 
             fn disposition(&self) -> BlockDisposition {
                 match self {
-                    ExpectedBlock::ExcerptHeader { .. } => BlockDisposition::Above,
+                    ExpectedBlock::ExcerptBoundary { is_last, .. } => {
+                        if *is_last {
+                            BlockDisposition::Below
+                        } else {
+                            BlockDisposition::Above
+                        }
+                    }
                     ExpectedBlock::Custom { disposition, .. } => *disposition,
-                    ExpectedBlock::ExcerptFooter { disposition, .. } => *disposition,
                 }
             }
         }
@@ -2348,21 +2302,15 @@ mod tests {
                         height: block.height,
                         priority: block.priority,
                     },
-                    Block::ExcerptHeader {
+                    Block::ExcerptBoundary {
                         height,
                         starts_new_buffer,
+                        next_excerpt,
                         ..
-                    } => ExpectedBlock::ExcerptHeader {
+                    } => ExpectedBlock::ExcerptBoundary {
                         height,
                         starts_new_buffer,
-                    },
-                    Block::ExcerptFooter {
-                        height,
-                        disposition,
-                        ..
-                    } => ExpectedBlock::ExcerptFooter {
-                        height,
-                        disposition,
+                        is_last: next_excerpt.is_none(),
                     },
                 }
             }
@@ -2380,8 +2328,7 @@ mod tests {
         fn as_custom(&self) -> Option<&CustomBlock> {
             match self {
                 Block::Custom(block) => Some(block),
-                Block::ExcerptHeader { .. } => None,
-                Block::ExcerptFooter { .. } => None,
+                Block::ExcerptBoundary { .. } => None,
             }
         }
     }
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 9d9cfde7b9c119..ba3841b4e2202e 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -73,12 +73,12 @@ use git::blame::GitBlame;
 use gpui::{
     div, impl_actions, point, prelude::*, px, relative, size, uniform_list, Action, AnyElement,
     AppContext, AsyncWindowContext, AvailableSpace, BackgroundExecutor, Bounds, ClipboardEntry,
-    ClipboardItem, Context, DispatchPhase, ElementId, EntityId, EventEmitter, FocusHandle,
-    FocusOutEvent, FocusableView, FontId, FontWeight, HighlightStyle, Hsla, InteractiveText,
-    KeyContext, ListSizingBehavior, Model, MouseButton, PaintQuad, ParentElement, Pixels, Render,
-    SharedString, Size, StrikethroughStyle, Styled, StyledText, Subscription, Task, TextStyle,
-    UTF16Selection, UnderlineStyle, UniformListScrollHandle, View, ViewContext, ViewInputHandler,
-    VisualContext, WeakFocusHandle, WeakView, WindowContext,
+    ClipboardItem, Context, DispatchPhase, ElementId, EventEmitter, FocusHandle, FocusOutEvent,
+    FocusableView, FontId, FontWeight, HighlightStyle, Hsla, InteractiveText, KeyContext,
+    ListSizingBehavior, Model, MouseButton, PaintQuad, ParentElement, Pixels, Render, SharedString,
+    Size, StrikethroughStyle, Styled, StyledText, Subscription, Task, TextStyle, UTF16Selection,
+    UnderlineStyle, UniformListScrollHandle, View, ViewContext, ViewInputHandler, VisualContext,
+    WeakFocusHandle, WeakView, WindowContext,
 };
 use highlight_matching_bracket::refresh_matching_bracket_highlights;
 use hover_popover::{hide_hover, HoverState};
@@ -171,7 +171,7 @@ use workspace::{Item as WorkspaceItem, OpenInTerminal, OpenTerminal, TabBarSetti
 use crate::hover_links::find_url;
 use crate::signature_help::{SignatureHelpHiddenBy, SignatureHelpState};
 
-pub const FILE_HEADER_HEIGHT: u32 = 1;
+pub const FILE_HEADER_HEIGHT: u32 = 2;
 pub const MULTI_BUFFER_EXCERPT_HEADER_HEIGHT: u32 = 1;
 pub const MULTI_BUFFER_EXCERPT_FOOTER_HEIGHT: u32 = 1;
 pub const DEFAULT_MULTIBUFFER_CONTEXT: u32 = 2;
@@ -640,7 +640,6 @@ pub struct Editor {
     tasks: BTreeMap<(BufferId, BufferRow), RunnableTasks>,
     tasks_update_task: Option<Task<()>>,
     previous_search_ranges: Option<Arc<[Range<Anchor>]>>,
-    file_header_size: u32,
     breadcrumb_header: Option<String>,
     focused_block: Option<FocusedBlock>,
     next_scroll_position: NextScrollCursorCenterTopBottom,
@@ -1846,7 +1845,6 @@ impl Editor {
             }),
             merge_adjacent: true,
         };
-        let file_header_size = if show_excerpt_controls { 3 } else { 2 };
         let display_map = cx.new_model(|cx| {
             DisplayMap::new(
                 buffer.clone(),
@@ -1854,7 +1852,7 @@ impl Editor {
                 font_size,
                 None,
                 show_excerpt_controls,
-                file_header_size,
+                FILE_HEADER_HEIGHT,
                 MULTI_BUFFER_EXCERPT_HEADER_HEIGHT,
                 MULTI_BUFFER_EXCERPT_FOOTER_HEIGHT,
                 fold_placeholder,
@@ -2038,7 +2036,6 @@ impl Editor {
                 .restore_unsaved_buffers,
             blame: None,
             blame_subscription: None,
-            file_header_size,
             tasks: Default::default(),
             _subscriptions: vec![
                 cx.observe(&buffer, Self::on_buffer_changed),
@@ -12808,7 +12805,7 @@ impl Editor {
     }
 
     pub fn file_header_size(&self) -> u32 {
-        self.file_header_size
+        FILE_HEADER_HEIGHT
     }
 
     pub fn revert(
@@ -14120,7 +14117,7 @@ pub fn diagnostic_block_renderer(
 
         let multi_line_diagnostic = diagnostic.message.contains('\n');
 
-        let buttons = |diagnostic: &Diagnostic, block_id: BlockId| {
+        let buttons = |diagnostic: &Diagnostic| {
             if multi_line_diagnostic {
                 v_flex()
             } else {
@@ -14128,7 +14125,7 @@ pub fn diagnostic_block_renderer(
             }
             .when(allow_closing, |div| {
                 div.children(diagnostic.is_primary.then(|| {
-                    IconButton::new(("close-block", EntityId::from(block_id)), IconName::XCircle)
+                    IconButton::new("close-block", IconName::XCircle)
                         .icon_color(Color::Muted)
                         .size(ButtonSize::Compact)
                         .style(ButtonStyle::Transparent)
@@ -14138,7 +14135,7 @@ pub fn diagnostic_block_renderer(
                 }))
             })
             .child(
-                IconButton::new(("copy-block", EntityId::from(block_id)), IconName::Copy)
+                IconButton::new("copy-block", IconName::Copy)
                     .icon_color(Color::Muted)
                     .size(ButtonSize::Compact)
                     .style(ButtonStyle::Transparent)
@@ -14153,7 +14150,7 @@ pub fn diagnostic_block_renderer(
             )
         };
 
-        let icon_size = buttons(&diagnostic, cx.block_id)
+        let icon_size = buttons(&diagnostic)
             .into_any_element()
             .layout_as_root(AvailableSpace::min_size(), cx);
 
@@ -14170,7 +14167,7 @@ pub fn diagnostic_block_renderer(
                     .w(cx.anchor_x - cx.gutter_dimensions.width - icon_size.width)
                     .flex_shrink(),
             )
-            .child(buttons(&diagnostic, cx.block_id))
+            .child(buttons(&diagnostic))
             .child(div().flex().flex_shrink_0().child(
                 StyledText::new(text_without_backticks.clone()).with_highlights(
                     &text_style,
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index a9dfe7e435df8e..77b78d059c955b 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -21,7 +21,8 @@ use crate::{
     EditorSnapshot, EditorStyle, ExpandExcerpts, FocusedBlock, GutterDimensions, HalfPageDown,
     HalfPageUp, HandleInput, HoveredCursor, HoveredHunk, LineDown, LineUp, OpenExcerpts, PageDown,
     PageUp, Point, RowExt, RowRangeExt, SelectPhase, Selection, SoftWrap, ToPoint,
-    CURSORS_VISIBLE_FOR, GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED, MAX_LINE_LEN,
+    CURSORS_VISIBLE_FOR, FILE_HEADER_HEIGHT, GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED, MAX_LINE_LEN,
+    MULTI_BUFFER_EXCERPT_HEADER_HEIGHT,
 };
 use client::ParticipantIndex;
 use collections::{BTreeMap, HashMap};
@@ -31,7 +32,7 @@ use gpui::{
     anchored, deferred, div, fill, outline, point, px, quad, relative, size, svg,
     transparent_black, Action, AnchorCorner, AnyElement, AvailableSpace, Bounds, ClipboardItem,
     ContentMask, Corners, CursorStyle, DispatchPhase, Edges, Element, ElementInputHandler, Entity,
-    EntityId, FontId, GlobalElementId, Hitbox, Hsla, InteractiveElement, IntoElement, Length,
+    FontId, GlobalElementId, Hitbox, Hsla, InteractiveElement, IntoElement, Length,
     ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, PaintQuad,
     ParentElement, Pixels, ScrollDelta, ScrollWheelEvent, ShapedLine, SharedString, Size,
     StatefulInteractiveElement, Style, Styled, TextRun, TextStyle, TextStyleRefinement, View,
@@ -46,7 +47,7 @@ use language::{
     ChunkRendererContext,
 };
 use lsp::DiagnosticSeverity;
-use multi_buffer::{Anchor, MultiBufferPoint, MultiBufferRow};
+use multi_buffer::{Anchor, ExcerptId, ExpandExcerptDirection, MultiBufferPoint, MultiBufferRow};
 use project::{
     project_settings::{GitGutterSetting, ProjectSettings},
     ProjectPath,
@@ -1632,7 +1633,7 @@ impl EditorElement {
         let mut block_offset = 0;
         let mut found_excerpt_header = false;
         for (_, block) in snapshot.blocks_in_range(prev_line..row_range.start) {
-            if matches!(block, Block::ExcerptHeader { .. }) {
+            if matches!(block, Block::ExcerptBoundary { .. }) {
                 found_excerpt_header = true;
                 break;
             }
@@ -1649,7 +1650,7 @@ impl EditorElement {
         let mut block_height = 0;
         let mut found_excerpt_header = false;
         for (_, block) in snapshot.blocks_in_range(row_range.end..cons_line) {
-            if matches!(block, Block::ExcerptHeader { .. }) {
+            if matches!(block, Block::ExcerptBoundary { .. }) {
                 found_excerpt_header = true;
             }
             block_height += block.height();
@@ -2100,23 +2101,14 @@ impl EditorElement {
                     .into_any_element()
             }
 
-            Block::ExcerptHeader {
-                buffer,
-                range,
+            Block::ExcerptBoundary {
+                prev_excerpt,
+                next_excerpt,
+                show_excerpt_controls,
                 starts_new_buffer,
                 height,
-                id,
-                show_excerpt_controls,
                 ..
             } => {
-                let include_root = self
-                    .editor
-                    .read(cx)
-                    .project
-                    .as_ref()
-                    .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
-                    .unwrap_or_default();
-
                 #[derive(Clone)]
                 struct JumpData {
                     position: Point,
@@ -2125,233 +2117,227 @@ impl EditorElement {
                     line_offset_from_top: u32,
                 }
 
-                let jump_data = project::File::from_dyn(buffer.file()).map(|file| {
-                    let jump_path = ProjectPath {
-                        worktree_id: file.worktree_id(cx),
-                        path: file.path.clone(),
-                    };
-                    let jump_anchor = range
-                        .primary
-                        .as_ref()
-                        .map_or(range.context.start, |primary| primary.start);
-
-                    let excerpt_start = range.context.start;
-                    let jump_position = language::ToPoint::to_point(&jump_anchor, buffer);
-                    let offset_from_excerpt_start = if jump_anchor == excerpt_start {
-                        0
-                    } else {
-                        let excerpt_start_row =
-                            language::ToPoint::to_point(&jump_anchor, buffer).row;
-                        jump_position.row - excerpt_start_row
-                    };
-
-                    let line_offset_from_top =
-                        block_row_start.0 + *height + offset_from_excerpt_start
-                            - snapshot
-                                .scroll_anchor
-                                .scroll_position(&snapshot.display_snapshot)
-                                .y as u32;
-
-                    JumpData {
-                        position: jump_position,
-                        anchor: jump_anchor,
-                        path: jump_path,
-                        line_offset_from_top,
-                    }
-                });
-
                 let icon_offset = gutter_dimensions.width
                     - (gutter_dimensions.left_padding + gutter_dimensions.margin);
 
-                let element = if *starts_new_buffer {
-                    let path = buffer.resolve_file_path(cx, include_root);
-                    let mut filename = None;
-                    let mut parent_path = None;
-                    // Can't use .and_then() because `.file_name()` and `.parent()` return references :(
-                    if let Some(path) = path {
-                        filename = path.file_name().map(|f| f.to_string_lossy().to_string());
-                        parent_path = path
-                            .parent()
-                            .map(|p| SharedString::from(p.to_string_lossy().to_string() + "/"));
-                    }
+                let header_padding = px(6.0);
 
-                    let header_padding = px(6.0);
+                let mut result = v_flex().id(block_id).w_full();
 
-                    v_flex()
-                        .id(("path excerpt header", EntityId::from(block_id)))
-                        .w_full()
-                        .px(header_padding)
-                        .pt(header_padding)
-                        .child(
-                            h_flex()
-                                .flex_basis(Length::Definite(DefiniteLength::Fraction(0.667)))
-                                .id("path header block")
-                                .h(2. * cx.line_height())
-                                .px(gpui::px(12.))
-                                .rounded_md()
-                                .shadow_md()
-                                .border_1()
-                                .border_color(cx.theme().colors().border)
-                                .bg(cx.theme().colors().editor_subheader_background)
-                                .justify_between()
-                                .hover(|style| style.bg(cx.theme().colors().element_hover))
-                                .child(
-                                    h_flex().gap_3().child(
-                                        h_flex()
-                                            .gap_2()
-                                            .child(
-                                                filename
-                                                    .map(SharedString::from)
-                                                    .unwrap_or_else(|| "untitled".into()),
-                                            )
-                                            .when_some(parent_path, |then, path| {
-                                                then.child(
-                                                    div()
-                                                        .child(path)
-                                                        .text_color(cx.theme().colors().text_muted),
-                                                )
-                                            }),
-                                    ),
-                                )
-                                .when_some(jump_data.clone(), |el, jump_data| {
-                                    el.child(Icon::new(IconName::ArrowUpRight))
-                                        .cursor_pointer()
-                                        .tooltip(|cx| {
-                                            Tooltip::for_action("Jump to File", &OpenExcerpts, cx)
-                                        })
-                                        .on_mouse_down(MouseButton::Left, |_, cx| {
-                                            cx.stop_propagation()
-                                        })
-                                        .on_click(cx.listener_for(&self.editor, {
-                                            move |editor, _, cx| {
-                                                editor.jump(
-                                                    jump_data.path.clone(),
-                                                    jump_data.position,
-                                                    jump_data.anchor,
-                                                    jump_data.line_offset_from_top,
-                                                    cx,
-                                                );
-                                            }
-                                        }))
-                                }),
-                        )
-                        .children(show_excerpt_controls.then(|| {
+                if let Some(prev_excerpt) = prev_excerpt {
+                    if *show_excerpt_controls {
+                        result = result.child(
                             h_flex()
-                                .flex_basis(Length::Definite(DefiniteLength::Fraction(0.333)))
-                                .h(1. * cx.line_height())
-                                .pt_1()
-                                .justify_end()
+                                .w(icon_offset)
+                                .h(MULTI_BUFFER_EXCERPT_HEADER_HEIGHT as f32 * cx.line_height())
                                 .flex_none()
-                                .w(icon_offset - header_padding)
+                                .justify_end()
+                                .child(self.render_expand_excerpt_button(
+                                    prev_excerpt.id,
+                                    ExpandExcerptDirection::Down,
+                                    IconName::ArrowDownFromLine,
+                                    cx,
+                                )),
+                        );
+                    }
+                }
+
+                if let Some(next_excerpt) = next_excerpt {
+                    let buffer = &next_excerpt.buffer;
+                    let range = &next_excerpt.range;
+                    let jump_data = project::File::from_dyn(buffer.file()).map(|file| {
+                        let jump_path = ProjectPath {
+                            worktree_id: file.worktree_id(cx),
+                            path: file.path.clone(),
+                        };
+                        let jump_anchor = range
+                            .primary
+                            .as_ref()
+                            .map_or(range.context.start, |primary| primary.start);
+
+                        let excerpt_start = range.context.start;
+                        let jump_position = language::ToPoint::to_point(&jump_anchor, buffer);
+                        let offset_from_excerpt_start = if jump_anchor == excerpt_start {
+                            0
+                        } else {
+                            let excerpt_start_row =
+                                language::ToPoint::to_point(&jump_anchor, buffer).row;
+                            jump_position.row - excerpt_start_row
+                        };
+
+                        let line_offset_from_top =
+                            block_row_start.0 + *height + offset_from_excerpt_start
+                                - snapshot
+                                    .scroll_anchor
+                                    .scroll_position(&snapshot.display_snapshot)
+                                    .y as u32;
+
+                        JumpData {
+                            position: jump_position,
+                            anchor: jump_anchor,
+                            path: jump_path,
+                            line_offset_from_top,
+                        }
+                    });
+
+                    if *starts_new_buffer {
+                        let include_root = self
+                            .editor
+                            .read(cx)
+                            .project
+                            .as_ref()
+                            .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
+                            .unwrap_or_default();
+                        let path = buffer.resolve_file_path(cx, include_root);
+                        let filename = path
+                            .as_ref()
+                            .and_then(|path| Some(path.file_name()?.to_string_lossy().to_string()));
+                        let parent_path = path.as_ref().and_then(|path| {
+                            Some(path.parent()?.to_string_lossy().to_string() + "/")
+                        });
+
+                        result = result.child(
+                            div()
+                                .px(header_padding)
+                                .pt(header_padding)
+                                .w_full()
+                                .h(FILE_HEADER_HEIGHT as f32 * cx.line_height())
                                 .child(
-                                    ButtonLike::new("expand-icon")
-                                        .style(ButtonStyle::Transparent)
+                                    h_flex()
+                                        .id("path header block")
+                                        .size_full()
+                                        .flex_basis(Length::Definite(DefiniteLength::Fraction(
+                                            0.667,
+                                        )))
+                                        .px(gpui::px(12.))
+                                        .rounded_md()
+                                        .shadow_md()
+                                        .border_1()
+                                        .border_color(cx.theme().colors().border)
+                                        .bg(cx.theme().colors().editor_subheader_background)
+                                        .justify_between()
+                                        .hover(|style| style.bg(cx.theme().colors().element_hover))
                                         .child(
-                                            svg()
-                                                .path(IconName::ArrowUpFromLine.path())
-                                                .size(IconSize::XSmall.rems())
-                                                .text_color(cx.theme().colors().editor_line_number)
-                                                .group("")
-                                                .hover(|style| {
-                                                    style.text_color(
-                                                        cx.theme()
-                                                            .colors()
-                                                            .editor_active_line_number,
+                                            h_flex().gap_3().child(
+                                                h_flex()
+                                                    .gap_2()
+                                                    .child(
+                                                        filename
+                                                            .map(SharedString::from)
+                                                            .unwrap_or_else(|| "untitled".into()),
                                                     )
-                                                }),
+                                                    .when_some(parent_path, |then, path| {
+                                                        then.child(div().child(path).text_color(
+                                                            cx.theme().colors().text_muted,
+                                                        ))
+                                                    }),
+                                            ),
                                         )
-                                        .on_click(cx.listener_for(&self.editor, {
-                                            let id = *id;
-                                            move |editor, _, cx| {
-                                                editor.expand_excerpt(
-                                                    id,
-                                                    multi_buffer::ExpandExcerptDirection::Up,
-                                                    cx,
-                                                );
-                                            }
-                                        }))
-                                        .tooltip({
-                                            move |cx| {
-                                                Tooltip::for_action(
-                                                    "Expand Excerpt",
-                                                    &ExpandExcerpts { lines: 0 },
-                                                    cx,
-                                                )
-                                            }
+                                        .when_some(jump_data, |el, jump_data| {
+                                            el.child(Icon::new(IconName::ArrowUpRight))
+                                                .cursor_pointer()
+                                                .tooltip(|cx| {
+                                                    Tooltip::for_action(
+                                                        "Jump to File",
+                                                        &OpenExcerpts,
+                                                        cx,
+                                                    )
+                                                })
+                                                .on_mouse_down(MouseButton::Left, |_, cx| {
+                                                    cx.stop_propagation()
+                                                })
+                                                .on_click(cx.listener_for(&self.editor, {
+                                                    move |editor, _, cx| {
+                                                        editor.jump(
+                                                            jump_data.path.clone(),
+                                                            jump_data.position,
+                                                            jump_data.anchor,
+                                                            jump_data.line_offset_from_top,
+                                                            cx,
+                                                        );
+                                                    }
+                                                }))
                                         }),
-                                )
-                        }))
-                } else {
-                    v_flex()
-                        .id(("excerpt header", EntityId::from(block_id)))
-                        .w_full()
-                        .h(snapshot.excerpt_header_height() as f32 * cx.line_height())
-                        .child(
-                            div()
-                                .flex()
-                                .v_flex()
+                                ),
+                        );
+                        if *show_excerpt_controls {
+                            result = result.child(
+                                h_flex()
+                                    .w(icon_offset)
+                                    .h(MULTI_BUFFER_EXCERPT_HEADER_HEIGHT as f32 * cx.line_height())
+                                    .flex_none()
+                                    .justify_end()
+                                    .child(self.render_expand_excerpt_button(
+                                        next_excerpt.id,
+                                        ExpandExcerptDirection::Up,
+                                        IconName::ArrowUpFromLine,
+                                        cx,
+                                    )),
+                            );
+                        }
+                    } else {
+                        result = result.child(
+                            h_flex()
+                                .id("excerpt header block")
+                                .group("excerpt-jump-action")
                                 .justify_start()
-                                .id("jump to collapsed context")
-                                .w(relative(1.0))
-                                .h_full()
+                                .w_full()
+                                .h(MULTI_BUFFER_EXCERPT_HEADER_HEIGHT as f32 * cx.line_height())
+                                .relative()
                                 .child(
                                     div()
-                                        .h_px()
+                                        .top(px(0.))
+                                        .absolute()
                                         .w_full()
+                                        .h_px()
                                         .bg(cx.theme().colors().border_variant)
                                         .group_hover("excerpt-jump-action", |style| {
                                             style.bg(cx.theme().colors().border)
                                         }),
-                                ),
-                        )
-                        .child(
-                            h_flex()
-                                .justify_end()
-                                .flex_none()
-                                .w(icon_offset)
-                                .h_full()
+                                )
+                                .cursor_pointer()
+                                .when_some(jump_data.clone(), |this, jump_data| {
+                                    this.on_click(cx.listener_for(&self.editor, {
+                                        let path = jump_data.path.clone();
+                                        move |editor, _, cx| {
+                                            cx.stop_propagation();
+
+                                            editor.jump(
+                                                path.clone(),
+                                                jump_data.position,
+                                                jump_data.anchor,
+                                                jump_data.line_offset_from_top,
+                                                cx,
+                                            );
+                                        }
+                                    }))
+                                    .tooltip(move |cx| {
+                                        Tooltip::for_action(
+                                            format!(
+                                                "Jump to {}:L{}",
+                                                jump_data.path.path.display(),
+                                                jump_data.position.row + 1
+                                            ),
+                                            &OpenExcerpts,
+                                            cx,
+                                        )
+                                    })
+                                })
                                 .child(
-                                    show_excerpt_controls
-                                        .then(|| {
-                                            ButtonLike::new("expand-icon")
-                                                .style(ButtonStyle::Transparent)
-                                                .child(
-                                                    svg()
-                                                        .path(IconName::ArrowUpFromLine.path())
-                                                        .size(IconSize::XSmall.rems())
-                                                        .text_color(
-                                                            cx.theme().colors().editor_line_number,
-                                                        )
-                                                        .group("")
-                                                        .hover(|style| {
-                                                            style.text_color(
-                                                                cx.theme()
-                                                                    .colors()
-                                                                    .editor_active_line_number,
-                                                            )
-                                                        }),
-                                                )
-                                                .on_click(cx.listener_for(&self.editor, {
-                                                    let id = *id;
-                                                    move |editor, _, cx| {
-                                                        editor.expand_excerpt(
-                                                        id,
-                                                        multi_buffer::ExpandExcerptDirection::Up,
-                                                        cx,
-                                                    );
-                                                    }
-                                                }))
-                                                .tooltip({
-                                                    move |cx| {
-                                                        Tooltip::for_action(
-                                                            "Expand Excerpt",
-                                                            &ExpandExcerpts { lines: 0 },
-                                                            cx,
-                                                        )
-                                                    }
-                                                })
-                                        })
-                                        .unwrap_or_else(|| {
+                                    h_flex()
+                                        .w(icon_offset)
+                                        .h(MULTI_BUFFER_EXCERPT_HEADER_HEIGHT as f32
+                                            * cx.line_height())
+                                        .flex_none()
+                                        .justify_end()
+                                        .child(if *show_excerpt_controls {
+                                            self.render_expand_excerpt_button(
+                                                next_excerpt.id,
+                                                ExpandExcerptDirection::Up,
+                                                IconName::ArrowUpFromLine,
+                                                cx,
+                                            )
+                                        } else {
                                             ButtonLike::new("jump-icon")
                                                 .style(ButtonStyle::Transparent)
                                                 .child(
@@ -2361,7 +2347,6 @@ impl EditorElement {
                                                         .text_color(
                                                             cx.theme().colors().border_variant,
                                                         )
-                                                        .group("excerpt-jump-action")
                                                         .group_hover(
                                                             "excerpt-jump-action",
                                                             |style| {
@@ -2371,118 +2356,13 @@ impl EditorElement {
                                                             },
                                                         ),
                                                 )
-                                                .when_some(jump_data.clone(), |this, jump_data| {
-                                                    this.on_click(cx.listener_for(&self.editor, {
-                                                        let path = jump_data.path.clone();
-                                                        move |editor, _, cx| {
-                                                            cx.stop_propagation();
-
-                                                            editor.jump(
-                                                                path.clone(),
-                                                                jump_data.position,
-                                                                jump_data.anchor,
-                                                                jump_data.line_offset_from_top,
-                                                                cx,
-                                                            );
-                                                        }
-                                                    }))
-                                                    .tooltip(move |cx| {
-                                                        Tooltip::for_action(
-                                                            format!(
-                                                                "Jump to {}:L{}",
-                                                                jump_data.path.path.display(),
-                                                                jump_data.position.row + 1
-                                                            ),
-                                                            &OpenExcerpts,
-                                                            cx,
-                                                        )
-                                                    })
-                                                })
                                         }),
                                 ),
-                        )
-                        .group("excerpt-jump-action")
-                        .cursor_pointer()
-                        .when_some(jump_data.clone(), |this, jump_data| {
-                            this.on_click(cx.listener_for(&self.editor, {
-                                let path = jump_data.path.clone();
-                                move |editor, _, cx| {
-                                    cx.stop_propagation();
-
-                                    editor.jump(
-                                        path.clone(),
-                                        jump_data.position,
-                                        jump_data.anchor,
-                                        jump_data.line_offset_from_top,
-                                        cx,
-                                    );
-                                }
-                            }))
-                            .tooltip(move |cx| {
-                                Tooltip::for_action(
-                                    format!(
-                                        "Jump to {}:L{}",
-                                        jump_data.path.path.display(),
-                                        jump_data.position.row + 1
-                                    ),
-                                    &OpenExcerpts,
-                                    cx,
-                                )
-                            })
-                        })
-                };
-                element.into_any()
-            }
+                        );
+                    }
+                }
 
-            Block::ExcerptFooter { id, .. } => {
-                let element = v_flex()
-                    .id(("excerpt footer", EntityId::from(block_id)))
-                    .w_full()
-                    .h(snapshot.excerpt_footer_height() as f32 * cx.line_height())
-                    .child(
-                        h_flex()
-                            .justify_end()
-                            .flex_none()
-                            .w(gutter_dimensions.width
-                                - (gutter_dimensions.left_padding + gutter_dimensions.margin))
-                            .h_full()
-                            .child(
-                                ButtonLike::new("expand-icon")
-                                    .style(ButtonStyle::Transparent)
-                                    .child(
-                                        svg()
-                                            .path(IconName::ArrowDownFromLine.path())
-                                            .size(IconSize::XSmall.rems())
-                                            .text_color(cx.theme().colors().editor_line_number)
-                                            .group("")
-                                            .hover(|style| {
-                                                style.text_color(
-                                                    cx.theme().colors().editor_active_line_number,
-                                                )
-                                            }),
-                                    )
-                                    .on_click(cx.listener_for(&self.editor, {
-                                        let id = *id;
-                                        move |editor, _, cx| {
-                                            editor.expand_excerpt(
-                                                id,
-                                                multi_buffer::ExpandExcerptDirection::Down,
-                                                cx,
-                                            );
-                                        }
-                                    }))
-                                    .tooltip({
-                                        move |cx| {
-                                            Tooltip::for_action(
-                                                "Expand Excerpt",
-                                                &ExpandExcerpts { lines: 0 },
-                                                cx,
-                                            )
-                                        }
-                                    }),
-                            ),
-                    );
-                element.into_any()
+                result.into_any()
             }
         };
 
@@ -2509,6 +2389,33 @@ impl EditorElement {
         (element, final_size)
     }
 
+    fn render_expand_excerpt_button(
+        &self,
+        excerpt_id: ExcerptId,
+        direction: ExpandExcerptDirection,
+        icon: IconName,
+        cx: &mut WindowContext,
+    ) -> ButtonLike {
+        ButtonLike::new("expand-icon")
+            .style(ButtonStyle::Transparent)
+            .child(
+                svg()
+                    .path(icon.path())
+                    .size(IconSize::XSmall.rems())
+                    .text_color(cx.theme().colors().editor_line_number)
+                    .group("")
+                    .hover(|style| style.text_color(cx.theme().colors().editor_active_line_number)),
+            )
+            .on_click(cx.listener_for(&self.editor, {
+                move |editor, _, cx| {
+                    editor.expand_excerpt(excerpt_id, direction, cx);
+                }
+            }))
+            .tooltip({
+                move |cx| Tooltip::for_action("Expand Excerpt", &ExpandExcerpts { lines: 0 }, cx)
+            })
+    }
+
     #[allow(clippy::too_many_arguments)]
     fn render_blocks(
         &self,
@@ -3367,7 +3274,7 @@ impl EditorElement {
                     let end_row_in_current_excerpt = snapshot
                         .blocks_in_range(start_row..end_row)
                         .find_map(|(start_row, block)| {
-                            if matches!(block, Block::ExcerptHeader { .. }) {
+                            if matches!(block, Block::ExcerptBoundary { .. }) {
                                 Some(start_row)
                             } else {
                                 None
diff --git a/crates/editor/src/movement.rs b/crates/editor/src/movement.rs
index 19e2a4ea95a676..19ba147e164dfd 100644
--- a/crates/editor/src/movement.rs
+++ b/crates/editor/src/movement.rs
@@ -952,7 +952,7 @@ mod tests {
                     px(14.0),
                     None,
                     true,
-                    2,
+                    0,
                     2,
                     0,
                     FoldPlaceholder::test(),
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index a239b5b77049e5..f091c86ed92abd 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -189,6 +189,7 @@ pub struct MultiBufferSnapshot {
     show_headers: bool,
 }
 
+#[derive(Clone)]
 pub struct ExcerptInfo {
     pub id: ExcerptId,
     pub buffer: BufferSnapshot,
@@ -201,6 +202,7 @@ impl std::fmt::Debug for ExcerptInfo {
         f.debug_struct(type_name::<Self>())
             .field("id", &self.id)
             .field("buffer_id", &self.buffer_id)
+            .field("path", &self.buffer.file().map(|f| f.path()))
             .field("range", &self.range)
             .finish()
     }
diff --git a/crates/repl/src/session.rs b/crates/repl/src/session.rs
index fcfc717efb31de..7f312023c34aae 100644
--- a/crates/repl/src/session.rs
+++ b/crates/repl/src/session.rs
@@ -17,8 +17,7 @@ use editor::{
 use futures::io::BufReader;
 use futures::{AsyncBufReadExt as _, FutureExt as _, StreamExt as _};
 use gpui::{
-    div, prelude::*, EntityId, EventEmitter, Model, Render, Subscription, Task, View, ViewContext,
-    WeakView,
+    div, prelude::*, EventEmitter, Model, Render, Subscription, Task, View, ViewContext, WeakView,
 };
 use language::Point;
 use project::Fs;
@@ -149,23 +148,21 @@ impl EditorBlock {
                 .w(text_line_height)
                 .h(text_line_height)
                 .child(
-                    IconButton::new(
-                        ("close_output_area", EntityId::from(cx.block_id)),
-                        IconName::Close,
-                    )
-                    .icon_size(IconSize::Small)
-                    .icon_color(Color::Muted)
-                    .size(ButtonSize::Compact)
-                    .shape(IconButtonShape::Square)
-                    .tooltip(|cx| Tooltip::text("Close output area", cx))
-                    .on_click(move |_, cx| {
-                        if let BlockId::Custom(block_id) = block_id {
-                            (on_close)(block_id, cx)
-                        }
-                    }),
+                    IconButton::new("close_output_area", IconName::Close)
+                        .icon_size(IconSize::Small)
+                        .icon_color(Color::Muted)
+                        .size(ButtonSize::Compact)
+                        .shape(IconButtonShape::Square)
+                        .tooltip(|cx| Tooltip::text("Close output area", cx))
+                        .on_click(move |_, cx| {
+                            if let BlockId::Custom(block_id) = block_id {
+                                (on_close)(block_id, cx)
+                            }
+                        }),
                 );
 
             div()
+                .id(cx.block_id)
                 .flex()
                 .items_start()
                 .min_h(text_line_height)